Updates max*BufferBindingSize limit tests to adhere to maxBufferSize (#2339)

Author: lokokung

src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts

@@ -4,9 +4,10 @@ import { align, roundDown } from '../../../../util/math.js';
 import {
   kMaximumLimitBaseParams,
   makeLimitTestGroup,
+  LimitMode,
+  getDefaultLimit,
   MaximumLimitValueTest,
   MaximumTestValue,
-  kMaximumLimitValueTestKeys,
 } from './limit_utils.js';
 
 const BufferParts = {
@@ -28,6 +29,9 @@ function getSizeAndOffsetForBufferPart(device: GPUDevice, bufferPart: BufferPart
 
 const kStorageBufferRequiredSizeAlignment = 4;
 
+// We also need to update the maxBufferSize limit when testing.
+const kExtraLimits = { maxBufferSize: 'maxLimit' as LimitMode };
+
 function getDeviceLimitToRequest(
   limitValueTest: MaximumLimitValueTest,
   defaultLimit: number,
@@ -104,6 +108,13 @@ g.test('createBindGroup,at_over')
         });
 
         const { size, offset } = getSizeAndOffsetForBufferPart(device, bufferPart, testValue);
+
+        // If the size of the buffer exceeds the related but separate maxBufferSize limit, we can
+        // skip the validation since the allocation will fail with a validation error.
+        if (size > device.limits.maxBufferSize) {
+          return;
+        }
+
         device.pushErrorScope('out-of-memory');
         const storageBuffer = t.trackForCleanup(
           device.createBuffer({
@@ -134,19 +145,15 @@ g.test('createBindGroup,at_over')
             `size: ${size}, offset: ${offset}, testValue: ${testValue}`
           );
         }
-      }
+      },
+      kExtraLimits
     );
   });
 
 g.test('validate,maxBufferSize')
   .desc(`Test that ${limit} <= maxBufferSize`)
-  .params(u => u.combine('limitTest', kMaximumLimitValueTestKeys))
-  .fn(async t => {
-    const { limitTest } = t.params;
-    const { defaultLimit, adapterLimit: maximumLimit } = t;
-    const requestedLimit = getDeviceLimitToRequest(limitTest, defaultLimit, maximumLimit);
-
-    await t.testDeviceWithSpecificLimits(requestedLimit, 0, ({ device, actualLimit }) => {
-      t.expect(actualLimit <= device.limits.maxBufferSize);
-    });
+  .fn(t => {
+    const { adapter, defaultLimit, adapterLimit } = t;
+    t.expect(defaultLimit <= getDefaultLimit('maxBufferSize'));
+    t.expect(adapterLimit <= adapter.limits.maxBufferSize);
   });

src/webgpu/api/validation/capability_checks/limits/maxUniformBufferBindingSize.spec.ts

@@ -1,8 +1,9 @@
 import { keysOf } from '../../../../../common/util/data_tables.js';
 
 import {
+  LimitMode,
+  getDefaultLimit,
   kMaximumLimitBaseParams,
-  kMaximumLimitValueTestKeys,
   makeLimitTestGroup,
 } from './limit_utils.js';
 
@@ -26,6 +27,9 @@ function getSizeAndOffsetForBufferPart(device: GPUDevice, bufferPart: BufferPart
 const limit = 'maxUniformBufferBindingSize';
 export const { g, description } = makeLimitTestGroup(limit);
 
+// We also need to update the maxBufferSize limit when testing.
+const kExtraLimits = { maxBufferSize: 'maxLimit' as LimitMode };
+
 g.test('createBindGroup,at_over')
   .desc(`Test using at and over ${limit} limit`)
   .params(kMaximumLimitBaseParams.combine('bufferPart', kBufferPartsKeys))
@@ -46,6 +50,13 @@ g.test('createBindGroup,at_over')
         });
 
         const { size, offset } = getSizeAndOffsetForBufferPart(device, bufferPart, testValue);
+
+        // If the size of the buffer exceeds the related but separate maxBufferSize limit, we can
+        // skip the validation since the allocation will fail with a validation error.
+        if (size > device.limits.maxBufferSize) {
+          return;
+        }
+
         device.pushErrorScope('out-of-memory');
         const uniformBuffer = t.trackForCleanup(
           device.createBuffer({
@@ -56,36 +67,35 @@ g.test('createBindGroup,at_over')
         const outOfMemoryError = await device.popErrorScope();
 
         if (!outOfMemoryError) {
-          await t.expectValidationError(() => {
-            device.createBindGroup({
-              layout: bindGroupLayout,
-              entries: [
-                {
-                  binding: 0,
-                  resource: {
-                    buffer: uniformBuffer,
-                    offset,
-                    size: testValue,
+          await t.expectValidationError(
+            () => {
+              device.createBindGroup({
+                layout: bindGroupLayout,
+                entries: [
+                  {
+                    binding: 0,
+                    resource: {
+                      buffer: uniformBuffer,
+                      offset,
+                      size: testValue,
+                    },
                   },
-                },
-              ],
-            });
-          }, shouldError);
+                ],
+              });
+            },
+            shouldError,
+            `size: ${size}, offset: ${offset}, testValue: ${testValue}`
+          );
         }
-      }
+      },
+      kExtraLimits
     );
   });
 
 g.test('validate,maxBufferSize')
   .desc(`Test that ${limit} <= maxBufferSize`)
-  .params(u => u.combine('limitTest', kMaximumLimitValueTestKeys))
-  .fn(async t => {
-    const { limitTest } = t.params;
-    await t.testDeviceWithRequestedMaximumLimits(
-      limitTest,
-      'atLimit',
-      ({ device, actualLimit }) => {
-        t.expect(actualLimit <= device.limits.maxBufferSize);
-      }
-    );
+  .fn(t => {
+    const { adapter, defaultLimit, adapterLimit } = t;
+    t.expect(defaultLimit <= getDefaultLimit('maxBufferSize'));
+    t.expect(adapterLimit <= adapter.limits.maxBufferSize);
   });