Add immediate size validation cases for pipeline creation

src/webgpu/api/validation/compute_pipeline.spec.ts

@@ -7,6 +7,8 @@ Note: entry point matching tests are in shader_module/entry_point.spec.ts
 import { AllFeaturesMaxLimitsGPUTest } from '../.././gpu_test.js';
 import { makeTestGroup } from '../../../common/framework/test_group.js';
 import { keysOf } from '../../../common/util/data_tables.js';
+import { getGPU } from '../../../common/util/navigator_gpu.js';
+import { supportsImmediateData } from '../../../common/util/util.js';
 import {
   isTextureFormatUsableWithStorageAccessMode,
   kPossibleStorageTextureFormats,
@@ -811,3 +813,74 @@ generates a validation error at createComputePipeline(Async)
     };
     vtu.doCreateComputePipelineTest(t, isAsync, success, descriptor);
   });
+
+g.test('pipeline_creation_immediate_size_mismatch')
+  .desc(
+    `
+    Validate that creating a pipeline fails if the shader uses immediate data
+    larger than the immediateSize specified in the pipeline layout, or larger than
+    maxImmediateSize if layout is 'auto'.
+    Also validates that using less or equal size is allowed.
+    `
+  )
+  .params(u => {
+    const kNumericCases = [
+      { shaderSize: 16, layoutSize: 16 }, // Equal
+      { shaderSize: 12, layoutSize: 16 }, // Shader smaller
+      { shaderSize: 20, layoutSize: 16 }, // Shader larger (small diff)
+      { shaderSize: 32, layoutSize: 16 }, // Shader larger
+    ] as const;
+    const kMaxLimitsCases = [
+      { shaderSize: 'max', layoutSize: 'auto' }, // Shader equal to limit (auto layout)
+      { shaderSize: 'max+4', layoutSize: 'auto' }, // Shader larger than limit (auto layout)
+    ] as const;
+    return u
+      .combine('isAsync', [true, false])
+      .combineWithParams([...kNumericCases, ...kMaxLimitsCases] as const);
+  })
+  .fn(t => {
+    t.skipIf(!supportsImmediateData(getGPU(t.rec)), 'Immediate data not supported');
+
+    const { isAsync, shaderSize, layoutSize } = t.params;
+
+    const maxImmediateSize = t.device.limits.maxImmediateSize!;
+
+    let actualLayout: GPUPipelineLayout | 'auto';
+    let validSize: number;
+
+    if (layoutSize === 'auto') {
+      actualLayout = 'auto';
+      // checked above
+      validSize = maxImmediateSize!;
+    } else {
+      actualLayout = t.device.createPipelineLayout({
+        bindGroupLayouts: [],
+        immediateSize: layoutSize as number,
+      });
+      validSize = layoutSize as number;
+    }
+
+    let actualShaderSize: number;
+    if (shaderSize === 'max') {
+      actualShaderSize = validSize;
+    } else if (shaderSize === 'max+4') {
+      actualShaderSize = validSize + 4;
+    } else {
+      actualShaderSize = shaderSize as number;
+    }
+
+    const code = `
+      var<immediate> data: array<u32, ${actualShaderSize / 4}>;
+      fn use() { _ = data[0]; }
+      @compute @workgroup_size(1) fn main_compute() { use(); }
+    `;
+
+    const shouldError = actualShaderSize > validSize;
+
+    vtu.doCreateComputePipelineTest(t, isAsync, !shouldError, {
+      layout: actualLayout,
+      compute: {
+        module: t.device.createShaderModule({ code }),
+      },
+    });
+  });

src/webgpu/api/validation/render_pipeline/misc.spec.ts

@@ -3,6 +3,8 @@ misc createRenderPipeline and createRenderPipelineAsync validation tests.
 `;
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
+import { getGPU } from '../../../../common/util/navigator_gpu.js';
+import { supportsImmediateData } from '../../../../common/util/util.js';
 import {
   isTextureFormatUsableWithStorageAccessMode,
   kPossibleStorageTextureFormats,
@@ -119,8 +121,10 @@ g.test('pipeline_layout,device_mismatch')
   });
 
 g.test('external_texture')
-  .desc('Tests createRenderPipeline() with an external_texture')
+  .desc('Tests createRenderPipeline(Async) with an external_texture')
+  .params(u => u.combine('isAsync', [false, true]))
   .fn(t => {
+    const { isAsync } = t.params;
     const shader = t.device.createShaderModule({
       code: `
         @vertex
@@ -149,7 +153,7 @@ g.test('external_texture')
       },
     };
 
-    vtu.doCreateRenderPipelineTest(t, false, true, descriptor);
+    vtu.doCreateRenderPipelineTest(t, isAsync, true, descriptor);
   });
 
 g.test('storage_texture,format')
@@ -192,3 +196,84 @@ generates a validation error at createComputePipeline(Async)
     };
     vtu.doCreateRenderPipelineTest(t, isAsync, success, descriptor);
   });
+
+g.test('pipeline_creation_immediate_size_mismatch')
+  .desc(
+    `
+    Validate that creating a pipeline fails if the shader uses immediate data
+    larger than the immediateSize specified in the pipeline layout, or larger than
+    maxImmediateSize if layout is 'auto'.
+    Also validates that using less or equal size is allowed.
+    `
+  )
+  .params(u => {
+    const kNumericCases = [
+      { vertexSize: 16, fragmentSize: 16, layoutSize: 16 }, // Equal
+      { vertexSize: 12, fragmentSize: 12, layoutSize: 16 }, // Shader smaller
+      { vertexSize: 20, fragmentSize: 20, layoutSize: 16 }, // Shader larger (small diff)
+      { vertexSize: 32, fragmentSize: 32, layoutSize: 16 }, // Shader larger
+    ] as const;
+    const kMaxLimitsCases = [
+      { vertexSize: 'max', fragmentSize: 0, layoutSize: 'auto' }, // Vertex = Limit (Control)
+      { vertexSize: 0, fragmentSize: 'max', layoutSize: 'auto' }, // Fragment = Limit (Control)
+      { vertexSize: 'max', fragmentSize: 'max', layoutSize: 'auto' }, // Both at Limit (Control)
+      { vertexSize: 'max+4', fragmentSize: 0, layoutSize: 'auto' }, // Vertex > Limit
+      { vertexSize: 0, fragmentSize: 'max+4', layoutSize: 'auto' }, // Fragment > Limit
+    ] as const;
+    return u
+      .combine('isAsync', [true, false])
+      .combineWithParams([...kNumericCases, ...kMaxLimitsCases] as const);
+  })
+  .fn(t => {
+    t.skipIf(!supportsImmediateData(getGPU(t.rec)), 'Immediate data not supported');
+
+    const { isAsync, vertexSize, fragmentSize, layoutSize } = t.params;
+
+    const maxImmediateSize = t.device.limits.maxImmediateSize!;
+
+    const resolveSize = (sizeDescriptor: number | string) => {
+      if (typeof sizeDescriptor === 'number') return sizeDescriptor;
+      if (sizeDescriptor === 'max') return maxImmediateSize;
+      if (sizeDescriptor === 'max+4') return maxImmediateSize + 4;
+      return 0;
+    };
+
+    const resolvedVertexImmediateSize = resolveSize(vertexSize);
+    const resolvedFragmentImmediateSize = resolveSize(fragmentSize);
+    const varSize = Math.max(resolvedVertexImmediateSize, resolvedFragmentImmediateSize);
+
+    const code = `
+      var<immediate> data: array<u32, ${varSize / 4}>;
+      fn use_v() { ${resolvedVertexImmediateSize > 0 ? '_ = data[0];' : ''} }
+      fn use_f() { ${resolvedFragmentImmediateSize > 0 ? '_ = data[0];' : ''} }
+      @vertex fn main_vertex() -> @builtin(position) vec4<f32> { use_v(); return vec4<f32>(0.0, 0.0, 0.0, 1.0); }
+      @fragment fn main_fragment() -> @location(0) vec4<f32> { use_f(); return vec4<f32>(0.0, 1.0, 0.0, 1.0); }
+    `;
+
+    let layout: GPUPipelineLayout | 'auto';
+    let validSize: number;
+
+    if (layoutSize === 'auto') {
+      layout = 'auto';
+      validSize = maxImmediateSize;
+    } else {
+      layout = t.device.createPipelineLayout({
+        bindGroupLayouts: [],
+        immediateSize: layoutSize as number,
+      });
+      validSize = layoutSize as number;
+    }
+
+    const shouldError = varSize > validSize;
+
+    vtu.doCreateRenderPipelineTest(t, isAsync, !shouldError, {
+      layout,
+      vertex: {
+        module: t.device.createShaderModule({ code }),
+      },
+      fragment: {
+        module: t.device.createShaderModule({ code }),
+        targets: [{ format: 'rgba8unorm' }],
+      },
+    });
+  });