const_array_elements limit test: split into MAX, MAX/8, MAX/64 cases (#4497)

The MAX const array size is 2047.

The driver compiler can take a long time compiling the MAX case.
For example a laptop with an Intel Gen12 LP GPU with the Mesa
driver can take 28s to compile the shader.  This exceeds Chrome's GPU
watchdog timeout (10s) and the test will fail.

Instead of completely disabling the test, split it into cases
for MAX, MAX/8, and MAX/64 elements.  This lets us skip the very
largest cases, but still attempt smaller bug significant array
sizes. That lets us get some signal that the large-ish const
arrays are viable.

The additional runtime for the new cases are insignificant
compared to the full case.

Fixed: #4496

Author: dneto0

src/webgpu/shader/execution/limits.spec.ts

@@ -412,11 +412,22 @@ g.test('workgroup_array_byte_size_override')
 
 g.test('const_array_elements')
   .desc(`Test that constant array expressions with the maximum number of elements are supported.`)
+  .params(
+    u =>
+      // Some backend shader compilers take too long to compile the maximum
+      // size. In that case the browser GPU process can time out.  The WGSL
+      // spec allows this as an 'uncategorized error'.
+      // To get some useful signal from this test, also check a const array
+      // with a significant size even though it may not be the maximum supported
+      // size listed in the spec.
+      u.combine('sizeDivisor', [64, 8, 1]) // Must include 1, to test largest size.
+  )
   .fn(t => {
-    const type = `array<u32, ${kMaxConstArrayElements}>`;
+    const elementCount = Math.ceil(kMaxConstArrayElements / t.params.sizeDivisor);
+    const type = `array<u32, ${elementCount}>`;
 
     let expr = `${type}(`;
-    for (let i = 0; i < kMaxConstArrayElements; i++) {
+    for (let i = 0; i < elementCount; i++) {
       expr += `${i}, `;
     }
     expr += `)`;
@@ -430,10 +441,5 @@ g.test('const_array_elements')
     }
     `;
 
-    runShaderTest(
-      t,
-      code,
-      new Uint32Array([...iterRange(kMaxConstArrayElements, _i => 0xdeadbeef)]),
-      i => i
-    );
+    runShaderTest(t, code, new Uint32Array([...iterRange(elementCount, _i => 0xdeadbeef)]), i => i);
   });