content/test/data/gpu/webgpu-unittest-utils.js - codesearch/chromium/src - Git at Google

 // Copyright 2022 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 // Test "enum" allows for specifying tests in webGpuUnitTests below.
 const WebGpuUnitTestId = {
   RenderTest: 'render-test',
   RenderTestAsync: 'render-test-async',
   ComputeTest: 'compute-test',
   ComputeTestAsync: 'compute-test-async',
 };

 // Implements a set of simple standalone unit tests to test WebGPU without
 // depending on the canvas. Each test returns a pair consisting of a bool
 // indicating whether the test passed (true) or failed (false), and a
 // potentially empty array of messages detailing why the test may have
 // failed.
 export const webGpuUnitTests = function() {
   //////////////////////////////////////////////////////////////////////////////
   // Private internal helpers

   // Initializes the adapter and devices for webgpu usage.
   const init = async function() {
     const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
     if (!adapter) {
       console.error('navigator.gpu && navigator.gpu.requestAdapter failed');
       return [
         null,
         null,
         ['WebGPU was unavailable and/or requesting adapter failed.']
       ];
     }
     const device = await adapter.requestDevice();
     if (!device) {
       console.error('adapter.requestDevice() failed');
       return [
         adapter,
         null,
         ['Failed to request a WebGPU device.']
       ];
     }
     return [adapter, device];
   };

   // Compares an actual array (a) to an expected one (e), returning [true, []]
   // iff the type and contents of the arrays are equal, otherwise returning
   // [false, [description]].
   const compareArrays = function(e, a) {
     if (e.constructor !== a.constructor) {
       return [
         false,
         [`Expected type '${e.constructor.name}', got '${a.constructor.name}'.`]
       ];
     }
     if (e.length !== a.length) {
       return [
         false,
         [`Expected length ${e.length}, got ${a.length}.`]
       ];
     }
     var equal = true;
     for (var i = 0; i !== e.length; i++) {
       if (e[i] != a[i]) {
         success = equal;
       }
     }
     return equal ?
         [true, []] :
         [false, [`Expected [${e.toString()}], got [${a.toString()}].`]];
   }

   // Render test base which allows for specifying whether to use async pipeline
   // creation. Renders a single pixel texture, copies it to a buffer, and
   // verifies.
   const renderTestBase = async function(useAsync) {
     const [adapter, device, errors] = await init();
     if (!adapter || !device) {
       return [false, errors];
     }

     // Create the WebGPU primitives and execute the rendering and buffer copy.
     const buffer = device.createBuffer({
       size: 4,
       usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
     });
     const texture = device.createTexture({
       format: 'rgba8unorm',
       size: { width: 1, height: 1 },
       usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
     });
     const view = texture.createView();
     const pipelineDesc = {
       layout: 'auto',
       vertex: {
         module: device.createShaderModule({
           code: `
             @vertex fn main(
               @builtin(vertex_index) VertexIndex : u32
               ) -> @builtin(position) vec4<f32> {
                 var pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>(
                     vec2<f32>(-1.0, -3.0),
                     vec2<f32>(3.0, 1.0),
                     vec2<f32>(-1.0, 1.0));
                 return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
               }
               `,
         }),
         entryPoint: 'main',
       },
       fragment: {
         module: device.createShaderModule({
           code: `
               @fragment fn main() -> @location(0) vec4<f32> {
                 return vec4<f32>(0.0, 1.0, 0.0, 1.0);
               }
               `,
         }),
         entryPoint: 'main',
         targets: [{ format: 'rgba8unorm' }],
       },
       primitive: { topology: 'triangle-list' },
     };
     const pipeline = useAsync
           ? await device.createRenderPipelineAsync(pipelineDesc)
           : device.createRenderPipeline(pipelineDesc);
     const encoder = device.createCommandEncoder();
     const pass = encoder.beginRenderPass({
       colorAttachments: [
         {
           view,
           storeOp: 'store',
           clearValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 },
           loadOp: 'clear',
         },
       ],
     });
     pass.setPipeline(pipeline);
     pass.draw(3);
     pass.end();
     encoder.copyTextureToBuffer(
         { texture, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
         { buffer, bytesPerRow: 256 },
         { width: 1, height: 1, depthOrArrayLayers: 1 }
     );
     device.queue.submit([encoder.finish()]);

     // Verify the contents of the buffer that the texture was copied into.
     var success = true;
     const expected = new Uint8Array([0x00, 0xff, 0x00, 0xff]);
     await buffer.mapAsync(GPUMapMode.READ);
     const actual = new Uint8Array(buffer.getMappedRange());
     return compareArrays(expected, actual);
   };

   // Compute test base which allows for specifying whether to use async pipeline
   // creation. Fills a buffer with global_invocation_id.x and verifies the
   // contents of the buffer.
   const computeTestBase = async function(useAsync) {
     const [adapter, device, errors] = await init();
     if (!adapter || !device) {
       return [false, errors];
     }

     // Test constants.
     const n = 16;
     const size = n * 4;

     // Create the WebGPU primitives and execute the compute and buffer copy.
     const pipelineDesc = {
       layout: 'auto',
       compute: {
         module: device.createShaderModule({
           code: `
             @group(0) @binding(0) var<storage, read_write> buffer: array<u32>;

             @compute @workgroup_size(1u) fn main(
               @builtin(global_invocation_id) id: vec3<u32>
             ) {
               buffer[id.x] = id.x;
             }
             `,
         }),
         entryPoint: 'main',
       },
     };
     const pipeline = useAsync
           ? await device.createComputePipelineAsync(pipelineDesc)
           : device.createComputePipeline(pipelineDesc);
     const buffer = device.createBuffer({
       size,
       usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
     });
     const result = device.createBuffer({
       size,
       usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
     });
     const bindGroup = device.createBindGroup({
       layout: pipeline.getBindGroupLayout(0),
       entries: [{ binding: 0, resource: { buffer } }],
     });
     const encoder = device.createCommandEncoder();
     const pass = encoder.beginComputePass();
     pass.setPipeline(pipeline);
     pass.setBindGroup(0, bindGroup);
     pass.dispatchWorkgroups(n);
     pass.end();
     encoder.copyBufferToBuffer(buffer, 0, result, 0, size);
     device.queue.submit([encoder.finish()]);

     // Verify the contents of the buffer that was copied into.
     var success = true;
     const expected = new Uint32Array([...Array(n).keys()]);
     await result.mapAsync(GPUMapMode.READ);
     const actual = new Uint32Array(result.getMappedRange());
     return compareArrays(expected, actual);
   };

   return {
     ////////////////////////////////////////////////////////////////////////////
     // Actual unit tests

     renderTest: async function() {
       return await renderTestBase(false);
     },
     renderTestAsync: async function() {
       return await renderTestBase(true);
     },
     computeTest: async function() {
       return await computeTestBase(false);
     },
     computeTestAsync: async function() {
       return await computeTestBase(true);
     },

     ////////////////////////////////////////////////////////////////////////////
     // Test driver
     runTest: async function(testId) {
       // Test running wrapper to prefix error messages with test name.
       const wrapper = async function(testId, testFunc) {
         const [success, errors] = await testFunc();
         if (success) {
           return [true, []];
         }
         return [
           false,
           [`WebGPU test '${testId}' failed with the following errors:`] +
               errors.map(function(e) { return '    ' + e; })];
       };

       switch (testId) {
         case WebGpuUnitTestId.RenderTest:
           return await wrapper(testId, this.renderTest);
           break;
         case WebGpuUnitTestId.RenderTestAsync:
           return await wrapper(testId, this.renderTestAsync);
           break;
         case WebGpuUnitTestId.ComputeTest:
           return await wrapper(testId, this.computeTest);
           break;
         case WebGpuUnitTestId.ComputeTestAsync:
           return await wrapper(testId, this.computeTestAsync);
           break;
         default:
           // Just fail for any undefined tests.
           return [false, [`Undefined WebGPU test '${testId}' specified.`]];
       }
     },
   };
 }();
	// Copyright 2022 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	// Test "enum" allows for specifying tests in webGpuUnitTests below.
	const WebGpuUnitTestId = {
	RenderTest: 'render-test',
	RenderTestAsync: 'render-test-async',
	ComputeTest: 'compute-test',
	ComputeTestAsync: 'compute-test-async',
	};

	// Implements a set of simple standalone unit tests to test WebGPU without
	// depending on the canvas. Each test returns a pair consisting of a bool
	// indicating whether the test passed (true) or failed (false), and a
	// potentially empty array of messages detailing why the test may have
	// failed.
	export const webGpuUnitTests = function() {
	//////////////////////////////////////////////////////////////////////////////
	// Private internal helpers

	// Initializes the adapter and devices for webgpu usage.
	const init = async function() {
	const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
	if (!adapter) {
	console.error('navigator.gpu && navigator.gpu.requestAdapter failed');
	return [
	null,
	null,
	['WebGPU was unavailable and/or requesting adapter failed.']
	];
	}
	const device = await adapter.requestDevice();
	if (!device) {
	console.error('adapter.requestDevice() failed');
	return [
	adapter,
	null,
	['Failed to request a WebGPU device.']
	];
	}
	return [adapter, device];
	};

	// Compares an actual array (a) to an expected one (e), returning [true, []]
	// iff the type and contents of the arrays are equal, otherwise returning
	// [false, [description]].
	const compareArrays = function(e, a) {
	if (e.constructor !== a.constructor) {
	return [
	false,
	[`Expected type '${e.constructor.name}', got '${a.constructor.name}'.`]
	];
	}
	if (e.length !== a.length) {
	return [
	false,
	[`Expected length ${e.length}, got ${a.length}.`]
	];
	}
	var equal = true;
	for (var i = 0; i !== e.length; i++) {
	if (e[i] != a[i]) {
	success = equal;
	}
	}
	return equal ?
	[true, []] :
	[false, [`Expected [${e.toString()}], got [${a.toString()}].`]];
	}

	// Render test base which allows for specifying whether to use async pipeline
	// creation. Renders a single pixel texture, copies it to a buffer, and
	// verifies.
	const renderTestBase = async function(useAsync) {
	const [adapter, device, errors] = await init();
	if (!adapter \|\| !device) {
	return [false, errors];
	}

	// Create the WebGPU primitives and execute the rendering and buffer copy.
	const buffer = device.createBuffer({
	size: 4,
	usage: GPUBufferUsage.MAP_READ \| GPUBufferUsage.COPY_DST,
	});
	const texture = device.createTexture({
	format: 'rgba8unorm',
	size: { width: 1, height: 1 },
	usage: GPUTextureUsage.COPY_SRC \| GPUTextureUsage.RENDER_ATTACHMENT,
	});
	const view = texture.createView();
	const pipelineDesc = {
	layout: 'auto',
	vertex: {
	module: device.createShaderModule({
	code: `
	@vertex fn main(
	@builtin(vertex_index) VertexIndex : u32
	) -> @builtin(position) vec4<f32> {
	var pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>(
	vec2<f32>(-1.0, -3.0),
	vec2<f32>(3.0, 1.0),
	vec2<f32>(-1.0, 1.0));
	return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
	}
	`,
	}),
	entryPoint: 'main',
	},
	fragment: {
	module: device.createShaderModule({
	code: `
	@fragment fn main() -> @location(0) vec4<f32> {
	return vec4<f32>(0.0, 1.0, 0.0, 1.0);
	}
	`,
	}),
	entryPoint: 'main',
	targets: [{ format: 'rgba8unorm' }],
	},
	primitive: { topology: 'triangle-list' },
	};
	const pipeline = useAsync
	? await device.createRenderPipelineAsync(pipelineDesc)
	: device.createRenderPipeline(pipelineDesc);
	const encoder = device.createCommandEncoder();
	const pass = encoder.beginRenderPass({
	colorAttachments: [
	{
	view,
	storeOp: 'store',
	clearValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 },
	loadOp: 'clear',
	},
	],
	});
	pass.setPipeline(pipeline);
	pass.draw(3);
	pass.end();
	encoder.copyTextureToBuffer(
	{ texture, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
	{ buffer, bytesPerRow: 256 },
	{ width: 1, height: 1, depthOrArrayLayers: 1 }
	);
	device.queue.submit([encoder.finish()]);

	// Verify the contents of the buffer that the texture was copied into.
	var success = true;
	const expected = new Uint8Array([0x00, 0xff, 0x00, 0xff]);
	await buffer.mapAsync(GPUMapMode.READ);
	const actual = new Uint8Array(buffer.getMappedRange());
	return compareArrays(expected, actual);
	};

	// Compute test base which allows for specifying whether to use async pipeline
	// creation. Fills a buffer with global_invocation_id.x and verifies the
	// contents of the buffer.
	const computeTestBase = async function(useAsync) {
	const [adapter, device, errors] = await init();
	if (!adapter \|\| !device) {
	return [false, errors];
	}

	// Test constants.
	const n = 16;
	const size = n * 4;

	// Create the WebGPU primitives and execute the compute and buffer copy.
	const pipelineDesc = {
	layout: 'auto',
	compute: {
	module: device.createShaderModule({
	code: `
	@group(0) @binding(0) var<storage, read_write> buffer: array<u32>;

	@compute @workgroup_size(1u) fn main(
	@builtin(global_invocation_id) id: vec3<u32>
	) {
	buffer[id.x] = id.x;
	}
	`,
	}),
	entryPoint: 'main',
	},
	};
	const pipeline = useAsync
	? await device.createComputePipelineAsync(pipelineDesc)
	: device.createComputePipeline(pipelineDesc);
	const buffer = device.createBuffer({
	size,
	usage: GPUBufferUsage.STORAGE \| GPUBufferUsage.COPY_SRC,
	});
	const result = device.createBuffer({
	size,
	usage: GPUBufferUsage.MAP_READ \| GPUBufferUsage.COPY_DST,
	});
	const bindGroup = device.createBindGroup({
	layout: pipeline.getBindGroupLayout(0),
	entries: [{ binding: 0, resource: { buffer } }],
	});
	const encoder = device.createCommandEncoder();
	const pass = encoder.beginComputePass();
	pass.setPipeline(pipeline);
	pass.setBindGroup(0, bindGroup);
	pass.dispatchWorkgroups(n);
	pass.end();
	encoder.copyBufferToBuffer(buffer, 0, result, 0, size);
	device.queue.submit([encoder.finish()]);

	// Verify the contents of the buffer that was copied into.
	var success = true;
	const expected = new Uint32Array([...Array(n).keys()]);
	await result.mapAsync(GPUMapMode.READ);
	const actual = new Uint32Array(result.getMappedRange());
	return compareArrays(expected, actual);
	};

	return {
	////////////////////////////////////////////////////////////////////////////
	// Actual unit tests

	renderTest: async function() {
	return await renderTestBase(false);
	},
	renderTestAsync: async function() {
	return await renderTestBase(true);
	},
	computeTest: async function() {
	return await computeTestBase(false);
	},
	computeTestAsync: async function() {
	return await computeTestBase(true);
	},

	////////////////////////////////////////////////////////////////////////////
	// Test driver
	runTest: async function(testId) {
	// Test running wrapper to prefix error messages with test name.
	const wrapper = async function(testId, testFunc) {
	const [success, errors] = await testFunc();
	if (success) {
	return [true, []];
	}
	return [
	false,
	[`WebGPU test '${testId}' failed with the following errors:`] +
	errors.map(function(e) { return ' ' + e; })];
	};

	switch (testId) {
	case WebGpuUnitTestId.RenderTest:
	return await wrapper(testId, this.renderTest);
	break;
	case WebGpuUnitTestId.RenderTestAsync:
	return await wrapper(testId, this.renderTestAsync);
	break;
	case WebGpuUnitTestId.ComputeTest:
	return await wrapper(testId, this.computeTest);
	break;
	case WebGpuUnitTestId.ComputeTestAsync:
	return await wrapper(testId, this.computeTestAsync);
	break;
	default:
	// Just fail for any undefined tests.
	return [false, [`Undefined WebGPU test '${testId}' specified.`]];
	}
	},
	};
	}();