Skip to content

armgit / 67.js

Public Imported from GitHub
0

3D engine that AI agents drive

6.4 KB
Raw Blame
// Compares the per-frame skin kernel in JavaScript (src/skinning.js) with the same kernel in Rust compiled to WebAssembly.
// Build first: cargo build --release --target wasm32-unknown-unknown (in bench/wasm-skin). Then: node bench/wasm-skin/bench.mjs
// It records joint matrices from 8 animated RobotExpressive characters (the runtime benchmark's skinned-characters load),
// runs both kernels on the same frames, checks that the palettes match bit for bit, and prints medians.
import { readFile } from 'node:fs/promises';
import { performance } from 'node:perf_hooks';
import { parseGltf } from '../../src/gltf.js';
import { createSkinPose, skinInfluenceSets, updateSkinPose, validateSkinPose, matrixDeterminant } from '../../src/skinning.js';

const CHARACTERS = 8;
const RECORDED_FRAMES = 240;
const ROUNDS = 7;
const repository = new URL('../../', import.meta.url);

const fixture = await readFile(new URL('tests/fixtures/RobotExpressive.glb', repository));
const skinnedParts = [];
const frames = [];
for (let character = 0; character < CHARACTERS; character++) {
  const asset = await parseGltf(fixture.buffer.slice(fixture.byteOffset, fixture.byteOffset + fixture.byteLength), { maxVertices: 500000 });
  const parts = asset.parts.filter(part => part.skin);
  for (const part of parts) skinnedParts.push({ asset, character, part });
}
for (let frame = 0; frame < RECORDED_FRAMES; frame++) {
  const time = frame / 60;
  const assets = new Set(skinnedParts.map(entry => entry.asset));
  [...assets].forEach((asset, index) => asset.applyAnimation(time + index * 0.37, 0));
  frames.push(skinnedParts.map(({ part }) => ({ jointWorld: Float32Array.from(part.skin.jointWorldMatrices), meshWorld: Float32Array.from(part.matrix) })));
}
const jobs = skinnedParts.map(({ part }) => {
  const sets = skinInfluenceSets(part.geometry);
  return {
    part, count: part.skin.jointMatrices.length / 16, inverseBind: part.skin.inverseBindMatrices, bind: Float32Array.from(part.skin.bindMatrix),
    sets, setCount: sets.joints.length / 4, jsPose: createSkinPose(part.skin.jointMatrices.length / 16),
  };
});
const skinnedVertices = jobs.reduce((sum, job) => sum + job.part.geometry.skinWeights.length / 4, 0);
const distinctSets = jobs.reduce((sum, job) => sum + job.setCount, 0);

// JavaScript kernel: the calls prepareSkinBinding makes per skinned part per frame.
function javascriptFrame(frame) {
  for (let index = 0; index < jobs.length; index++) {
    const job = jobs[index];
    const input = frame[index];
    updateSkinPose(job.jsPose, input.jointWorld, job.inverseBind, input.meshWorld, job.bind);
    validateSkinPose(job.jsPose, job.part.geometry, input.meshWorld);
  }
}

// WebAssembly kernel: same work, plus copying the frame's matrices in and the palette out.
const wasmBytes = await readFile(new URL('bench/wasm-skin/target/wasm32-unknown-unknown/release/skin_kernel.wasm', repository));
const { instance } = await WebAssembly.instantiate(wasmBytes, {});
const kernel = instance.exports;
const floats = () => new Float32Array(kernel.memory.buffer);
const integers = () => new Int32Array(kernel.memory.buffer);
for (const job of jobs) {
  job.jointWorldPointer = kernel.allocate(job.count * 64);
  job.inverseBindPointer = kernel.allocate(job.count * 64);
  job.meshWorldPointer = kernel.allocate(64);
  job.bindPointer = kernel.allocate(64);
  job.palettePointer = kernel.allocate(job.count * 64);
  job.jointsPointer = kernel.allocate(job.setCount * 16);
  job.weightsPointer = kernel.allocate(job.setCount * 16);
  job.wasmPalette = new Float32Array(job.count * 16);
}
for (const job of jobs) {
  floats().set(job.inverseBind, job.inverseBindPointer / 4);
  floats().set(job.bind, job.bindPointer / 4);
  integers().set(job.sets.joints, job.jointsPointer / 4);
  floats().set(job.sets.weights, job.weightsPointer / 4);
}
function wasmFrame(frame) {
  const memory = floats();
  for (let index = 0; index < jobs.length; index++) {
    const job = jobs[index];
    const input = frame[index];
    memory.set(input.jointWorld, job.jointWorldPointer / 4);
    memory.set(input.meshWorld, job.meshWorldPointer / 4);
    let status = kernel.skin_update(job.count, job.jointWorldPointer, job.inverseBindPointer, job.meshWorldPointer, job.bindPointer, job.palettePointer);
    if (status === 0) status = kernel.skin_validate(job.palettePointer, job.count, job.jointsPointer, job.weightsPointer, job.setCount, matrixDeterminant(input.meshWorld, 0), 1);
    if (status !== 0) throw new Error(`WebAssembly kernel status ${status}`);
    job.wasmPalette.set(memory.subarray(job.palettePointer / 4, job.palettePointer / 4 + job.count * 16));
  }
}

// Same palettes, bit for bit, on every recorded frame.
let mismatches = 0;
for (const frame of frames) {
  javascriptFrame(frame);
  wasmFrame(frame);
  for (const job of jobs) {
    const left = new Uint32Array(job.jsPose.jointMatrices.buffer, job.jsPose.jointMatrices.byteOffset, job.count * 16);
    const right = new Uint32Array(job.wasmPalette.buffer);
    for (let index = 0; index < left.length; index++) if (left[index] !== right[index]) mismatches++;
  }
}

function measure(runFrame) {
  const perFrame = [];
  for (let round = 0; round < ROUNDS; round++) {
    const started = performance.now();
    for (const frame of frames) runFrame(frame);
    perFrame.push((performance.now() - started) / frames.length);
  }
  perFrame.sort((a, b) => a - b);
  return perFrame;
}
// Warm both paths, then alternate the order so neither always runs on a hotter or colder machine.
measure(javascriptFrame);
measure(wasmFrame);
const javascriptTimes = [];
const wasmTimes = [];
for (let pass = 0; pass < 3; pass++) {
  if (pass % 2 === 0) { javascriptTimes.push(...measure(javascriptFrame)); wasmTimes.push(...measure(wasmFrame)); }
  else { wasmTimes.push(...measure(wasmFrame)); javascriptTimes.push(...measure(javascriptFrame)); }
}
const median = values => [...values].sort((a, b) => a - b)[values.length >> 1];
const range = values => `${Math.min(...values).toFixed(4)} to ${Math.max(...values).toFixed(4)}`;
console.log(JSON.stringify({
  characters: CHARACTERS, skinnedParts: jobs.length, jointsPerPart: jobs[0].count, skinnedVertices, distinctInfluenceSets: distinctSets,
  wasmBytes: wasmBytes.length, paletteMismatches: mismatches,
  javascriptMsPerFrame: Number(median(javascriptTimes).toFixed(4)), javascriptRange: range(javascriptTimes),
  wasmMsPerFrame: Number(median(wasmTimes).toFixed(4)), wasmRange: range(wasmTimes),
  speedup: Number((median(javascriptTimes) / median(wasmTimes)).toFixed(2)),
}, null, 2));