content / test / data / gpu / webgpu-unittest-utils.js [blame]

// 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.`]];
      }
    },
  };
}();