209 lines
8.6 KiB
JavaScript
209 lines
8.6 KiB
JavaScript
import { computeDasMap } from "/packages/acoustics-core/das.js";
|
||
import { distance3 } from "/packages/acoustics-core/math.js";
|
||
import { synthesizeMicrophoneSignals } from "/packages/acoustics-core/propagation.js";
|
||
import { computeDasWithBackend } from "/packages/webgpu-kernels/compute.js";
|
||
import { computeDasWebGpu } from "/packages/webgpu-kernels/das.js";
|
||
|
||
function createArray(columns, rows, width, height) {
|
||
const microphones = [];
|
||
for (let row = 0; row < rows; row += 1) {
|
||
for (let column = 0; column < columns; column += 1) {
|
||
const index = row * columns + column;
|
||
microphones.push({
|
||
id: `gpu-mic-${row}-${column}`,
|
||
position: [
|
||
-width / 2 + (column * width) / (columns - 1),
|
||
-height / 2 + (row * height) / (rows - 1),
|
||
0,
|
||
],
|
||
sensitivityDb: (index % 3) * 2 - 2,
|
||
phaseOffsetDeg: (index % 5) * 8 - 16,
|
||
});
|
||
}
|
||
}
|
||
return { id: "gpu-test-array", aperture: { width, height }, microphones };
|
||
}
|
||
|
||
function createFixture(backend = "webgpu") {
|
||
const arrayDefinition = createArray(4, 4, 0.3, 0.3);
|
||
const scene = {
|
||
id: "gpu-das-scene",
|
||
sampleRate: 8_000,
|
||
duration: 0.064,
|
||
speedOfSound: 343,
|
||
seed: 11,
|
||
mix: { normalization: "none", targetPeak: 0.95 },
|
||
sources: [{
|
||
id: "source",
|
||
name: "source",
|
||
position: [0.1, 0.1, 1.2],
|
||
gainDb: -12,
|
||
startTime: 0,
|
||
duration: 0.064,
|
||
signal: { type: "tone", frequency: 1_000, phaseDeg: 0 },
|
||
}],
|
||
ambient: [],
|
||
};
|
||
const experiment = {
|
||
stft: { fftSize: 128, hopSize: 64, window: "hann" },
|
||
scan: { z: 1.2, xMin: -0.4, xMax: 0.4, yMin: -0.4, yMax: 0.4, columns: 9, rows: 9 },
|
||
frequencyBands: [{ id: "1k", minHz: 990, maxHz: 1_010, color: "#65f2bf" }],
|
||
beamforming: { backend, algorithm: "das", normalization: "peak" },
|
||
};
|
||
const synthesis = synthesizeMicrophoneSignals({ scene, arrayDefinition });
|
||
return {
|
||
channels: synthesis.channels,
|
||
sampleRate: synthesis.sampleRate,
|
||
arrayDefinition,
|
||
scene,
|
||
experiment,
|
||
};
|
||
}
|
||
|
||
function normalizedMapError(reference, actual) {
|
||
const referenceScale = Math.max(...reference);
|
||
let squaredError = 0;
|
||
let maximumAbsoluteError = 0;
|
||
for (let index = 0; index < reference.length; index += 1) {
|
||
const error = Math.abs(actual[index] - reference[index]) / referenceScale;
|
||
squaredError += error * error;
|
||
maximumAbsoluteError = Math.max(maximumAbsoluteError, error);
|
||
}
|
||
return {
|
||
rms: Math.sqrt(squaredError / reference.length),
|
||
maximumAbsoluteError,
|
||
};
|
||
}
|
||
|
||
test("WebGPU DAS가 CPU 수치 기준과 일치하거나 auto CPU fallback한다", async () => {
|
||
const adapter = await globalThis.navigator?.gpu?.requestAdapter();
|
||
if (!adapter) {
|
||
const fixture = createFixture("auto");
|
||
const result = await computeDasWithBackend(fixture);
|
||
assertEqual(result.backend, "cpu", "auto fallback backend without adapter");
|
||
assert(result.bands[0].peak.rawPower > 0, "fallback produced a usable map");
|
||
document.documentElement.dataset.webgpuIntegration = "cpu-fallback";
|
||
return;
|
||
}
|
||
|
||
const fixture = createFixture("webgpu");
|
||
const cpuResult = await computeDasMap(fixture);
|
||
const gpuResult = await computeDasWebGpu(fixture);
|
||
const cpuBand = cpuResult.bands[0];
|
||
const gpuBand = gpuResult.bands[0];
|
||
const error = normalizedMapError(cpuBand.rawMap, gpuBand.rawMap);
|
||
|
||
assertEqual(gpuResult.backend, "webgpu", "actual WebGPU backend");
|
||
assertEqual(gpuBand.rawMap.length, cpuBand.rawMap.length, "map size");
|
||
assert(error.rms <= 2e-3, `CPU/GPU normalized RMS error=${error.rms}`);
|
||
assert(
|
||
error.maximumAbsoluteError <= 1e-2,
|
||
`CPU/GPU normalized maximum absolute error=${error.maximumAbsoluteError}`,
|
||
);
|
||
const gridDiagonal = Math.hypot(
|
||
(fixture.experiment.scan.xMax - fixture.experiment.scan.xMin) /
|
||
(fixture.experiment.scan.columns - 1),
|
||
(fixture.experiment.scan.yMax - fixture.experiment.scan.yMin) /
|
||
(fixture.experiment.scan.rows - 1),
|
||
);
|
||
assert(
|
||
distance3(gpuBand.peak.position, cpuBand.peak.position) <= gridDiagonal + 1e-9,
|
||
"CPU/GPU peak positions are within one grid diagonal",
|
||
);
|
||
assert(
|
||
distance3(gpuBand.peak.position, fixture.scene.sources[0].position) <= 0.071,
|
||
`GPU localization error=${distance3(gpuBand.peak.position, fixture.scene.sources[0].position)} m`,
|
||
);
|
||
document.documentElement.dataset.webgpuIntegration = "gpu";
|
||
document.documentElement.dataset.webgpuRmsError = error.rms.toExponential(3);
|
||
});
|
||
|
||
test("WebGPU DAS-PHAT가 CPU score map과 일치하거나 auto CPU fallback한다", async () => {
|
||
const adapter = await globalThis.navigator?.gpu?.requestAdapter();
|
||
const fixture = createFixture(adapter ? "webgpu" : "auto");
|
||
fixture.experiment.beamforming.algorithm = "das-phat";
|
||
fixture.experiment.frequencyBands = [
|
||
{ id: "phase-1k", minHz: 900, maxHz: 1_100, color: "#65f2bf" },
|
||
];
|
||
|
||
if (!adapter) {
|
||
const result = await computeDasWithBackend(fixture);
|
||
assertEqual(result.backend, "cpu", "DAS-PHAT auto fallback backend");
|
||
assertEqual(result.algorithm, "das-phat", "DAS-PHAT fallback algorithm");
|
||
assertEqual(result.bands[0].rawScale, "score", "DAS-PHAT fallback scale");
|
||
return;
|
||
}
|
||
|
||
const cpuResult = await computeDasMap(fixture);
|
||
const gpuResult = await computeDasWebGpu(fixture);
|
||
const cpuBand = cpuResult.bands[0];
|
||
const gpuBand = gpuResult.bands[0];
|
||
const error = normalizedMapError(cpuBand.rawMap, gpuBand.rawMap);
|
||
|
||
assertEqual(gpuResult.algorithm, "das-phat", "actual WebGPU DAS-PHAT algorithm");
|
||
assertEqual(gpuBand.rawScale, "score", "actual WebGPU DAS-PHAT scale");
|
||
assert(!("rawPower" in gpuBand.peak), "DAS-PHAT GPU peak is not mislabeled as power");
|
||
assert(error.rms <= 0.005, `DAS-PHAT CPU/GPU normalized RMS error=${error.rms}`);
|
||
assert(
|
||
error.maximumAbsoluteError <= 0.02,
|
||
`DAS-PHAT CPU/GPU normalized max error=${error.maximumAbsoluteError}`,
|
||
);
|
||
});
|
||
|
||
test("192채널 · 50×50 WebGPU map이 CPU baseline 허용 오차를 만족한다", async () => {
|
||
const adapter = await globalThis.navigator?.gpu?.requestAdapter();
|
||
if (!adapter) {
|
||
document.documentElement.dataset.webgpuBaseline = "unavailable";
|
||
return;
|
||
}
|
||
const baseline = globalThis.__micarrsimCpuBaseline;
|
||
assert(baseline, "CPU baseline fixture is available");
|
||
const experiment = {
|
||
...baseline.experiment,
|
||
beamforming: { ...baseline.experiment.beamforming, backend: "webgpu" },
|
||
};
|
||
const result = await computeDasWebGpu({ ...baseline, experiment });
|
||
const cpuBand = baseline.result.bands[0];
|
||
const gpuBand = result.bands[0];
|
||
const error = normalizedMapError(cpuBand.rawMap, gpuBand.rawMap);
|
||
const peakPowerRelativeError =
|
||
Math.abs(gpuBand.peak.rawPower - cpuBand.peak.rawPower) / cpuBand.peak.rawPower;
|
||
const gridDiagonal = Math.hypot(
|
||
(experiment.scan.xMax - experiment.scan.xMin) / (experiment.scan.columns - 1),
|
||
(experiment.scan.yMax - experiment.scan.yMin) / (experiment.scan.rows - 1),
|
||
);
|
||
|
||
assert(gpuBand.rawMap.every((value) => Number.isFinite(value) && value >= 0), "finite nonnegative GPU map");
|
||
assert(error.rms <= 0.005, `192ch CPU/GPU normalized RMS error=${error.rms}`);
|
||
assert(error.maximumAbsoluteError <= 0.02, `192ch CPU/GPU normalized max error=${error.maximumAbsoluteError}`);
|
||
assert(peakPowerRelativeError <= 0.02, `192ch CPU/GPU peak power relative error=${peakPowerRelativeError}`);
|
||
assert(
|
||
distance3(gpuBand.peak.position, cpuBand.peak.position) <= gridDiagonal + 1e-9,
|
||
"192ch CPU/GPU peaks are within one grid diagonal",
|
||
);
|
||
document.documentElement.dataset.webgpuBaseline = "gpu";
|
||
document.documentElement.dataset.webgpuBaselineMs = result.timingMs.total.toFixed(1);
|
||
document.documentElement.dataset.webgpuBaselineRmsError = error.rms.toExponential(3);
|
||
});
|
||
|
||
test("WebGPU bin·point 강제 batching 결과가 CPU map과 일치한다", async () => {
|
||
const adapter = await globalThis.navigator?.gpu?.requestAdapter();
|
||
if (!adapter) return;
|
||
const fixture = createFixture("webgpu");
|
||
fixture.experiment.frequencyBands = [
|
||
{ id: "wide-1k", minHz: 900, maxHz: 1_100, color: "#65f2bf" },
|
||
];
|
||
const cpuResult = await computeDasMap(fixture);
|
||
const gpuResult = await computeDasWebGpu({
|
||
...fixture,
|
||
maximumSpectrumBatchBins: 1,
|
||
maximumSteeringBufferBytes: 512,
|
||
});
|
||
const error = normalizedMapError(cpuResult.bands[0].rawMap, gpuResult.bands[0].rawMap);
|
||
|
||
assertEqual(gpuResult.gpu.batchPlan.binBatchSize, 1, "forced bin batch size");
|
||
assertEqual(gpuResult.gpu.batchPlan.pointBatchSize, 4, "forced point batch size");
|
||
assert(error.rms <= 0.005, `chunked CPU/GPU normalized RMS error=${error.rms}`);
|
||
assert(error.maximumAbsoluteError <= 0.02, `chunked CPU/GPU max error=${error.maximumAbsoluteError}`);
|
||
});
|