3D engine that AI agents drive
JavaScript 3d3d-engineagentic-aiai-agentsblenderclaude-codegame-enginegaussian-splattinggltfjavascriptmcpmcp-servermodel-context-protocolpath-tracerpath-tracingpbrrenderingthreejs-alternativewebgl2webgpu
Destroy the buffers of a WebGPU pass whose setup throws (#2628)
abu-tahir-068d6a01d7f54
diff --git a/changes/2628.md b/changes/2628.mdnew file mode 100644index 00000000..9391da1b--- /dev/null+++ b/changes/2628.md@@ -0,0 +1 @@+- A WebGPU real-time cache or denoiser that fails to set up now destroys the buffers it made, instead of keeping their memory until the page closes (#2628)diff --git a/src/path-tracer-realtime-webgpu-passes.js b/src/path-tracer-realtime-webgpu-passes.jsindex 9cc519d0..9573c58c 100644--- a/src/path-tracer-realtime-webgpu-passes.js+++ b/src/path-tracer-realtime-webgpu-passes.js@@ -371,6 +371,20 @@ const storage = (device, label, bytes, extraUsage = 0) => device.createBuffer({const uniform = (device, label, bytes) => device.createBuffer({ label, size: bytes, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });const bind = (device, pipeline, buffers) => device.createBindGroup({ layout: pipeline.getBindGroupLayout(0), entries: buffers.map((buffer, binding) => ({ binding, resource: { buffer } })) });+// Collects the buffers a pass makes, so a failed setup can destroy them instead of keeping their memory until the page closes.+function createBufferCleanup() {+ const buffers = [];+ return {+ keep(buffer) {+ buffers.push(buffer);+ return buffer;+ },+ release() {+ for (const buffer of buffers) buffer.destroy();+ },+ };+}+/*** The cache table (CACHE_SLOT_COUNT vec4: mean radiance and the number of records behind it) and the pass that folds the* records of a frame in. `table` is bound by the tracer kernel; `encode(pass, records, recordCount)` adds the dispatches.@@ -378,32 +392,38 @@ const bind = (device, pipeline, buffers) => device.createBindGroup({ layout: pipexport async function createWebGpuRadianceCache(device) {const module = await compileModule(device, 'radiance cache', CACHE_SOURCE);const [scatterPipeline, resolvePipeline] = await Promise.all([createPipeline(device, module, 'scatterRecords'), createPipeline(device, module, 'resolveCells')]);- const table = storage(device, 'radiance cache', CACHE_SLOT_COUNT * 16, GPUBufferUsage.COPY_DST);- const sums = storage(device, 'radiance cache sums', CACHE_SLOT_COUNT * 16);- const recordCountBuffer = uniform(device, 'record count', CACHE_PARAMETER_BYTES);- let scatterGroup = null;- let resolveGroup = null;- return {- table,- clear(encoder) {- encoder.clearBuffer(table);- },- encode(pass, records, recordCount) {- device.queue.writeBuffer(recordCountBuffer, 0, new Uint32Array([recordCount, 0, 0, 0]));- scatterGroup ??= device.createBindGroup({ layout: scatterPipeline.getBindGroupLayout(0), entries: [[0, records], [1, sums], [3, recordCountBuffer]].map(([binding, buffer]) => ({ binding, resource: { buffer } })) });- resolveGroup ??= device.createBindGroup({ layout: resolvePipeline.getBindGroupLayout(0), entries: [sums, table].map((buffer, index) => ({ binding: index + 1, resource: { buffer } })) });- pass.setPipeline(scatterPipeline);- pass.setBindGroup(0, scatterGroup);- const recordGroups = Math.ceil(recordCount / CACHE_WORKGROUP_SIZE);- pass.dispatchWorkgroups(Math.min(recordGroups, 4096), Math.ceil(recordGroups / 4096));- pass.setPipeline(resolvePipeline);- pass.setBindGroup(0, resolveGroup);- pass.dispatchWorkgroups(4096, CACHE_SLOT_COUNT / CACHE_WORKGROUP_SIZE / 4096);- },- dispose() {- for (const buffer of [table, sums, recordCountBuffer]) buffer.destroy();- },- };+ const cleanup = createBufferCleanup();+ try {+ const table = cleanup.keep(storage(device, 'radiance cache', CACHE_SLOT_COUNT * 16, GPUBufferUsage.COPY_DST));+ const sums = cleanup.keep(storage(device, 'radiance cache sums', CACHE_SLOT_COUNT * 16));+ const recordCountBuffer = cleanup.keep(uniform(device, 'record count', CACHE_PARAMETER_BYTES));+ let scatterGroup = null;+ let resolveGroup = null;+ return {+ table,+ clear(encoder) {+ encoder.clearBuffer(table);+ },+ encode(pass, records, recordCount) {+ device.queue.writeBuffer(recordCountBuffer, 0, new Uint32Array([recordCount, 0, 0, 0]));+ scatterGroup ??= device.createBindGroup({ layout: scatterPipeline.getBindGroupLayout(0), entries: [[0, records], [1, sums], [3, recordCountBuffer]].map(([binding, buffer]) => ({ binding, resource: { buffer } })) });+ resolveGroup ??= device.createBindGroup({ layout: resolvePipeline.getBindGroupLayout(0), entries: [sums, table].map((buffer, index) => ({ binding: index + 1, resource: { buffer } })) });+ pass.setPipeline(scatterPipeline);+ pass.setBindGroup(0, scatterGroup);+ const recordGroups = Math.ceil(recordCount / CACHE_WORKGROUP_SIZE);+ pass.dispatchWorkgroups(Math.min(recordGroups, 4096), Math.ceil(recordGroups / 4096));+ pass.setPipeline(resolvePipeline);+ pass.setBindGroup(0, resolveGroup);+ pass.dispatchWorkgroups(4096, CACHE_SLOT_COUNT / CACHE_WORKGROUP_SIZE / 4096);+ },+ dispose() {+ for (const buffer of [table, sums, recordCountBuffer]) buffer.destroy();+ },+ };+ } catch (error) {+ cleanup.release();+ throw error;+ }}/** Rows of a texture copy start at multiples of 256 bytes. */@@ -436,45 +456,51 @@ export async function createWebGpuDenoiser(device, { traceWidth, traceHeight, ouconst [accumulatePipeline, atrousPipeline, presentPipeline] = await Promise.all([createPipeline(device, accumulateModule, 'accumulate'), createPipeline(device, atrousModule, 'atrous'), createPipeline(device, presentModule, 'present'),]);- const plane = traceWidth * traceHeight * 16;- const rowWords = outputRowWords(outputWidth);- const sizes = [traceWidth, traceHeight, outputWidth, outputHeight];- const histories = [0, 1].map(index => storage(device, `history ${index}`, plane * 3));- const filters = [0, 1].map(index => storage(device, `filter ${index}`, plane));- const outputBuffer = storage(device, 'output pixels', rowWords * 4 * outputHeight, GPUBufferUsage.COPY_SRC);- const accumulateParameters = uniform(device, 'accumulate parameters', DENOISE_PARAMETER_BYTES);- const atrousParameters = Array.from({ length: filterIterations }, () => uniform(device, 'a-trous parameters', DENOISE_PARAMETER_BYTES));- const presentParameters = uniform(device, 'present parameters', DENOISE_PARAMETER_BYTES);- const finalFilter = filters[filterIterations % 2];- const groupsFor = (width, height) => [Math.ceil(width / 8), Math.ceil(height / 8)];- const sets = [0, 1].map(set => ({- accumulate: bind(device, accumulatePipeline, [accumulateParameters, tracedBuffers[set], tracedBuffers[1 - set], histories[1 - set], histories[set], filters[0], motionBuffer]),- atrous: atrousParameters.map((parameters, iteration) => bind(device, atrousPipeline, [parameters, tracedBuffers[set], filters[iteration % 2], filters[1 - iteration % 2]])),- present: bind(device, presentPipeline, [presentParameters, tracedBuffers[set], finalFilter, histories[set], outputBuffer]),- }));-- return {- outputBuffer,- rowWords,- encode(pass, set, inputs) {- const settings = { ...inputs, historyLimit };- writeDenoiseParameters(device, accumulateParameters, settings, sizes, 1, rowWords, swapped);- atrousParameters.forEach((buffer, iteration) => writeDenoiseParameters(device, buffer, settings, sizes, 1 << iteration, rowWords, swapped));- writeDenoiseParameters(device, presentParameters, settings, sizes, 1, rowWords, swapped);- pass.setPipeline(accumulatePipeline);- pass.setBindGroup(0, sets[set].accumulate);- pass.dispatchWorkgroups(...groupsFor(traceWidth, traceHeight));- pass.setPipeline(atrousPipeline);- for (const group of sets[set].atrous) {- pass.setBindGroup(0, group);+ const cleanup = createBufferCleanup();+ try {+ const plane = traceWidth * traceHeight * 16;+ const rowWords = outputRowWords(outputWidth);+ const sizes = [traceWidth, traceHeight, outputWidth, outputHeight];+ const histories = [0, 1].map(index => cleanup.keep(storage(device, `history ${index}`, plane * 3)));+ const filters = [0, 1].map(index => cleanup.keep(storage(device, `filter ${index}`, plane)));+ const outputBuffer = cleanup.keep(storage(device, 'output pixels', rowWords * 4 * outputHeight, GPUBufferUsage.COPY_SRC));+ const accumulateParameters = cleanup.keep(uniform(device, 'accumulate parameters', DENOISE_PARAMETER_BYTES));+ const atrousParameters = Array.from({ length: filterIterations }, () => cleanup.keep(uniform(device, 'a-trous parameters', DENOISE_PARAMETER_BYTES)));+ const presentParameters = cleanup.keep(uniform(device, 'present parameters', DENOISE_PARAMETER_BYTES));+ const finalFilter = filters[filterIterations % 2];+ const groupsFor = (width, height) => [Math.ceil(width / 8), Math.ceil(height / 8)];+ const sets = [0, 1].map(set => ({+ accumulate: bind(device, accumulatePipeline, [accumulateParameters, tracedBuffers[set], tracedBuffers[1 - set], histories[1 - set], histories[set], filters[0], motionBuffer]),+ atrous: atrousParameters.map((parameters, iteration) => bind(device, atrousPipeline, [parameters, tracedBuffers[set], filters[iteration % 2], filters[1 - iteration % 2]])),+ present: bind(device, presentPipeline, [presentParameters, tracedBuffers[set], finalFilter, histories[set], outputBuffer]),+ }));++ return {+ outputBuffer,+ rowWords,+ encode(pass, set, inputs) {+ const settings = { ...inputs, historyLimit };+ writeDenoiseParameters(device, accumulateParameters, settings, sizes, 1, rowWords, swapped);+ atrousParameters.forEach((buffer, iteration) => writeDenoiseParameters(device, buffer, settings, sizes, 1 << iteration, rowWords, swapped));+ writeDenoiseParameters(device, presentParameters, settings, sizes, 1, rowWords, swapped);+ pass.setPipeline(accumulatePipeline);+ pass.setBindGroup(0, sets[set].accumulate);pass.dispatchWorkgroups(...groupsFor(traceWidth, traceHeight));- }- pass.setPipeline(presentPipeline);- pass.setBindGroup(0, sets[set].present);- pass.dispatchWorkgroups(...groupsFor(outputWidth, outputHeight));- },- dispose() {- for (const buffer of [...histories, ...filters, outputBuffer, accumulateParameters, presentParameters, ...atrousParameters]) buffer.destroy();- },- };+ pass.setPipeline(atrousPipeline);+ for (const group of sets[set].atrous) {+ pass.setBindGroup(0, group);+ pass.dispatchWorkgroups(...groupsFor(traceWidth, traceHeight));+ }+ pass.setPipeline(presentPipeline);+ pass.setBindGroup(0, sets[set].present);+ pass.dispatchWorkgroups(...groupsFor(outputWidth, outputHeight));+ },+ dispose() {+ cleanup.release();+ },+ };+ } catch (error) {+ cleanup.release();+ throw error;+ }}diff --git a/tests/path-tracer-realtime-webgpu-pass-cleanup.test.js b/tests/path-tracer-realtime-webgpu-pass-cleanup.test.jsnew file mode 100644index 00000000..e41c4d48--- /dev/null+++ b/tests/path-tracer-realtime-webgpu-pass-cleanup.test.js@@ -0,0 +1,65 @@+import test from 'node:test';+import assert from 'node:assert/strict';++import { createWebGpuRadianceCache, createWebGpuDenoiser } from '../src/path-tracer-realtime-webgpu-passes.js';++globalThis.GPUBufferUsage = { STORAGE: 16, UNIFORM: 8, COPY_DST: 4, COPY_SRC: 2 };++// A device that counts the buffers a pass makes, and fails the call at a chosen position as a real one does on a large allocation.+function countingDevice({ failBufferAt = Infinity, failBindGroupAt = Infinity } = {}) {+ const buffers = [];+ let bufferCalls = 0;+ let bindGroupCalls = 0;+ return {+ buffers,+ live: () => buffers.filter(buffer => !buffer.destroyed),+ createBuffer(descriptor) {+ if (++bufferCalls === failBufferAt) throw new RangeError(`buffer ${descriptor.label} is too large`);+ const buffer = { label: descriptor.label, size: descriptor.size, destroyed: false, destroy() { this.destroyed = true; } };+ buffers.push(buffer);+ return buffer;+ },+ createShaderModule: () => ({ async getCompilationInfo() { return { messages: [] }; } }),+ createComputePipelineAsync: async () => ({ getBindGroupLayout: () => ({}) }),+ createBindGroup() {+ if (++bindGroupCalls === failBindGroupAt) throw new RangeError('bind group too large');+ return {};+ },+ queue: { writeBuffer() {} },+ };+}++const denoiserOptions = {+ traceWidth: 8, traceHeight: 8, outputWidth: 8, outputHeight: 8, filterIterations: 2,+ tracedBuffers: [{ label: 'traced 0' }, { label: 'traced 1' }], motionBuffer: { label: 'motion' },+};++test('a failed radiance cache setup destroys the buffers it made (#2628)', async () => {+ const device = countingDevice({ failBufferAt: 2 });+ await assert.rejects(createWebGpuRadianceCache(device), /too large/);+ assert.equal(device.buffers.length, 1);+ assert.deepEqual(device.live(), []);+});++test('a failed denoiser buffer destroys the ones made before it (#2628)', async () => {+ const device = countingDevice({ failBufferAt: 4 });+ await assert.rejects(createWebGpuDenoiser(device, denoiserOptions), /too large/);+ assert.equal(device.buffers.length, 3);+ assert.deepEqual(device.live(), []);+});++test('a failed denoiser bind group destroys every buffer the pass made (#2628)', async () => {+ const device = countingDevice({ failBindGroupAt: 1 });+ await assert.rejects(createWebGpuDenoiser(device, denoiserOptions), /bind group too large/);+ assert.ok(device.buffers.length > 0);+ assert.deepEqual(device.live(), []);+});++test('a denoiser that sets up keeps its buffers until dispose (#2628)', async () => {+ const device = countingDevice();+ const denoiser = await createWebGpuDenoiser(device, denoiserOptions);+ assert.equal(denoiser.rowWords, 64);+ assert.equal(device.live().length, device.buffers.length);+ denoiser.dispose();+ assert.deepEqual(device.live(), []);+});