From 3acbf58bd5c2d28fb84d953e65de7582fad28faa Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 22 Aug 2023 12:14:04 +0800
Subject: [PATCH 001/166] wgsl: f16 built-in execution test for bitcast (#2897)

This PR add execution tests for bitcast built-in from and to f16 types.

Issue: #1248, #1609
---
 .../expression/call/builtin/bitcast.spec.ts   | 973 +++++++++++++++---
 .../expression/call/builtin/builtin.ts        |  14 +-
 .../shader/execution/expression/expression.ts | 294 +++---
 3 files changed, 1033 insertions(+), 248 deletions(-)

diff --git a/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
index 5d635fbb6a0a..7269d0a1772f 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
@@ -20,34 +20,49 @@ T is i32, u32, f32
 
 import { TestParams } from '../../../../../../common/framework/fixture.js';
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
+import { assert } from '../../../../../../common/util/util.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { Comparator, alwaysPass, anyOf } from '../../../../../util/compare.js';
 import { kBit, kValue } from '../../../../../util/constants.js';
 import {
   reinterpretI32AsF32,
+  reinterpretI32AsU32,
   reinterpretF32AsI32,
   reinterpretF32AsU32,
   reinterpretU32AsF32,
   reinterpretU32AsI32,
+  reinterpretU16AsF16,
+  reinterpretF16AsU16,
   f32,
   i32,
   u32,
-  Type,
+  f16,
   TypeF32,
   TypeI32,
   TypeU32,
+  TypeF16,
+  TypeVec,
+  Vector,
+  Scalar,
+  toVector,
 } from '../../../../../util/conversion.js';
+import { FPInterval, FP } from '../../../../../util/floating_point.js';
 import {
   fullF32Range,
   fullI32Range,
   fullU32Range,
+  fullF16Range,
   linearRange,
   isSubnormalNumberF32,
+  isSubnormalNumberF16,
+  cartesianProduct,
+  isFiniteF32,
+  isFiniteF16,
 } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run, CaseList, InputSource, ShaderBuilder } from '../../expression.js';
+import { allInputSources, run, ShaderBuilder } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { builtinWithPredeclaration } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -71,44 +86,197 @@ const f32InfAndNaNInI32 = f32InfAndNaNInU32.map(u => reinterpretU32AsI32(u));
 const f32ZerosInU32 = [0, kBit.f32.negative.zero];
 const f32ZerosInF32 = f32ZerosInU32.map(u => reinterpretU32AsF32(u));
 const f32ZerosInI32 = f32ZerosInU32.map(u => reinterpretU32AsI32(u));
+const f32ZerosInterval: FPInterval = new FPInterval('f32', -0.0, 0.0);
 
 // f32FiniteRange is a list of finite f32s. fullF32Range() already
 // has +0, we only need to add -0.
 const f32FiniteRange: number[] = [...fullF32Range(), kValue.f32.negative.zero];
 const f32RangeWithInfAndNaN: number[] = [...f32FiniteRange, ...f32InfAndNaNInF32];
 
+// F16 values, finite, Inf/NaN, and zeros. Represented in float and u16.
+const f16FiniteInF16: number[] = [...fullF16Range(), kValue.f16.negative.zero];
+const f16FiniteInU16: number[] = f16FiniteInF16.map(u => reinterpretF16AsU16(u));
+
+const f16InfAndNaNInU16: number[] = [
+  // Cover NaNs evenly in integer space.
+  // The positive NaN with the lowest integer representation is the integer
+  // for infinity, plus one.
+  // The positive NaN with the highest integer representation is u16 0x7fff i.e. 32767.
+  ...linearRange(kBit.f16.infinity.positive + 1, 32767, numNaNs).map(v => Math.ceil(v)),
+  // The negative NaN with the lowest integer representation is the integer
+  // for negative infinity, plus one.
+  // The negative NaN with the highest integer representation is u16 0xffff i.e. 65535
+  ...linearRange(kBit.f16.infinity.negative + 1, 65535, numNaNs).map(v => Math.floor(v)),
+  kBit.f16.infinity.positive,
+  kBit.f16.infinity.negative,
+];
+const f16InfAndNaNInF16 = f16InfAndNaNInU16.map(u => reinterpretU16AsF16(u));
+
+const f16ZerosInU16 = [kBit.f16.negative.zero, 0];
+
+// f16 interval that match +/-0.0.
+const f16ZerosInterval: FPInterval = new FPInterval('f16', -0.0, 0.0);
+
+/**
+ * @returns an u32 whose lower and higher 16bits are the two elements of the
+ * given array of two u16 respectively, in little-endian.
+ */
+function u16x2ToU32(u16x2: number[]): number {
+  assert(u16x2.length === 2);
+  // Create a DataView with 4 bytes buffer.
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  // Enforce little-endian.
+  view.setUint16(0, u16x2[0], true);
+  view.setUint16(2, u16x2[1], true);
+  return view.getUint32(0, true);
+}
+
+/**
+ * @returns an array of two u16, respectively the lower and higher 16bits of
+ * given u32 in little-endian.
+ */
+function u32ToU16x2(u32: number): number[] {
+  // Create a DataView with 4 bytes buffer.
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  // Enforce little-endian.
+  view.setUint32(0, u32, true);
+  return [view.getUint16(0, true), view.getUint16(2, true)];
+}
+
+/**
+ * @returns a vec2<f16> from an array of two u16, each reinterpreted as f16.
+ */
+function u16x2ToVec2F16(u16x2: number[]): Vector {
+  assert(u16x2.length === 2);
+  return toVector(u16x2.map(reinterpretU16AsF16), f16);
+}
+
+/**
+ * @returns a vec4<f16> from an array of four u16, each reinterpreted as f16.
+ */
+function u16x4ToVec4F16(u16x4: number[]): Vector {
+  assert(u16x4.length === 4);
+  return toVector(u16x4.map(reinterpretU16AsF16), f16);
+}
+
+/**
+ * @returns true if and only if a given u32 can bitcast to a vec2<f16> with all elements
+ * being finite f16 values.
+ */
+function canU32BitcastToFiniteVec2F16(u32: number): boolean {
+  return u32ToU16x2(u32)
+    .map(u16 => isFiniteF16(reinterpretU16AsF16(u16)))
+    .reduce((a, b) => a && b, true);
+}
+
+/**
+ * @returns an array of N elements with the i-th element being an array of len elements
+ * [a_i, a_((i+1)%N), ..., a_((i+len-1)%N)], for the input array of N element [a_1, ... a_N]
+ * and the given len. For example, slidingSlice([1, 2, 3], 2) result in
+ * [[1, 2], [2, 3], [3, 1]].
+ * This helper function is used for generating vector cases from scalar values array.
+ */
+function slidingSlice(input: number[], len: number) {
+  const result: number[][] = [];
+  for (let i = 0; i < input.length; i++) {
+    const sub: number[] = [];
+    for (let j = 0; j < len; j++) {
+      sub.push(input[(i + j) % input.length]);
+    }
+    result.push(sub);
+  }
+  return result;
+}
+
+// vec2<f16> interesting (zeros, Inf, and NaN) values for testing cases.
+// vec2<f16> values that has at least one Inf/NaN f16 element, reinterpreted as u32/i32.
+const f16Vec2InfAndNaNInU32 = [
+  ...cartesianProduct(f16InfAndNaNInU16, [...f16InfAndNaNInU16, ...f16FiniteInU16]),
+  ...cartesianProduct(f16FiniteInU16, f16InfAndNaNInU16),
+].map(u16x2ToU32);
+const f16Vec2InfAndNaNInI32 = f16Vec2InfAndNaNInU32.map(u => reinterpretU32AsI32(u));
+// vec2<f16> values with two f16 0.0 element, reinterpreted as u32/i32.
+const f16Vec2ZerosInU32 = cartesianProduct(f16ZerosInU16, f16ZerosInU16).map(u16x2ToU32);
+const f16Vec2ZerosInI32 = f16Vec2ZerosInU32.map(u => reinterpretU32AsI32(u));
+
+// i32/u32/f32 range for bitcasting to vec2<f16>
+// u32 values for bitcasting to vec2<f16> finite, Inf, and NaN.
+const u32RangeForF16Vec2FiniteInfNaN: number[] = [
+  ...fullU32Range(),
+  ...f16Vec2ZerosInU32,
+  ...f16Vec2InfAndNaNInU32,
+];
+// u32 values for bitcasting to finite only vec2<f16>, used for constant evaluation.
+const u32RangeForF16Vec2Finite: number[] = u32RangeForF16Vec2FiniteInfNaN.filter(
+  canU32BitcastToFiniteVec2F16
+);
+// i32 values for bitcasting to vec2<f16> finite, zeros, Inf, and NaN.
+const i32RangeForF16Vec2FiniteInfNaN: number[] = [
+  ...fullI32Range(),
+  ...f16Vec2ZerosInI32,
+  ...f16Vec2InfAndNaNInI32,
+];
+// i32 values for bitcasting to finite only vec2<f16>, used for constant evaluation.
+const i32RangeForF16Vec2Finite: number[] = i32RangeForF16Vec2FiniteInfNaN.filter(u =>
+  canU32BitcastToFiniteVec2F16(reinterpretI32AsU32(u))
+);
+// f32 values with finite/Inf/NaN f32, for bitcasting to vec2<f16> finite, zeros, Inf, and NaN.
+const f32RangeWithInfAndNaNForF16Vec2FiniteInfNaN: number[] = [
+  ...f32RangeWithInfAndNaN,
+  ...u32RangeForF16Vec2FiniteInfNaN.map(reinterpretU32AsF32),
+];
+// Finite f32 values for bitcasting to finite only vec2<f16>, used for constant evaluation.
+const f32FiniteRangeForF16Vec2Finite: number[] = f32RangeWithInfAndNaNForF16Vec2FiniteInfNaN
+  .filter(isFiniteF32)
+  .filter(u => canU32BitcastToFiniteVec2F16(reinterpretF32AsU32(u)));
+
+// vec2<f16> cases for bitcasting to i32/u32/f32, by combining f16 values into pairs
+const f16Vec2FiniteInU16x2 = slidingSlice(f16FiniteInU16, 2);
+const f16Vec2FiniteInfNanInU16x2 = slidingSlice([...f16FiniteInU16, ...f16InfAndNaNInU16], 2);
+// vec4<f16> cases for bitcasting to vec2<i32/u32/f32>, by combining f16 values 4-by-4
+const f16Vec2FiniteInU16x4 = slidingSlice(f16FiniteInU16, 4);
+const f16Vec2FiniteInfNanInU16x4 = slidingSlice([...f16FiniteInU16, ...f16InfAndNaNInU16], 4);
+
+// alwaysPass comparator for i32/u32/f32 cases. For f32/f16 we also use unbound interval, which
+// allow per-element unbounded expectation for vector.
 const anyF32 = alwaysPass('any f32');
 const anyI32 = alwaysPass('any i32');
 const anyU32 = alwaysPass('any u32');
 
-const i32RangeWithBitsForInfAndNaNAndZeros: number[] = [
+// Unbounded FPInterval
+const f32UnboundedInterval = FP.f32.constants().unboundedInterval;
+const f16UnboundedInterval = FP.f16.constants().unboundedInterval;
+
+// i32 and u32 cases for bitcasting to f32.
+// i32 cases for bitcasting to f32 finite, zeros, Inf, and NaN.
+const i32RangeForF32FiniteInfNaN: number[] = [
   ...fullI32Range(),
   ...f32ZerosInI32,
   ...f32InfAndNaNInI32,
 ];
-const i32RangeWithFiniteF32: number[] = i32RangeWithBitsForInfAndNaNAndZeros.filter(i =>
-  isFinite(reinterpretI32AsF32(i))
+// i32 cases for bitcasting to f32 finite only.
+const i32RangeForF32Finite: number[] = i32RangeForF32FiniteInfNaN.filter(i =>
+  isFiniteF32(reinterpretI32AsF32(i))
 );
-
-const u32RangeWithBitsForInfAndNaNAndZeros: number[] = [
+// u32 cases for bitcasting to f32 finite, zeros, Inf, and NaN.
+const u32RangeForF32FiniteInfNaN: number[] = [
   ...fullU32Range(),
   ...f32ZerosInU32,
   ...f32InfAndNaNInU32,
 ];
-const u32RangeWithFiniteF32: number[] = u32RangeWithBitsForInfAndNaNAndZeros.filter(u =>
-  isFinite(reinterpretU32AsF32(u))
+// u32 cases for bitcasting to f32 finite only.
+const u32RangeForF32Finite: number[] = u32RangeForF32FiniteInfNaN.filter(u =>
+  isFiniteF32(reinterpretU32AsF32(u))
 );
 
-function isFinite(f: number): boolean {
-  return !(Number.isNaN(f) || f === Number.POSITIVE_INFINITY || f === Number.NEGATIVE_INFINITY);
-}
-
 /**
  * @returns a Comparator for checking if a f32 value is a valid
  * bitcast conversion from f32.
  */
 function bitcastF32ToF32Comparator(f: number): Comparator {
-  if (!isFinite(f)) return anyF32;
+  if (!isFiniteF32(f)) return anyF32;
   const acceptable: number[] = [f, ...(isSubnormalNumberF32(f) ? f32ZerosInF32 : [])];
   return anyOf(...acceptable.map(f32));
 }
@@ -118,7 +286,7 @@ function bitcastF32ToF32Comparator(f: number): Comparator {
  * bitcast conversion from f32.
  */
 function bitcastF32ToU32Comparator(f: number): Comparator {
-  if (!isFinite(f)) return anyU32;
+  if (!isFiniteF32(f)) return anyU32;
   const acceptable: number[] = [
     reinterpretF32AsU32(f),
     ...(isSubnormalNumberF32(f) ? f32ZerosInU32 : []),
@@ -131,7 +299,7 @@ function bitcastF32ToU32Comparator(f: number): Comparator {
  * bitcast conversion from f32.
  */
 function bitcastF32ToI32Comparator(f: number): Comparator {
-  if (!isFinite(f)) return anyI32;
+  if (!isFiniteF32(f)) return anyI32;
   const acceptable: number[] = [
     reinterpretF32AsI32(f),
     ...(isSubnormalNumberF32(f) ? f32ZerosInI32 : []),
@@ -145,7 +313,7 @@ function bitcastF32ToI32Comparator(f: number): Comparator {
  */
 function bitcastI32ToF32Comparator(i: number): Comparator {
   const f: number = reinterpretI32AsF32(i);
-  if (!isFinite(f)) return anyI32;
+  if (!isFiniteF32(f)) return anyI32;
   // Positive or negative zero bit pattern map to any zero.
   if (f32ZerosInI32.includes(i)) return anyOf(...f32ZerosInF32.map(f32));
   const acceptable: number[] = [f, ...(isSubnormalNumberF32(f) ? f32ZerosInF32 : [])];
@@ -158,13 +326,320 @@ function bitcastI32ToF32Comparator(i: number): Comparator {
  */
 function bitcastU32ToF32Comparator(u: number): Comparator {
   const f: number = reinterpretU32AsF32(u);
-  if (!isFinite(f)) return anyU32;
+  if (!isFiniteF32(f)) return anyU32;
   // Positive or negative zero bit pattern map to any zero.
   if (f32ZerosInU32.includes(u)) return anyOf(...f32ZerosInF32.map(f32));
   const acceptable: number[] = [f, ...(isSubnormalNumberF32(f) ? f32ZerosInF32 : [])];
   return anyOf(...acceptable.map(f32));
 }
 
+/**
+ * @returns an array of expected f16 FPInterval for the given bitcasted f16 value, which may be
+ * subnormal, Inf, or NaN. Test cases that bitcasted to vector of f16 use this function to get
+ * per-element expectation and build vector expectation using cartesianProduct.
+ */
+function generateF16ExpectationIntervals(bitcastedF16Value: number): FPInterval[] {
+  // If the bitcasted f16 value is inf or nan, the result is unbounded
+  if (!isFiniteF16(bitcastedF16Value)) {
+    return [f16UnboundedInterval];
+  }
+  // If the casted f16 value is +/-0.0, the result can be one of both. Note that in JS -0.0 === 0.0.
+  if (bitcastedF16Value === 0.0) {
+    return [f16ZerosInterval];
+  }
+  const exactInterval = FP.f16.toInterval(bitcastedF16Value);
+  // If the casted f16 value is subnormal, it also may be flushed to +/-0.0.
+  return [exactInterval, ...(isSubnormalNumberF16(bitcastedF16Value) ? [f16ZerosInterval] : [])];
+}
+
+/**
+ * @returns a Comparator for checking if a f16 value is a valid
+ * bitcast conversion from f16.
+ */
+function bitcastF16ToF16Comparator(f: number): Comparator {
+  if (!isFiniteF16(f)) return anyOf(f16UnboundedInterval);
+  return anyOf(...generateF16ExpectationIntervals(f));
+}
+
+/**
+ * @returns a Comparator for checking if a vec2<f16> is a valid bitcast
+ * conversion from u32.
+ */
+function bitcastU32ToVec2F16Comparator(u: number): Comparator {
+  const bitcastedVec2F16InU16x2 = u32ToU16x2(u).map(reinterpretU16AsF16);
+  // Generate expection for vec2 f16 result, by generating expected intervals for each elements and
+  // then do cartesian product.
+  const expectedIntervalsCombination = cartesianProduct(
+    ...bitcastedVec2F16InU16x2.map(generateF16ExpectationIntervals)
+  );
+  return anyOf(...expectedIntervalsCombination);
+}
+
+/**
+ * @returns a Comparator for checking if a vec2<f16> value is a valid
+ * bitcast conversion from i32.
+ */
+function bitcastI32ToVec2F16Comparator(i: number): Comparator {
+  const bitcastedVec2F16InU16x2 = u32ToU16x2(reinterpretI32AsU32(i)).map(reinterpretU16AsF16);
+  // Generate expection for vec2 f16 result, by generating expected intervals for each elements and
+  // then do cartesian product.
+  const expectedIntervalsCombination = cartesianProduct(
+    ...bitcastedVec2F16InU16x2.map(generateF16ExpectationIntervals)
+  );
+  return anyOf(...expectedIntervalsCombination);
+}
+
+/**
+ * @returns a Comparator for checking if a vec2<f16> value is a valid
+ * bitcast conversion from f32.
+ */
+function bitcastF32ToVec2F16Comparator(f: number): Comparator {
+  // If input f32 is not finite, it can be evaluated to any value and thus any result f16 vec2 is
+  // possible.
+  if (!isFiniteF32(f)) {
+    return anyOf([f16UnboundedInterval, f16UnboundedInterval]);
+  }
+  const bitcastedVec2F16InU16x2 = u32ToU16x2(reinterpretF32AsU32(f)).map(reinterpretU16AsF16);
+  // Generate expection for vec2 f16 result, by generating expected intervals for each elements and
+  // then do cartesian product.
+  const expectedIntervalsCombination = cartesianProduct(
+    ...bitcastedVec2F16InU16x2.map(generateF16ExpectationIntervals)
+  );
+  return anyOf(...expectedIntervalsCombination);
+}
+
+/**
+ * @returns a Comparator for checking if a vec4<f16> is a valid
+ * bitcast conversion from vec2<u32>.
+ */
+function bitcastVec2U32ToVec4F16Comparator(u32x2: number[]): Comparator {
+  assert(u32x2.length === 2);
+  const bitcastedVec4F16InU16x4 = u32x2.flatMap(u32ToU16x2).map(reinterpretU16AsF16);
+  // Generate expection for vec4 f16 result, by generating expected intervals for each elements and
+  // then do cartesian product.
+  const expectedIntervalsCombination = cartesianProduct(
+    ...bitcastedVec4F16InU16x4.map(generateF16ExpectationIntervals)
+  );
+  return anyOf(...expectedIntervalsCombination);
+}
+
+/**
+ * @returns a Comparator for checking if a vec4<f16> is a valid
+ * bitcast conversion from vec2<i32>.
+ */
+function bitcastVec2I32ToVec4F16Comparator(i32x2: number[]): Comparator {
+  assert(i32x2.length === 2);
+  const bitcastedVec4F16InU16x4 = i32x2
+    .map(reinterpretI32AsU32)
+    .flatMap(u32ToU16x2)
+    .map(reinterpretU16AsF16);
+  // Generate expection for vec4 f16 result, by generating expected intervals for each elements and
+  // then do cartesian product.
+  const expectedIntervalsCombination = cartesianProduct(
+    ...bitcastedVec4F16InU16x4.map(generateF16ExpectationIntervals)
+  );
+  return anyOf(...expectedIntervalsCombination);
+}
+
+/**
+ * @returns a Comparator for checking if a vec4<f16> is a valid
+ * bitcast conversion from vec2<f32>.
+ */
+function bitcastVec2F32ToVec4F16Comparator(f32x2: number[]): Comparator {
+  assert(f32x2.length === 2);
+  const bitcastedVec4F16InU16x4 = f32x2
+    .map(reinterpretF32AsU32)
+    .flatMap(u32ToU16x2)
+    .map(reinterpretU16AsF16);
+  // Generate expection for vec4 f16 result, by generating expected intervals for each elements and
+  // then do cartesian product.
+  const expectedIntervalsCombination = cartesianProduct(
+    ...bitcastedVec4F16InU16x4.map(generateF16ExpectationIntervals)
+  );
+  return anyOf(...expectedIntervalsCombination);
+}
+
+// Structure that store the expectations of a single 32bit scalar/element bitcasted from two f16.
+interface ExpectionFor32BitsScalarFromF16x2 {
+  // possibleExpectations is Scalar array if the expectation is for i32/u32 and FPInterval array for
+  // f32. Note that if the expectation for i32/u32 is unbound, possibleExpectations is meaningless.
+  possibleExpectations: (Scalar | FPInterval)[];
+  isUnbounded: boolean;
+}
+
+/**
+ * @returns the array of possible 16bits, represented in u16, that bitcasted
+ * from a given finite f16 represented in u16, handling the possible subnormal
+ * flushing. Used to build up 32bits or larger results.
+ */
+function possibleBitsInU16FromFiniteF16InU16(f16InU16: number): number[] {
+  const h = reinterpretU16AsF16(f16InU16);
+  assert(isFiniteF16(h));
+  return [f16InU16, ...(isSubnormalNumberF16(h) ? f16ZerosInU16 : [])];
+}
+
+/**
+ * @returns the expectation for a single 32bit scalar bitcasted from given pair of
+ * f16, result in ExpectionFor32BitsScalarFromF16x2.
+ */
+function possible32BitScalarIntervalsFromF16x2(
+  f16x2InU16x2: number[],
+  type: 'i32' | 'u32' | 'f32'
+): ExpectionFor32BitsScalarFromF16x2 {
+  assert(f16x2InU16x2.length === 2);
+  let reinterpretFromU32: (x: number) => number;
+  let expectationsForValue: (x: number) => Scalar[] | FPInterval[];
+  let unboundedExpectations: FPInterval[] | Scalar[];
+  if (type === 'u32') {
+    reinterpretFromU32 = (x: number) => x;
+    expectationsForValue = x => [u32(x)];
+    // Scalar expectation can not express "unbounded" for i32 and u32, so use 0 here as a
+    // placeholder, and the possibleExpectations should be ignored if the result is unbounded.
+    unboundedExpectations = [u32(0)];
+  } else if (type === 'i32') {
+    reinterpretFromU32 = (x: number) => reinterpretU32AsI32(x);
+    expectationsForValue = x => [i32(x)];
+    // Scalar expectation can not express "unbounded" for i32 and u32, so use 0 here as a
+    // placeholder, and the possibleExpectations should be ignored if the result is unbounded.
+    unboundedExpectations = [i32(0)];
+  } else {
+    assert(type === 'f32');
+    reinterpretFromU32 = (x: number) => reinterpretU32AsF32(x);
+    expectationsForValue = x => {
+      // Handle the possible Inf/NaN/zeros and subnormal cases for f32 result.
+      if (!isFiniteF32(x)) {
+        return [f32UnboundedInterval];
+      }
+      // If the casted f16 value is +/-0.0, the result can be one of both. Note that in JS -0.0 === 0.0.
+      if (x === 0.0) {
+        return [f32ZerosInterval];
+      }
+      const exactInterval = FP.f32.toInterval(x);
+      // If the casted f16 value is subnormal, it also may be flushed to +/-0.0.
+      return [exactInterval, ...(isSubnormalNumberF32(x) ? [f32ZerosInterval] : [])];
+    };
+    unboundedExpectations = [f32UnboundedInterval];
+  }
+  // Return unbounded expection if f16 Inf/NaN occurs
+  if (
+    !isFiniteF16(reinterpretU16AsF16(f16x2InU16x2[0])) ||
+    !isFiniteF16(reinterpretU16AsF16(f16x2InU16x2[1]))
+  ) {
+    return { possibleExpectations: unboundedExpectations, isUnbounded: true };
+  }
+  const possibleU16Bits = f16x2InU16x2.map(possibleBitsInU16FromFiniteF16InU16);
+  const possibleExpectations = cartesianProduct(...possibleU16Bits).flatMap<Scalar | FPInterval>(
+    (possibleBitsU16x2: number[]) => {
+      assert(possibleBitsU16x2.length === 2);
+      return expectationsForValue(reinterpretFromU32(u16x2ToU32(possibleBitsU16x2)));
+    }
+  );
+  return { possibleExpectations, isUnbounded: false };
+}
+
+/**
+ * @returns a Comparator for checking if a u32 value is a valid
+ * bitcast conversion from vec2 f16.
+ */
+function bitcastVec2F16ToU32Comparator(vec2F16InU16x2: number[]): Comparator {
+  assert(vec2F16InU16x2.length === 2);
+  const expectations = possible32BitScalarIntervalsFromF16x2(vec2F16InU16x2, 'u32');
+  // Return alwaysPass if result is expected unbounded.
+  if (expectations.isUnbounded) {
+    return anyU32;
+  }
+  return anyOf(...expectations.possibleExpectations);
+}
+
+/**
+ * @returns a Comparator for checking if a i32 value is a valid
+ * bitcast conversion from vec2 f16.
+ */
+function bitcastVec2F16ToI32Comparator(vec2F16InU16x2: number[]): Comparator {
+  assert(vec2F16InU16x2.length === 2);
+  const expectations = possible32BitScalarIntervalsFromF16x2(vec2F16InU16x2, 'i32');
+  // Return alwaysPass if result is expected unbounded.
+  if (expectations.isUnbounded) {
+    return anyI32;
+  }
+  return anyOf(...expectations.possibleExpectations);
+}
+
+/**
+ * @returns a Comparator for checking if a i32 value is a valid
+ * bitcast conversion from vec2 f16.
+ */
+function bitcastVec2F16ToF32Comparator(vec2F16InU16x2: number[]): Comparator {
+  assert(vec2F16InU16x2.length === 2);
+  const expectations = possible32BitScalarIntervalsFromF16x2(vec2F16InU16x2, 'f32');
+  // Return alwaysPass if result is expected unbounded.
+  if (expectations.isUnbounded) {
+    return anyF32;
+  }
+  return anyOf(...expectations.possibleExpectations);
+}
+
+/**
+ * @returns a Comparator for checking if a vec2 u32 value is a valid
+ * bitcast conversion from vec4 f16.
+ */
+function bitcastVec4F16ToVec2U32Comparator(vec4F16InU16x4: number[]): Comparator {
+  assert(vec4F16InU16x4.length === 4);
+  const expectationsPerElement = [vec4F16InU16x4.slice(0, 2), vec4F16InU16x4.slice(2, 4)].map(e =>
+    possible32BitScalarIntervalsFromF16x2(e, 'u32')
+  );
+  // Return alwaysPass if any element is expected unbounded. Although it may be only one unbounded
+  // element in the result vector, currently we don't have a way to build a comparator that expect
+  // only one element of i32/u32 vector unbounded.
+  if (expectationsPerElement.map(e => e.isUnbounded).reduce((a, b) => a || b, false)) {
+    return alwaysPass('any vec2<u32>');
+  }
+  return anyOf(
+    ...cartesianProduct(...expectationsPerElement.map(e => e.possibleExpectations)).map(
+      e => new Vector(e as Scalar[])
+    )
+  );
+}
+
+/**
+ * @returns a Comparator for checking if a vec2 i32 value is a valid
+ * bitcast conversion from vec4 f16.
+ */
+function bitcastVec4F16ToVec2I32Comparator(vec4F16InU16x4: number[]): Comparator {
+  assert(vec4F16InU16x4.length === 4);
+  const expectationsPerElement = [vec4F16InU16x4.slice(0, 2), vec4F16InU16x4.slice(2, 4)].map(e =>
+    possible32BitScalarIntervalsFromF16x2(e, 'i32')
+  );
+  // Return alwaysPass if any element is expected unbounded. Although it may be only one unbounded
+  // element in the result vector, currently we don't have a way to build a comparator that expect
+  // only one element of i32/u32 vector unbounded.
+  if (expectationsPerElement.map(e => e.isUnbounded).reduce((a, b) => a || b, false)) {
+    return alwaysPass('any vec2<i32>');
+  }
+  return anyOf(
+    ...cartesianProduct(...expectationsPerElement.map(e => e.possibleExpectations)).map(
+      e => new Vector(e as Scalar[])
+    )
+  );
+}
+
+/**
+ * @returns a Comparator for checking if a vec2 f32 value is a valid
+ * bitcast conversion from vec4 f16.
+ */
+function bitcastVec4F16ToVec2F32Comparator(vec4F16InU16x4: number[]): Comparator {
+  assert(vec4F16InU16x4.length === 4);
+  const expectationsPerElement = [vec4F16InU16x4.slice(0, 2), vec4F16InU16x4.slice(2, 4)].map(e =>
+    possible32BitScalarIntervalsFromF16x2(e, 'f32')
+  );
+  return anyOf(
+    ...cartesianProduct(...expectationsPerElement.map(e => e.possibleExpectations)).map(e => [
+      e[0] as FPInterval,
+      e[1] as FPInterval,
+    ])
+  );
+}
+
 export const d = makeCaseCache('bitcast', {
   // Identity Cases
   i32_to_i32: () => fullI32Range().map(e => ({ input: i32(e), expected: i32(e) })),
@@ -176,27 +651,34 @@ export const d = makeCaseCache('bitcast', {
     })),
   f32_to_f32: () =>
     f32FiniteRange.map(e => ({ input: f32(e), expected: bitcastF32ToF32Comparator(e) })),
+  f16_inf_nan_to_f16: () =>
+    [...f16FiniteInF16, ...f16InfAndNaNInF16].map(e => ({
+      input: f16(e),
+      expected: bitcastF16ToF16Comparator(e),
+    })),
+  f16_to_f16: () =>
+    f16FiniteInF16.map(e => ({ input: f16(e), expected: bitcastF16ToF16Comparator(e) })),
 
   // i32,u32,f32 to different i32,u32,f32
   i32_to_u32: () => fullI32Range().map(e => ({ input: i32(e), expected: u32(e) })),
   i32_to_f32: () =>
-    i32RangeWithFiniteF32.map(e => ({
+    i32RangeForF32Finite.map(e => ({
       input: i32(e),
       expected: bitcastI32ToF32Comparator(e),
     })),
   i32_to_f32_inf_nan: () =>
-    i32RangeWithBitsForInfAndNaNAndZeros.map(e => ({
+    i32RangeForF32FiniteInfNaN.map(e => ({
       input: i32(e),
       expected: bitcastI32ToF32Comparator(e),
     })),
   u32_to_i32: () => fullU32Range().map(e => ({ input: u32(e), expected: i32(e) })),
   u32_to_f32: () =>
-    u32RangeWithFiniteF32.map(e => ({
+    u32RangeForF32Finite.map(e => ({
       input: u32(e),
       expected: bitcastU32ToF32Comparator(e),
     })),
   u32_to_f32_inf_nan: () =>
-    u32RangeWithBitsForInfAndNaNAndZeros.map(e => ({
+    u32RangeForF32FiniteInfNaN.map(e => ({
       input: u32(e),
       expected: bitcastU32ToF32Comparator(e),
     })),
@@ -215,6 +697,142 @@ export const d = makeCaseCache('bitcast', {
     })),
   f32_to_u32: () =>
     f32FiniteRange.map(e => ({ input: f32(e), expected: bitcastF32ToU32Comparator(e) })),
+
+  // i32,u32,f32 to vec2<f16>
+  u32_to_vec2_f16_inf_nan: () =>
+    u32RangeForF16Vec2FiniteInfNaN.map(e => ({
+      input: u32(e),
+      expected: bitcastU32ToVec2F16Comparator(e),
+    })),
+  u32_to_vec2_f16: () =>
+    u32RangeForF16Vec2Finite.map(e => ({
+      input: u32(e),
+      expected: bitcastU32ToVec2F16Comparator(e),
+    })),
+  i32_to_vec2_f16_inf_nan: () =>
+    i32RangeForF16Vec2FiniteInfNaN.map(e => ({
+      input: i32(e),
+      expected: bitcastI32ToVec2F16Comparator(e),
+    })),
+  i32_to_vec2_f16: () =>
+    i32RangeForF16Vec2Finite.map(e => ({
+      input: i32(e),
+      expected: bitcastI32ToVec2F16Comparator(e),
+    })),
+  f32_inf_nan_to_vec2_f16_inf_nan: () =>
+    f32RangeWithInfAndNaNForF16Vec2FiniteInfNaN.map(e => ({
+      input: f32(e),
+      expected: bitcastF32ToVec2F16Comparator(e),
+    })),
+  f32_to_vec2_f16: () =>
+    f32FiniteRangeForF16Vec2Finite.map(e => ({
+      input: f32(e),
+      expected: bitcastF32ToVec2F16Comparator(e),
+    })),
+
+  // vec2<i32>, vec2<u32>, vec2<f32> to vec4<f16>
+  vec2_i32_to_vec4_f16_inf_nan: () =>
+    slidingSlice(i32RangeForF16Vec2FiniteInfNaN, 2).map(e => ({
+      input: toVector(e, i32),
+      expected: bitcastVec2I32ToVec4F16Comparator(e),
+    })),
+  vec2_i32_to_vec4_f16: () =>
+    slidingSlice(i32RangeForF16Vec2Finite, 2).map(e => ({
+      input: toVector(e, i32),
+      expected: bitcastVec2I32ToVec4F16Comparator(e),
+    })),
+  vec2_u32_to_vec4_f16_inf_nan: () =>
+    slidingSlice(u32RangeForF16Vec2FiniteInfNaN, 2).map(e => ({
+      input: toVector(e, u32),
+      expected: bitcastVec2U32ToVec4F16Comparator(e),
+    })),
+  vec2_u32_to_vec4_f16: () =>
+    slidingSlice(u32RangeForF16Vec2Finite, 2).map(e => ({
+      input: toVector(e, u32),
+      expected: bitcastVec2U32ToVec4F16Comparator(e),
+    })),
+  vec2_f32_inf_nan_to_vec4_f16_inf_nan: () =>
+    slidingSlice(f32RangeWithInfAndNaNForF16Vec2FiniteInfNaN, 2).map(e => ({
+      input: toVector(e, f32),
+      expected: bitcastVec2F32ToVec4F16Comparator(e),
+    })),
+  vec2_f32_to_vec4_f16: () =>
+    slidingSlice(f32FiniteRangeForF16Vec2Finite, 2).map(e => ({
+      input: toVector(e, f32),
+      expected: bitcastVec2F32ToVec4F16Comparator(e),
+    })),
+
+  // vec2<f16> to i32, u32, f32
+  vec2_f16_to_u32: () =>
+    f16Vec2FiniteInU16x2.map(e => ({
+      input: u16x2ToVec2F16(e),
+      expected: bitcastVec2F16ToU32Comparator(e),
+    })),
+  vec2_f16_inf_nan_to_u32: () =>
+    f16Vec2FiniteInfNanInU16x2.map(e => ({
+      input: u16x2ToVec2F16(e),
+      expected: bitcastVec2F16ToU32Comparator(e),
+    })),
+  vec2_f16_to_i32: () =>
+    f16Vec2FiniteInU16x2.map(e => ({
+      input: u16x2ToVec2F16(e),
+      expected: bitcastVec2F16ToI32Comparator(e),
+    })),
+  vec2_f16_inf_nan_to_i32: () =>
+    f16Vec2FiniteInfNanInU16x2.map(e => ({
+      input: u16x2ToVec2F16(e),
+      expected: bitcastVec2F16ToI32Comparator(e),
+    })),
+  vec2_f16_to_f32_finite: () =>
+    f16Vec2FiniteInU16x2
+      .filter(u16x2 => isFiniteF32(reinterpretU32AsF32(u16x2ToU32(u16x2))))
+      .map(e => ({
+        input: u16x2ToVec2F16(e),
+        expected: bitcastVec2F16ToF32Comparator(e),
+      })),
+  vec2_f16_inf_nan_to_f32: () =>
+    f16Vec2FiniteInfNanInU16x2.map(e => ({
+      input: u16x2ToVec2F16(e),
+      expected: bitcastVec2F16ToF32Comparator(e),
+    })),
+
+  // vec4<f16> to vec2 of i32, u32, f32
+  vec4_f16_to_vec2_u32: () =>
+    f16Vec2FiniteInU16x4.map(e => ({
+      input: u16x4ToVec4F16(e),
+      expected: bitcastVec4F16ToVec2U32Comparator(e),
+    })),
+  vec4_f16_inf_nan_to_vec2_u32: () =>
+    f16Vec2FiniteInfNanInU16x4.map(e => ({
+      input: u16x4ToVec4F16(e),
+      expected: bitcastVec4F16ToVec2U32Comparator(e),
+    })),
+  vec4_f16_to_vec2_i32: () =>
+    f16Vec2FiniteInU16x4.map(e => ({
+      input: u16x4ToVec4F16(e),
+      expected: bitcastVec4F16ToVec2I32Comparator(e),
+    })),
+  vec4_f16_inf_nan_to_vec2_i32: () =>
+    f16Vec2FiniteInfNanInU16x4.map(e => ({
+      input: u16x4ToVec4F16(e),
+      expected: bitcastVec4F16ToVec2I32Comparator(e),
+    })),
+  vec4_f16_to_vec2_f32_finite: () =>
+    f16Vec2FiniteInU16x4
+      .filter(
+        u16x4 =>
+          isFiniteF32(reinterpretU32AsF32(u16x2ToU32(u16x4.slice(0, 2)))) &&
+          isFiniteF32(reinterpretU32AsF32(u16x2ToU32(u16x4.slice(2, 4))))
+      )
+      .map(e => ({
+        input: u16x4ToVec4F16(e),
+        expected: bitcastVec4F16ToVec2F32Comparator(e),
+      })),
+  vec4_f16_inf_nan_to_vec2_f32: () =>
+    f16Vec2FiniteInfNanInU16x4.map(e => ({
+      input: u16x4ToVec4F16(e),
+      expected: bitcastVec4F16ToVec2F32Comparator(e),
+    })),
 });
 
 /**
@@ -227,17 +845,10 @@ function bitcastBuilder(canonicalDestType: string, params: TestParams): ShaderBu
     ? `vec${params.vectorize}<${canonicalDestType}>`
     : canonicalDestType;
 
-  if (params.alias) {
-    return (
-      parameterTypes: Array<Type>,
-      resultType: Type,
-      cases: CaseList,
-      inputSource: InputSource
-    ) =>
-      `alias myalias = ${destType};\n` +
-      builtin(`bitcast<myalias>`)(parameterTypes, resultType, cases, inputSource);
-  }
-  return builtin(`bitcast<${destType}>`);
+  return builtinWithPredeclaration(
+    `bitcast<${destType}>`,
+    params.alias ? `alias myalias = ${destType};` : ''
+  );
 }
 
 // Identity cases
@@ -399,140 +1010,264 @@ g.test('f16_to_f16')
       .combine('vectorize', [undefined, 2, 3, 4] as const)
       .combine('alias', [false, true])
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'f16_to_f16' : 'f16_inf_nan_to_f16'
+    );
+    await run(t, bitcastBuilder('f16', t.params), [TypeF16], TypeF16, t.params, cases);
+  });
 
 // f16: 32-bit scalar numeric to vec2<f16>
 g.test('i32_to_vec2h')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast i32 to vec2h tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'i32_to_vec2_f16' : 'i32_to_vec2_f16_inf_nan'
+    );
+    await run(
+      t,
+      bitcastBuilder('vec2<f16>', t.params),
+      [TypeI32],
+      TypeVec(2, TypeF16),
+      t.params,
+      cases
+    );
+  });
 
 g.test('u32_to_vec2h')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast u32 to vec2h tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'u32_to_vec2_f16' : 'u32_to_vec2_f16_inf_nan'
+    );
+    await run(
+      t,
+      bitcastBuilder('vec2<f16>', t.params),
+      [TypeU32],
+      TypeVec(2, TypeF16),
+      t.params,
+      cases
+    );
+  });
 
 g.test('f32_to_vec2h')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast u32 to vec2h tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'f32_to_vec2_f16' : 'f32_inf_nan_to_vec2_f16_inf_nan'
+    );
+    await run(
+      t,
+      bitcastBuilder('vec2<f16>', t.params),
+      [TypeF32],
+      TypeVec(2, TypeF16),
+      t.params,
+      cases
+    );
+  });
 
 // f16: vec2<32-bit scalar numeric> to vec4<f16>
 g.test('vec2i_to_vec4h')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast vec2i to vec4h tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'vec2_i32_to_vec4_f16' : 'vec2_i32_to_vec4_f16_inf_nan'
+    );
+    await run(
+      t,
+      bitcastBuilder('vec4<f16>', t.params),
+      [TypeVec(2, TypeI32)],
+      TypeVec(4, TypeF16),
+      t.params,
+      cases
+    );
+  });
 
 g.test('vec2u_to_vec4h')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast vec2u to vec4h tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'vec2_u32_to_vec4_f16' : 'vec2_u32_to_vec4_f16_inf_nan'
+    );
+    await run(
+      t,
+      bitcastBuilder('vec4<f16>', t.params),
+      [TypeVec(2, TypeU32)],
+      TypeVec(4, TypeF16),
+      t.params,
+      cases
+    );
+  });
 
 g.test('vec2f_to_vec4h')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast vec2f to vec2h tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const'
+        ? 'vec2_f32_to_vec4_f16'
+        : 'vec2_f32_inf_nan_to_vec4_f16_inf_nan'
+    );
+    await run(
+      t,
+      bitcastBuilder('vec4<f16>', t.params),
+      [TypeVec(2, TypeF32)],
+      TypeVec(4, TypeF16),
+      t.params,
+      cases
+    );
+  });
 
 // f16: vec2<f16> to 32-bit scalar numeric
 g.test('vec2h_to_i32')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast vec2h to i32 tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'vec2_f16_to_i32' : 'vec2_f16_inf_nan_to_i32'
+    );
+    await run(t, bitcastBuilder('i32', t.params), [TypeVec(2, TypeF16)], TypeI32, t.params, cases);
+  });
 
 g.test('vec2h_to_u32')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast vec2h to u32 tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'vec2_f16_to_u32' : 'vec2_f16_inf_nan_to_u32'
+    );
+    await run(t, bitcastBuilder('u32', t.params), [TypeVec(2, TypeF16)], TypeU32, t.params, cases);
+  });
 
 g.test('vec2h_to_f32')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast vec2h to f32 tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'vec2_f16_to_f32_finite' : 'vec2_f16_inf_nan_to_f32'
+    );
+    await run(t, bitcastBuilder('f32', t.params), [TypeVec(2, TypeF16)], TypeF32, t.params, cases);
+  });
 
 // f16: vec4<f16> to vec2<32-bit scalar numeric>
 g.test('vec4h_to_vec2i')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast vec4h to vec2i tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'vec4_f16_to_vec2_i32' : 'vec4_f16_inf_nan_to_vec2_i32'
+    );
+    await run(
+      t,
+      bitcastBuilder('vec2<i32>', t.params),
+      [TypeVec(4, TypeF16)],
+      TypeVec(2, TypeI32),
+      t.params,
+      cases
+    );
+  });
 
 g.test('vec4h_to_vec2u')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast vec4h to vec2u tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const' ? 'vec4_f16_to_vec2_u32' : 'vec4_f16_inf_nan_to_vec2_u32'
+    );
+    await run(
+      t,
+      bitcastBuilder('vec2<u32>', t.params),
+      [TypeVec(4, TypeF16)],
+      TypeVec(2, TypeU32),
+      t.params,
+      cases
+    );
+  });
 
 g.test('vec4h_to_vec2f')
   .specURL('https://www.w3.org/TR/WGSL/#bitcast-builtin')
   .desc(`bitcast vec4h to vec2f tests`)
-  .params(u =>
-    u
-      .combine('inputSource', allInputSources)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-      .combine('alias', [false, true])
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('alias', [false, true]))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      // Infinities and NaNs are errors in const-eval.
+      t.params.inputSource === 'const'
+        ? 'vec4_f16_to_vec2_f32_finite'
+        : 'vec4_f16_inf_nan_to_vec2_f32'
+    );
+    await run(
+      t,
+      bitcastBuilder('vec2<f32>', t.params),
+      [TypeVec(4, TypeF16)],
+      TypeVec(2, TypeF32),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/builtin.ts b/src/webgpu/shader/execution/expression/call/builtin/builtin.ts
index f25faa30440b..26424dd1ce6e 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/builtin.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/builtin.ts
@@ -1,6 +1,18 @@
-import { basicExpressionBuilder, ShaderBuilder } from '../../expression.js';
+import {
+  basicExpressionBuilder,
+  basicExpressionWithPredeclarationBuilder,
+  ShaderBuilder,
+} from '../../expression.js';
 
 /* @returns a ShaderBuilder that calls the builtin with the given name */
 export function builtin(name: string): ShaderBuilder {
   return basicExpressionBuilder(values => `${name}(${values.join(', ')})`);
 }
+
+/* @returns a ShaderBuilder that calls the builtin with the given name and has given predeclaration */
+export function builtinWithPredeclaration(name: string, predeclaration: string): ShaderBuilder {
+  return basicExpressionWithPredeclarationBuilder(
+    values => `${name}(${values.join(', ')})`,
+    predeclaration
+  );
+}
diff --git a/src/webgpu/shader/execution/expression/expression.ts b/src/webgpu/shader/execution/expression/expression.ts
index 80fb0fbf8006..e12a3f71392d 100644
--- a/src/webgpu/shader/execution/expression/expression.ts
+++ b/src/webgpu/shader/execution/expression/expression.ts
@@ -501,107 +501,107 @@ export type ExpressionBuilder = (values: Array<string>) => string;
  * Returns a ShaderBuilder that builds a basic expression test shader.
  * @param expressionBuilder the expression builder
  */
-export function basicExpressionBuilder(expressionBuilder: ExpressionBuilder): ShaderBuilder {
-  return (
-    parameterTypes: Array<Type>,
-    resultType: Type,
-    cases: CaseList,
-    inputSource: InputSource
-  ) => {
-    if (inputSource === 'const') {
-      //////////////////////////////////////////////////////////////////////////
-      // Constant eval
-      //////////////////////////////////////////////////////////////////////////
-      let body = '';
-      if (
-        scalarTypeOf(resultType).kind !== 'abstract-float' &&
-        parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')
-      ) {
-        // Directly assign the expression to the output, to avoid an
-        // intermediate store, which will concretize the value early
-        body = cases
-          .map(
-            (c, i) =>
-              `  outputs[${i}].value = ${toStorage(
-                resultType,
-                expressionBuilder(map(c.input, v => v.wgsl()))
-              )};`
-          )
-          .join('\n  ');
-      } else if (scalarTypeOf(resultType).kind === 'abstract-float') {
-        // AbstractFloats are f64s under the hood. WebGPU does not support
-        // putting f64s in buffers, so the result needs to be split up into u32s
-        // and rebuilt in the test framework.
-        //
-        // This is complicated by the fact that user defined functions cannot
-        // take/return AbstractFloats, and AbstractFloats cannot be stored in
-        // variables, so the code cannot just inject a simple utility function
-        // at the top of the shader, instead this snippet needs to be inlined
-        // everywhere the test needs to return an AbstractFloat.
-        //
-        // select is used below, since ifs are not available during constant
-        // eval. This has the side effect of short-circuiting doesn't occur, so
-        // both sides of the select have to evaluate and be valid.
-        //
-        // This snippet implements FTZ for subnormals to bypass the need for
-        // complex subnormal specific logic.
-        //
-        // Expressions resulting in subnormals can still be reasonably tested,
-        // since this snippet will return 0 with the correct sign, which is
-        // always in the acceptance interval for a subnormal result, since an
-        // implementation may FTZ.
-        //
-        // Document for the snippet is included here in this code block, since
-        // shader length affects compilation time  significantly on some
-        // backends.
-        //
-        // Snippet with documentation:
-        //   const kExponentBias = 1022;
-        //
-        //   // Detect if the value is zero or subnormal, so that FTZ behaviour
-        //   // can occur
-        //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
-        //
-        //   // MSB of the upper u32 is 1 if the value is negative, otherwise 0
-        //   // Extract the sign bit early, so that abs() can be used with
-        //   // frexp() so negative cases do not need to be handled
-        //   const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
-        //
-        //   // Use frexp() to obtain the exponent and fractional parts, and
-        //   // then perform FTZ if needed
-        //   const f = frexp(abs(${expr}));
-        //   const f_fract = select(f.fract, 0, subnormal_or_zero);
-        //   const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
-        //
-        //   // Adjust for the exponent bias and shift for storing in bits
-        //   // [20..31] of the upper u32
-        //   const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
-        //
-        //   // Extract the portion of the mantissa that appears in upper u32 as
-        //   // a float for later use
-        //   const high_mantissa = ldexp(f_fract, 21);
-        //
-        //   // Extract the portion of the mantissa that appears in upper u32 as
-        //   // as bits. This value is masked, because normals will explicitly
-        //   // have the implicit leading 1 that should not be in the final
-        //   // result.
-        //   const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
-        //
-        //   // Calculate the mantissa stored in the lower u32 as a float
-        //   const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
-        //
-        //   // Convert the lower u32 mantissa to bits
-        //   const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
-        //
-        //   // Pack the result into 2x u32s for writing out to the testing
-        //   // framework
-        //   outputs[${i}].value.x = low_mantissa_bits;
-        //   outputs[${i}].value.y = sign_bit | exponent_bits | high_mantissa_bits;
-        body = cases
-          .map((c, i) => {
-            const expr = `${expressionBuilder(map(c.input, v => v.wgsl()))}`;
-            // prettier-ignore
-            return `  {
+function basicExpressionShaderBody(
+  expressionBuilder: ExpressionBuilder,
+  parameterTypes: Array<Type>,
+  resultType: Type,
+  cases: CaseList,
+  inputSource: InputSource
+): string {
+  if (inputSource === 'const') {
+    //////////////////////////////////////////////////////////////////////////
+    // Constant eval
+    //////////////////////////////////////////////////////////////////////////
+    let body = '';
+    if (
+      scalarTypeOf(resultType).kind !== 'abstract-float' &&
+      parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')
+    ) {
+      // Directly assign the expression to the output, to avoid an
+      // intermediate store, which will concretize the value early
+      body = cases
+        .map(
+          (c, i) =>
+            `  outputs[${i}].value = ${toStorage(
+              resultType,
+              expressionBuilder(map(c.input, v => v.wgsl()))
+            )};`
+        )
+        .join('\n  ');
+    } else if (scalarTypeOf(resultType).kind === 'abstract-float') {
+      // AbstractFloats are f64s under the hood. WebGPU does not support
+      // putting f64s in buffers, so the result needs to be split up into u32s
+      // and rebuilt in the test framework.
+      //
+      // This is complicated by the fact that user defined functions cannot
+      // take/return AbstractFloats, and AbstractFloats cannot be stored in
+      // variables, so the code cannot just inject a simple utility function
+      // at the top of the shader, instead this snippet needs to be inlined
+      // everywhere the test needs to return an AbstractFloat.
+      //
+      // select is used below, since ifs are not available during constant
+      // eval. This has the side effect of short-circuiting doesn't occur, so
+      // both sides of the select have to evaluate and be valid.
+      //
+      // This snippet implements FTZ for subnormals to bypass the need for
+      // complex subnormal specific logic.
+      //
+      // Expressions resulting in subnormals can still be reasonably tested,
+      // since this snippet will return 0 with the correct sign, which is
+      // always in the acceptance interval for a subnormal result, since an
+      // implementation may FTZ.
+      //
+      // Document for the snippet is included here in this code block, since
+      // shader length affects compilation time  significantly on some
+      // backends.
+      //
+      // Snippet with documentation:
+      //   const kExponentBias = 1022;
+      //
+      //   // Detect if the value is zero or subnormal, so that FTZ behaviour
+      //   // can occur
+      //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
+      //
+      //   // MSB of the upper u32 is 1 if the value is negative, otherwise 0
+      //   // Extract the sign bit early, so that abs() can be used with
+      //   // frexp() so negative cases do not need to be handled
+      //   const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
+      //
+      //   // Use frexp() to obtain the exponent and fractional parts, and
+      //   // then perform FTZ if needed
+      //   const f = frexp(abs(${expr}));
+      //   const f_fract = select(f.fract, 0, subnormal_or_zero);
+      //   const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
+      //
+      //   // Adjust for the exponent bias and shift for storing in bits
+      //   // [20..31] of the upper u32
+      //   const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
+      //
+      //   // Extract the portion of the mantissa that appears in upper u32 as
+      //   // a float for later use
+      //   const high_mantissa = ldexp(f_fract, 21);
+      //
+      //   // Extract the portion of the mantissa that appears in upper u32 as
+      //   // as bits. This value is masked, because normals will explicitly
+      //   // have the implicit leading 1 that should not be in the final
+      //   // result.
+      //   const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
+      //
+      //   // Calculate the mantissa stored in the lower u32 as a float
+      //   const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
+      //
+      //   // Convert the lower u32 mantissa to bits
+      //   const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
+      //
+      //   // Pack the result into 2x u32s for writing out to the testing
+      //   // framework
+      //   outputs[${i}].value.x = low_mantissa_bits;
+      //   outputs[${i}].value.y = sign_bit | exponent_bits | high_mantissa_bits;
+      body = cases
+        .map((c, i) => {
+          const expr = `${expressionBuilder(map(c.input, v => v.wgsl()))}`;
+          // prettier-ignore
+          return `  {
     const kExponentBias = 1022;
     const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
     const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
@@ -616,25 +616,23 @@ export function basicExpressionBuilder(expressionBuilder: ExpressionBuilder): Sh
     outputs[${i}].value.x = low_mantissa_bits;
     outputs[${i}].value.y = sign_bit | exponent_bits | high_mantissa_bits;
   }`;
-          })
-          .join('\n  ');
-      } else if (globalTestConfig.unrollConstEvalLoops) {
-        body = cases
-          .map((_, i) => {
-            const value = `values[${i}]`;
-            return `  outputs[${i}].value = ${toStorage(resultType, value)};`;
-          })
-          .join('\n  ');
-      } else {
-        body = `
+        })
+        .join('\n  ');
+    } else if (globalTestConfig.unrollConstEvalLoops) {
+      body = cases
+        .map((_, i) => {
+          const value = `values[${i}]`;
+          return `  outputs[${i}].value = ${toStorage(resultType, value)};`;
+        })
+        .join('\n  ');
+    } else {
+      body = `
   for (var i = 0u; i < ${cases.length}; i++) {
     outputs[i].value = ${toStorage(resultType, `values[i]`)};
   }`;
-      }
-
-      return `
-${wgslHeader(parameterTypes, resultType)}
+    }
 
+    return `
 ${wgslOutputs(resultType, cases.length)}
 
 ${wgslValuesArray(parameterTypes, resultType, cases, expressionBuilder)}
@@ -643,20 +641,18 @@ ${wgslValuesArray(parameterTypes, resultType, cases, expressionBuilder)}
 fn main() {
 ${body}
 }`;
-    } else {
-      //////////////////////////////////////////////////////////////////////////
-      // Runtime eval
-      //////////////////////////////////////////////////////////////////////////
-
-      // returns the WGSL expression to load the ith parameter of the given type from the input buffer
-      const paramExpr = (ty: Type, i: number) => fromStorage(ty, `inputs[i].param${i}`);
+  } else {
+    //////////////////////////////////////////////////////////////////////////
+    // Runtime eval
+    //////////////////////////////////////////////////////////////////////////
 
-      // resolves to the expression that calls the builtin
-      const expr = toStorage(resultType, expressionBuilder(parameterTypes.map(paramExpr)));
+    // returns the WGSL expression to load the ith parameter of the given type from the input buffer
+    const paramExpr = (ty: Type, i: number) => fromStorage(ty, `inputs[i].param${i}`);
 
-      return `
-${wgslHeader(parameterTypes, resultType)}
+    // resolves to the expression that calls the builtin
+    const expr = toStorage(resultType, expressionBuilder(parameterTypes.map(paramExpr)));
 
+    return `
 struct Input {
 ${parameterTypes
   .map((ty, i) => `  @size(${valueStride(ty)}) param${i} : ${storageType(ty)},`)
@@ -674,7 +670,49 @@ fn main() {
   }
 }
 `;
-    }
+  }
+}
+
+/**
+ * Returns a ShaderBuilder that builds a basic expression test shader.
+ * @param expressionBuilder the expression builder
+ */
+export function basicExpressionBuilder(expressionBuilder: ExpressionBuilder): ShaderBuilder {
+  return (
+    parameterTypes: Array<Type>,
+    resultType: Type,
+    cases: CaseList,
+    inputSource: InputSource
+  ) => {
+    return `\
+${wgslHeader(parameterTypes, resultType)}
+
+${basicExpressionShaderBody(expressionBuilder, parameterTypes, resultType, cases, inputSource)}`;
+  };
+}
+
+/**
+ * Returns a ShaderBuilder that builds a basic expression test shader with given predeclaration
+ * string goes after WGSL header (i.e. enable directives) if any but before anything else.
+ * @param expressionBuilder the expression builder
+ * @param predeclaration the predeclaration string
+ */
+export function basicExpressionWithPredeclarationBuilder(
+  expressionBuilder: ExpressionBuilder,
+  predeclaration: string
+): ShaderBuilder {
+  return (
+    parameterTypes: Array<Type>,
+    resultType: Type,
+    cases: CaseList,
+    inputSource: InputSource
+  ) => {
+    return `\
+${wgslHeader(parameterTypes, resultType)}
+
+${predeclaration}
+
+${basicExpressionShaderBody(expressionBuilder, parameterTypes, resultType, cases, inputSource)}`;
   };
 }
 

From 4fc748388076ebf618edb742505be93892e4057a Mon Sep 17 00:00:00 2001
From: David Neto <dneto@google.com>
Date: Tue, 22 Aug 2023 16:37:56 -0400
Subject: [PATCH 002/166] Remove TODO about f32(-0.0) printing as '-0.0f'
 (#2903)

It's not guaranteed that the -0.0 value will survive once
it is stored in a Scalar object

Issue: #2901
---
 src/unittests/conversion.spec.ts | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/unittests/conversion.spec.ts b/src/unittests/conversion.spec.ts
index 95da248a3087..589e20fdc652 100644
--- a/src/unittests/conversion.spec.ts
+++ b/src/unittests/conversion.spec.ts
@@ -193,9 +193,11 @@ g.test('floatBitsToULPFromZero,32').fn(t => {
 g.test('scalarWGSL').fn(t => {
   const cases: Array<[Scalar, string]> = [
     [f32(0.0), '0.0f'],
-    // f32(-0.0) should map to '-0.0f'
-    // Tracked by https://github.com/gpuweb/cts/issues/2901
-    [f32(-0.0), '0.0f'],
+    // The number -0.0 can be remapped to 0.0 when stored in a Scalar
+    // object. It is not possible to guarantee that '-0.0f' will
+    // be emitted. So the WGSL scalar value printing does not try
+    // to handle this case.
+    [f32(-0.0), '0.0f'], // -0.0 can be remapped to 0.0
     [f32(1.0), '1.0f'],
     [f32(-1.0), '-1.0f'],
     [f32Bits(0x70000000), '1.5845632502852868e+29f'],

From 2ee990a4cb91b41491f83b52c9520476b18a9fd8 Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Tue, 22 Aug 2023 15:45:19 -0700
Subject: [PATCH 003/166] Prevent details toggle if user is selecting text
 (#2906)

* Prevent details toggle if user is selecting text
* select all on click
---
 src/common/runtime/standalone.ts | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/common/runtime/standalone.ts b/src/common/runtime/standalone.ts
index da647de29a01..046265db8c29 100644
--- a/src/common/runtime/standalone.ts
+++ b/src/common/runtime/standalone.ts
@@ -390,6 +390,19 @@ function makeTreeNodeHeaderHTML(
   const div = $('<details>').addClass('nodeheader');
   const header = $('<summary>').appendTo(div);
 
+  // prevent toggling if user is selecting text from an input element
+  {
+    let lastNodeName = '';
+    div.on('pointerdown', event => {
+      lastNodeName = event.target.nodeName;
+    });
+    div.on('click', event => {
+      if (lastNodeName === 'INPUT') {
+        event.preventDefault();
+      }
+    });
+  }
+
   const setChecked = () => {
     div.prop('open', true); // (does not fire onChange)
     onChange(true);
@@ -445,6 +458,9 @@ function makeTreeNodeHeaderHTML(
       .attr('type', 'text')
       .prop('readonly', true)
       .addClass('nodequery')
+      .on('click', event => {
+        (event.target as HTMLInputElement).select();
+      })
       .val(n.query.toString())
       .appendTo(nodecolumns);
     if (n.subtreeCounts) {

From 5dfa3b88f0863c3949f713804e0461c9cc34a030 Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Wed, 23 Aug 2023 16:42:08 -0700
Subject: [PATCH 004/166] Fix handling of batches in case filtering (#2908)

---
 src/common/internal/test_group.ts       | 60 +++++++++++++++++++------
 src/common/internal/tree.ts             |  6 +--
 src/unittests/loaders_and_trees.spec.ts | 51 ++++++++++++++++++---
 3 files changed, 95 insertions(+), 22 deletions(-)

diff --git a/src/common/internal/test_group.ts b/src/common/internal/test_group.ts
index 76b110af68cd..bf5c67e4abdf 100644
--- a/src/common/internal/test_group.ts
+++ b/src/common/internal/test_group.ts
@@ -74,6 +74,9 @@ export function makeTestGroupForUnitTesting<F extends Fixture>(
   return new TestGroup(fixture);
 }
 
+/** Parameter name for batch number (see also TestBuilder.batch). */
+const kBatchParamName = 'batch__';
+
 type TestFn<F extends Fixture, P extends {}> = (t: F & { params: P }) => Promise<void> | void;
 type BeforeAllSubcasesFn<S extends SubcaseBatchState, P extends {}> = (
   s: S & { params: P }
@@ -283,7 +286,7 @@ class TestBuilder<S extends SubcaseBatchState, F extends Fixture> {
     for (const [caseParams, subcases] of builderIterateCasesWithSubcases(this.testCases, null)) {
       for (const subcaseParams of subcases ?? [{}]) {
         const params = mergeParams(caseParams, subcaseParams);
-        assert(this.batchSize === 0 || !('batch__' in params));
+        assert(this.batchSize === 0 || !(kBatchParamName in params));
 
         // stringifyPublicParams also checks for invalid params values
         let testcaseString;
@@ -348,24 +351,53 @@ class TestBuilder<S extends SubcaseBatchState, F extends Fixture> {
 
   *iterate(caseFilter: TestParams | null): IterableIterator<RunCase> {
     this.testCases ??= kUnitCaseParamsBuilder;
+
+    // Remove the batch__ from the caseFilter because the params builder doesn't
+    // know about it (we don't add it until later in this function).
+    let filterToBatch: number | undefined;
+    const caseFilterWithoutBatch = caseFilter ? { ...caseFilter } : null;
+    if (caseFilterWithoutBatch && kBatchParamName in caseFilterWithoutBatch) {
+      const batchParam = caseFilterWithoutBatch[kBatchParamName];
+      assert(typeof batchParam === 'number');
+      filterToBatch = batchParam;
+      delete caseFilterWithoutBatch[kBatchParamName];
+    }
+
     for (const [caseParams, subcases] of builderIterateCasesWithSubcases(
       this.testCases,
-      caseFilter
+      caseFilterWithoutBatch
     )) {
+      // If batches are not used, yield just one case.
       if (this.batchSize === 0 || subcases === undefined) {
         yield this.makeCaseSpecific(caseParams, subcases);
-      } else {
-        const subcaseArray = Array.from(subcases);
-        if (subcaseArray.length <= this.batchSize) {
-          yield this.makeCaseSpecific(caseParams, subcaseArray);
-        } else {
-          for (let i = 0; i < subcaseArray.length; i = i + this.batchSize) {
-            yield this.makeCaseSpecific(
-              { ...caseParams, batch__: i / this.batchSize },
-              subcaseArray.slice(i, Math.min(subcaseArray.length, i + this.batchSize))
-            );
-          }
-        }
+        continue;
+      }
+
+      // Same if there ends up being only one batch.
+      const subcaseArray = Array.from(subcases);
+      if (subcaseArray.length <= this.batchSize) {
+        yield this.makeCaseSpecific(caseParams, subcaseArray);
+        continue;
+      }
+
+      // There are multiple batches. Helper function for this case:
+      const makeCaseForBatch = (batch: number) => {
+        const sliceStart = batch * this.batchSize;
+        return this.makeCaseSpecific(
+          { ...caseParams, [kBatchParamName]: batch },
+          subcaseArray.slice(sliceStart, Math.min(subcaseArray.length, sliceStart + this.batchSize))
+        );
+      };
+
+      // If we filter to just one batch, yield it.
+      if (filterToBatch !== undefined) {
+        yield makeCaseForBatch(filterToBatch);
+        continue;
+      }
+
+      // Finally, if not, yield all of the batches.
+      for (let batch = 0; batch * this.batchSize < subcaseArray.length; ++batch) {
+        yield makeCaseForBatch(batch);
       }
     }
   }
diff --git a/src/common/internal/tree.ts b/src/common/internal/tree.ts
index 812b88c59e91..6cdce2d39a60 100644
--- a/src/common/internal/tree.ts
+++ b/src/common/internal/tree.ts
@@ -350,14 +350,14 @@ export async function loadTreeForQuery(
       subtreeL2.subtreeCounts ??= { tests: 1, nodesWithTODO: 0 };
       if (t.description) setSubtreeDescriptionAndCountTODOs(subtreeL2, t.description);
 
-      let paramsFilter = null;
+      let caseFilter = null;
       if ('params' in queryToLoad) {
-        paramsFilter = queryToLoad.params;
+        caseFilter = queryToLoad.params;
       }
 
       // MAINTENANCE_TODO: If tree generation gets too slow, avoid actually iterating the cases in a
       // file if there's no need to (based on the subqueriesToExpand).
-      for (const c of t.iterate(paramsFilter)) {
+      for (const c of t.iterate(caseFilter)) {
         // iterate() guarantees c's query is equal to or a subset of queryToLoad.
 
         if (queryToLoad instanceof TestQuerySingleCase) {
diff --git a/src/unittests/loaders_and_trees.spec.ts b/src/unittests/loaders_and_trees.spec.ts
index 238c89af147c..080fa762a5fd 100644
--- a/src/unittests/loaders_and_trees.spec.ts
+++ b/src/unittests/loaders_and_trees.spec.ts
@@ -74,6 +74,11 @@ const specsData: { [k: string]: SpecFile } = {
           { b: 3, a: 1, _c: 0 },
         ])
         .fn(() => {});
+      g.test('batched')
+        // creates two cases: one for subcases 1,2 and one for subcase 3
+        .paramsSubcasesOnly(u => u.combine('x', [1, 2, 3]))
+        .batch(2)
+        .fn(() => {});
       return g;
     })(),
   },
@@ -141,7 +146,7 @@ g.test('suite').fn(t => {
 
 g.test('group').fn(async t => {
   t.collectEvents();
-  t.expect((await t.load('suite1:*')).length === 8);
+  t.expect((await t.load('suite1:*')).length === 10);
   t.expect(
     objectEquals(t.events, [
       'suite1/foo.spec.js',
@@ -187,7 +192,7 @@ g.test('test').fn(async t => {
 
   t.expect((await t.load('suite1:foo:*')).length === 3);
   t.expect((await t.load('suite1:bar,buzz,buzz:*')).length === 1);
-  t.expect((await t.load('suite1:baz:*')).length === 4);
+  t.expect((await t.load('suite1:baz:*')).length === 6);
 
   t.expect((await t.load('suite2:foof:bluh,*')).length === 1);
   t.expect((await t.load('suite2:foof:bluh,a,*')).length === 1);
@@ -239,6 +244,13 @@ g.test('case').fn(async t => {
   }
 });
 
+g.test('batching').fn(async t => {
+  t.expect((await t.load('suite1:baz:batched,*')).length === 2);
+  t.expect((await t.load('suite1:baz:batched:*')).length === 2);
+  t.expect((await t.load('suite1:baz:batched:batch__=1;*')).length === 1);
+  t.expect((await t.load('suite1:baz:batched:batch__=1')).length === 1);
+});
+
 async function runTestcase(
   t: Fixture,
   log: Logger,
@@ -738,6 +750,7 @@ g.test('iterateCollapsed').fn(async t => {
       ['suite1:bar,buzz,buzz:zap:*', 0],
       ['suite1:baz:wye:*', 0],
       ['suite1:baz:zed:*', 0],
+      ['suite1:baz:batched:*', 0],
     ]
   );
   await testIterateCollapsed(
@@ -753,6 +766,8 @@ g.test('iterateCollapsed').fn(async t => {
       ['suite1:baz:wye:x=1', undefined],
       ['suite1:baz:zed:a=1;b=2', undefined],
       ['suite1:baz:zed:b=3;a=1', undefined],
+      ['suite1:baz:batched:batch__=0', undefined],
+      ['suite1:baz:batched:batch__=1', undefined],
     ]
   );
 
@@ -780,6 +795,7 @@ g.test('iterateCollapsed').fn(async t => {
       'suite1:bar,buzz,buzz:zap:*',
       'suite1:baz:wye:*',
       'suite1:baz:zed:*',
+      'suite1:baz:batched:*',
     ]
   );
   // Test with includeEmptySubtrees=true
@@ -808,6 +824,7 @@ g.test('iterateCollapsed').fn(async t => {
       'suite1:bar,buzz,buzz:zap:*',
       'suite1:baz:wye:*',
       'suite1:baz:zed:*',
+      'suite1:baz:batched:*',
       'suite1:empty,*',
     ],
     true
@@ -818,19 +835,37 @@ g.test('iterateCollapsed').fn(async t => {
     t,
     1,
     ['suite1:baz:wye:*'],
-    ['suite1:foo:*', 'suite1:bar,buzz,buzz:*', 'suite1:baz:wye:*', 'suite1:baz:zed,*']
+    [
+      'suite1:foo:*',
+      'suite1:bar,buzz,buzz:*',
+      'suite1:baz:wye:*',
+      'suite1:baz:zed,*',
+      'suite1:baz:batched,*',
+    ]
   );
   await testIterateCollapsed(
     t,
     1,
     ['suite1:baz:zed:*'],
-    ['suite1:foo:*', 'suite1:bar,buzz,buzz:*', 'suite1:baz:wye,*', 'suite1:baz:zed:*']
+    [
+      'suite1:foo:*',
+      'suite1:bar,buzz,buzz:*',
+      'suite1:baz:wye,*',
+      'suite1:baz:zed:*',
+      'suite1:baz:batched,*',
+    ]
   );
   await testIterateCollapsed(
     t,
     1,
     ['suite1:baz:wye:*', 'suite1:baz:zed:*'],
-    ['suite1:foo:*', 'suite1:bar,buzz,buzz:*', 'suite1:baz:wye:*', 'suite1:baz:zed:*']
+    [
+      'suite1:foo:*',
+      'suite1:bar,buzz,buzz:*',
+      'suite1:baz:wye:*',
+      'suite1:baz:zed:*',
+      'suite1:baz:batched,*',
+    ]
   );
   await testIterateCollapsed(
     t,
@@ -842,6 +877,7 @@ g.test('iterateCollapsed').fn(async t => {
       'suite1:baz:wye:',
       'suite1:baz:wye:x=1;*',
       'suite1:baz:zed,*',
+      'suite1:baz:batched,*',
     ]
   );
   await testIterateCollapsed(
@@ -854,6 +890,7 @@ g.test('iterateCollapsed').fn(async t => {
       'suite1:baz:wye:',
       'suite1:baz:wye:x=1',
       'suite1:baz:zed,*',
+      'suite1:baz:batched,*',
     ]
   );
   await testIterateCollapsed(
@@ -866,6 +903,7 @@ g.test('iterateCollapsed').fn(async t => {
       'suite1:baz:wye:',
       'suite1:baz:wye:x=1;*',
       'suite1:baz:zed,*',
+      'suite1:baz:batched,*',
     ]
   );
   await testIterateCollapsed(
@@ -880,6 +918,7 @@ g.test('iterateCollapsed').fn(async t => {
       'suite1:baz:wye:',
       'suite1:baz:wye:x=1;*',
       'suite1:baz:zed:*',
+      'suite1:baz:batched:*',
     ]
   );
   await testIterateCollapsed(
@@ -894,6 +933,7 @@ g.test('iterateCollapsed').fn(async t => {
       'suite1:baz:wye:',
       'suite1:baz:wye:x=1',
       'suite1:baz:zed:*',
+      'suite1:baz:batched:*',
     ]
   );
   await testIterateCollapsed(
@@ -908,6 +948,7 @@ g.test('iterateCollapsed').fn(async t => {
       'suite1:baz:wye:',
       'suite1:baz:wye:x=1;*',
       'suite1:baz:zed:*',
+      'suite1:baz:batched:*',
     ]
   );
 

From 75c54607fe0072e4736b740d68d5826d4be75a03 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 28 Aug 2023 15:02:48 -0400
Subject: [PATCH 005/166] wgsl: Add execution tests for AF negation (#2909)

This refactors the existing code to have a clearer separation from the
non-AF test running code, and sets up for implementing vector support.

Issue #1626
---
 src/unittests/floating_point.spec.ts          | 104 ++++--
 .../shader/execution/expression/expression.ts | 327 ++++++++++++------
 .../expression/unary/af_arithmetic.spec.ts    |  43 +++
 .../expression/unary/af_assignment.spec.ts    |  28 +-
 .../execution/expression/unary/unary.ts       |  11 +-
 src/webgpu/util/floating_point.ts             |   6 +-
 6 files changed, 370 insertions(+), 149 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 3bab3682872b..9ef92528a342 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -13,6 +13,7 @@ import {
   map2DArray,
   oneULPF32,
   oneULPF16,
+  oneULPF64,
 } from '../webgpu/util/math.js';
 
 import { UnitTest } from './unit_test.js';
@@ -37,6 +38,9 @@ const kPlusNULPFunctions = {
   f16: (x: number, n: number) => {
     return x + n * oneULPF16(x);
   },
+  abstract: (x: number, n: number) => {
+    return x + n * oneULPF64(x);
+  },
 };
 
 /** @returns a number one ULP greater than the provided number */
@@ -47,6 +51,9 @@ const kPlusOneULPFunctions = {
   f16: (x: number): number => {
     return kPlusNULPFunctions['f16'](x, 1);
   },
+  abstract: (x: number): number => {
+    return kPlusNULPFunctions['abstract'](x, 1);
+  },
 };
 
 /** @returns a number N * ULP less than the provided number */
@@ -57,6 +64,9 @@ const kMinusNULPFunctions = {
   f16: (x: number, n: number) => {
     return x - n * oneULPF16(x);
   },
+  abstract: (x: number, n: number) => {
+    return x - n * oneULPF64(x);
+  },
 };
 
 /** @returns a number one ULP less than the provided number */
@@ -67,6 +77,9 @@ const kMinusOneULPFunctions = {
   f16: (x: number): number => {
     return kMinusNULPFunctions['f16'](x, 1);
   },
+  abstract: (x: number): number => {
+    return kMinusNULPFunctions['abstract'](x, 1);
+  },
 };
 
 /** @returns the expected IntervalBounds adjusted by the given error function
@@ -3074,39 +3087,74 @@ g.test('log2Interval')
     );
   });
 
-g.test('negationInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      { input: 0, expected: 0 },
-      { input: 0.1, expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] }, // ~-0.1
-      { input: 1.0, expected: -1.0 },
-      { input: 1.9, expected: [reinterpretU32AsF32(0xbff33334), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbff33334))] },  // ~-1.9
-      { input: -0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] }, // ~0.1
-      { input: -1.0, expected: 1 },
-      { input: -1.9, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3ff33334)), reinterpretU32AsF32(0x3ff33334)] },  // ~1.9
-
-      // Edge cases
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.positive.max, expected: kValue.f32.negative.min },
-      { input: kValue.f32.positive.min, expected: kValue.f32.negative.max },
-      { input: kValue.f32.negative.min, expected: kValue.f32.positive.max },
-      { input: kValue.f32.negative.max, expected: kValue.f32.positive.min },
+// prettier-ignore
+const kNegationIntervalCases = {
+  f32: [
+    // Edge cases
+    { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
+    { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
+    { input: kValue.f32.positive.max, expected: kValue.f32.negative.min },
+    { input: kValue.f32.positive.min, expected: kValue.f32.negative.max },
+    { input: kValue.f32.negative.min, expected: kValue.f32.positive.max },
+    { input: kValue.f32.negative.max, expected: kValue.f32.positive.min },
+
+    // Normals
+    { input: 0.1, expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] }, // ~-0.1
+    { input: 1.9, expected: [reinterpretU32AsF32(0xbff33334), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbff33334))] },  // ~-1.9
+    { input: -0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] }, // ~0.1
+    { input: -1.9, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3ff33334)), reinterpretU32AsF32(0x3ff33334)] },  // ~1.9
+
+    // Subnormals
+    { input: kValue.f32.subnormal.positive.max, expected: [kValue.f32.subnormal.negative.min, 0] },
+    { input: kValue.f32.subnormal.positive.min, expected: [kValue.f32.subnormal.negative.max, 0] },
+    { input: kValue.f32.subnormal.negative.min, expected: [0, kValue.f32.subnormal.positive.max] },
+    { input: kValue.f32.subnormal.negative.max, expected: [0, kValue.f32.subnormal.positive.min] },
+  ] as ScalarToIntervalCase[],
+  abstract: [
+    // Edge cases
+    { input: kValue.f64.infinity.positive, expected: kUnboundedBounds },
+    { input: kValue.f64.infinity.negative, expected: kUnboundedBounds },
+    { input: kValue.f64.positive.max, expected: kValue.f64.negative.min },
+    { input: kValue.f64.positive.min, expected: kValue.f64.negative.max },
+    { input: kValue.f64.negative.min, expected: kValue.f64.positive.max },
+    { input: kValue.f64.negative.max, expected: kValue.f64.positive.min },
+
+    // Normals
+    { input: 0.1, expected: -0.1 },
+    { input: 1.9, expected: -1.9 },
+    { input: -0.1, expected: 0.1 },
+    { input: -1.9, expected: 1.9 },
+
+    // Subnormals
+    { input: kValue.f64.subnormal.positive.max, expected: [kValue.f64.subnormal.negative.min, 0] },
+    { input: kValue.f64.subnormal.positive.min, expected: [kValue.f64.subnormal.negative.max, 0] },
+    { input: kValue.f64.subnormal.negative.min, expected: [0, kValue.f64.subnormal.positive.max] },
+    { input: kValue.f64.subnormal.negative.max, expected: [0, kValue.f64.subnormal.positive.min] },
+  ] as ScalarToIntervalCase[],
+} as const;
 
-      // 32-bit subnormals
-      { input: kValue.f32.subnormal.positive.max, expected: [kValue.f32.subnormal.negative.min, 0] },
-      { input: kValue.f32.subnormal.positive.min, expected: [kValue.f32.subnormal.negative.max, 0] },
-      { input: kValue.f32.subnormal.negative.min, expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: kValue.f32.subnormal.negative.max, expected: [0, kValue.f32.subnormal.positive.min] },
-    ]
+g.test('negationInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'abstract'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        // prettier-ignore
+        return [
+          { input: 0, expected: 0 },
+          { input: 1.0, expected: -1.0 },
+          { input: -1.0, expected: 1 },
+          ...kNegationIntervalCases[p.trait],
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.negationInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.negationInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.negationInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.negationInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/shader/execution/expression/expression.ts b/src/webgpu/shader/execution/expression/expression.ts
index e12a3f71392d..8ff28c217fc4 100644
--- a/src/webgpu/shader/execution/expression/expression.ts
+++ b/src/webgpu/shader/execution/expression/expression.ts
@@ -70,6 +70,9 @@ export type InputSource =
 /** All possible input sources */
 export const allInputSources: InputSource[] = ['const', 'uniform', 'storage_r', 'storage_rw'];
 
+/** Just constant input source */
+export const onlyConstInputSource: InputSource[] = ['const'];
+
 /** Configuration for running a expression test */
 export type Config = {
   // Where the input values are read from
@@ -85,6 +88,22 @@ export type Config = {
 
 // Helper for returning the stride for a given Type
 function valueStride(ty: Type): number {
+  // AbstractFloats are passed out of the shader via a struct of 2x u32s and
+  // unpacking containers as arrays
+  if (scalarTypeOf(ty).kind === 'abstract-float') {
+    if (ty instanceof ScalarType) {
+      return 16;
+    }
+    if (ty instanceof VectorType) {
+      if (ty.width === 2) {
+        return 16;
+      }
+      // vec3s have padding to make them the same size as vec4s
+      return 32;
+    }
+    unreachable('Matrices of AbstractFloats have not yet been implemented');
+  }
+
   if (ty instanceof MatrixType) {
     switch (ty.cols) {
       case 2:
@@ -135,10 +154,11 @@ function valueStrides(tys: Type[]): number {
 // Helper for returning the WGSL storage type for the given Type.
 function storageType(ty: Type): Type {
   if (ty instanceof ScalarType) {
-    assert(ty.kind !== 'f64', `'No storage type defined for 'f64' values`);
-    if (ty.kind === 'abstract-float') {
-      return TypeVec(2, TypeU32);
-    }
+    assert(ty.kind !== 'f64', `No storage type defined for 'f64' values`);
+    assert(
+      ty.kind !== 'abstract-float',
+      `Custom handling is implemented for 'abstract-float' values`
+    );
     if (ty.kind === 'bool') {
       return TypeU32;
     }
@@ -161,7 +181,7 @@ function fromStorage(ty: Type, expr: string): string {
   if (ty instanceof VectorType) {
     assert(
       ty.elementType.kind !== 'abstract-float',
-      `AbstractFloat values should not be in input storage`
+      `AbstractFloat values cannot appear in input storage`
     );
     assert(ty.elementType.kind !== 'f64', `'No storage type defined for 'f64' values`);
     if (ty.elementType.kind === 'bool') {
@@ -176,7 +196,7 @@ function toStorage(ty: Type, expr: string): string {
   if (ty instanceof ScalarType) {
     assert(
       ty.kind !== 'abstract-float',
-      `AbstractFloat values have custom code writing to input storage`
+      `AbstractFloat values have custom code for writing to storage`
     );
     assert(ty.kind !== 'f64', `No storage type defined for 'f64' values`);
     if (ty.kind === 'bool') {
@@ -186,7 +206,7 @@ function toStorage(ty: Type, expr: string): string {
   if (ty instanceof VectorType) {
     assert(
       ty.elementType.kind !== 'abstract-float',
-      `AbstractFloat values have custom code writing to input storage`
+      `AbstractFloat values have custom code for writing to storage`
     );
     assert(ty.elementType.kind !== 'f64', `'No storage type defined for 'f64' values`);
     if (ty.elementType.kind === 'bool') {
@@ -438,11 +458,40 @@ export type ShaderBuilder = (
  * Helper that returns the WGSL to declare the output storage buffer for a shader
  */
 function wgslOutputs(resultType: Type, count: number): string {
-  return `
+  let output_struct = undefined;
+  if (scalarTypeOf(resultType).kind !== 'abstract-float') {
+    output_struct = `
 struct Output {
   @size(${valueStride(resultType)}) value : ${storageType(resultType)}
+};`;
+  } else {
+    if (resultType instanceof ScalarType) {
+      output_struct = `struct AF {
+  low: u32,
+  high: u32,
+};
+
+struct Output {
+  @size(${valueStride(resultType)}) value: AF,
+};`;
+    }
+    if (resultType instanceof VectorType) {
+      const dim = resultType.width;
+      output_struct = `struct AF {
+  low: u32,
+  high: u32,
 };
-@group(0) @binding(0) var<storage, read_write> outputs : array<Output, ${count}>;`;
+
+struct Output {
+  @size(${valueStride(resultType)}) value: array<AF, ${dim}>,
+};`;
+    }
+    // TBD: Implement Matrix result support
+  }
+  assert(output_struct !== undefined, `No implementation for result type '${resultType}'`);
+  return `${output_struct}
+@group(0) @binding(0) var<storage, read_write> outputs : array<Output, ${count}>;
+`;
 }
 
 /**
@@ -454,10 +503,6 @@ function wgslValuesArray(
   cases: CaseList,
   expressionBuilder: ExpressionBuilder
 ): string {
-  // AbstractFloat values cannot be stored in an array
-  if (parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')) {
-    return '';
-  }
   return `
 const values = array(
   ${cases.map(c => expressionBuilder(map(c.input, v => v.wgsl()))).join(',\n  ')}
@@ -508,15 +553,16 @@ function basicExpressionShaderBody(
   cases: CaseList,
   inputSource: InputSource
 ): string {
+  assert(
+    scalarTypeOf(resultType).kind !== 'abstract-float',
+    `abstractFloatShaderBuilder should be used when result type is 'abstract-float`
+  );
   if (inputSource === 'const') {
     //////////////////////////////////////////////////////////////////////////
     // Constant eval
     //////////////////////////////////////////////////////////////////////////
     let body = '';
-    if (
-      scalarTypeOf(resultType).kind !== 'abstract-float' &&
-      parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')
-    ) {
+    if (parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')) {
       // Directly assign the expression to the output, to avoid an
       // intermediate store, which will concretize the value early
       body = cases
@@ -528,96 +574,6 @@ function basicExpressionShaderBody(
             )};`
         )
         .join('\n  ');
-    } else if (scalarTypeOf(resultType).kind === 'abstract-float') {
-      // AbstractFloats are f64s under the hood. WebGPU does not support
-      // putting f64s in buffers, so the result needs to be split up into u32s
-      // and rebuilt in the test framework.
-      //
-      // This is complicated by the fact that user defined functions cannot
-      // take/return AbstractFloats, and AbstractFloats cannot be stored in
-      // variables, so the code cannot just inject a simple utility function
-      // at the top of the shader, instead this snippet needs to be inlined
-      // everywhere the test needs to return an AbstractFloat.
-      //
-      // select is used below, since ifs are not available during constant
-      // eval. This has the side effect of short-circuiting doesn't occur, so
-      // both sides of the select have to evaluate and be valid.
-      //
-      // This snippet implements FTZ for subnormals to bypass the need for
-      // complex subnormal specific logic.
-      //
-      // Expressions resulting in subnormals can still be reasonably tested,
-      // since this snippet will return 0 with the correct sign, which is
-      // always in the acceptance interval for a subnormal result, since an
-      // implementation may FTZ.
-      //
-      // Document for the snippet is included here in this code block, since
-      // shader length affects compilation time  significantly on some
-      // backends.
-      //
-      // Snippet with documentation:
-      //   const kExponentBias = 1022;
-      //
-      //   // Detect if the value is zero or subnormal, so that FTZ behaviour
-      //   // can occur
-      //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
-      //
-      //   // MSB of the upper u32 is 1 if the value is negative, otherwise 0
-      //   // Extract the sign bit early, so that abs() can be used with
-      //   // frexp() so negative cases do not need to be handled
-      //   const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
-      //
-      //   // Use frexp() to obtain the exponent and fractional parts, and
-      //   // then perform FTZ if needed
-      //   const f = frexp(abs(${expr}));
-      //   const f_fract = select(f.fract, 0, subnormal_or_zero);
-      //   const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
-      //
-      //   // Adjust for the exponent bias and shift for storing in bits
-      //   // [20..31] of the upper u32
-      //   const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
-      //
-      //   // Extract the portion of the mantissa that appears in upper u32 as
-      //   // a float for later use
-      //   const high_mantissa = ldexp(f_fract, 21);
-      //
-      //   // Extract the portion of the mantissa that appears in upper u32 as
-      //   // as bits. This value is masked, because normals will explicitly
-      //   // have the implicit leading 1 that should not be in the final
-      //   // result.
-      //   const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
-      //
-      //   // Calculate the mantissa stored in the lower u32 as a float
-      //   const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
-      //
-      //   // Convert the lower u32 mantissa to bits
-      //   const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
-      //
-      //   // Pack the result into 2x u32s for writing out to the testing
-      //   // framework
-      //   outputs[${i}].value.x = low_mantissa_bits;
-      //   outputs[${i}].value.y = sign_bit | exponent_bits | high_mantissa_bits;
-      body = cases
-        .map((c, i) => {
-          const expr = `${expressionBuilder(map(c.input, v => v.wgsl()))}`;
-          // prettier-ignore
-          return `  {
-    const kExponentBias = 1022;
-    const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
-    const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
-    const f = frexp(abs(${expr}));
-    const f_fract = select(f.fract, 0, subnormal_or_zero);
-    const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
-    const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
-    const high_mantissa = ldexp(f_fract, 21);
-    const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
-    const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
-    const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
-    outputs[${i}].value.x = low_mantissa_bits;
-    outputs[${i}].value.y = sign_bit | exponent_bits | high_mantissa_bits;
-  }`;
-        })
-        .join('\n  ');
     } else if (globalTestConfig.unrollConstEvalLoops) {
       body = cases
         .map((_, i) => {
@@ -808,6 +764,163 @@ fn main() {
   };
 }
 
+/**
+ * @returns a string that extracts the value of an AbstractFloat into an output
+ *          destination
+ * @param expr expression for an AbstractFloat value, if working with vectors or
+ *             matrices, this string needs to include indexing into the
+ *             container.
+ * @param case_idx index in the case output array to assign the result
+ * @param accessor string representing how access the AF that needs to be extracted.
+ *              For scalars this should be left as ''.
+ *              For vectors and matrices this will be an indexing operation,
+ *              i.e. '[i]'
+ * */
+function abstractFloatSnippet(expr: string, case_idx: number, accessor: string = ''): string {
+  // AbstractFloats are f64s under the hood. WebGPU does not support
+  // putting f64s in buffers, so the result needs to be split up into u32s
+  // and rebuilt in the test framework.
+  //
+  // Since there is no 64-bit data type that can be used as an element for a
+  // vector or a matrix in WGSL, the testing framework needs to pass the u32s
+  // via a struct with two u32s, and deconstruct vectors and matrices into
+  // arrays.
+  //
+  // This is complicated by the fact that user defined functions cannot
+  // take/return AbstractFloats, and AbstractFloats cannot be stored in
+  // variables, so the code cannot just inject a simple utility function
+  // at the top of the shader, instead this snippet needs to be inlined
+  // everywhere the test needs to return an AbstractFloat.
+  //
+  // select is used below, since ifs are not available during constant
+  // eval. This has the side effect of short-circuiting doesn't occur, so
+  // both sides of the select have to evaluate and be valid.
+  //
+  // This snippet implements FTZ for subnormals to bypass the need for
+  // complex subnormal specific logic.
+  //
+  // Expressions resulting in subnormals can still be reasonably tested,
+  // since this snippet will return 0 with the correct sign, which is
+  // always in the acceptance interval for a subnormal result, since an
+  // implementation may FTZ.
+  //
+  // Documentation for the snippet working with scalar results is included here
+  // in this code block, since shader length affects compilation time
+  // significantly on some backends. The code for vectors and matrices basically
+  // the same thing, with extra indexing operations.
+  //
+  // Snippet with documentation:
+  //   const kExponentBias = 1022;
+  //
+  //   // Detect if the value is zero or subnormal, so that FTZ behaviour
+  //   // can occur
+  //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
+  //
+  //   // MSB of the upper u32 is 1 if the value is negative, otherwise 0
+  //   // Extract the sign bit early, so that abs() can be used with
+  //   // frexp() so negative cases do not need to be handled
+  //   const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
+  //
+  //   // Use frexp() to obtain the exponent and fractional parts, and
+  //   // then perform FTZ if needed
+  //   const f = frexp(abs(${expr}));
+  //   const f_fract = select(f.fract, 0, subnormal_or_zero);
+  //   const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
+  //
+  //   // Adjust for the exponent bias and shift for storing in bits
+  //   // [20..31] of the upper u32
+  //   const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
+  //
+  //   // Extract the portion of the mantissa that appears in upper u32 as
+  //   // a float for later use
+  //   const high_mantissa = ldexp(f_fract, 21);
+  //
+  //   // Extract the portion of the mantissa that appears in upper u32 as
+  //   // as bits. This value is masked, because normals will explicitly
+  //   // have the implicit leading 1 that should not be in the final
+  //   // result.
+  //   const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
+  //
+  //   // Calculate the mantissa stored in the lower u32 as a float
+  //   const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
+  //
+  //   // Convert the lower u32 mantissa to bits
+  //   const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
+  //
+  //   outputs[${i}].value.high = sign_bit | exponent_bits | high_mantissa_bits;
+  //   outputs[${i}].value.low = low_mantissa_bits;
+  // prettier-ignore
+  return `  {
+    const kExponentBias = 1022;
+    const subnormal_or_zero : bool = (${expr}${accessor} <= ${kValue.f64.subnormal.positive.max}) && (${expr}${accessor} >= ${kValue.f64.subnormal.negative.min});
+    const sign_bit : u32 = select(0, 0x80000000, ${expr}${accessor} < 0);
+    const f = frexp(abs(${expr}${accessor}));
+    const f_fract = select(f.fract, 0, subnormal_or_zero);
+    const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
+    const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
+    const high_mantissa = ldexp(f_fract, 21);
+    const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
+    const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
+    const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
+    outputs[${case_idx}].value${accessor}.high = sign_bit | exponent_bits | high_mantissa_bits;
+    outputs[${case_idx}].value${accessor}.low = low_mantissa_bits;
+  }`;
+}
+
+/** @returns a string for a specific case that has a AbstractFloat result */
+function abstractFloatCaseBody(expr: string, resultType: Type, i: number): string {
+  if (resultType instanceof ScalarType) {
+    return abstractFloatSnippet(expr, i);
+  }
+
+  if (resultType instanceof VectorType) {
+    return [...Array(resultType.width).keys()]
+      .map(dim_idx => abstractFloatSnippet(expr, i, `[${dim_idx}]`))
+      .join('  \n');
+  }
+  // TDB implement matrix support
+
+  unreachable(`Results of type '${resultType}' not yet implemented`);
+}
+
+/**
+ * @returns a ShaderBuilder that builds a test shader hands AbstractFloat results.
+ * @param expressionBuilder an expression builder that will return AbstractFloats
+ */
+export function abstractFloatShaderBuilder(expressionBuilder: ExpressionBuilder): ShaderBuilder {
+  return (
+    parameterTypes: Array<Type>,
+    resultType: Type,
+    cases: CaseList,
+    inputSource: InputSource
+  ) => {
+    assert(inputSource === 'const', 'AbstractFloat results are only defined for const-eval');
+    assert(
+      scalarTypeOf(resultType).kind === 'abstract-float',
+      `Expected resultType of 'abstract-float', received '${scalarTypeOf(resultType).kind}' instead`
+    );
+
+    const body = cases
+      .map((c, i) => {
+        const expr = `${expressionBuilder(map(c.input, v => v.wgsl()))}`;
+        return abstractFloatCaseBody(expr, resultType, i);
+      })
+      .join('\n  ');
+
+    return `
+${wgslHeader(parameterTypes, resultType)}
+
+${wgslOutputs(resultType, cases.length)}
+
+${wgslValuesArray(parameterTypes, resultType, cases, expressionBuilder)}
+
+@compute @workgroup_size(1)
+fn main() {
+${body}
+}`;
+  };
+}
+
 /**
  * Constructs and returns a GPUComputePipeline and GPUBindGroup for running a
  * batch of test cases. If a pre-created pipeline can be found in
diff --git a/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts b/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts
new file mode 100644
index 000000000000..d7939ad2b17f
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts
@@ -0,0 +1,43 @@
+export const description = `
+Execution Tests for AbstractFloat arithmetic unary expression operations
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractFloat } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { fullF64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { abstract_unary } from './unary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+export const d = makeCaseCache('unary/f32_arithmetic', {
+  negation: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      fullF64Range({ neg_norm: 250, neg_sub: 20, pos_sub: 20, pos_norm: 250 }),
+      'unfiltered',
+      FP.abstract.negationInterval
+    );
+  },
+});
+
+g.test('negation')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: -x
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cases = await d.get('negation');
+    await run(t, abstract_unary('-'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
+  });
diff --git a/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts b/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
index eecc43a9b2a7..372051c949a3 100644
--- a/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
@@ -14,9 +14,21 @@ import {
   reinterpretU64AsF64,
 } from '../../../../util/math.js';
 import { makeCaseCache } from '../case_cache.js';
-import { allInputSources, run } from '../expression.js';
+import {
+  abstractFloatShaderBuilder,
+  basicExpressionBuilder,
+  onlyConstInputSource,
+  run,
+  ShaderBuilder,
+} from '../expression.js';
+
+function concrete_assignment(): ShaderBuilder {
+  return basicExpressionBuilder(value => `${value}`);
+}
 
-import { assignment } from './unary.js';
+function abstract_assignment(): ShaderBuilder {
+  return abstractFloatShaderBuilder(value => `${value}`);
+}
 
 export const g = makeTestGroup(GPUTest);
 
@@ -68,10 +80,10 @@ g.test('abstract')
 testing that extracting abstract floats works
 `
   )
-  .params(u => u.combine('inputSource', [allInputSources[0]])) // Only defined for const-eval
+  .params(u => u.combine('inputSource', onlyConstInputSource))
   .fn(async t => {
     const cases = await d.get('abstract');
-    await run(t, assignment(), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
+    await run(t, abstract_assignment(), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
   });
 
 g.test('f32')
@@ -81,10 +93,10 @@ g.test('f32')
 concretizing to f32
 `
   )
-  .params(u => u.combine('inputSource', [allInputSources[0]])) // Only defined for const-eval
+  .params(u => u.combine('inputSource', onlyConstInputSource))
   .fn(async t => {
     const cases = await d.get('f32');
-    await run(t, assignment(), [TypeAbstractFloat], TypeF32, t.params, cases);
+    await run(t, concrete_assignment(), [TypeAbstractFloat], TypeF32, t.params, cases);
   });
 
 g.test('f16')
@@ -97,8 +109,8 @@ concretizing to f16
   .beforeAllSubcases(t => {
     t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
   })
-  .params(u => u.combine('inputSource', [allInputSources[0]])) // Only defined for const-eval
+  .params(u => u.combine('inputSource', onlyConstInputSource))
   .fn(async t => {
     const cases = await d.get('f16');
-    await run(t, assignment(), [TypeAbstractFloat], TypeF16, t.params, cases);
+    await run(t, concrete_assignment(), [TypeAbstractFloat], TypeF16, t.params, cases);
   });
diff --git a/src/webgpu/shader/execution/expression/unary/unary.ts b/src/webgpu/shader/execution/expression/unary/unary.ts
index ce9d6b814747..995ca3ea172d 100644
--- a/src/webgpu/shader/execution/expression/unary/unary.ts
+++ b/src/webgpu/shader/execution/expression/unary/unary.ts
@@ -1,10 +1,15 @@
-import { basicExpressionBuilder, ShaderBuilder } from '../expression.js';
+import {
+  abstractFloatShaderBuilder,
+  basicExpressionBuilder,
+  ShaderBuilder,
+} from '../expression.js';
 
 /* @returns a ShaderBuilder that evaluates a prefix unary operation */
 export function unary(op: string): ShaderBuilder {
   return basicExpressionBuilder(value => `${op}(${value})`);
 }
 
-export function assignment(): ShaderBuilder {
-  return basicExpressionBuilder(value => `${value}`);
+/* @returns a ShaderBuilder that evaluates a prefix unary operation that returns AbstractFloats */
+export function abstract_unary(op: string): ShaderBuilder {
+  return abstractFloatShaderBuilder(value => `${op}(${value})`);
 }
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index a1b459359c9e..29ca13c39ff8 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5,9 +5,9 @@ import { Case, IntervalFilter } from '../shader/execution/expression/expression.
 import { anyOf } from './compare.js';
 import { kValue } from './constants.js';
 import {
+  abstractFloat,
   f16,
   f32,
-  f64,
   isFloatType,
   reinterpretF16AsU16,
   reinterpretF32AsU32,
@@ -4820,7 +4820,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly isSubnormal = isSubnormalNumberF64;
   public readonly flushSubnormal = flushSubnormalNumberF64;
   public readonly oneULP = oneULPF64;
-  public readonly scalarBuilder = f64;
+  public readonly scalarBuilder = abstractFloat;
 
   // Framework - Fundamental Error Intervals - Overrides
   public readonly absoluteErrorInterval = this.unboundedAbsoluteErrorInterval.bind(this);
@@ -4886,7 +4886,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly multiplicationVectorMatrixInterval = this.unimplementedVectorMatrixToVector.bind(
     this
   );
-  public readonly negationInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly negationInterval = this.negationIntervalImpl.bind(this);
   public readonly normalizeInterval = this.unimplementedVectorToVector.bind(this);
   public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this);
   public readonly quantizeToF16Interval = this.unimplementedScalarToInterval.bind(this);

From a0dcafc9407e51555921b07b2c91ca5ea2faee35 Mon Sep 17 00:00:00 2001
From: Austin Eng <enga@chromium.org>
Date: Tue, 29 Aug 2023 09:57:57 -0700
Subject: [PATCH 006/166] Revert "wgsl: Add execution tests for AF negation
 (#2909)" (#2912)

This reverts commit 75c54607fe0072e4736b740d68d5826d4be75a03.
---
 src/unittests/floating_point.spec.ts          | 104 ++----
 .../shader/execution/expression/expression.ts | 327 ++++++------------
 .../expression/unary/af_arithmetic.spec.ts    |  43 ---
 .../expression/unary/af_assignment.spec.ts    |  28 +-
 .../execution/expression/unary/unary.ts       |  11 +-
 src/webgpu/util/floating_point.ts             |   6 +-
 6 files changed, 149 insertions(+), 370 deletions(-)
 delete mode 100644 src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 9ef92528a342..3bab3682872b 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -13,7 +13,6 @@ import {
   map2DArray,
   oneULPF32,
   oneULPF16,
-  oneULPF64,
 } from '../webgpu/util/math.js';
 
 import { UnitTest } from './unit_test.js';
@@ -38,9 +37,6 @@ const kPlusNULPFunctions = {
   f16: (x: number, n: number) => {
     return x + n * oneULPF16(x);
   },
-  abstract: (x: number, n: number) => {
-    return x + n * oneULPF64(x);
-  },
 };
 
 /** @returns a number one ULP greater than the provided number */
@@ -51,9 +47,6 @@ const kPlusOneULPFunctions = {
   f16: (x: number): number => {
     return kPlusNULPFunctions['f16'](x, 1);
   },
-  abstract: (x: number): number => {
-    return kPlusNULPFunctions['abstract'](x, 1);
-  },
 };
 
 /** @returns a number N * ULP less than the provided number */
@@ -64,9 +57,6 @@ const kMinusNULPFunctions = {
   f16: (x: number, n: number) => {
     return x - n * oneULPF16(x);
   },
-  abstract: (x: number, n: number) => {
-    return x - n * oneULPF64(x);
-  },
 };
 
 /** @returns a number one ULP less than the provided number */
@@ -77,9 +67,6 @@ const kMinusOneULPFunctions = {
   f16: (x: number): number => {
     return kMinusNULPFunctions['f16'](x, 1);
   },
-  abstract: (x: number): number => {
-    return kMinusNULPFunctions['abstract'](x, 1);
-  },
 };
 
 /** @returns the expected IntervalBounds adjusted by the given error function
@@ -3087,74 +3074,39 @@ g.test('log2Interval')
     );
   });
 
-// prettier-ignore
-const kNegationIntervalCases = {
-  f32: [
-    // Edge cases
-    { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-    { input: kValue.f32.positive.max, expected: kValue.f32.negative.min },
-    { input: kValue.f32.positive.min, expected: kValue.f32.negative.max },
-    { input: kValue.f32.negative.min, expected: kValue.f32.positive.max },
-    { input: kValue.f32.negative.max, expected: kValue.f32.positive.min },
-
-    // Normals
-    { input: 0.1, expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] }, // ~-0.1
-    { input: 1.9, expected: [reinterpretU32AsF32(0xbff33334), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbff33334))] },  // ~-1.9
-    { input: -0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] }, // ~0.1
-    { input: -1.9, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3ff33334)), reinterpretU32AsF32(0x3ff33334)] },  // ~1.9
-
-    // Subnormals
-    { input: kValue.f32.subnormal.positive.max, expected: [kValue.f32.subnormal.negative.min, 0] },
-    { input: kValue.f32.subnormal.positive.min, expected: [kValue.f32.subnormal.negative.max, 0] },
-    { input: kValue.f32.subnormal.negative.min, expected: [0, kValue.f32.subnormal.positive.max] },
-    { input: kValue.f32.subnormal.negative.max, expected: [0, kValue.f32.subnormal.positive.min] },
-  ] as ScalarToIntervalCase[],
-  abstract: [
-    // Edge cases
-    { input: kValue.f64.infinity.positive, expected: kUnboundedBounds },
-    { input: kValue.f64.infinity.negative, expected: kUnboundedBounds },
-    { input: kValue.f64.positive.max, expected: kValue.f64.negative.min },
-    { input: kValue.f64.positive.min, expected: kValue.f64.negative.max },
-    { input: kValue.f64.negative.min, expected: kValue.f64.positive.max },
-    { input: kValue.f64.negative.max, expected: kValue.f64.positive.min },
-
-    // Normals
-    { input: 0.1, expected: -0.1 },
-    { input: 1.9, expected: -1.9 },
-    { input: -0.1, expected: 0.1 },
-    { input: -1.9, expected: 1.9 },
-
-    // Subnormals
-    { input: kValue.f64.subnormal.positive.max, expected: [kValue.f64.subnormal.negative.min, 0] },
-    { input: kValue.f64.subnormal.positive.min, expected: [kValue.f64.subnormal.negative.max, 0] },
-    { input: kValue.f64.subnormal.negative.min, expected: [0, kValue.f64.subnormal.positive.max] },
-    { input: kValue.f64.subnormal.negative.max, expected: [0, kValue.f64.subnormal.positive.min] },
-  ] as ScalarToIntervalCase[],
-} as const;
+g.test('negationInterval_f32')
+  .paramsSubcasesOnly<ScalarToIntervalCase>(
+    // prettier-ignore
+    [
+      { input: 0, expected: 0 },
+      { input: 0.1, expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] }, // ~-0.1
+      { input: 1.0, expected: -1.0 },
+      { input: 1.9, expected: [reinterpretU32AsF32(0xbff33334), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbff33334))] },  // ~-1.9
+      { input: -0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] }, // ~0.1
+      { input: -1.0, expected: 1 },
+      { input: -1.9, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3ff33334)), reinterpretU32AsF32(0x3ff33334)] },  // ~1.9
 
-g.test('negationInterval')
-  .params(u =>
-    u
-      .combine('trait', ['f32', 'abstract'] as const)
-      .beginSubcases()
-      .expandWithParams<ScalarToIntervalCase>(p => {
-        // prettier-ignore
-        return [
-          { input: 0, expected: 0 },
-          { input: 1.0, expected: -1.0 },
-          { input: -1.0, expected: 1 },
-          ...kNegationIntervalCases[p.trait],
-        ];
-      })
+      // Edge cases
+      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
+      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
+      { input: kValue.f32.positive.max, expected: kValue.f32.negative.min },
+      { input: kValue.f32.positive.min, expected: kValue.f32.negative.max },
+      { input: kValue.f32.negative.min, expected: kValue.f32.positive.max },
+      { input: kValue.f32.negative.max, expected: kValue.f32.positive.min },
+
+      // 32-bit subnormals
+      { input: kValue.f32.subnormal.positive.max, expected: [kValue.f32.subnormal.negative.min, 0] },
+      { input: kValue.f32.subnormal.positive.min, expected: [kValue.f32.subnormal.negative.max, 0] },
+      { input: kValue.f32.subnormal.negative.min, expected: [0, kValue.f32.subnormal.positive.max] },
+      { input: kValue.f32.subnormal.negative.max, expected: [0, kValue.f32.subnormal.positive.min] },
+    ]
   )
   .fn(t => {
-    const trait = FP[t.params.trait];
-    const expected = trait.toInterval(t.params.expected);
-    const got = trait.negationInterval(t.params.input);
+    const expected = FP.f32.toInterval(t.params.expected);
+    const got = FP.f32.negationInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `${t.params.trait}.negationInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `f32.negationInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/shader/execution/expression/expression.ts b/src/webgpu/shader/execution/expression/expression.ts
index 8ff28c217fc4..e12a3f71392d 100644
--- a/src/webgpu/shader/execution/expression/expression.ts
+++ b/src/webgpu/shader/execution/expression/expression.ts
@@ -70,9 +70,6 @@ export type InputSource =
 /** All possible input sources */
 export const allInputSources: InputSource[] = ['const', 'uniform', 'storage_r', 'storage_rw'];
 
-/** Just constant input source */
-export const onlyConstInputSource: InputSource[] = ['const'];
-
 /** Configuration for running a expression test */
 export type Config = {
   // Where the input values are read from
@@ -88,22 +85,6 @@ export type Config = {
 
 // Helper for returning the stride for a given Type
 function valueStride(ty: Type): number {
-  // AbstractFloats are passed out of the shader via a struct of 2x u32s and
-  // unpacking containers as arrays
-  if (scalarTypeOf(ty).kind === 'abstract-float') {
-    if (ty instanceof ScalarType) {
-      return 16;
-    }
-    if (ty instanceof VectorType) {
-      if (ty.width === 2) {
-        return 16;
-      }
-      // vec3s have padding to make them the same size as vec4s
-      return 32;
-    }
-    unreachable('Matrices of AbstractFloats have not yet been implemented');
-  }
-
   if (ty instanceof MatrixType) {
     switch (ty.cols) {
       case 2:
@@ -154,11 +135,10 @@ function valueStrides(tys: Type[]): number {
 // Helper for returning the WGSL storage type for the given Type.
 function storageType(ty: Type): Type {
   if (ty instanceof ScalarType) {
-    assert(ty.kind !== 'f64', `No storage type defined for 'f64' values`);
-    assert(
-      ty.kind !== 'abstract-float',
-      `Custom handling is implemented for 'abstract-float' values`
-    );
+    assert(ty.kind !== 'f64', `'No storage type defined for 'f64' values`);
+    if (ty.kind === 'abstract-float') {
+      return TypeVec(2, TypeU32);
+    }
     if (ty.kind === 'bool') {
       return TypeU32;
     }
@@ -181,7 +161,7 @@ function fromStorage(ty: Type, expr: string): string {
   if (ty instanceof VectorType) {
     assert(
       ty.elementType.kind !== 'abstract-float',
-      `AbstractFloat values cannot appear in input storage`
+      `AbstractFloat values should not be in input storage`
     );
     assert(ty.elementType.kind !== 'f64', `'No storage type defined for 'f64' values`);
     if (ty.elementType.kind === 'bool') {
@@ -196,7 +176,7 @@ function toStorage(ty: Type, expr: string): string {
   if (ty instanceof ScalarType) {
     assert(
       ty.kind !== 'abstract-float',
-      `AbstractFloat values have custom code for writing to storage`
+      `AbstractFloat values have custom code writing to input storage`
     );
     assert(ty.kind !== 'f64', `No storage type defined for 'f64' values`);
     if (ty.kind === 'bool') {
@@ -206,7 +186,7 @@ function toStorage(ty: Type, expr: string): string {
   if (ty instanceof VectorType) {
     assert(
       ty.elementType.kind !== 'abstract-float',
-      `AbstractFloat values have custom code for writing to storage`
+      `AbstractFloat values have custom code writing to input storage`
     );
     assert(ty.elementType.kind !== 'f64', `'No storage type defined for 'f64' values`);
     if (ty.elementType.kind === 'bool') {
@@ -458,40 +438,11 @@ export type ShaderBuilder = (
  * Helper that returns the WGSL to declare the output storage buffer for a shader
  */
 function wgslOutputs(resultType: Type, count: number): string {
-  let output_struct = undefined;
-  if (scalarTypeOf(resultType).kind !== 'abstract-float') {
-    output_struct = `
+  return `
 struct Output {
   @size(${valueStride(resultType)}) value : ${storageType(resultType)}
-};`;
-  } else {
-    if (resultType instanceof ScalarType) {
-      output_struct = `struct AF {
-  low: u32,
-  high: u32,
-};
-
-struct Output {
-  @size(${valueStride(resultType)}) value: AF,
-};`;
-    }
-    if (resultType instanceof VectorType) {
-      const dim = resultType.width;
-      output_struct = `struct AF {
-  low: u32,
-  high: u32,
 };
-
-struct Output {
-  @size(${valueStride(resultType)}) value: array<AF, ${dim}>,
-};`;
-    }
-    // TBD: Implement Matrix result support
-  }
-  assert(output_struct !== undefined, `No implementation for result type '${resultType}'`);
-  return `${output_struct}
-@group(0) @binding(0) var<storage, read_write> outputs : array<Output, ${count}>;
-`;
+@group(0) @binding(0) var<storage, read_write> outputs : array<Output, ${count}>;`;
 }
 
 /**
@@ -503,6 +454,10 @@ function wgslValuesArray(
   cases: CaseList,
   expressionBuilder: ExpressionBuilder
 ): string {
+  // AbstractFloat values cannot be stored in an array
+  if (parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')) {
+    return '';
+  }
   return `
 const values = array(
   ${cases.map(c => expressionBuilder(map(c.input, v => v.wgsl()))).join(',\n  ')}
@@ -553,16 +508,15 @@ function basicExpressionShaderBody(
   cases: CaseList,
   inputSource: InputSource
 ): string {
-  assert(
-    scalarTypeOf(resultType).kind !== 'abstract-float',
-    `abstractFloatShaderBuilder should be used when result type is 'abstract-float`
-  );
   if (inputSource === 'const') {
     //////////////////////////////////////////////////////////////////////////
     // Constant eval
     //////////////////////////////////////////////////////////////////////////
     let body = '';
-    if (parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')) {
+    if (
+      scalarTypeOf(resultType).kind !== 'abstract-float' &&
+      parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')
+    ) {
       // Directly assign the expression to the output, to avoid an
       // intermediate store, which will concretize the value early
       body = cases
@@ -574,6 +528,96 @@ function basicExpressionShaderBody(
             )};`
         )
         .join('\n  ');
+    } else if (scalarTypeOf(resultType).kind === 'abstract-float') {
+      // AbstractFloats are f64s under the hood. WebGPU does not support
+      // putting f64s in buffers, so the result needs to be split up into u32s
+      // and rebuilt in the test framework.
+      //
+      // This is complicated by the fact that user defined functions cannot
+      // take/return AbstractFloats, and AbstractFloats cannot be stored in
+      // variables, so the code cannot just inject a simple utility function
+      // at the top of the shader, instead this snippet needs to be inlined
+      // everywhere the test needs to return an AbstractFloat.
+      //
+      // select is used below, since ifs are not available during constant
+      // eval. This has the side effect of short-circuiting doesn't occur, so
+      // both sides of the select have to evaluate and be valid.
+      //
+      // This snippet implements FTZ for subnormals to bypass the need for
+      // complex subnormal specific logic.
+      //
+      // Expressions resulting in subnormals can still be reasonably tested,
+      // since this snippet will return 0 with the correct sign, which is
+      // always in the acceptance interval for a subnormal result, since an
+      // implementation may FTZ.
+      //
+      // Document for the snippet is included here in this code block, since
+      // shader length affects compilation time  significantly on some
+      // backends.
+      //
+      // Snippet with documentation:
+      //   const kExponentBias = 1022;
+      //
+      //   // Detect if the value is zero or subnormal, so that FTZ behaviour
+      //   // can occur
+      //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
+      //
+      //   // MSB of the upper u32 is 1 if the value is negative, otherwise 0
+      //   // Extract the sign bit early, so that abs() can be used with
+      //   // frexp() so negative cases do not need to be handled
+      //   const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
+      //
+      //   // Use frexp() to obtain the exponent and fractional parts, and
+      //   // then perform FTZ if needed
+      //   const f = frexp(abs(${expr}));
+      //   const f_fract = select(f.fract, 0, subnormal_or_zero);
+      //   const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
+      //
+      //   // Adjust for the exponent bias and shift for storing in bits
+      //   // [20..31] of the upper u32
+      //   const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
+      //
+      //   // Extract the portion of the mantissa that appears in upper u32 as
+      //   // a float for later use
+      //   const high_mantissa = ldexp(f_fract, 21);
+      //
+      //   // Extract the portion of the mantissa that appears in upper u32 as
+      //   // as bits. This value is masked, because normals will explicitly
+      //   // have the implicit leading 1 that should not be in the final
+      //   // result.
+      //   const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
+      //
+      //   // Calculate the mantissa stored in the lower u32 as a float
+      //   const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
+      //
+      //   // Convert the lower u32 mantissa to bits
+      //   const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
+      //
+      //   // Pack the result into 2x u32s for writing out to the testing
+      //   // framework
+      //   outputs[${i}].value.x = low_mantissa_bits;
+      //   outputs[${i}].value.y = sign_bit | exponent_bits | high_mantissa_bits;
+      body = cases
+        .map((c, i) => {
+          const expr = `${expressionBuilder(map(c.input, v => v.wgsl()))}`;
+          // prettier-ignore
+          return `  {
+    const kExponentBias = 1022;
+    const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
+    const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
+    const f = frexp(abs(${expr}));
+    const f_fract = select(f.fract, 0, subnormal_or_zero);
+    const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
+    const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
+    const high_mantissa = ldexp(f_fract, 21);
+    const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
+    const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
+    const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
+    outputs[${i}].value.x = low_mantissa_bits;
+    outputs[${i}].value.y = sign_bit | exponent_bits | high_mantissa_bits;
+  }`;
+        })
+        .join('\n  ');
     } else if (globalTestConfig.unrollConstEvalLoops) {
       body = cases
         .map((_, i) => {
@@ -764,163 +808,6 @@ fn main() {
   };
 }
 
-/**
- * @returns a string that extracts the value of an AbstractFloat into an output
- *          destination
- * @param expr expression for an AbstractFloat value, if working with vectors or
- *             matrices, this string needs to include indexing into the
- *             container.
- * @param case_idx index in the case output array to assign the result
- * @param accessor string representing how access the AF that needs to be extracted.
- *              For scalars this should be left as ''.
- *              For vectors and matrices this will be an indexing operation,
- *              i.e. '[i]'
- * */
-function abstractFloatSnippet(expr: string, case_idx: number, accessor: string = ''): string {
-  // AbstractFloats are f64s under the hood. WebGPU does not support
-  // putting f64s in buffers, so the result needs to be split up into u32s
-  // and rebuilt in the test framework.
-  //
-  // Since there is no 64-bit data type that can be used as an element for a
-  // vector or a matrix in WGSL, the testing framework needs to pass the u32s
-  // via a struct with two u32s, and deconstruct vectors and matrices into
-  // arrays.
-  //
-  // This is complicated by the fact that user defined functions cannot
-  // take/return AbstractFloats, and AbstractFloats cannot be stored in
-  // variables, so the code cannot just inject a simple utility function
-  // at the top of the shader, instead this snippet needs to be inlined
-  // everywhere the test needs to return an AbstractFloat.
-  //
-  // select is used below, since ifs are not available during constant
-  // eval. This has the side effect of short-circuiting doesn't occur, so
-  // both sides of the select have to evaluate and be valid.
-  //
-  // This snippet implements FTZ for subnormals to bypass the need for
-  // complex subnormal specific logic.
-  //
-  // Expressions resulting in subnormals can still be reasonably tested,
-  // since this snippet will return 0 with the correct sign, which is
-  // always in the acceptance interval for a subnormal result, since an
-  // implementation may FTZ.
-  //
-  // Documentation for the snippet working with scalar results is included here
-  // in this code block, since shader length affects compilation time
-  // significantly on some backends. The code for vectors and matrices basically
-  // the same thing, with extra indexing operations.
-  //
-  // Snippet with documentation:
-  //   const kExponentBias = 1022;
-  //
-  //   // Detect if the value is zero or subnormal, so that FTZ behaviour
-  //   // can occur
-  //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
-  //
-  //   // MSB of the upper u32 is 1 if the value is negative, otherwise 0
-  //   // Extract the sign bit early, so that abs() can be used with
-  //   // frexp() so negative cases do not need to be handled
-  //   const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
-  //
-  //   // Use frexp() to obtain the exponent and fractional parts, and
-  //   // then perform FTZ if needed
-  //   const f = frexp(abs(${expr}));
-  //   const f_fract = select(f.fract, 0, subnormal_or_zero);
-  //   const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
-  //
-  //   // Adjust for the exponent bias and shift for storing in bits
-  //   // [20..31] of the upper u32
-  //   const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
-  //
-  //   // Extract the portion of the mantissa that appears in upper u32 as
-  //   // a float for later use
-  //   const high_mantissa = ldexp(f_fract, 21);
-  //
-  //   // Extract the portion of the mantissa that appears in upper u32 as
-  //   // as bits. This value is masked, because normals will explicitly
-  //   // have the implicit leading 1 that should not be in the final
-  //   // result.
-  //   const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
-  //
-  //   // Calculate the mantissa stored in the lower u32 as a float
-  //   const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
-  //
-  //   // Convert the lower u32 mantissa to bits
-  //   const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
-  //
-  //   outputs[${i}].value.high = sign_bit | exponent_bits | high_mantissa_bits;
-  //   outputs[${i}].value.low = low_mantissa_bits;
-  // prettier-ignore
-  return `  {
-    const kExponentBias = 1022;
-    const subnormal_or_zero : bool = (${expr}${accessor} <= ${kValue.f64.subnormal.positive.max}) && (${expr}${accessor} >= ${kValue.f64.subnormal.negative.min});
-    const sign_bit : u32 = select(0, 0x80000000, ${expr}${accessor} < 0);
-    const f = frexp(abs(${expr}${accessor}));
-    const f_fract = select(f.fract, 0, subnormal_or_zero);
-    const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
-    const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
-    const high_mantissa = ldexp(f_fract, 21);
-    const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
-    const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
-    const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
-    outputs[${case_idx}].value${accessor}.high = sign_bit | exponent_bits | high_mantissa_bits;
-    outputs[${case_idx}].value${accessor}.low = low_mantissa_bits;
-  }`;
-}
-
-/** @returns a string for a specific case that has a AbstractFloat result */
-function abstractFloatCaseBody(expr: string, resultType: Type, i: number): string {
-  if (resultType instanceof ScalarType) {
-    return abstractFloatSnippet(expr, i);
-  }
-
-  if (resultType instanceof VectorType) {
-    return [...Array(resultType.width).keys()]
-      .map(dim_idx => abstractFloatSnippet(expr, i, `[${dim_idx}]`))
-      .join('  \n');
-  }
-  // TDB implement matrix support
-
-  unreachable(`Results of type '${resultType}' not yet implemented`);
-}
-
-/**
- * @returns a ShaderBuilder that builds a test shader hands AbstractFloat results.
- * @param expressionBuilder an expression builder that will return AbstractFloats
- */
-export function abstractFloatShaderBuilder(expressionBuilder: ExpressionBuilder): ShaderBuilder {
-  return (
-    parameterTypes: Array<Type>,
-    resultType: Type,
-    cases: CaseList,
-    inputSource: InputSource
-  ) => {
-    assert(inputSource === 'const', 'AbstractFloat results are only defined for const-eval');
-    assert(
-      scalarTypeOf(resultType).kind === 'abstract-float',
-      `Expected resultType of 'abstract-float', received '${scalarTypeOf(resultType).kind}' instead`
-    );
-
-    const body = cases
-      .map((c, i) => {
-        const expr = `${expressionBuilder(map(c.input, v => v.wgsl()))}`;
-        return abstractFloatCaseBody(expr, resultType, i);
-      })
-      .join('\n  ');
-
-    return `
-${wgslHeader(parameterTypes, resultType)}
-
-${wgslOutputs(resultType, cases.length)}
-
-${wgslValuesArray(parameterTypes, resultType, cases, expressionBuilder)}
-
-@compute @workgroup_size(1)
-fn main() {
-${body}
-}`;
-  };
-}
-
 /**
  * Constructs and returns a GPUComputePipeline and GPUBindGroup for running a
  * batch of test cases. If a pre-created pipeline can be found in
diff --git a/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts b/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts
deleted file mode 100644
index d7939ad2b17f..000000000000
--- a/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-export const description = `
-Execution Tests for AbstractFloat arithmetic unary expression operations
-`;
-
-import { makeTestGroup } from '../../../../../common/framework/test_group.js';
-import { GPUTest } from '../../../../gpu_test.js';
-import { TypeAbstractFloat } from '../../../../util/conversion.js';
-import { FP } from '../../../../util/floating_point.js';
-import { fullF64Range } from '../../../../util/math.js';
-import { makeCaseCache } from '../case_cache.js';
-import { onlyConstInputSource, run } from '../expression.js';
-
-import { abstract_unary } from './unary.js';
-
-export const g = makeTestGroup(GPUTest);
-
-export const d = makeCaseCache('unary/f32_arithmetic', {
-  negation: () => {
-    return FP.abstract.generateScalarToIntervalCases(
-      fullF64Range({ neg_norm: 250, neg_sub: 20, pos_sub: 20, pos_norm: 250 }),
-      'unfiltered',
-      FP.abstract.negationInterval
-    );
-  },
-});
-
-g.test('negation')
-  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
-  .desc(
-    `
-Expression: -x
-Accuracy: Correctly rounded
-`
-  )
-  .params(u =>
-    u
-      .combine('inputSource', onlyConstInputSource)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
-  .fn(async t => {
-    const cases = await d.get('negation');
-    await run(t, abstract_unary('-'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
-  });
diff --git a/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts b/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
index 372051c949a3..eecc43a9b2a7 100644
--- a/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
@@ -14,21 +14,9 @@ import {
   reinterpretU64AsF64,
 } from '../../../../util/math.js';
 import { makeCaseCache } from '../case_cache.js';
-import {
-  abstractFloatShaderBuilder,
-  basicExpressionBuilder,
-  onlyConstInputSource,
-  run,
-  ShaderBuilder,
-} from '../expression.js';
-
-function concrete_assignment(): ShaderBuilder {
-  return basicExpressionBuilder(value => `${value}`);
-}
+import { allInputSources, run } from '../expression.js';
 
-function abstract_assignment(): ShaderBuilder {
-  return abstractFloatShaderBuilder(value => `${value}`);
-}
+import { assignment } from './unary.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -80,10 +68,10 @@ g.test('abstract')
 testing that extracting abstract floats works
 `
   )
-  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .params(u => u.combine('inputSource', [allInputSources[0]])) // Only defined for const-eval
   .fn(async t => {
     const cases = await d.get('abstract');
-    await run(t, abstract_assignment(), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
+    await run(t, assignment(), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
   });
 
 g.test('f32')
@@ -93,10 +81,10 @@ g.test('f32')
 concretizing to f32
 `
   )
-  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .params(u => u.combine('inputSource', [allInputSources[0]])) // Only defined for const-eval
   .fn(async t => {
     const cases = await d.get('f32');
-    await run(t, concrete_assignment(), [TypeAbstractFloat], TypeF32, t.params, cases);
+    await run(t, assignment(), [TypeAbstractFloat], TypeF32, t.params, cases);
   });
 
 g.test('f16')
@@ -109,8 +97,8 @@ concretizing to f16
   .beforeAllSubcases(t => {
     t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
   })
-  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .params(u => u.combine('inputSource', [allInputSources[0]])) // Only defined for const-eval
   .fn(async t => {
     const cases = await d.get('f16');
-    await run(t, concrete_assignment(), [TypeAbstractFloat], TypeF16, t.params, cases);
+    await run(t, assignment(), [TypeAbstractFloat], TypeF16, t.params, cases);
   });
diff --git a/src/webgpu/shader/execution/expression/unary/unary.ts b/src/webgpu/shader/execution/expression/unary/unary.ts
index 995ca3ea172d..ce9d6b814747 100644
--- a/src/webgpu/shader/execution/expression/unary/unary.ts
+++ b/src/webgpu/shader/execution/expression/unary/unary.ts
@@ -1,15 +1,10 @@
-import {
-  abstractFloatShaderBuilder,
-  basicExpressionBuilder,
-  ShaderBuilder,
-} from '../expression.js';
+import { basicExpressionBuilder, ShaderBuilder } from '../expression.js';
 
 /* @returns a ShaderBuilder that evaluates a prefix unary operation */
 export function unary(op: string): ShaderBuilder {
   return basicExpressionBuilder(value => `${op}(${value})`);
 }
 
-/* @returns a ShaderBuilder that evaluates a prefix unary operation that returns AbstractFloats */
-export function abstract_unary(op: string): ShaderBuilder {
-  return abstractFloatShaderBuilder(value => `${op}(${value})`);
+export function assignment(): ShaderBuilder {
+  return basicExpressionBuilder(value => `${value}`);
 }
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 29ca13c39ff8..a1b459359c9e 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5,9 +5,9 @@ import { Case, IntervalFilter } from '../shader/execution/expression/expression.
 import { anyOf } from './compare.js';
 import { kValue } from './constants.js';
 import {
-  abstractFloat,
   f16,
   f32,
+  f64,
   isFloatType,
   reinterpretF16AsU16,
   reinterpretF32AsU32,
@@ -4820,7 +4820,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly isSubnormal = isSubnormalNumberF64;
   public readonly flushSubnormal = flushSubnormalNumberF64;
   public readonly oneULP = oneULPF64;
-  public readonly scalarBuilder = abstractFloat;
+  public readonly scalarBuilder = f64;
 
   // Framework - Fundamental Error Intervals - Overrides
   public readonly absoluteErrorInterval = this.unboundedAbsoluteErrorInterval.bind(this);
@@ -4886,7 +4886,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly multiplicationVectorMatrixInterval = this.unimplementedVectorMatrixToVector.bind(
     this
   );
-  public readonly negationInterval = this.negationIntervalImpl.bind(this);
+  public readonly negationInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly normalizeInterval = this.unimplementedVectorToVector.bind(this);
   public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this);
   public readonly quantizeToF16Interval = this.unimplementedScalarToInterval.bind(this);

From 7f4eced1cd152835addd5a88b36bea4c68393adc Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Tue, 29 Aug 2023 10:22:56 -0700
Subject: [PATCH 007/166] Don't color tests which have not been run as skipped
 (#2910)

---
 src/common/runtime/standalone.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/common/runtime/standalone.ts b/src/common/runtime/standalone.ts
index 046265db8c29..87689ebac733 100644
--- a/src/common/runtime/standalone.ts
+++ b/src/common/runtime/standalone.ts
@@ -321,7 +321,7 @@ function makeSubtreeHTML(n: TestSubtree, parentLevel: TestQueryLevel): Visualize
       if (subtreeResult.fail > 0) {
         status += 'fail';
       }
-      if (subtreeResult.skip === subtreeResult.total) {
+      if (subtreeResult.skip === subtreeResult.total && subtreeResult.total > 0) {
         status += 'skip';
       }
       div.setAttribute('data-status', status);

From 03819a515332bd0ac6daf11ab13839bdd75eae7f Mon Sep 17 00:00:00 2001
From: Brandon Jones <tojiro@gmail.com>
Date: Tue, 29 Aug 2023 16:49:49 -0700
Subject: [PATCH 008/166] Remove orientation from several texture copy tests
 (#2914)

* Remove orientation from several texture copy tests

The orientation argument for these tests was copied from tests which
use an ImageBitmap source. Because CreateImageBitmap has an
imageOrientation option it made sense to test against all variants
of it. However, other tests, such as those that consume ImageData
directly, don't have any native mechanism for Y-flipping the source.
The data could be generated Y-flipped, but that doesn't increase
coverage of any implementation features. Despite not flipping the
source orientation, however, the test was still expected the data
to be flipped.

By removing this argument and no longer testing for flipped source
data, these tests all begin passing with no loss of platform coverage.

Bug: dawn:2017

* Lint fix
---
 .../copyToTexture/ImageData.spec.ts             | 17 ++++-------------
 .../web_platform/copyToTexture/image.spec.ts    | 17 ++++-------------
 2 files changed, 8 insertions(+), 26 deletions(-)

diff --git a/src/webgpu/web_platform/copyToTexture/ImageData.spec.ts b/src/webgpu/web_platform/copyToTexture/ImageData.spec.ts
index 6bb549326a2d..38876f041928 100644
--- a/src/webgpu/web_platform/copyToTexture/ImageData.spec.ts
+++ b/src/webgpu/web_platform/copyToTexture/ImageData.spec.ts
@@ -39,7 +39,6 @@ g.test('from_ImageData')
   )
   .params(u =>
     u
-      .combine('orientation', ['none', 'flipY'] as const)
       .combine('srcDoFlipYDuringCopy', [true, false])
       .combine('dstColorFormat', kValidTextureFormatsForCopyE2T)
       .combine('dstPremultiplied', [true, false])
@@ -51,14 +50,7 @@ g.test('from_ImageData')
     t.skipIfTextureFormatNotSupported(t.params.dstColorFormat);
   })
   .fn(t => {
-    const {
-      width,
-      height,
-      orientation,
-      dstColorFormat,
-      dstPremultiplied,
-      srcDoFlipYDuringCopy,
-    } = t.params;
+    const { width, height, dstColorFormat, dstPremultiplied, srcDoFlipYDuringCopy } = t.params;
 
     const testColors = kTestColorsAll;
 
@@ -87,7 +79,7 @@ g.test('from_ImageData')
     });
 
     const expFormat = kTextureFormatInfo[dstColorFormat].baseFormat ?? dstColorFormat;
-    const flipSrcBeforeCopy = orientation === 'flipY';
+    const flipSrcBeforeCopy = false;
     const texelViewExpected = t.getExpectedDstPixelsFromSrcPixels({
       srcPixels: imageData.data,
       srcOrigin: [0, 0],
@@ -155,14 +147,13 @@ g.test('copy_subrect_from_ImageData')
   )
   .params(u =>
     u
-      .combine('orientation', ['none', 'flipY'] as const)
       .combine('srcDoFlipYDuringCopy', [true, false])
       .combine('dstPremultiplied', [true, false])
       .beginSubcases()
       .combine('copySubRectInfo', kCopySubrectInfo)
   )
   .fn(t => {
-    const { copySubRectInfo, orientation, dstPremultiplied, srcDoFlipYDuringCopy } = t.params;
+    const { copySubRectInfo, dstPremultiplied, srcDoFlipYDuringCopy } = t.params;
 
     const testColors = kTestColorsAll;
     const { srcOrigin, dstOrigin, srcSize, dstSize, copyExtent } = copySubRectInfo;
@@ -192,7 +183,7 @@ g.test('copy_subrect_from_ImageData')
         GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
     });
 
-    const flipSrcBeforeCopy = orientation === 'flipY';
+    const flipSrcBeforeCopy = false;
     const texelViewExpected = t.getExpectedDstPixelsFromSrcPixels({
       srcPixels: imageData.data,
       srcOrigin,
diff --git a/src/webgpu/web_platform/copyToTexture/image.spec.ts b/src/webgpu/web_platform/copyToTexture/image.spec.ts
index b25ade90ab10..e19f986c0f85 100644
--- a/src/webgpu/web_platform/copyToTexture/image.spec.ts
+++ b/src/webgpu/web_platform/copyToTexture/image.spec.ts
@@ -53,7 +53,6 @@ g.test('from_image')
   )
   .params(u =>
     u
-      .combine('orientation', ['none', 'flipY'] as const)
       .combine('srcDoFlipYDuringCopy', [true, false])
       .combine('dstColorFormat', kValidTextureFormatsForCopyE2T)
       .combine('dstPremultiplied', [true, false])
@@ -66,14 +65,7 @@ g.test('from_image')
     if (typeof HTMLImageElement === 'undefined') t.skip('HTMLImageElement not available');
   })
   .fn(async t => {
-    const {
-      width,
-      height,
-      orientation,
-      dstColorFormat,
-      dstPremultiplied,
-      srcDoFlipYDuringCopy,
-    } = t.params;
+    const { width, height, dstColorFormat, dstPremultiplied, srcDoFlipYDuringCopy } = t.params;
 
     const imageCanvas = document.createElement('canvas');
     imageCanvas.width = width;
@@ -117,7 +109,7 @@ g.test('from_image')
     });
 
     const expFormat = kTextureFormatInfo[dstColorFormat].baseFormat ?? dstColorFormat;
-    const flipSrcBeforeCopy = orientation === 'flipY';
+    const flipSrcBeforeCopy = false;
     const texelViewExpected = t.getExpectedDstPixelsFromSrcPixels({
       srcPixels: imageData.data,
       srcOrigin: [0, 0],
@@ -186,7 +178,6 @@ g.test('copy_subrect_from_2D_Canvas')
   )
   .params(u =>
     u
-      .combine('orientation', ['none', 'flipY'] as const)
       .combine('srcDoFlipYDuringCopy', [true, false])
       .combine('dstPremultiplied', [true, false])
       .beginSubcases()
@@ -196,7 +187,7 @@ g.test('copy_subrect_from_2D_Canvas')
     if (typeof HTMLImageElement === 'undefined') t.skip('HTMLImageElement not available');
   })
   .fn(async t => {
-    const { copySubRectInfo, orientation, dstPremultiplied, srcDoFlipYDuringCopy } = t.params;
+    const { copySubRectInfo, dstPremultiplied, srcDoFlipYDuringCopy } = t.params;
 
     const { srcOrigin, dstOrigin, srcSize, dstSize, copyExtent } = copySubRectInfo;
     const kColorFormat = 'rgba8unorm';
@@ -242,7 +233,7 @@ g.test('copy_subrect_from_2D_Canvas')
         GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
     });
 
-    const flipSrcBeforeCopy = orientation === 'flipY';
+    const flipSrcBeforeCopy = false;
     const texelViewExpected = t.getExpectedDstPixelsFromSrcPixels({
       srcPixels: imageData.data,
       srcOrigin,

From 4c8d2f67ecd03fbd3cb4c517ef8461427b6d635d Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Tue, 5 Sep 2023 10:52:37 +0100
Subject: [PATCH 009/166] Add `generate-cache` step to `grunt pre`

This is run by `npm test`, and should catch cache file collision issues which have caused reverts in the past.
---
 Gruntfile.js                  |  3 ++-
 src/common/tools/gen_cache.ts | 25 ++++++++++++++++++-------
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/Gruntfile.js b/Gruntfile.js
index 03f5d1cfcc38..05d70074afc3 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -32,7 +32,7 @@ module.exports = function (grunt) {
       },
       'generate-cache': {
         cmd: 'node',
-        args: ['tools/gen_cache', 'out/data', 'src/webgpu'],
+        args: ['tools/gen_cache', 'out', 'src/webgpu'],
       },
       unittest: {
         cmd: 'node',
@@ -193,6 +193,7 @@ module.exports = function (grunt) {
     'run:generate-listings',
     'build-wpt',
     'run:build-out-node',
+    'run:generate-cache',
     'build-done-message',
     'ts:check',
     'run:presubmit',
diff --git a/src/common/tools/gen_cache.ts b/src/common/tools/gen_cache.ts
index e7e6d8514f1a..f4674d14db3a 100644
--- a/src/common/tools/gen_cache.ts
+++ b/src/common/tools/gen_cache.ts
@@ -14,22 +14,30 @@ DataCache will load this instead of building the expensive data at CTS runtime.
 Options:
   --help          Print this message and exit.
   --list          Print the list of output files without writing them.
+  --verbose       Print each action taken.
 `);
   process.exit(rc);
 }
 
 let mode: 'emit' | 'list' = 'emit';
+let verbose = false;
 
 const nonFlagsArgs: string[] = [];
 for (const a of process.argv) {
   if (a.startsWith('-')) {
-    if (a === '--list') {
-      mode = 'list';
-    } else if (a === '--help') {
-      usage(0);
-    } else {
-      console.log('unrecognized flag: ', a);
-      usage(1);
+    switch (a) {
+      case '--list':
+        mode = 'list';
+        break;
+      case '--help':
+        usage(0);
+        break;
+      case '--verbose':
+        verbose = true;
+        break;
+      default:
+        console.log('unrecognized flag: ', a);
+        usage(1);
     }
   } else {
     nonFlagsArgs.push(a);
@@ -127,6 +135,9 @@ and
 
         switch (mode) {
           case 'emit': {
+            if (verbose) {
+              console.log(`building '${outPath}'`);
+            }
             const data = await cacheable.build();
             const serialized = cacheable.serialize(data);
             fs.mkdirSync(path.dirname(outPath), { recursive: true });

From d2b2badc17f2894a78b7da92f4b38c47590bdfac Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Mon, 4 Sep 2023 13:47:12 +0100
Subject: [PATCH 010/166] Update fp_primer.md

---
 docs/fp_primer.md | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/docs/fp_primer.md b/docs/fp_primer.md
index 6d0294b4d1e5..4d08d588f5e0 100644
--- a/docs/fp_primer.md
+++ b/docs/fp_primer.md
@@ -69,7 +69,7 @@ reference, see
 [binary64 on Wikipedia](https://en.wikipedia.org/wiki/Double-precision_floating-point_format),
 [binary32 on Wikipedia](https://en.wikipedia.org/wiki/Single-precision_floating-point_format),
 and
-[binar16 on Wikipedia](https://en.wikipedia.org/wiki/Half-precision_floating-point_format).
+[binary16 on Wikipedia](https://en.wikipedia.org/wiki/Half-precision_floating-point_format).
 
 In the floating points formats described above, there are two possible zero
 values, one with all bits being 0, called positive zero, and one all the same
@@ -144,7 +144,7 @@ This concept of near-overflow vs far-overflow divides the real number line into
 | -∞ < `x` <= `-(2 ** (exp_max + 1))`           | must round to -∞                |
 | `-(2 ** (exp_max + 1))` < `x` <= min fp value | must round to -∞ or min value   |
 | min fp value < `x` < max fp value             | round as discussed below        |
-| min fp value <= `x` < `2 ** (exp_max + 1)`    | must round to max value or ∞    |
+| max fp value <= `x` < `2 ** (exp_max + 1)`    | must round to max value or ∞    |
 | `2 ** (exp_max + 1))` < `x`                   | implementations must round to ∞ |
 
 
@@ -184,7 +184,7 @@ operations.
 Operations, which can be thought of as mathematical functions, are mappings from
 a set of inputs to a set of outputs.
 
-Denoted `f(x, y) = X`, where f is a placeholder or the name of the operation,
+Denoted `f(x, y) = X`, where `f` is a placeholder or the name of the operation,
 lower case variables are the inputs to the function, and uppercase variables are
 the outputs of the function.
 
@@ -208,7 +208,7 @@ Some examples of different types of operations:
 `multiplication(x, y) = X`, which represents the WGSL expression `x * y`, takes
 in floating point values, `x` and `y`, and produces a floating point value `X`.
 
-`lessThen(x, y) = X`, which represents the WGSL expression `x < y`, again takes
+`lessThan(x, y) = X`, which represents the WGSL expression `x < y`, again takes
 in floating point values, but in this case returns a boolean value.
 
 `ldexp(x, y) = X`, which builds a floating point value, takes in a floating
@@ -406,9 +406,9 @@ In more precise terms:
 
   X = [min(f(x)), max(f(x))]
   X = [min(f([a, b])), max(f([a, b]))]
-  X = [f(m), f(M)]
+  X = [f(m), f(n)]
 ```
-where m and M are in `[a, b]`, `m <= M`, and produce the min and max results
+where `m` and `n` are in `[a, b]`, `m <= n`, and produce the min and max results
 for `f` on the interval, respectively.
 
 So how do we find the minima and maxima for our operation in the domain?
@@ -499,15 +499,15 @@ literally pages of expanded intervals.
 
   sin(π/2) => [sin(π/2) - 2 ** -11, sin(π/2) + 2 ** -11]
            => [0 - 2 ** -11, 0 + 2 ** -11]
-           => [-0.000488.., 0.000488...]
+           => [-0.000488…, 0.000488…]
   cos(π/2) => [cos(π/2) - 2 ** -11, cos(π/2) + 2 ** -11]
-           => [-0.500488, -0.499511...]
+           => [-0.500488…, -0.499511…]
 
   tan(π/2) => sin(π/2)/cos(π/2)
-           => [-0.000488.., 0.000488...]/[-0.500488..., -0.499511...]
-           => [min({-0.000488.../-0.500488..., -0.000488.../-0.499511..., ...}),
-               max(min({-0.000488.../-0.500488..., -0.000488.../-0.499511..., ...}) ]
-           => [0.000488.../-0.499511..., 0.000488.../0.499511...]
+           => [-0.000488…, 0.000488…]/[-0.500488…, -0.499511…]
+           => [min(-0.000488…/-0.500488…, -0.000488…/-0.499511…, 0.000488…/-0.500488…, 0.000488…/-0.499511…),
+               max(-0.000488…/-0.500488…, -0.000488…/-0.499511…, 0.000488…/-0.500488…, 0.000488…/-0.499511…)]
+           => [0.000488…/-0.499511…, 0.000488…/0.499511…]
            => [-0.0009775171, 0.0009775171]
 ```
 
@@ -553,10 +553,10 @@ These are compile vs run time, and CPU vs GPU. Broadly speaking compile time
 execution happens on the host CPU, and run time evaluation occurs on a dedicated
 GPU.
 
-(SwiftShader technically breaks this by being a software emulation of a GPU that
-runs on the CPU, but conceptually one can think of SwiftShader has being a type
-of GPU in this context, since it has similar constraints when it comes to
-precision, etc.)
+(Software graphics implementations like WARP and SwiftShader technically break this by
+being a software emulation of a GPU that runs on the CPU, but conceptually one can
+think of these implementations being a type of GPU in this context, since it has 
+similar constraints when it comes to precision, etc.)
 
 Compile time evaluation is execution that occurs when setting up a shader
 module, i.e. when compiling WGSL to a platform specific shading language. It is
@@ -588,18 +588,18 @@ let c: f32 = a + b
 and
 ```
 // compile time
-const c: f32 = 1 + 2
+const c: f32 = 1.0f + 2.0f
 ```
-should produce the same result of `3` in the variable `c`, assuming `1` and `2`
-were passed in as `a` & `b`.
+should produce the same result of `3.0` in the variable `c`, assuming `1.0` and `2.0`
+were passed in as `a` and `b`.
 
 The only difference, is when/where the execution occurs.
 
 The difference in behaviour between these two occur when the result of the
 operation is not finite for the underlying floating point type.
 
-If instead of `1` and `2`, we had `10` and `f32.max`, so the true result is
-`f32.max + 10`, the user will see a difference. Specifically the runtime
+If instead of `1.0` and `2.0`, we had `10.0` and `f32.max`, so the true result is
+`f32.max + 10.0`, the behaviours differ. Specifically the runtime
 evaluated version will still run, but the result in `c` will be an indeterminate
 value, which is any finite f32 value. For the compile time example instead,
 compiling the shader will fail validation.
@@ -611,7 +611,7 @@ execution.
 
 Unfortunately we are dealing with intervals of results and not precise results.
 So this leads to more even conceptual complexity. For runtime evaluation, this
-isn't too bad, because the rule becomes if any part of the interval is
+isn't too bad, because the rule becomes: if any part of the interval is
 non-finite then an indeterminate value can be a result, and the interval for an
 indeterminate result `[fp min, fp max]`, will include any finite portions of the
 interval.

From d8c45b27fcd54d7f79ea12009f8d947b137f6619 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 5 Sep 2023 13:49:33 -0400
Subject: [PATCH 011/166] Reland AF negation tests: (#2920)

wgsl: Add execution tests for AF negation (#2909)

    This refactors the existing code to have a clearer separation from the
    non-AF test running code, and sets up for implementing vector support.

    Issue #1626

This PR fixes the issues with cache collisions that caused the initial
revert
---
 src/unittests/floating_point.spec.ts          | 104 ++++--
 .../shader/execution/expression/expression.ts | 327 ++++++++++++------
 .../expression/unary/af_arithmetic.spec.ts    |  43 +++
 .../expression/unary/af_assignment.spec.ts    |  28 +-
 .../execution/expression/unary/unary.ts       |  11 +-
 src/webgpu/util/floating_point.ts             |   6 +-
 6 files changed, 370 insertions(+), 149 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 3bab3682872b..9ef92528a342 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -13,6 +13,7 @@ import {
   map2DArray,
   oneULPF32,
   oneULPF16,
+  oneULPF64,
 } from '../webgpu/util/math.js';
 
 import { UnitTest } from './unit_test.js';
@@ -37,6 +38,9 @@ const kPlusNULPFunctions = {
   f16: (x: number, n: number) => {
     return x + n * oneULPF16(x);
   },
+  abstract: (x: number, n: number) => {
+    return x + n * oneULPF64(x);
+  },
 };
 
 /** @returns a number one ULP greater than the provided number */
@@ -47,6 +51,9 @@ const kPlusOneULPFunctions = {
   f16: (x: number): number => {
     return kPlusNULPFunctions['f16'](x, 1);
   },
+  abstract: (x: number): number => {
+    return kPlusNULPFunctions['abstract'](x, 1);
+  },
 };
 
 /** @returns a number N * ULP less than the provided number */
@@ -57,6 +64,9 @@ const kMinusNULPFunctions = {
   f16: (x: number, n: number) => {
     return x - n * oneULPF16(x);
   },
+  abstract: (x: number, n: number) => {
+    return x - n * oneULPF64(x);
+  },
 };
 
 /** @returns a number one ULP less than the provided number */
@@ -67,6 +77,9 @@ const kMinusOneULPFunctions = {
   f16: (x: number): number => {
     return kMinusNULPFunctions['f16'](x, 1);
   },
+  abstract: (x: number): number => {
+    return kMinusNULPFunctions['abstract'](x, 1);
+  },
 };
 
 /** @returns the expected IntervalBounds adjusted by the given error function
@@ -3074,39 +3087,74 @@ g.test('log2Interval')
     );
   });
 
-g.test('negationInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      { input: 0, expected: 0 },
-      { input: 0.1, expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] }, // ~-0.1
-      { input: 1.0, expected: -1.0 },
-      { input: 1.9, expected: [reinterpretU32AsF32(0xbff33334), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbff33334))] },  // ~-1.9
-      { input: -0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] }, // ~0.1
-      { input: -1.0, expected: 1 },
-      { input: -1.9, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3ff33334)), reinterpretU32AsF32(0x3ff33334)] },  // ~1.9
-
-      // Edge cases
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.positive.max, expected: kValue.f32.negative.min },
-      { input: kValue.f32.positive.min, expected: kValue.f32.negative.max },
-      { input: kValue.f32.negative.min, expected: kValue.f32.positive.max },
-      { input: kValue.f32.negative.max, expected: kValue.f32.positive.min },
+// prettier-ignore
+const kNegationIntervalCases = {
+  f32: [
+    // Edge cases
+    { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
+    { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
+    { input: kValue.f32.positive.max, expected: kValue.f32.negative.min },
+    { input: kValue.f32.positive.min, expected: kValue.f32.negative.max },
+    { input: kValue.f32.negative.min, expected: kValue.f32.positive.max },
+    { input: kValue.f32.negative.max, expected: kValue.f32.positive.min },
+
+    // Normals
+    { input: 0.1, expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] }, // ~-0.1
+    { input: 1.9, expected: [reinterpretU32AsF32(0xbff33334), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbff33334))] },  // ~-1.9
+    { input: -0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] }, // ~0.1
+    { input: -1.9, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3ff33334)), reinterpretU32AsF32(0x3ff33334)] },  // ~1.9
+
+    // Subnormals
+    { input: kValue.f32.subnormal.positive.max, expected: [kValue.f32.subnormal.negative.min, 0] },
+    { input: kValue.f32.subnormal.positive.min, expected: [kValue.f32.subnormal.negative.max, 0] },
+    { input: kValue.f32.subnormal.negative.min, expected: [0, kValue.f32.subnormal.positive.max] },
+    { input: kValue.f32.subnormal.negative.max, expected: [0, kValue.f32.subnormal.positive.min] },
+  ] as ScalarToIntervalCase[],
+  abstract: [
+    // Edge cases
+    { input: kValue.f64.infinity.positive, expected: kUnboundedBounds },
+    { input: kValue.f64.infinity.negative, expected: kUnboundedBounds },
+    { input: kValue.f64.positive.max, expected: kValue.f64.negative.min },
+    { input: kValue.f64.positive.min, expected: kValue.f64.negative.max },
+    { input: kValue.f64.negative.min, expected: kValue.f64.positive.max },
+    { input: kValue.f64.negative.max, expected: kValue.f64.positive.min },
+
+    // Normals
+    { input: 0.1, expected: -0.1 },
+    { input: 1.9, expected: -1.9 },
+    { input: -0.1, expected: 0.1 },
+    { input: -1.9, expected: 1.9 },
+
+    // Subnormals
+    { input: kValue.f64.subnormal.positive.max, expected: [kValue.f64.subnormal.negative.min, 0] },
+    { input: kValue.f64.subnormal.positive.min, expected: [kValue.f64.subnormal.negative.max, 0] },
+    { input: kValue.f64.subnormal.negative.min, expected: [0, kValue.f64.subnormal.positive.max] },
+    { input: kValue.f64.subnormal.negative.max, expected: [0, kValue.f64.subnormal.positive.min] },
+  ] as ScalarToIntervalCase[],
+} as const;
 
-      // 32-bit subnormals
-      { input: kValue.f32.subnormal.positive.max, expected: [kValue.f32.subnormal.negative.min, 0] },
-      { input: kValue.f32.subnormal.positive.min, expected: [kValue.f32.subnormal.negative.max, 0] },
-      { input: kValue.f32.subnormal.negative.min, expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: kValue.f32.subnormal.negative.max, expected: [0, kValue.f32.subnormal.positive.min] },
-    ]
+g.test('negationInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'abstract'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        // prettier-ignore
+        return [
+          { input: 0, expected: 0 },
+          { input: 1.0, expected: -1.0 },
+          { input: -1.0, expected: 1 },
+          ...kNegationIntervalCases[p.trait],
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.negationInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.negationInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.negationInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.negationInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/shader/execution/expression/expression.ts b/src/webgpu/shader/execution/expression/expression.ts
index e12a3f71392d..8ff28c217fc4 100644
--- a/src/webgpu/shader/execution/expression/expression.ts
+++ b/src/webgpu/shader/execution/expression/expression.ts
@@ -70,6 +70,9 @@ export type InputSource =
 /** All possible input sources */
 export const allInputSources: InputSource[] = ['const', 'uniform', 'storage_r', 'storage_rw'];
 
+/** Just constant input source */
+export const onlyConstInputSource: InputSource[] = ['const'];
+
 /** Configuration for running a expression test */
 export type Config = {
   // Where the input values are read from
@@ -85,6 +88,22 @@ export type Config = {
 
 // Helper for returning the stride for a given Type
 function valueStride(ty: Type): number {
+  // AbstractFloats are passed out of the shader via a struct of 2x u32s and
+  // unpacking containers as arrays
+  if (scalarTypeOf(ty).kind === 'abstract-float') {
+    if (ty instanceof ScalarType) {
+      return 16;
+    }
+    if (ty instanceof VectorType) {
+      if (ty.width === 2) {
+        return 16;
+      }
+      // vec3s have padding to make them the same size as vec4s
+      return 32;
+    }
+    unreachable('Matrices of AbstractFloats have not yet been implemented');
+  }
+
   if (ty instanceof MatrixType) {
     switch (ty.cols) {
       case 2:
@@ -135,10 +154,11 @@ function valueStrides(tys: Type[]): number {
 // Helper for returning the WGSL storage type for the given Type.
 function storageType(ty: Type): Type {
   if (ty instanceof ScalarType) {
-    assert(ty.kind !== 'f64', `'No storage type defined for 'f64' values`);
-    if (ty.kind === 'abstract-float') {
-      return TypeVec(2, TypeU32);
-    }
+    assert(ty.kind !== 'f64', `No storage type defined for 'f64' values`);
+    assert(
+      ty.kind !== 'abstract-float',
+      `Custom handling is implemented for 'abstract-float' values`
+    );
     if (ty.kind === 'bool') {
       return TypeU32;
     }
@@ -161,7 +181,7 @@ function fromStorage(ty: Type, expr: string): string {
   if (ty instanceof VectorType) {
     assert(
       ty.elementType.kind !== 'abstract-float',
-      `AbstractFloat values should not be in input storage`
+      `AbstractFloat values cannot appear in input storage`
     );
     assert(ty.elementType.kind !== 'f64', `'No storage type defined for 'f64' values`);
     if (ty.elementType.kind === 'bool') {
@@ -176,7 +196,7 @@ function toStorage(ty: Type, expr: string): string {
   if (ty instanceof ScalarType) {
     assert(
       ty.kind !== 'abstract-float',
-      `AbstractFloat values have custom code writing to input storage`
+      `AbstractFloat values have custom code for writing to storage`
     );
     assert(ty.kind !== 'f64', `No storage type defined for 'f64' values`);
     if (ty.kind === 'bool') {
@@ -186,7 +206,7 @@ function toStorage(ty: Type, expr: string): string {
   if (ty instanceof VectorType) {
     assert(
       ty.elementType.kind !== 'abstract-float',
-      `AbstractFloat values have custom code writing to input storage`
+      `AbstractFloat values have custom code for writing to storage`
     );
     assert(ty.elementType.kind !== 'f64', `'No storage type defined for 'f64' values`);
     if (ty.elementType.kind === 'bool') {
@@ -438,11 +458,40 @@ export type ShaderBuilder = (
  * Helper that returns the WGSL to declare the output storage buffer for a shader
  */
 function wgslOutputs(resultType: Type, count: number): string {
-  return `
+  let output_struct = undefined;
+  if (scalarTypeOf(resultType).kind !== 'abstract-float') {
+    output_struct = `
 struct Output {
   @size(${valueStride(resultType)}) value : ${storageType(resultType)}
+};`;
+  } else {
+    if (resultType instanceof ScalarType) {
+      output_struct = `struct AF {
+  low: u32,
+  high: u32,
+};
+
+struct Output {
+  @size(${valueStride(resultType)}) value: AF,
+};`;
+    }
+    if (resultType instanceof VectorType) {
+      const dim = resultType.width;
+      output_struct = `struct AF {
+  low: u32,
+  high: u32,
 };
-@group(0) @binding(0) var<storage, read_write> outputs : array<Output, ${count}>;`;
+
+struct Output {
+  @size(${valueStride(resultType)}) value: array<AF, ${dim}>,
+};`;
+    }
+    // TBD: Implement Matrix result support
+  }
+  assert(output_struct !== undefined, `No implementation for result type '${resultType}'`);
+  return `${output_struct}
+@group(0) @binding(0) var<storage, read_write> outputs : array<Output, ${count}>;
+`;
 }
 
 /**
@@ -454,10 +503,6 @@ function wgslValuesArray(
   cases: CaseList,
   expressionBuilder: ExpressionBuilder
 ): string {
-  // AbstractFloat values cannot be stored in an array
-  if (parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')) {
-    return '';
-  }
   return `
 const values = array(
   ${cases.map(c => expressionBuilder(map(c.input, v => v.wgsl()))).join(',\n  ')}
@@ -508,15 +553,16 @@ function basicExpressionShaderBody(
   cases: CaseList,
   inputSource: InputSource
 ): string {
+  assert(
+    scalarTypeOf(resultType).kind !== 'abstract-float',
+    `abstractFloatShaderBuilder should be used when result type is 'abstract-float`
+  );
   if (inputSource === 'const') {
     //////////////////////////////////////////////////////////////////////////
     // Constant eval
     //////////////////////////////////////////////////////////////////////////
     let body = '';
-    if (
-      scalarTypeOf(resultType).kind !== 'abstract-float' &&
-      parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')
-    ) {
+    if (parameterTypes.some(ty => scalarTypeOf(ty).kind === 'abstract-float')) {
       // Directly assign the expression to the output, to avoid an
       // intermediate store, which will concretize the value early
       body = cases
@@ -528,96 +574,6 @@ function basicExpressionShaderBody(
             )};`
         )
         .join('\n  ');
-    } else if (scalarTypeOf(resultType).kind === 'abstract-float') {
-      // AbstractFloats are f64s under the hood. WebGPU does not support
-      // putting f64s in buffers, so the result needs to be split up into u32s
-      // and rebuilt in the test framework.
-      //
-      // This is complicated by the fact that user defined functions cannot
-      // take/return AbstractFloats, and AbstractFloats cannot be stored in
-      // variables, so the code cannot just inject a simple utility function
-      // at the top of the shader, instead this snippet needs to be inlined
-      // everywhere the test needs to return an AbstractFloat.
-      //
-      // select is used below, since ifs are not available during constant
-      // eval. This has the side effect of short-circuiting doesn't occur, so
-      // both sides of the select have to evaluate and be valid.
-      //
-      // This snippet implements FTZ for subnormals to bypass the need for
-      // complex subnormal specific logic.
-      //
-      // Expressions resulting in subnormals can still be reasonably tested,
-      // since this snippet will return 0 with the correct sign, which is
-      // always in the acceptance interval for a subnormal result, since an
-      // implementation may FTZ.
-      //
-      // Document for the snippet is included here in this code block, since
-      // shader length affects compilation time  significantly on some
-      // backends.
-      //
-      // Snippet with documentation:
-      //   const kExponentBias = 1022;
-      //
-      //   // Detect if the value is zero or subnormal, so that FTZ behaviour
-      //   // can occur
-      //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
-      //
-      //   // MSB of the upper u32 is 1 if the value is negative, otherwise 0
-      //   // Extract the sign bit early, so that abs() can be used with
-      //   // frexp() so negative cases do not need to be handled
-      //   const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
-      //
-      //   // Use frexp() to obtain the exponent and fractional parts, and
-      //   // then perform FTZ if needed
-      //   const f = frexp(abs(${expr}));
-      //   const f_fract = select(f.fract, 0, subnormal_or_zero);
-      //   const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
-      //
-      //   // Adjust for the exponent bias and shift for storing in bits
-      //   // [20..31] of the upper u32
-      //   const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
-      //
-      //   // Extract the portion of the mantissa that appears in upper u32 as
-      //   // a float for later use
-      //   const high_mantissa = ldexp(f_fract, 21);
-      //
-      //   // Extract the portion of the mantissa that appears in upper u32 as
-      //   // as bits. This value is masked, because normals will explicitly
-      //   // have the implicit leading 1 that should not be in the final
-      //   // result.
-      //   const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
-      //
-      //   // Calculate the mantissa stored in the lower u32 as a float
-      //   const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
-      //
-      //   // Convert the lower u32 mantissa to bits
-      //   const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
-      //
-      //   // Pack the result into 2x u32s for writing out to the testing
-      //   // framework
-      //   outputs[${i}].value.x = low_mantissa_bits;
-      //   outputs[${i}].value.y = sign_bit | exponent_bits | high_mantissa_bits;
-      body = cases
-        .map((c, i) => {
-          const expr = `${expressionBuilder(map(c.input, v => v.wgsl()))}`;
-          // prettier-ignore
-          return `  {
-    const kExponentBias = 1022;
-    const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
-    const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
-    const f = frexp(abs(${expr}));
-    const f_fract = select(f.fract, 0, subnormal_or_zero);
-    const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
-    const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
-    const high_mantissa = ldexp(f_fract, 21);
-    const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
-    const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
-    const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
-    outputs[${i}].value.x = low_mantissa_bits;
-    outputs[${i}].value.y = sign_bit | exponent_bits | high_mantissa_bits;
-  }`;
-        })
-        .join('\n  ');
     } else if (globalTestConfig.unrollConstEvalLoops) {
       body = cases
         .map((_, i) => {
@@ -808,6 +764,163 @@ fn main() {
   };
 }
 
+/**
+ * @returns a string that extracts the value of an AbstractFloat into an output
+ *          destination
+ * @param expr expression for an AbstractFloat value, if working with vectors or
+ *             matrices, this string needs to include indexing into the
+ *             container.
+ * @param case_idx index in the case output array to assign the result
+ * @param accessor string representing how access the AF that needs to be extracted.
+ *              For scalars this should be left as ''.
+ *              For vectors and matrices this will be an indexing operation,
+ *              i.e. '[i]'
+ * */
+function abstractFloatSnippet(expr: string, case_idx: number, accessor: string = ''): string {
+  // AbstractFloats are f64s under the hood. WebGPU does not support
+  // putting f64s in buffers, so the result needs to be split up into u32s
+  // and rebuilt in the test framework.
+  //
+  // Since there is no 64-bit data type that can be used as an element for a
+  // vector or a matrix in WGSL, the testing framework needs to pass the u32s
+  // via a struct with two u32s, and deconstruct vectors and matrices into
+  // arrays.
+  //
+  // This is complicated by the fact that user defined functions cannot
+  // take/return AbstractFloats, and AbstractFloats cannot be stored in
+  // variables, so the code cannot just inject a simple utility function
+  // at the top of the shader, instead this snippet needs to be inlined
+  // everywhere the test needs to return an AbstractFloat.
+  //
+  // select is used below, since ifs are not available during constant
+  // eval. This has the side effect of short-circuiting doesn't occur, so
+  // both sides of the select have to evaluate and be valid.
+  //
+  // This snippet implements FTZ for subnormals to bypass the need for
+  // complex subnormal specific logic.
+  //
+  // Expressions resulting in subnormals can still be reasonably tested,
+  // since this snippet will return 0 with the correct sign, which is
+  // always in the acceptance interval for a subnormal result, since an
+  // implementation may FTZ.
+  //
+  // Documentation for the snippet working with scalar results is included here
+  // in this code block, since shader length affects compilation time
+  // significantly on some backends. The code for vectors and matrices basically
+  // the same thing, with extra indexing operations.
+  //
+  // Snippet with documentation:
+  //   const kExponentBias = 1022;
+  //
+  //   // Detect if the value is zero or subnormal, so that FTZ behaviour
+  //   // can occur
+  //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
+  //
+  //   // MSB of the upper u32 is 1 if the value is negative, otherwise 0
+  //   // Extract the sign bit early, so that abs() can be used with
+  //   // frexp() so negative cases do not need to be handled
+  //   const sign_bit : u32 = select(0, 0x80000000, ${expr} < 0);
+  //
+  //   // Use frexp() to obtain the exponent and fractional parts, and
+  //   // then perform FTZ if needed
+  //   const f = frexp(abs(${expr}));
+  //   const f_fract = select(f.fract, 0, subnormal_or_zero);
+  //   const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
+  //
+  //   // Adjust for the exponent bias and shift for storing in bits
+  //   // [20..31] of the upper u32
+  //   const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
+  //
+  //   // Extract the portion of the mantissa that appears in upper u32 as
+  //   // a float for later use
+  //   const high_mantissa = ldexp(f_fract, 21);
+  //
+  //   // Extract the portion of the mantissa that appears in upper u32 as
+  //   // as bits. This value is masked, because normals will explicitly
+  //   // have the implicit leading 1 that should not be in the final
+  //   // result.
+  //   const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
+  //
+  //   // Calculate the mantissa stored in the lower u32 as a float
+  //   const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
+  //
+  //   // Convert the lower u32 mantissa to bits
+  //   const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
+  //
+  //   outputs[${i}].value.high = sign_bit | exponent_bits | high_mantissa_bits;
+  //   outputs[${i}].value.low = low_mantissa_bits;
+  // prettier-ignore
+  return `  {
+    const kExponentBias = 1022;
+    const subnormal_or_zero : bool = (${expr}${accessor} <= ${kValue.f64.subnormal.positive.max}) && (${expr}${accessor} >= ${kValue.f64.subnormal.negative.min});
+    const sign_bit : u32 = select(0, 0x80000000, ${expr}${accessor} < 0);
+    const f = frexp(abs(${expr}${accessor}));
+    const f_fract = select(f.fract, 0, subnormal_or_zero);
+    const f_exp = select(f.exp, -kExponentBias, subnormal_or_zero);
+    const exponent_bits : u32 = (f_exp + kExponentBias) << 20;
+    const high_mantissa = ldexp(f_fract, 21);
+    const high_mantissa_bits : u32 = u32(ldexp(f_fract, 21)) & 0x000fffff;
+    const low_mantissa = f_fract - ldexp(floor(high_mantissa), -21);
+    const low_mantissa_bits = u32(ldexp(low_mantissa, 53));
+    outputs[${case_idx}].value${accessor}.high = sign_bit | exponent_bits | high_mantissa_bits;
+    outputs[${case_idx}].value${accessor}.low = low_mantissa_bits;
+  }`;
+}
+
+/** @returns a string for a specific case that has a AbstractFloat result */
+function abstractFloatCaseBody(expr: string, resultType: Type, i: number): string {
+  if (resultType instanceof ScalarType) {
+    return abstractFloatSnippet(expr, i);
+  }
+
+  if (resultType instanceof VectorType) {
+    return [...Array(resultType.width).keys()]
+      .map(dim_idx => abstractFloatSnippet(expr, i, `[${dim_idx}]`))
+      .join('  \n');
+  }
+  // TDB implement matrix support
+
+  unreachable(`Results of type '${resultType}' not yet implemented`);
+}
+
+/**
+ * @returns a ShaderBuilder that builds a test shader hands AbstractFloat results.
+ * @param expressionBuilder an expression builder that will return AbstractFloats
+ */
+export function abstractFloatShaderBuilder(expressionBuilder: ExpressionBuilder): ShaderBuilder {
+  return (
+    parameterTypes: Array<Type>,
+    resultType: Type,
+    cases: CaseList,
+    inputSource: InputSource
+  ) => {
+    assert(inputSource === 'const', 'AbstractFloat results are only defined for const-eval');
+    assert(
+      scalarTypeOf(resultType).kind === 'abstract-float',
+      `Expected resultType of 'abstract-float', received '${scalarTypeOf(resultType).kind}' instead`
+    );
+
+    const body = cases
+      .map((c, i) => {
+        const expr = `${expressionBuilder(map(c.input, v => v.wgsl()))}`;
+        return abstractFloatCaseBody(expr, resultType, i);
+      })
+      .join('\n  ');
+
+    return `
+${wgslHeader(parameterTypes, resultType)}
+
+${wgslOutputs(resultType, cases.length)}
+
+${wgslValuesArray(parameterTypes, resultType, cases, expressionBuilder)}
+
+@compute @workgroup_size(1)
+fn main() {
+${body}
+}`;
+  };
+}
+
 /**
  * Constructs and returns a GPUComputePipeline and GPUBindGroup for running a
  * batch of test cases. If a pre-created pipeline can be found in
diff --git a/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts b/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts
new file mode 100644
index 000000000000..67b2390bfa88
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts
@@ -0,0 +1,43 @@
+export const description = `
+Execution Tests for AbstractFloat arithmetic unary expression operations
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractFloat } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { fullF64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { abstract_unary } from './unary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+export const d = makeCaseCache('unary/af_arithmetic', {
+  negation: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      fullF64Range({ neg_norm: 250, neg_sub: 20, pos_sub: 20, pos_norm: 250 }),
+      'unfiltered',
+      FP.abstract.negationInterval
+    );
+  },
+});
+
+g.test('negation')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: -x
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cases = await d.get('negation');
+    await run(t, abstract_unary('-'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
+  });
diff --git a/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts b/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
index eecc43a9b2a7..372051c949a3 100644
--- a/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
@@ -14,9 +14,21 @@ import {
   reinterpretU64AsF64,
 } from '../../../../util/math.js';
 import { makeCaseCache } from '../case_cache.js';
-import { allInputSources, run } from '../expression.js';
+import {
+  abstractFloatShaderBuilder,
+  basicExpressionBuilder,
+  onlyConstInputSource,
+  run,
+  ShaderBuilder,
+} from '../expression.js';
+
+function concrete_assignment(): ShaderBuilder {
+  return basicExpressionBuilder(value => `${value}`);
+}
 
-import { assignment } from './unary.js';
+function abstract_assignment(): ShaderBuilder {
+  return abstractFloatShaderBuilder(value => `${value}`);
+}
 
 export const g = makeTestGroup(GPUTest);
 
@@ -68,10 +80,10 @@ g.test('abstract')
 testing that extracting abstract floats works
 `
   )
-  .params(u => u.combine('inputSource', [allInputSources[0]])) // Only defined for const-eval
+  .params(u => u.combine('inputSource', onlyConstInputSource))
   .fn(async t => {
     const cases = await d.get('abstract');
-    await run(t, assignment(), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
+    await run(t, abstract_assignment(), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
   });
 
 g.test('f32')
@@ -81,10 +93,10 @@ g.test('f32')
 concretizing to f32
 `
   )
-  .params(u => u.combine('inputSource', [allInputSources[0]])) // Only defined for const-eval
+  .params(u => u.combine('inputSource', onlyConstInputSource))
   .fn(async t => {
     const cases = await d.get('f32');
-    await run(t, assignment(), [TypeAbstractFloat], TypeF32, t.params, cases);
+    await run(t, concrete_assignment(), [TypeAbstractFloat], TypeF32, t.params, cases);
   });
 
 g.test('f16')
@@ -97,8 +109,8 @@ concretizing to f16
   .beforeAllSubcases(t => {
     t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
   })
-  .params(u => u.combine('inputSource', [allInputSources[0]])) // Only defined for const-eval
+  .params(u => u.combine('inputSource', onlyConstInputSource))
   .fn(async t => {
     const cases = await d.get('f16');
-    await run(t, assignment(), [TypeAbstractFloat], TypeF16, t.params, cases);
+    await run(t, concrete_assignment(), [TypeAbstractFloat], TypeF16, t.params, cases);
   });
diff --git a/src/webgpu/shader/execution/expression/unary/unary.ts b/src/webgpu/shader/execution/expression/unary/unary.ts
index ce9d6b814747..995ca3ea172d 100644
--- a/src/webgpu/shader/execution/expression/unary/unary.ts
+++ b/src/webgpu/shader/execution/expression/unary/unary.ts
@@ -1,10 +1,15 @@
-import { basicExpressionBuilder, ShaderBuilder } from '../expression.js';
+import {
+  abstractFloatShaderBuilder,
+  basicExpressionBuilder,
+  ShaderBuilder,
+} from '../expression.js';
 
 /* @returns a ShaderBuilder that evaluates a prefix unary operation */
 export function unary(op: string): ShaderBuilder {
   return basicExpressionBuilder(value => `${op}(${value})`);
 }
 
-export function assignment(): ShaderBuilder {
-  return basicExpressionBuilder(value => `${value}`);
+/* @returns a ShaderBuilder that evaluates a prefix unary operation that returns AbstractFloats */
+export function abstract_unary(op: string): ShaderBuilder {
+  return abstractFloatShaderBuilder(value => `${op}(${value})`);
 }
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index a1b459359c9e..29ca13c39ff8 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5,9 +5,9 @@ import { Case, IntervalFilter } from '../shader/execution/expression/expression.
 import { anyOf } from './compare.js';
 import { kValue } from './constants.js';
 import {
+  abstractFloat,
   f16,
   f32,
-  f64,
   isFloatType,
   reinterpretF16AsU16,
   reinterpretF32AsU32,
@@ -4820,7 +4820,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly isSubnormal = isSubnormalNumberF64;
   public readonly flushSubnormal = flushSubnormalNumberF64;
   public readonly oneULP = oneULPF64;
-  public readonly scalarBuilder = f64;
+  public readonly scalarBuilder = abstractFloat;
 
   // Framework - Fundamental Error Intervals - Overrides
   public readonly absoluteErrorInterval = this.unboundedAbsoluteErrorInterval.bind(this);
@@ -4886,7 +4886,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly multiplicationVectorMatrixInterval = this.unimplementedVectorMatrixToVector.bind(
     this
   );
-  public readonly negationInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly negationInterval = this.negationIntervalImpl.bind(this);
   public readonly normalizeInterval = this.unimplementedVectorToVector.bind(this);
   public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this);
   public readonly quantizeToF16Interval = this.unimplementedScalarToInterval.bind(this);

From 4f3574d1833552d60cf54d63078eaa99f5291328 Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Tue, 5 Sep 2023 15:31:23 -0700
Subject: [PATCH 012/166] Compat: Skip if copyTextureToTexture not supported
 (#2923)

This may be a temporary change if copying compressed textures get
removed from core and moved to a feature.
---
 .../command_buffer/copyTextureToTexture.spec.ts        |  3 ++-
 src/webgpu/gpu_test.ts                                 | 10 ++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/webgpu/api/operation/command_buffer/copyTextureToTexture.spec.ts b/src/webgpu/api/operation/command_buffer/copyTextureToTexture.spec.ts
index 05ffcef0decb..4c55b5162f9b 100644
--- a/src/webgpu/api/operation/command_buffer/copyTextureToTexture.spec.ts
+++ b/src/webgpu/api/operation/command_buffer/copyTextureToTexture.spec.ts
@@ -904,6 +904,7 @@ g.test('color_textures,compressed,non_array')
   )
   .beforeAllSubcases(t => {
     const { srcFormat, dstFormat } = t.params;
+    t.skipIfCopyTextureToTextureNotSupportedForFormat(srcFormat, dstFormat);
     t.selectDeviceOrSkipTestCase([
       kTextureFormatInfo[srcFormat].feature,
       kTextureFormatInfo[dstFormat].feature,
@@ -1058,7 +1059,7 @@ g.test('color_textures,compressed,array')
   )
   .beforeAllSubcases(t => {
     const { srcFormat, dstFormat } = t.params;
-
+    t.skipIfCopyTextureToTextureNotSupportedForFormat(srcFormat, dstFormat);
     t.selectDeviceOrSkipTestCase([
       kTextureFormatInfo[srcFormat].feature,
       kTextureFormatInfo[dstFormat].feature,
diff --git a/src/webgpu/gpu_test.ts b/src/webgpu/gpu_test.ts
index 8a8eff5e0404..68683b63fe0c 100644
--- a/src/webgpu/gpu_test.ts
+++ b/src/webgpu/gpu_test.ts
@@ -213,6 +213,16 @@ export class GPUTestSubcaseBatchState extends SubcaseBatchState {
     }
   }
 
+  skipIfCopyTextureToTextureNotSupportedForFormat(...formats: (GPUTextureFormat | undefined)[]) {
+    if (this.isCompatibility) {
+      for (const format of formats) {
+        if (format && isCompressedTextureFormat(format)) {
+          this.skip(`copyTextureToTexture with ${format} is not supported`);
+        }
+      }
+    }
+  }
+
   skipIfTextureViewDimensionNotSupported(...dimensions: (GPUTextureViewDimension | undefined)[]) {
     if (this.isCompatibility) {
       for (const dimension of dimensions) {

From 8ca48c83c4e95a77d74b234cbd144a0adde19cea Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 6 Sep 2023 10:40:12 +0800
Subject: [PATCH 013/166] wgsl: f16 built-in execution test for clamp (#2918)

This PR add execution tests for f16 built-in clamp.

Issue: #1248
---
 src/unittests/floating_point.spec.ts          | 176 ++++++++++--------
 .../expression/call/builtin/clamp.spec.ts     | 104 ++++++-----
 src/webgpu/util/floating_point.ts             |   4 +-
 3 files changed, 157 insertions(+), 127 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 9ef92528a342..40e2534f38d9 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -4589,103 +4589,119 @@ interface ScalarTripleToIntervalCase {
   expected: number | IntervalBounds;
 }
 
-g.test('clampMedianInterval_f32')
-  .paramsSubcasesOnly<ScalarTripleToIntervalCase>(
-    // prettier-ignore
-    [
-      // Normals
-      { input: [0, 0, 0], expected: 0 },
-      { input: [1, 0, 0], expected: 0 },
-      { input: [0, 1, 0], expected: 0 },
-      { input: [0, 0, 1], expected: 0 },
-      { input: [1, 0, 1], expected: 1 },
-      { input: [1, 1, 0], expected: 1 },
-      { input: [0, 1, 1], expected: 1 },
-      { input: [1, 1, 1], expected: 1 },
-      { input: [1, 10, 100], expected: 10 },
-      { input: [10, 1, 100], expected: 10 },
-      { input: [100, 1, 10], expected: 10 },
-      { input: [-10, 1, 100], expected: 1 },
-      { input: [10, 1, -100], expected: 1 },
-      { input: [-10, 1, -100], expected: -10 },
-      { input: [-10, -10, -10], expected: -10 },
+g.test('clampMedianInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarTripleToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          // Normals
+          { input: [0, 0, 0], expected: 0 },
+          { input: [1, 0, 0], expected: 0 },
+          { input: [0, 1, 0], expected: 0 },
+          { input: [0, 0, 1], expected: 0 },
+          { input: [1, 0, 1], expected: 1 },
+          { input: [1, 1, 0], expected: 1 },
+          { input: [0, 1, 1], expected: 1 },
+          { input: [1, 1, 1], expected: 1 },
+          { input: [1, 10, 100], expected: 10 },
+          { input: [10, 1, 100], expected: 10 },
+          { input: [100, 1, 10], expected: 10 },
+          { input: [-10, 1, 100], expected: 1 },
+          { input: [10, 1, -100], expected: 1 },
+          { input: [-10, 1, -100], expected: -10 },
+          { input: [-10, -10, -10], expected: -10 },
 
-      // Subnormals
-      { input: [kValue.f32.subnormal.positive.max, 0, 0], expected: 0 },
-      { input: [0, kValue.f32.subnormal.positive.max, 0], expected: 0 },
-      { input: [0, 0, kValue.f32.subnormal.positive.max], expected: 0 },
-      { input: [kValue.f32.subnormal.positive.max, 0, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, 0], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [0, kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.negative.max], expected: [0, kValue.f32.subnormal.positive.min] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max], expected: [kValue.f32.subnormal.negative.max, 0] },
-      { input: [kValue.f32.positive.max, kValue.f32.positive.max, kValue.f32.subnormal.positive.min], expected: kValue.f32.positive.max },
+          // Subnormals
+          { input: [constants.positive.subnormal.max, 0, 0], expected: 0 },
+          { input: [0, constants.positive.subnormal.max, 0], expected: 0 },
+          { input: [0, 0, constants.positive.subnormal.max], expected: 0 },
+          { input: [constants.positive.subnormal.max, 0, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          { input: [constants.positive.subnormal.max, constants.positive.subnormal.max, 0], expected: [0, constants.positive.subnormal.max] },
+          { input: [0, constants.positive.subnormal.max, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          { input: [constants.positive.subnormal.max, constants.positive.subnormal.max, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          { input: [constants.positive.subnormal.max, constants.positive.subnormal.min, constants.negative.subnormal.max], expected: [0, constants.positive.subnormal.min] },
+          { input: [constants.positive.subnormal.max, constants.negative.subnormal.min, constants.negative.subnormal.max], expected: [constants.negative.subnormal.max, 0] },
+          { input: [constants.positive.max, constants.positive.max, constants.positive.subnormal.min], expected: constants.positive.max },
 
-      // Infinities
-      { input: [0, 1, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [0, kValue.f32.infinity.positive, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-    ]
+          // Infinities
+          { input: [0, 1, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [0, constants.positive.infinity, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity, constants.negative.infinity], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
     const [x, y, z] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.clampMedianInterval(x, y, z);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.clampMedianInterval(x, y, z);
     t.expect(
       objectEquals(expected, got),
-      `f32.clampMedianInterval(${x}, ${y}, ${z}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.clampMedianInterval(${x}, ${y}, ${z}) returned ${got}. Expected ${expected}`
     );
   });
 
-g.test('clampMinMaxInterval_f32')
-  .paramsSubcasesOnly<ScalarTripleToIntervalCase>(
-    // prettier-ignore
-    [
-      // Normals
-      { input: [0, 0, 0], expected: 0 },
-      { input: [1, 0, 0], expected: 0 },
-      { input: [0, 1, 0], expected: 0 },
-      { input: [0, 0, 1], expected: 0 },
-      { input: [1, 0, 1], expected: 1 },
-      { input: [1, 1, 0], expected: 0 },
-      { input: [0, 1, 1], expected: 1 },
-      { input: [1, 1, 1], expected: 1 },
-      { input: [1, 10, 100], expected: 10 },
-      { input: [10, 1, 100], expected: 10 },
-      { input: [100, 1, 10], expected: 10 },
-      { input: [-10, 1, 100], expected: 1 },
-      { input: [10, 1, -100], expected: -100 },
-      { input: [-10, 1, -100], expected: -100 },
-      { input: [-10, -10, -10], expected: -10 },
+g.test('clampMinMaxInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarTripleToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          // Normals
+          { input: [0, 0, 0], expected: 0 },
+          { input: [1, 0, 0], expected: 0 },
+          { input: [0, 1, 0], expected: 0 },
+          { input: [0, 0, 1], expected: 0 },
+          { input: [1, 0, 1], expected: 1 },
+          { input: [1, 1, 0], expected: 0 },
+          { input: [0, 1, 1], expected: 1 },
+          { input: [1, 1, 1], expected: 1 },
+          { input: [1, 10, 100], expected: 10 },
+          { input: [10, 1, 100], expected: 10 },
+          { input: [100, 1, 10], expected: 10 },
+          { input: [-10, 1, 100], expected: 1 },
+          { input: [10, 1, -100], expected: -100 },
+          { input: [-10, 1, -100], expected: -100 },
+          { input: [-10, -10, -10], expected: -10 },
 
-      // Subnormals
-      { input: [kValue.f32.subnormal.positive.max, 0, 0], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [0, kValue.f32.subnormal.positive.max, 0], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [0, 0, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, 0, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, 0], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [0, kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.negative.max], expected: [kValue.f32.subnormal.negative.max, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max], expected: [kValue.f32.subnormal.negative.min, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.positive.max, kValue.f32.positive.max, kValue.f32.subnormal.positive.min], expected: [0, kValue.f32.subnormal.positive.min] },
+          // Subnormals
+          { input: [constants.positive.subnormal.max, 0, 0], expected: [0, constants.positive.subnormal.max] },
+          { input: [0, constants.positive.subnormal.max, 0], expected: [0, constants.positive.subnormal.max] },
+          { input: [0, 0, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          { input: [constants.positive.subnormal.max, 0, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          { input: [constants.positive.subnormal.max, constants.positive.subnormal.max, 0], expected: [0, constants.positive.subnormal.max] },
+          { input: [0, constants.positive.subnormal.max, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          { input: [constants.positive.subnormal.max, constants.positive.subnormal.max, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          { input: [constants.positive.subnormal.max, constants.positive.subnormal.min, constants.negative.subnormal.max], expected: [constants.negative.subnormal.max, constants.positive.subnormal.max] },
+          { input: [constants.positive.subnormal.max, constants.negative.subnormal.min, constants.negative.subnormal.max], expected: [constants.negative.subnormal.min, constants.positive.subnormal.max] },
+          { input: [constants.positive.max, constants.positive.max, constants.positive.subnormal.min], expected: [0, constants.positive.subnormal.min] },
 
-      // Infinities
-      { input: [0, 1, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [0, kValue.f32.infinity.positive, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-    ]
+          // Infinities
+          { input: [0, 1, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [0, constants.positive.infinity, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity, constants.negative.infinity], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
     const [x, y, z] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.clampMinMaxInterval(x, y, z);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.clampMinMaxInterval(x, y, z);
     t.expect(
       objectEquals(expected, got),
-      `f32.clampMinMaxInterval(${x}, ${y}, ${z}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.clampMinMaxInterval(${x}, ${y}, ${z}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts
index 308fb852fbbc..a7fb74d56e89 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts
@@ -16,9 +16,9 @@ Component-wise when T is a vector.
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { kValue } from '../../../../../util/constants.js';
-import { ScalarType, TypeF32, TypeI32, TypeU32 } from '../../../../../util/conversion.js';
+import { ScalarType, TypeF32, TypeF16, TypeI32, TypeU32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseF32Range } from '../../../../../util/math.js';
+import { sparseF32Range, sparseF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, Case, run } from '../../expression.js';
 
@@ -26,9 +26,20 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
-const u32Values = [kValue.u32.min, 1, 2, 0x70000000, 0x80000000, kValue.u32.max];
-
-const i32Values = [kValue.i32.negative.min, -2, -1, 0, 1, 2, 0x70000000, kValue.i32.positive.max];
+const u32Values = [0, 1, 2, 3, 0x70000000, 0x80000000, kValue.u32.max];
+
+const i32Values = [
+  kValue.i32.negative.min,
+  -3,
+  -2,
+  -1,
+  0,
+  1,
+  2,
+  3,
+  0x70000000,
+  kValue.i32.positive.max,
+];
 
 export const d = makeCaseCache('clamp', {
   u32_non_const: () => {
@@ -44,10 +55,16 @@ export const d = makeCaseCache('clamp', {
     return generateIntegerTestCases(i32Values, TypeI32, 'const');
   },
   f32_const: () => {
-    return generateF32TestCases(sparseF32Range(), 'const');
+    return generateFloatTestCases(sparseF32Range(), 'f32', 'const');
   },
   f32_non_const: () => {
-    return generateF32TestCases(sparseF32Range(), 'non-const');
+    return generateFloatTestCases(sparseF32Range(), 'f32', 'non-const');
+  },
+  f16_const: () => {
+    return generateFloatTestCases(sparseF16Range(), 'f16', 'const');
+  },
+  f16_non_const: () => {
+    return generateFloatTestCases(sparseF16Range(), 'f16', 'non-const');
   },
 });
 
@@ -57,48 +74,39 @@ function generateIntegerTestCases(
   type: ScalarType,
   stage: 'const' | 'non-const'
 ): Array<Case> {
-  const cases = new Array<Case>();
-  for (const e of test_values) {
-    for (const low of test_values) {
-      for (const high of test_values) {
-        if (stage === 'const' && low > high) {
-          continue; // This would result in a shader compilation error
-        }
-        cases.push({
-          input: [type.create(e), type.create(low), type.create(high)],
-          expected: type.create(Math.min(Math.max(e, low), high)),
-        });
-      }
-    }
-  }
-  return cases;
+  return test_values.flatMap(low =>
+    test_values.flatMap(high =>
+      stage === 'const' && low > high
+        ? []
+        : test_values.map(e => ({
+            input: [type.create(e), type.create(low), type.create(high)],
+            expected: type.create(Math.min(Math.max(e, low), high)),
+          }))
+    )
+  );
 }
 
-function generateF32TestCases(
+function generateFloatTestCases(
   test_values: Array<number>,
+  trait: 'f32' | 'f16',
   stage: 'const' | 'non-const'
 ): Array<Case> {
-  const cases = new Array<Case>();
-  for (const e of test_values) {
-    for (const low of test_values) {
-      for (const high of test_values) {
-        if (stage === 'const' && low > high) {
-          continue; // This would result in a shader compilation error
-        }
-        const c = FP.f32.makeScalarTripleToIntervalCase(
-          e,
-          low,
-          high,
-          stage === 'const' ? 'finite' : 'unfiltered',
-          ...FP.f32.clampIntervals
-        );
-        if (c !== undefined) {
-          cases.push(c);
-        }
-      }
-    }
-  }
-  return cases;
+  return test_values.flatMap(low =>
+    test_values.flatMap(high =>
+      stage === 'const' && low > high
+        ? []
+        : test_values.flatMap(e => {
+            const c = FP[trait].makeScalarTripleToIntervalCase(
+              e,
+              low,
+              high,
+              stage === 'const' ? 'finite' : 'unfiltered',
+              ...FP[trait].clampIntervals
+            );
+            return c === undefined ? [] : [c];
+          })
+    )
+  );
 }
 
 g.test('abstract_int')
@@ -156,4 +164,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('clamp'), [TypeF16, TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 29ca13c39ff8..2197ecc60f4e 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5127,8 +5127,8 @@ class F16Traits extends FPTraits {
   public readonly atan2Interval = this.atan2IntervalImpl.bind(this);
   public readonly atanhInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly ceilInterval = this.ceilIntervalImpl.bind(this);
-  public readonly clampMedianInterval = this.unimplementedScalarTripleToInterval.bind(this);
-  public readonly clampMinMaxInterval = this.unimplementedScalarTripleToInterval.bind(this);
+  public readonly clampMedianInterval = this.clampMedianIntervalImpl.bind(this);
+  public readonly clampMinMaxInterval = this.clampMinMaxIntervalImpl.bind(this);
   public readonly clampIntervals = [this.clampMedianInterval, this.clampMinMaxInterval];
   public readonly cosInterval = this.cosIntervalImpl.bind(this);
   public readonly coshInterval = this.unimplementedScalarToInterval.bind(this);

From ef82e7bde92132c7981574bb8c976a6ff91d9357 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 6 Sep 2023 10:51:18 +0800
Subject: [PATCH 014/166] wgsl: f16 built-in execution test for sign and step
 (#2911)

This PR add execution tests for f16 built-in sign and step.

Issue: #1248, #2583, #2529
---
 src/unittests/floating_point.spec.ts          | 252 +++++++++---------
 .../expression/call/builtin/sign.spec.ts      |  15 +-
 .../expression/call/builtin/step.spec.ts      |  70 ++---
 src/webgpu/util/floating_point.ts             |   4 +-
 4 files changed, 183 insertions(+), 158 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 40e2534f38d9..9a423e914e02 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3246,37 +3246,37 @@ g.test('roundInterval')
         const constants = FP[p.trait].constants();
         // prettier-ignore
         return [
-      { input: 0, expected: 0 },
-      { input: 0.1, expected: 0 },
-      { input: 0.5, expected: 0 },  // Testing tie breaking
-      { input: 0.9, expected: 1 },
-      { input: 1.0, expected: 1 },
-      { input: 1.1, expected: 1 },
-      { input: 1.5, expected: 2 },  // Testing tie breaking
-      { input: 1.9, expected: 2 },
-      { input: -0.1, expected: 0 },
-      { input: -0.5, expected: 0 },  // Testing tie breaking
-      { input: -0.9, expected: -1 },
-      { input: -1.0, expected: -1 },
-      { input: -1.1, expected: -1 },
-      { input: -1.5, expected: -2 },  // Testing tie breaking
-      { input: -1.9, expected: -2 },
+          { input: 0, expected: 0 },
+          { input: 0.1, expected: 0 },
+          { input: 0.5, expected: 0 },  // Testing tie breaking
+          { input: 0.9, expected: 1 },
+          { input: 1.0, expected: 1 },
+          { input: 1.1, expected: 1 },
+          { input: 1.5, expected: 2 },  // Testing tie breaking
+          { input: 1.9, expected: 2 },
+          { input: -0.1, expected: 0 },
+          { input: -0.5, expected: 0 },  // Testing tie breaking
+          { input: -0.9, expected: -1 },
+          { input: -1.0, expected: -1 },
+          { input: -1.1, expected: -1 },
+          { input: -1.5, expected: -2 },  // Testing tie breaking
+          { input: -1.9, expected: -2 },
 
-      // Edge cases
-      { input: constants.positive.infinity, expected: kUnboundedBounds },
-      { input: constants.negative.infinity, expected: kUnboundedBounds },
-      { input: constants.positive.max, expected: constants.positive.max },
-      { input: constants.positive.min, expected: 0 },
-      { input: constants.negative.min, expected: constants.negative.min },
-      { input: constants.negative.max, expected: 0 },
-      ...kRoundIntervalCases[p.trait],
+          // Edge cases
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: constants.positive.max },
+          { input: constants.positive.min, expected: 0 },
+          { input: constants.negative.min, expected: constants.negative.min },
+          { input: constants.negative.max, expected: 0 },
+          ...kRoundIntervalCases[p.trait],
 
-      // 32-bit subnormals
-      { input: constants.positive.subnormal.max, expected: 0 },
-      { input: constants.positive.subnormal.min, expected: 0 },
-      { input: constants.negative.subnormal.min, expected: 0 },
-      { input: constants.negative.subnormal.max, expected: 0 },
-    ];
+          // 32-bit subnormals
+          { input: constants.positive.subnormal.max, expected: 0 },
+          { input: constants.positive.subnormal.min, expected: 0 },
+          { input: constants.negative.subnormal.min, expected: 0 },
+          { input: constants.negative.subnormal.max, expected: 0 },
+        ];
       })
   )
   .fn(t => {
@@ -3327,35 +3327,42 @@ g.test('saturateInterval_f32')
     );
   });
 
-g.test('signInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: -1 },
-      { input: -10, expected: -1 },
-      { input: -1, expected: -1 },
-      { input: -0.1, expected: -1 },
-      { input: kValue.f32.negative.max, expected:  -1 },
-      { input: kValue.f32.subnormal.negative.min, expected: [-1, 0] },
-      { input: kValue.f32.subnormal.negative.max, expected: [-1, 0] },
-      { input: 0, expected: 0 },
-      { input: kValue.f32.subnormal.positive.max, expected: [0, 1] },
-      { input: kValue.f32.subnormal.positive.min, expected: [0, 1] },
-      { input: kValue.f32.positive.min, expected: 1 },
-      { input: 0.1, expected: 1 },
-      { input: 1, expected: 1 },
-      { input: 10, expected: 1 },
-      { input: kValue.f32.positive.max, expected: 1 },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+g.test('signInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const constants = FP[p.trait].constants();
+        // prettier-ignore
+        return [
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: -1 },
+          { input: -10, expected: -1 },
+          { input: -1, expected: -1 },
+          { input: -0.1, expected: -1 },
+          { input: constants.negative.max, expected:  -1 },
+          { input: constants.negative.subnormal.min, expected: [-1, 0] },
+          { input: constants.negative.subnormal.max, expected: [-1, 0] },
+          { input: 0, expected: 0 },
+          { input: constants.positive.subnormal.max, expected: [0, 1] },
+          { input: constants.positive.subnormal.min, expected: [0, 1] },
+          { input: constants.positive.min, expected: 1 },
+          { input: 0.1, expected: 1 },
+          { input: 1, expected: 1 },
+          { input: 10, expected: 1 },
+          { input: constants.positive.max, expected: 1 },
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.signInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.signInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.signInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.signInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -4415,79 +4422,86 @@ g.test('remainderInterval_f32')
     );
   });
 
-g.test('stepInterval_f32')
-  .paramsSubcasesOnly<ScalarPairToIntervalCase>(
-    // prettier-ignore
-    [
-      // 32-bit normals
-      { input: [0, 0], expected: 1 },
-      { input: [1, 1], expected: 1 },
-      { input: [0, 1], expected: 1 },
-      { input: [1, 0], expected: 0 },
-      { input: [-1, -1], expected: 1 },
-      { input: [0, -1], expected: 0 },
-      { input: [-1, 0], expected: 1 },
-      { input: [-1, 1], expected: 1 },
-      { input: [1, -1], expected: 0 },
+g.test('stepInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarPairToIntervalCase>(p => {
+        const constants = FP[p.trait].constants();
+        // prettier-ignore
+        return [
+          // 32-bit normals
+          { input: [0, 0], expected: 1 },
+          { input: [1, 1], expected: 1 },
+          { input: [0, 1], expected: 1 },
+          { input: [1, 0], expected: 0 },
+          { input: [-1, -1], expected: 1 },
+          { input: [0, -1], expected: 0 },
+          { input: [-1, 0], expected: 1 },
+          { input: [-1, 1], expected: 1 },
+          { input: [1, -1], expected: 0 },
 
-      // 64-bit normals
-      { input: [0.1, 0.1], expected: [0, 1] },
-      { input: [0, 0.1], expected: 1 },
-      { input: [0.1, 0], expected: 0 },
-      { input: [0.1, 1], expected: 1 },
-      { input: [1, 0.1], expected: 0 },
-      { input: [-0.1, -0.1], expected: [0, 1] },
-      { input: [0, -0.1], expected: 0 },
-      { input: [-0.1, 0], expected: 1 },
-      { input: [-0.1, -1], expected: 0 },
-      { input: [-1, -0.1], expected: 1 },
+          // 64-bit normals
+          { input: [0.1, 0.1], expected: [0, 1] },
+          { input: [0, 0.1], expected: 1 },
+          { input: [0.1, 0], expected: 0 },
+          { input: [0.1, 1], expected: 1 },
+          { input: [1, 0.1], expected: 0 },
+          { input: [-0.1, -0.1], expected: [0, 1] },
+          { input: [0, -0.1], expected: 0 },
+          { input: [-0.1, 0], expected: 1 },
+          { input: [-0.1, -1], expected: 0 },
+          { input: [-1, -0.1], expected: 1 },
 
-      // Subnormals
-      { input: [0, kValue.f32.subnormal.positive.max], expected: 1 },
-      { input: [0, kValue.f32.subnormal.positive.min], expected: 1 },
-      { input: [0, kValue.f32.subnormal.negative.max], expected: [0, 1] },
-      { input: [0, kValue.f32.subnormal.negative.min], expected: [0, 1] },
-      { input: [1, kValue.f32.subnormal.positive.max], expected: 0 },
-      { input: [1, kValue.f32.subnormal.positive.min], expected: 0 },
-      { input: [1, kValue.f32.subnormal.negative.max], expected: 0 },
-      { input: [1, kValue.f32.subnormal.negative.min], expected: 0 },
-      { input: [-1, kValue.f32.subnormal.positive.max], expected: 1 },
-      { input: [-1, kValue.f32.subnormal.positive.min], expected: 1 },
-      { input: [-1, kValue.f32.subnormal.negative.max], expected: 1 },
-      { input: [-1, kValue.f32.subnormal.negative.min], expected: 1 },
-      { input: [kValue.f32.subnormal.positive.max, 0], expected: [0, 1] },
-      { input: [kValue.f32.subnormal.positive.min, 0], expected: [0, 1] },
-      { input: [kValue.f32.subnormal.negative.max, 0], expected: 1 },
-      { input: [kValue.f32.subnormal.negative.min, 0], expected: 1 },
-      { input: [kValue.f32.subnormal.positive.max, 1], expected: 1 },
-      { input: [kValue.f32.subnormal.positive.min, 1], expected: 1 },
-      { input: [kValue.f32.subnormal.negative.max, 1], expected: 1 },
-      { input: [kValue.f32.subnormal.negative.min, 1], expected: 1 },
-      { input: [kValue.f32.subnormal.positive.max, -1], expected: 0 },
-      { input: [kValue.f32.subnormal.positive.min, -1], expected: 0 },
-      { input: [kValue.f32.subnormal.negative.max, -1], expected: 0 },
-      { input: [kValue.f32.subnormal.negative.min, -1], expected: 0 },
-      { input: [kValue.f32.subnormal.negative.min, kValue.f32.subnormal.positive.max], expected: 1 },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.min], expected: [0, 1] },
+          // Subnormals
+          { input: [0, constants.positive.subnormal.max], expected: 1 },
+          { input: [0, constants.positive.subnormal.min], expected: 1 },
+          { input: [0, constants.negative.subnormal.max], expected: [0, 1] },
+          { input: [0, constants.negative.subnormal.min], expected: [0, 1] },
+          { input: [1, constants.positive.subnormal.max], expected: 0 },
+          { input: [1, constants.positive.subnormal.min], expected: 0 },
+          { input: [1, constants.negative.subnormal.max], expected: 0 },
+          { input: [1, constants.negative.subnormal.min], expected: 0 },
+          { input: [-1, constants.positive.subnormal.max], expected: 1 },
+          { input: [-1, constants.positive.subnormal.min], expected: 1 },
+          { input: [-1, constants.negative.subnormal.max], expected: 1 },
+          { input: [-1, constants.negative.subnormal.min], expected: 1 },
+          { input: [constants.positive.subnormal.max, 0], expected: [0, 1] },
+          { input: [constants.positive.subnormal.min, 0], expected: [0, 1] },
+          { input: [constants.negative.subnormal.max, 0], expected: 1 },
+          { input: [constants.negative.subnormal.min, 0], expected: 1 },
+          { input: [constants.positive.subnormal.max, 1], expected: 1 },
+          { input: [constants.positive.subnormal.min, 1], expected: 1 },
+          { input: [constants.negative.subnormal.max, 1], expected: 1 },
+          { input: [constants.negative.subnormal.min, 1], expected: 1 },
+          { input: [constants.positive.subnormal.max, -1], expected: 0 },
+          { input: [constants.positive.subnormal.min, -1], expected: 0 },
+          { input: [constants.negative.subnormal.max, -1], expected: 0 },
+          { input: [constants.negative.subnormal.min, -1], expected: 0 },
+          { input: [constants.negative.subnormal.min, constants.positive.subnormal.max], expected: 1 },
+          { input: [constants.positive.subnormal.max, constants.negative.subnormal.min], expected: [0, 1] },
 
-      // Infinities
-      { input: [0, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.positive, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.positive, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [0, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.positive, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-    ]
+          // Infinities
+          { input: [0, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [constants.positive.infinity, 0], expected: kUnboundedBounds },
+          { input: [constants.positive.infinity, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [0, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, 0], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [constants.positive.infinity, constants.negative.infinity], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
+    const trait = FP[t.params.trait];
     const [edge, x] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.stepInterval(edge, x);
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.stepInterval(edge, x);
     t.expect(
       objectEquals(expected, got),
-      `f32.stepInterval(${edge}, ${x}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.stepInterval(${edge}, ${x}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/shader/execution/expression/call/builtin/sign.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/sign.spec.ts
index 70a4c45fb716..454ff48e6edc 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/sign.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/sign.spec.ts
@@ -9,9 +9,9 @@ Returns the sign of e. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { i32, TypeF32, TypeI32 } from '../../../../../util/conversion.js';
+import { i32, TypeF32, TypeF16, TypeI32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, fullI32Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range, fullI32Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -23,6 +23,9 @@ export const d = makeCaseCache('sign', {
   f32: () => {
     return FP.f32.generateScalarToIntervalCases(fullF32Range(), 'unfiltered', FP.f32.signInterval);
   },
+  f16: () => {
+    return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'unfiltered', FP.f16.signInterval);
+  },
   i32: () =>
     fullI32Range().map(i => {
       const signFunc = (i: number): number => (i < 0 ? -1 : i > 0 ? 1 : 0);
@@ -74,4 +77,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('sign'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/step.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/step.spec.ts
index f0892b6c4a71..752e2676e651 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/step.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/step.spec.ts
@@ -10,9 +10,9 @@ Returns 1.0 if edge ≤ x, and 0.0 otherwise. Component-wise when T is a vector.
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { anyOf } from '../../../../../util/compare.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, Case, run } from '../../expression.js';
 
@@ -20,40 +20,36 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('step', {
-  f32: () => {
-    const zeroInterval = FP.f32.toInterval(0);
-    const oneInterval = FP.f32.toInterval(1);
-
-    // stepInterval's return value isn't always interpreted as an acceptance
-    // interval, so makeBinaryToF32IntervalCase cannot be used here.
-    // See the comment block on stepInterval for more details
-    const makeCase = (edge: number, x: number): Case => {
-      edge = FP.f32.quantize(edge);
-      x = FP.f32.quantize(x);
-      const expected = FP.f32.stepInterval(edge, x);
+// stepInterval's return value can't always be interpreted as a single acceptance
+// interval, valid result may be 0.0 or 1.0 or both of them, but will never be a
+// value in interval (0.0, 1.0).
+// See the comment block on stepInterval for more details
+const makeCase = (trait: 'f32' | 'f16', edge: number, x: number): Case => {
+  const FPTrait = FP[trait];
+  edge = FPTrait.quantize(edge);
+  x = FPTrait.quantize(x);
+  const expected = FPTrait.stepInterval(edge, x);
 
-      // [0, 0], [1, 1], or [-∞, +∞] cases
-      if (expected.isPoint() || !expected.isFinite()) {
-        return { input: [FP.f32.scalarBuilder(edge), FP.f32.scalarBuilder(x)], expected };
-      }
+  // [0, 0], [1, 1], or [-∞, +∞] cases
+  if (expected.isPoint() || !expected.isFinite()) {
+    return { input: [FPTrait.scalarBuilder(edge), FPTrait.scalarBuilder(x)], expected };
+  }
 
-      // [0, 1] case
-      return {
-        input: [FP.f32.scalarBuilder(edge), FP.f32.scalarBuilder(x)],
-        expected: anyOf(zeroInterval, oneInterval),
-      };
-    };
+  // [0, 1] case, valid result is either 0.0 or 1.0.
+  const zeroInterval = FPTrait.toInterval(0);
+  const oneInterval = FPTrait.toInterval(1);
+  return {
+    input: [FPTrait.scalarBuilder(edge), FPTrait.scalarBuilder(x)],
+    expected: anyOf(zeroInterval, oneInterval),
+  };
+};
 
-    const range = fullF32Range();
-    const cases: Array<Case> = [];
-    range.forEach(edge => {
-      range.forEach(x => {
-        cases.push(makeCase(edge, x));
-      });
-    });
-
-    return cases;
+export const d = makeCaseCache('step', {
+  f32: () => {
+    return fullF32Range().flatMap(edge => fullF32Range().map(x => makeCase('f32', edge, x)));
+  },
+  f16: () => {
+    return fullF16Range().flatMap(edge => fullF16Range().map(x => makeCase('f16', edge, x)));
   },
 });
 
@@ -82,4 +78,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('step'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 2197ecc60f4e..746efe587fc8 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5181,12 +5181,12 @@ class F16Traits extends FPTraits {
   public readonly remainderInterval = this.unimplementedScalarPairToInterval.bind(this);
   public readonly roundInterval = this.roundIntervalImpl.bind(this);
   public readonly saturateInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly signInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly signInterval = this.signIntervalImpl.bind(this);
   public readonly sinInterval = this.sinIntervalImpl.bind(this);
   public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly smoothStepInterval = this.unimplementedScalarTripleToInterval.bind(this);
   public readonly sqrtInterval = this.sqrtIntervalImpl.bind(this);
-  public readonly stepInterval = this.unimplementedScalarPairToInterval.bind(this);
+  public readonly stepInterval = this.stepIntervalImpl.bind(this);
   public readonly subtractionInterval = this.subtractionIntervalImpl.bind(this);
   public readonly subtractionMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(this);
   public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);

From 23cdd20d853a1fde201af27a90eea546167c4dea Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 6 Sep 2023 10:48:35 -0400
Subject: [PATCH 015/166] wgsl: Implement scalar/vector AbstractFloat addition
 execution tests (#2922)

Matrix addition will be covered in future PRs.

Issue #1626

Co-authored-by: jzm-intel <zhaoming.jiang@intel.com>
---
 src/unittests/floating_point.spec.ts          |  17 +-
 .../expression/binary/af_addition.spec.ts     | 151 ++++++++++++++++++
 .../execution/expression/binary/binary.ts     |  12 +-
 .../expression/binary/f32_addition.spec.ts    |   8 -
 .../expression/unary/af_arithmetic.spec.ts    |   4 +-
 .../execution/expression/unary/unary.ts       |   2 +-
 src/webgpu/util/floating_point.ts             |   2 +-
 src/webgpu/util/math.ts                       |  32 ++++
 8 files changed, 214 insertions(+), 14 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/binary/af_addition.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 9a423e914e02..8b1e588be858 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3670,12 +3670,27 @@ const kAdditionInterval64BitsNormalCases = {
     // -0.1+0.1 expect f16 interval [0xAE67+0x2E66, 0xAE66+0x2E67]
     { input: [-0.1, 0.1], expected: [reinterpretU16AsF16(0xae67)+reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0xae66)+reinterpretU16AsF16(0x2e67)] },  // ~0.0
   ] as ScalarPairToIntervalCase[],
+  abstract: [
+    // 0.1 isn't exactly representable in f64, but will be quantized to an
+    // exact value when storing to a 'number' (0x3FB999999999999A).
+    // This is why below the expectations are not intervals.
+    { input: [0.1, 0], expected: [0.1] },
+    { input: [0, 0.1], expected: [0.1] },
+    { input: [-0.1, 0], expected: [-0.1] },
+    { input: [0, -0.1], expected: [-0.1] },
+    // f64 0x3FB999999999999A+0x3FB999999999999A = 0x3FC999999999999A
+    { input: [0.1, 0.1], expected: [reinterpretU64AsF64(0x3FC999999999999An)] },  // ~0.2
+    // f64 0xBFB999999999999A+0xBFB999999999999A = 0xBFC999999999999A
+    { input: [-0.1, -0.1], expected: [reinterpretU64AsF64(0xBFC999999999999An)] },  // ~-0.2
+    { input: [0.1, -0.1], expected: [0] },
+    { input: [-0.1, 0.1], expected: [0] },
+  ] as ScalarPairToIntervalCase[],
 } as const;
 
 g.test('additionInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarPairToIntervalCase>(p => {
         const trait = FP[p.trait];
diff --git a/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
new file mode 100644
index 000000000000..777b801e131d
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
@@ -0,0 +1,151 @@
+export const description = `
+Execution Tests for non-matrix AbstractFloat addition expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractFloat, TypeVec } from '../../../../util/conversion.js';
+import { FP, FPVector } from '../../../../util/floating_point.js';
+import { sparseF64Range, sparseVectorF64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { abstractBinary } from './binary.js';
+
+const additionVectorScalarInterval = (v: number[], s: number): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.additionInterval(e, s)));
+};
+
+const additionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.additionInterval(s, e)));
+};
+
+export const g = makeTestGroup(GPUTest);
+
+export const d = makeCaseCache('binary/af_addition', {
+  scalar: () => {
+    return FP.abstract.generateScalarPairToIntervalCases(
+      sparseF64Range(),
+      sparseF64Range(),
+      'finite',
+      FP.abstract.additionInterval
+    );
+  },
+  vec2_scalar: () => {
+    return FP.abstract.generateVectorScalarToVectorCases(
+      sparseVectorF64Range(2),
+      sparseF64Range(),
+      'finite',
+      additionVectorScalarInterval
+    );
+  },
+  vec3_scalar: () => {
+    return FP.abstract.generateVectorScalarToVectorCases(
+      sparseVectorF64Range(3),
+      sparseF64Range(),
+      'finite',
+      additionVectorScalarInterval
+    );
+  },
+  vec4_scalar: () => {
+    return FP.abstract.generateVectorScalarToVectorCases(
+      sparseVectorF64Range(4),
+      sparseF64Range(),
+      'finite',
+      additionVectorScalarInterval
+    );
+  },
+  scalar_vec2: () => {
+    return FP.abstract.generateScalarVectorToVectorCases(
+      sparseF64Range(),
+      sparseVectorF64Range(2),
+      'finite',
+      additionScalarVectorInterval
+    );
+  },
+  scalar_vec3: () => {
+    return FP.abstract.generateScalarVectorToVectorCases(
+      sparseF64Range(),
+      sparseVectorF64Range(3),
+      'finite',
+      additionScalarVectorInterval
+    );
+  },
+  scalar_vec4: () => {
+    return FP.abstract.generateScalarVectorToVectorCases(
+      sparseF64Range(),
+      sparseVectorF64Range(4),
+      'finite',
+      additionScalarVectorInterval
+    );
+  },
+});
+
+g.test('scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x + y
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cases = await d.get('scalar');
+    await run(
+      t,
+      abstractBinary('+'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector_scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x + y, where x is a vector and y is a scalar
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`vec${dim}_scalar`);
+    await run(
+      t,
+      abstractBinary('+'),
+      [TypeVec(dim, TypeAbstractFloat), TypeAbstractFloat],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('scalar_vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x + y, where x is a scalar and y is a vector
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`scalar_vec${dim}`);
+    await run(
+      t,
+      abstractBinary('+'),
+      [TypeAbstractFloat, TypeVec(dim, TypeAbstractFloat)],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/binary/binary.ts b/src/webgpu/shader/execution/expression/binary/binary.ts
index 5642f164d149..f0b01b839b22 100644
--- a/src/webgpu/shader/execution/expression/binary/binary.ts
+++ b/src/webgpu/shader/execution/expression/binary/binary.ts
@@ -1,4 +1,9 @@
-import { ShaderBuilder, basicExpressionBuilder, compoundAssignmentBuilder } from '../expression.js';
+import {
+  ShaderBuilder,
+  basicExpressionBuilder,
+  compoundAssignmentBuilder,
+  abstractFloatShaderBuilder,
+} from '../expression.js';
 
 /* @returns a ShaderBuilder that evaluates a binary operation */
 export function binary(op: string): ShaderBuilder {
@@ -9,3 +14,8 @@ export function binary(op: string): ShaderBuilder {
 export function compoundBinary(op: string): ShaderBuilder {
   return compoundAssignmentBuilder(op);
 }
+
+/* @returns a ShaderBuilder that evaluates a binary operation that returns AbstractFloats */
+export function abstractBinary(op: string): ShaderBuilder {
+  return abstractFloatShaderBuilder(values => `(${values.map(v => `(${v})`).join(op)})`);
+}
diff --git a/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
index cf57768286db..d3c9bcfb02c3 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
@@ -135,14 +135,6 @@ export const d = makeCaseCache('binary/f32_addition', {
       additionScalarVectorInterval
     );
   },
-  subtraction_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'finite',
-      FP.f32.subtractionInterval
-    );
-  },
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts b/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts
index 67b2390bfa88..182c0d76a979 100644
--- a/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts
@@ -10,7 +10,7 @@ import { fullF64Range } from '../../../../util/math.js';
 import { makeCaseCache } from '../case_cache.js';
 import { onlyConstInputSource, run } from '../expression.js';
 
-import { abstract_unary } from './unary.js';
+import { abstractUnary } from './unary.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -39,5 +39,5 @@ Accuracy: Correctly rounded
   )
   .fn(async t => {
     const cases = await d.get('negation');
-    await run(t, abstract_unary('-'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
+    await run(t, abstractUnary('-'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
   });
diff --git a/src/webgpu/shader/execution/expression/unary/unary.ts b/src/webgpu/shader/execution/expression/unary/unary.ts
index 995ca3ea172d..160e4651783d 100644
--- a/src/webgpu/shader/execution/expression/unary/unary.ts
+++ b/src/webgpu/shader/execution/expression/unary/unary.ts
@@ -10,6 +10,6 @@ export function unary(op: string): ShaderBuilder {
 }
 
 /* @returns a ShaderBuilder that evaluates a prefix unary operation that returns AbstractFloats */
-export function abstract_unary(op: string): ShaderBuilder {
+export function abstractUnary(op: string): ShaderBuilder {
   return abstractFloatShaderBuilder(value => `${op}(${value})`);
 }
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 746efe587fc8..9b2ec9bf5062 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4834,7 +4834,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly acoshAlternativeInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly acoshPrimaryInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly acoshIntervals = [this.acoshAlternativeInterval, this.acoshPrimaryInterval];
-  public readonly additionInterval = this.unimplementedScalarPairToInterval.bind(this);
+  public readonly additionInterval = this.additionIntervalImpl.bind(this);
   public readonly additionMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(this);
   public readonly asinInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly asinhInterval = this.unimplementedScalarToInterval.bind(this);
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 93b8c5d8d853..ad1021aaa55f 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -1728,6 +1728,38 @@ export function vectorF64Range(dim: number): number[][] {
   return kVectorF64Values[dim];
 }
 
+const kSparseVectorF64Values = {
+  2: sparseF64Range().map((f, idx) => [idx % 2 === 0 ? f : idx, idx % 2 === 1 ? f : -idx]),
+  3: sparseF64Range().map((f, idx) => [
+    idx % 3 === 0 ? f : idx,
+    idx % 3 === 1 ? f : -idx,
+    idx % 3 === 2 ? f : idx,
+  ]),
+  4: sparseF64Range().map((f, idx) => [
+    idx % 4 === 0 ? f : idx,
+    idx % 4 === 1 ? f : -idx,
+    idx % 4 === 2 ? f : idx,
+    idx % 4 === 3 ? f : -idx,
+  ]),
+};
+
+/**
+ * Minimal set of vectors, indexed by dimension, that contain interesting f64
+ * values.
+ *
+ * This is an even more stripped down version of `vectorF64Range` for when
+ * pairs of vectors are being tested.
+ * All the interesting floats from sparseF64 are guaranteed to be tested, but
+ * not in every position.
+ */
+export function sparseVectorF64Range(dim: number): number[][] {
+  assert(
+    dim === 2 || dim === 3 || dim === 4,
+    'sparseVectorF64Range only accepts dimensions 2, 3, and 4'
+  );
+  return kSparseVectorF64Values[dim];
+}
+
 /**
  * @returns the result matrix in Array<Array<number>> type.
  *

From 7f1e5afb4181f26f510e9a04160343a3458f0330 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Fri, 8 Sep 2023 10:36:02 +0800
Subject: [PATCH 016/166] wgsl: f16 built-in execution test for frexp (#2925)

This PR make frexp function in util/math.ts handle f16 and f64 as well as f32, and add f16 execution test for built-in frexp.

Issue: #1248, #2587
---
 src/unittests/floating_point.spec.ts          |  54 ++---
 src/unittests/maths.spec.ts                   |  76 +++++--
 .../expression/call/builtin/frexp.spec.ts     | 202 +++++++++++++-----
 src/webgpu/util/math.ts                       | 159 ++++++++++----
 4 files changed, 356 insertions(+), 135 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 8b1e588be858..a9a92e181c37 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -2557,33 +2557,33 @@ g.test('ceilInterval')
         const constants = FP[p.trait].constants();
         // prettier-ignore
         return [
-        { input: 0, expected: 0 },
-        { input: 0.1, expected: 1 },
-        { input: 0.9, expected: 1 },
-        { input: 1.0, expected: 1 },
-        { input: 1.1, expected: 2 },
-        { input: 1.9, expected: 2 },
-        { input: -0.1, expected: 0 },
-        { input: -0.9, expected: 0 },
-        { input: -1.0, expected: -1 },
-        { input: -1.1, expected: -1 },
-        { input: -1.9, expected: -1 },
-
-        // Edge cases
-        { input: constants.positive.infinity, expected: kUnboundedBounds },
-        { input: constants.negative.infinity, expected: kUnboundedBounds },
-        { input: constants.positive.max, expected: constants.positive.max },
-        { input: constants.positive.min, expected: 1 },
-        { input: constants.negative.min, expected: constants.negative.min },
-        { input: constants.negative.max, expected: 0 },
-        ...kCeilIntervalCases[p.trait],
-
-        // 32-bit subnormals
-        { input: constants.positive.subnormal.max, expected: [0, 1] },
-        { input: constants.positive.subnormal.min, expected: [0, 1] },
-        { input: constants.negative.subnormal.min, expected: 0 },
-        { input: constants.negative.subnormal.max, expected: 0 },
-      ];
+          { input: 0, expected: 0 },
+          { input: 0.1, expected: 1 },
+          { input: 0.9, expected: 1 },
+          { input: 1.0, expected: 1 },
+          { input: 1.1, expected: 2 },
+          { input: 1.9, expected: 2 },
+          { input: -0.1, expected: 0 },
+          { input: -0.9, expected: 0 },
+          { input: -1.0, expected: -1 },
+          { input: -1.1, expected: -1 },
+          { input: -1.9, expected: -1 },
+
+          // Edge cases
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: constants.positive.max },
+          { input: constants.positive.min, expected: 1 },
+          { input: constants.negative.min, expected: constants.negative.min },
+          { input: constants.negative.max, expected: 0 },
+          ...kCeilIntervalCases[p.trait],
+
+          // 32-bit subnormals
+          { input: constants.positive.subnormal.max, expected: [0, 1] },
+          { input: constants.positive.subnormal.min, expected: [0, 1] },
+          { input: constants.negative.subnormal.min, expected: 0 },
+          { input: constants.negative.subnormal.max, expected: 0 },
+        ];
       })
   )
   .fn(t => {
diff --git a/src/unittests/maths.spec.ts b/src/unittests/maths.spec.ts
index bc505c0e5b29..fa3899e21e9a 100644
--- a/src/unittests/maths.spec.ts
+++ b/src/unittests/maths.spec.ts
@@ -1058,20 +1058,9 @@ interface frexpCase {
   exp: number;
 }
 
-g.test('frexp')
-  .paramsSimple<frexpCase>([
-    { input: 0, fract: 0, exp: 0 },
-    { input: -0, fract: -0, exp: 0 },
-    { input: Number.POSITIVE_INFINITY, fract: Number.POSITIVE_INFINITY, exp: 0 },
-    { input: Number.NEGATIVE_INFINITY, fract: Number.NEGATIVE_INFINITY, exp: 0 },
-    { input: 0.5, fract: 0.5, exp: 0 },
-    { input: -0.5, fract: -0.5, exp: 0 },
-    { input: 1, fract: 0.5, exp: 1 },
-    { input: -1, fract: -0.5, exp: 1 },
-    { input: 2, fract: 0.5, exp: 2 },
-    { input: -2, fract: -0.5, exp: 2 },
-    { input: 10000, fract: 0.6103515625, exp: 14 },
-    { input: -10000, fract: -0.6103515625, exp: 14 },
+// prettier-ignore
+const kFrexpCases = {
+  f32: [
     { input: kValue.f32.positive.max, fract: 0.9999999403953552, exp: 128 },
     { input: kValue.f32.positive.min, fract: 0.5, exp: -125 },
     { input: kValue.f32.negative.max, fract: -0.5, exp: -125 },
@@ -1080,15 +1069,68 @@ g.test('frexp')
     { input: kValue.f32.subnormal.positive.min, fract: 0.5, exp: -148 },
     { input: kValue.f32.subnormal.negative.max, fract: -0.5, exp: -148 },
     { input: kValue.f32.subnormal.negative.min, fract: -0.9999998807907104, exp: -126 },
-  ])
+  ] as frexpCase[],
+  f16: [
+    { input: kValue.f16.positive.max, fract: 0.99951171875, exp: 16 },
+    { input: kValue.f16.positive.min, fract: 0.5, exp: -13 },
+    { input: kValue.f16.negative.max, fract: -0.5, exp: -13 },
+    { input: kValue.f16.negative.min, fract: -0.99951171875, exp: 16 },
+    { input: kValue.f16.subnormal.positive.max, fract: 0.9990234375, exp: -14 },
+    { input: kValue.f16.subnormal.positive.min, fract: 0.5, exp: -23 },
+    { input: kValue.f16.subnormal.negative.max, fract: -0.5, exp: -23 },
+    { input: kValue.f16.subnormal.negative.min, fract: -0.9990234375, exp: -14 },
+  ] as frexpCase[],
+  f64: [
+    { input: kValue.f64.positive.max, fract: reinterpretU64AsF64(0x3fef_ffff_ffff_ffffn) /* ~0.9999999999999999 */, exp: 1024 },
+    { input: kValue.f64.positive.min, fract: 0.5, exp: -1021 },
+    { input: kValue.f64.negative.max, fract: -0.5, exp: -1021 },
+    { input: kValue.f64.negative.min, fract: reinterpretU64AsF64(0xbfef_ffff_ffff_ffffn) /* ~-0.9999999999999999 */, exp: 1024 },
+    { input: kValue.f64.subnormal.positive.max, fract: reinterpretU64AsF64(0x3fef_ffff_ffff_fffen) /* ~0.9999999999999998 */, exp: -1022 },
+    { input: kValue.f64.subnormal.positive.min, fract: 0.5, exp: -1073 },
+    { input: kValue.f64.subnormal.negative.max, fract: -0.5, exp: -1073 },
+    { input: kValue.f64.subnormal.negative.min, fract: reinterpretU64AsF64(0xbfef_ffff_ffff_fffen) /* ~-0.9999999999999998 */, exp: -1022 },
+  ] as frexpCase[],
+} as const;
+
+g.test('frexp')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16', 'f64'] as const)
+      .beginSubcases()
+      .expandWithParams<frexpCase>(p => {
+        // prettier-ignore
+        return [
+          // +/- 0.0
+          { input: 0, fract: 0, exp: 0 },
+          { input: -0, fract: -0, exp: 0 },
+          // Normal float values that can be exactly represented by all float types
+          { input: 0.171875, fract: 0.6875, exp: -2 },
+          { input: -0.171875, fract: -0.6875, exp: -2 },
+          { input: 0.5, fract: 0.5, exp: 0 },
+          { input: -0.5, fract: -0.5, exp: 0 },
+          { input: 1, fract: 0.5, exp: 1 },
+          { input: -1, fract: -0.5, exp: 1 },
+          { input: 2, fract: 0.5, exp: 2 },
+          { input: -2, fract: -0.5, exp: 2 },
+          { input: 10000, fract: 0.6103515625, exp: 14 },
+          { input: -10000, fract: -0.6103515625, exp: 14 },
+          // Normal ans subnormal cases that are different for each type
+          ...kFrexpCases[p.trait],
+          // Inf and NaN
+          { input: Number.POSITIVE_INFINITY, fract: Number.POSITIVE_INFINITY, exp: 0 },
+          { input: Number.NEGATIVE_INFINITY, fract: Number.NEGATIVE_INFINITY, exp: 0 },
+          { input: Number.NaN, fract: Number.NaN, exp: 0 },
+        ];
+      })
+  )
   .fn(test => {
     const input = test.params.input;
-    const got = frexp(input);
+    const got = frexp(input, test.params.trait);
     const expect = { fract: test.params.fract, exp: test.params.exp };
 
     test.expect(
       objectEquals(got, expect),
-      `frexp(${input}) returned { fract: ${got.fract}, exp: ${got.exp} }. Expected { fract: ${expect.fract}, exp: ${expect.exp} }`
+      `frexp(${input}, ${test.params.trait}) returned { fract: ${got.fract}, exp: ${got.exp} }. Expected { fract: ${expect.fract}, exp: ${expect.exp} }`
     );
   });
 
diff --git a/src/webgpu/shader/execution/expression/call/builtin/frexp.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/frexp.spec.ts
index 6bee96d2e4c3..3d74fc354799 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/frexp.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/frexp.spec.ts
@@ -16,12 +16,22 @@ The magnitude of the significand is in the range of [0.5, 1.0) or 0.
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { skipUndefined } from '../../../../../util/compare.js';
-import { f32, i32, toVector, TypeF32, TypeI32, TypeVec } from '../../../../../util/conversion.js';
+import {
+  i32,
+  Scalar,
+  toVector,
+  TypeF32,
+  TypeF16,
+  TypeI32,
+  TypeVec,
+  Vector,
+} from '../../../../../util/conversion.js';
+import { FP } from '../../../../../util/floating_point.js';
 import {
   frexp,
+  fullF16Range,
   fullF32Range,
-  isSubnormalNumberF32,
-  quantizeToF32,
+  vectorF16Range,
   vectorF32Range,
 } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
@@ -45,72 +55,110 @@ function expBuilder(): ShaderBuilder {
   return basicExpressionBuilder(value => `frexp(${value}).exp`);
 }
 
-/* @returns a fract Case for a given vector input */
-function makeVectorCaseFract(v: number[]): Case {
-  v = v.map(quantizeToF32);
-  if (v.some(e => e !== 0 && isSubnormalNumberF32(e))) {
-    return { input: toVector(v, f32), expected: skipUndefined(undefined) };
+/* @returns a fract Case for a given scalar or vector input */
+function makeVectorCaseFract(v: number | number[], trait: 'f32' | 'f16'): Case {
+  const fp = FP[trait];
+  let toInput: (n: number[]) => Scalar | Vector;
+  let toOutput: (n: number[]) => Scalar | Vector;
+  if (v instanceof Array) {
+    // Input is vector
+    toInput = (n: number[]) => toVector(n, fp.scalarBuilder);
+    toOutput = (n: number[]) => toVector(n, fp.scalarBuilder);
+  } else {
+    // Input is scalar, also wrap it in an array.
+    v = [v];
+    toInput = (n: number[]) => fp.scalarBuilder(n[0]);
+    toOutput = (n: number[]) => fp.scalarBuilder(n[0]);
+  }
+
+  v = v.map(fp.quantize);
+  if (v.some(e => e !== 0 && fp.isSubnormal(e))) {
+    return { input: toInput(v), expected: skipUndefined(undefined) };
   }
 
   const fs = v.map(e => {
-    return frexp(e).fract;
+    return frexp(e, trait).fract;
   });
 
-  return { input: toVector(v, f32), expected: toVector(fs, f32) };
+  return { input: toInput(v), expected: toOutput(fs) };
 }
 
-/* @returns an exp Case for a given vector input */
-function makeVectorCaseExp(v: number[]): Case {
-  v = v.map(quantizeToF32);
-  if (v.some(e => e !== 0 && isSubnormalNumberF32(e))) {
-    return { input: toVector(v, f32), expected: skipUndefined(undefined) };
+/* @returns an exp Case for a given scalar or vector input */
+function makeVectorCaseExp(v: number | number[], trait: 'f32' | 'f16'): Case {
+  const fp = FP[trait];
+  let toInput: (n: number[]) => Scalar | Vector;
+  let toOutput: (n: number[]) => Scalar | Vector;
+  if (v instanceof Array) {
+    // Input is vector
+    toInput = (n: number[]) => toVector(n, fp.scalarBuilder);
+    toOutput = (n: number[]) => toVector(n, i32);
+  } else {
+    // Input is scalar, also wrap it in an array.
+    v = [v];
+    toInput = (n: number[]) => fp.scalarBuilder(n[0]);
+    toOutput = (n: number[]) => i32(n[0]);
+  }
+
+  v = v.map(fp.quantize);
+  if (v.some(e => e !== 0 && fp.isSubnormal(e))) {
+    return { input: toInput(v), expected: skipUndefined(undefined) };
   }
 
   const fs = v.map(e => {
-    return frexp(e).exp;
+    return frexp(e, trait).exp;
   });
 
-  return { input: toVector(v, f32), expected: toVector(fs, i32) };
+  return { input: toInput(v), expected: toOutput(fs) };
 }
 
 export const d = makeCaseCache('frexp', {
   f32_fract: () => {
-    const makeCase = (n: number): Case => {
-      n = quantizeToF32(n);
-      if (n !== 0 && isSubnormalNumberF32(n)) {
-        return { input: f32(n), expected: skipUndefined(undefined) };
-      }
-      return { input: f32(n), expected: f32(frexp(n).fract) };
-    };
-    return fullF32Range().map(makeCase);
+    return fullF32Range().map(v => makeVectorCaseFract(v, 'f32'));
   },
   f32_exp: () => {
-    const makeCase = (n: number): Case => {
-      n = quantizeToF32(n);
-      if (n !== 0 && isSubnormalNumberF32(n)) {
-        return { input: f32(n), expected: skipUndefined(undefined) };
-      }
-      return { input: f32(n), expected: i32(frexp(n).exp) };
-    };
-    return fullF32Range().map(makeCase);
+    return fullF32Range().map(v => makeVectorCaseExp(v, 'f32'));
   },
   f32_vec2_fract: () => {
-    return vectorF32Range(2).map(makeVectorCaseFract);
+    return vectorF32Range(2).map(v => makeVectorCaseFract(v, 'f32'));
   },
   f32_vec2_exp: () => {
-    return vectorF32Range(2).map(makeVectorCaseExp);
+    return vectorF32Range(2).map(v => makeVectorCaseExp(v, 'f32'));
   },
   f32_vec3_fract: () => {
-    return vectorF32Range(3).map(makeVectorCaseFract);
+    return vectorF32Range(3).map(v => makeVectorCaseFract(v, 'f32'));
   },
   f32_vec3_exp: () => {
-    return vectorF32Range(3).map(makeVectorCaseExp);
+    return vectorF32Range(3).map(v => makeVectorCaseExp(v, 'f32'));
   },
   f32_vec4_fract: () => {
-    return vectorF32Range(4).map(makeVectorCaseFract);
+    return vectorF32Range(4).map(v => makeVectorCaseFract(v, 'f32'));
   },
   f32_vec4_exp: () => {
-    return vectorF32Range(4).map(makeVectorCaseExp);
+    return vectorF32Range(4).map(v => makeVectorCaseExp(v, 'f32'));
+  },
+  f16_fract: () => {
+    return fullF16Range().map(v => makeVectorCaseFract(v, 'f16'));
+  },
+  f16_exp: () => {
+    return fullF16Range().map(v => makeVectorCaseExp(v, 'f16'));
+  },
+  f16_vec2_fract: () => {
+    return vectorF16Range(2).map(v => makeVectorCaseFract(v, 'f16'));
+  },
+  f16_vec2_exp: () => {
+    return vectorF16Range(2).map(v => makeVectorCaseExp(v, 'f16'));
+  },
+  f16_vec3_fract: () => {
+    return vectorF16Range(3).map(v => makeVectorCaseFract(v, 'f16'));
+  },
+  f16_vec3_exp: () => {
+    return vectorF16Range(3).map(v => makeVectorCaseExp(v, 'f16'));
+  },
+  f16_vec4_fract: () => {
+    return vectorF16Range(4).map(v => makeVectorCaseFract(v, 'f16'));
+  },
+  f16_vec4_exp: () => {
+    return vectorF16Range(4).map(v => makeVectorCaseExp(v, 'f16'));
   },
 });
 
@@ -120,7 +168,7 @@ g.test('f32_fract')
     `
 T is f32
 
-struct __frexp_result {
+struct __frexp_result_f32 {
   fract : f32, // fract part
   exp : i32  // exponent part
 }
@@ -138,7 +186,7 @@ g.test('f32_exp')
     `
 T is f32
 
-struct __frexp_result {
+struct __frexp_result_f32 {
   fract : f32, // fract part
   exp : i32  // exponent part
 }
@@ -156,7 +204,7 @@ g.test('f32_vec2_fract')
     `
 T is vec2<f32>
 
-struct __frexp_result {
+struct __frexp_result_vec2_f32 {
   fract : vec2<f32>, // fract part
   exp : vec2<i32>  // exponent part
 }
@@ -264,14 +312,20 @@ g.test('f16_fract')
     `
 T is f16
 
-struct __frexp_result {
+struct __frexp_result_f16 {
   fract : f16, // fract part
   exp : i32  // exponent part
 }
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_fract');
+    await run(t, fractBuilder(), [TypeF16], TypeF16, t.params, cases);
+  });
 
 g.test('f16_exp')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -279,14 +333,20 @@ g.test('f16_exp')
     `
 T is f16
 
-struct __frexp_result {
+struct __frexp_result_f16 {
   fract : f16, // fract part
   exp : i32  // exponent part
 }
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_exp');
+    await run(t, expBuilder(), [TypeF16], TypeI32, t.params, cases);
+  });
 
 g.test('f16_vec2_fract')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -294,14 +354,20 @@ g.test('f16_vec2_fract')
     `
 T is vec2<f16>
 
-struct __frexp_result {
+struct __frexp_result_vec2_f16 {
   fract : vec2<f16>, // fract part
   exp : vec2<i32>  // exponent part
 }
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec2_fract');
+    await run(t, fractBuilder(), [TypeVec(2, TypeF16)], TypeVec(2, TypeF16), t.params, cases);
+  });
 
 g.test('f16_vec2_exp')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -316,7 +382,13 @@ struct __frexp_result_vec2_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec2_exp');
+    await run(t, expBuilder(), [TypeVec(2, TypeF16)], TypeVec(2, TypeI32), t.params, cases);
+  });
 
 g.test('f16_vec3_fract')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -331,7 +403,13 @@ struct __frexp_result_vec3_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec3_fract');
+    await run(t, fractBuilder(), [TypeVec(3, TypeF16)], TypeVec(3, TypeF16), t.params, cases);
+  });
 
 g.test('f16_vec3_exp')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -346,7 +424,13 @@ struct __frexp_result_vec3_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec3_exp');
+    await run(t, expBuilder(), [TypeVec(3, TypeF16)], TypeVec(3, TypeI32), t.params, cases);
+  });
 
 g.test('f16_vec4_fract')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -361,7 +445,13 @@ struct __frexp_result_vec4_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec4_fract');
+    await run(t, fractBuilder(), [TypeVec(4, TypeF16)], TypeVec(4, TypeF16), t.params, cases);
+  });
 
 g.test('f16_vec4_exp')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -376,4 +466,10 @@ struct __frexp_result_vec4_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec4_exp');
+    await run(t, expBuilder(), [TypeVec(4, TypeF16)], TypeVec(4, TypeI32), t.params, cases);
+  });
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index ad1021aaa55f..30733e5fc017 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -1,5 +1,9 @@
 import { assert } from '../../common/util/util.js';
-import { Float16Array } from '../../external/petamoriken/float16/float16.js';
+import {
+  Float16Array,
+  getFloat16,
+  setFloat16,
+} from '../../external/petamoriken/float16/float16.js';
 
 import { kBit, kValue } from './constants.js';
 import {
@@ -621,15 +625,6 @@ export function correctlyRoundedF16(n: number): number[] {
   return [Number.NEGATIVE_INFINITY];
 }
 
-/**
- * Once-allocated ArrayBuffer/views to avoid overhead of allocation in frexp
- *
- * This makes frexp non-reentrant due to shared state between calls.
- */
-const frexpData = new ArrayBuffer(4);
-const frexpDataU32 = new Uint32Array(frexpData);
-const frexpDataF32 = new Float32Array(frexpData);
-
 /**
  * Calculates WGSL frexp
  *
@@ -637,41 +632,129 @@ const frexpDataF32 = new Float32Array(frexpData);
  * val = fraction * 2 ^ exponent.
  * The fraction is 0.0 or its magnitude is in the range [0.5, 1.0).
  *
- * Inspired by golang's implementation of frexp.
- *
- * This code is non-reentrant due to the use of a non-local data buffer and
- * views.
- *
- * @param val the f32 to split
+ * @param val the float to split
+ * @param trait the float type, f32 or f16 or f64
  * @returns the results of splitting val
  */
-export function frexp(val: number): { fract: number; exp: number } {
-  frexpDataF32[0] = val;
-  // Do not directly use val after this point, so that changes are reflected in
-  // both the f32 and u32 views.
+export function frexp(val: number, trait: 'f32' | 'f16' | 'f64'): { fract: number; exp: number } {
+  const buffer = new ArrayBuffer(8);
+  const dataView = new DataView(buffer);
+
+  // expBitCount and fractBitCount is the bitwidth of exponent and fractional part of the given FP type.
+  // expBias is the bias constant of exponent of the given FP type.
+  // Biased exponent (unsigned integer, i.e. the exponent part of float) = unbiased exponent (signed integer) + expBias.
+  let expBitCount: number, fractBitCount: number, expBias: number;
+  // To handle the exponent bits of given FP types (f16, f32, and f64), considering the highest 16
+  // bits is enough.
+  // expMaskForHigh16Bits indicates the exponent bitfield in the highest 16 bits of the given FP
+  // type, and targetExpBitsForHigh16Bits is the exponent bits that corresponding to unbiased
+  // exponent -1, i.e. the exponent bits when the FP values is in range [0.5, 1.0).
+  let expMaskForHigh16Bits: number, targetExpBitsForHigh16Bits: number;
+  // Helper function that store the given FP value into buffer as the given FP types
+  let setFloatToBuffer: (v: number) => void;
+  // Helper function that read back FP value from buffer as the given FP types
+  let getFloatFromBuffer: () => number;
+
+  let isFinite: (v: number) => boolean;
+  let isSubnormal: (v: number) => boolean;
+
+  if (trait === 'f32') {
+    // f32 bit pattern: s_eeeeeeee_fffffff_ffffffffffffffff
+    expBitCount = 8;
+    fractBitCount = 23;
+    expBias = 127;
+    // The exponent bitmask for high 16 bits of f32.
+    expMaskForHigh16Bits = 0x7f80;
+    // The target exponent bits is equal to those for f32 0.5 = 0x3f000000.
+    targetExpBitsForHigh16Bits = 0x3f00;
+    isFinite = isFiniteF32;
+    isSubnormal = isSubnormalNumberF32;
+    // Enforce big-endian so that offset 0 is highest byte.
+    setFloatToBuffer = (v: number) => dataView.setFloat32(0, v, false);
+    getFloatFromBuffer = () => dataView.getFloat32(0, false);
+  } else if (trait === 'f16') {
+    // f16 bit pattern: s_eeeee_ffffffffff
+    expBitCount = 5;
+    fractBitCount = 10;
+    expBias = 15;
+    // The exponent bitmask for 16 bits of f16.
+    expMaskForHigh16Bits = 0x7c00;
+    // The target exponent bits is equal to those for f16 0.5 = 0x3800.
+    targetExpBitsForHigh16Bits = 0x3800;
+    isFinite = isFiniteF16;
+    isSubnormal = isSubnormalNumberF16;
+    // Enforce big-endian so that offset 0 is highest byte.
+    setFloatToBuffer = (v: number) => setFloat16(dataView, 0, v, false);
+    getFloatFromBuffer = () => getFloat16(dataView, 0, false);
+  } else {
+    assert(trait === 'f64');
+    // f64 bit pattern: s_eeeeeeeeeee_ffff_ffffffffffffffffffffffffffffffffffffffffffffffff
+    expBitCount = 11;
+    fractBitCount = 52;
+    expBias = 1023;
+    // The exponent bitmask for 16 bits of f64.
+    expMaskForHigh16Bits = 0x7ff0;
+    // The target exponent bits is equal to those for f64 0.5 = 0x3fe0_0000_0000_0000.
+    targetExpBitsForHigh16Bits = 0x3fe0;
+    isFinite = Number.isFinite;
+    isSubnormal = isSubnormalNumberF64;
+    // Enforce big-endian so that offset 0 is highest byte.
+    setFloatToBuffer = (v: number) => dataView.setFloat64(0, v, false);
+    getFloatFromBuffer = () => dataView.getFloat64(0, false);
+  }
+  // Helper function that extract the unbiased exponent of the float in buffer.
+  const extractUnbiasedExpFromNormalFloatInBuffer = () => {
+    // Assert the float in buffer is finite normal float.
+    assert(isFinite(getFloatFromBuffer()) && !isSubnormal(getFloatFromBuffer()));
+    // Get the highest 16 bits of float as uint16, which can contain the whole exponent part for both f16, f32, and f64.
+    const high16BitsAsUint16 = dataView.getUint16(0, false);
+    // Return the unbiased exp by masking, shifting and unbiasing.
+    return ((high16BitsAsUint16 & expMaskForHigh16Bits) >> (16 - 1 - expBitCount)) - expBias;
+  };
+  // Helper function that modify the exponent of float in buffer to make it in range [0.5, 1.0).
+  // By setting the unbiased exponent to -1, the fp value will be in range 2**-1 * [1.0, 2.0), i.e. [0.5, 1.0).
+  const modifyExpOfNormalFloatInBuffer = () => {
+    // Assert the float in buffer is finite normal float.
+    assert(isFinite(getFloatFromBuffer()) && !isSubnormal(getFloatFromBuffer()));
+    // Get the highest 16 bits of float as uint16, which contains the whole exponent part for both f16, f32, and f64.
+    const high16BitsAsUint16 = dataView.getUint16(0, false);
+    // Modify the exponent bits.
+    const modifiedHigh16Bits =
+      (high16BitsAsUint16 & ~expMaskForHigh16Bits) | targetExpBitsForHigh16Bits;
+    // Set back to buffer
+    dataView.setUint16(0, modifiedHigh16Bits, false);
+  };
 
-  // Handles 0 and -0
-  if (frexpDataF32[0] === 0) {
-    return { fract: frexpDataF32[0], exp: 0 };
+  // +/- 0.0
+  if (val === 0) {
+    return { fract: val, exp: 0 };
   }
-
-  // Covers NaNs, OOB and Infinities
-  if (!isFiniteF32(frexpDataF32[0])) {
-    return { fract: frexpDataF32[0], exp: 0 };
+  // NaN and Inf
+  if (!isFinite(val)) {
+    return { fract: val, exp: 0 };
   }
 
-  // Normalize if subnormal
-  let exp = 0;
-  if (isSubnormalNumberF32(frexpDataF32[0])) {
-    frexpDataF32[0] = frexpDataF32[0] * (1 << 23);
-    exp = -23;
-  }
-  exp += ((frexpDataU32[0] >> 23) & 0xff) - 126; // shift & mask, minus the bias + 1
+  setFloatToBuffer(val);
+  // Don't use val below. Use helper functions working with buffer instead.
 
-  frexpDataU32[0] &= 0x807fffff; // mask the exponent bits
-  frexpDataU32[0] |= 0x3f000000; // extract the mantissa bits
-  const fract = frexpDataF32[0]; // Convert from bits to number
-  return { fract, exp };
+  let exp = 0;
+  // Normailze the value if it is subnormal. Increase the exponent by multiplying a subnormal value
+  // with 2**fractBitCount will result in a finite normal FP value of the given FP type.
+  if (isSubnormal(getFloatFromBuffer())) {
+    setFloatToBuffer(getFloatFromBuffer() * 2 ** fractBitCount);
+    exp = -fractBitCount;
+  }
+  // A normal FP value v is represented as v = ((-1)**s)*(2**(unbiased exponent))*f, where f is in
+  // range [1.0, 2.0). By moving a factor 2 from f to exponent, we have
+  // v = ((-1)**s)*(2**(unbiased exponent + 1))*(f / 2), where (f / 2) is in range [0.5, 1.0), so
+  // the exp = (unbiased exponent + 1) and fract = ((-1)**s)*(f / 2) is what we expect to get from
+  // frexp function. Note that fract and v only differs in exponent bitfield as long as v is normal.
+  // Calc the result exp by getting the unbiased float exponent and plus 1.
+  exp += extractUnbiasedExpFromNormalFloatInBuffer() + 1;
+  // Modify the exponent of float in buffer to make it be in range [0.5, 1.0) to get fract.
+  modifyExpOfNormalFloatInBuffer();
+
+  return { fract: getFloatFromBuffer(), exp };
 }
 
 /**

From 01267244f661b8c9831bffa2a94187028e6823e3 Mon Sep 17 00:00:00 2001
From: Lokbondo Kung <lokokung@google.com>
Date: Fri, 8 Sep 2023 17:08:02 -0700
Subject: [PATCH 017/166] Implements filtering tests for mag/min/mipmapFilters
 with additional float32-filterable formats. (#2915)

* Adds magFilter op tests

* Adds inital minFilter tests

* Adds remaining sampling tests

* Fix formatting issue

* Redo min/magFilter tests for mirror, and adds more doc.
---
 .../operation/sampling/filter_mode.spec.ts    | 1140 ++++++++++++++++-
 src/webgpu/capability_info.ts                 |   14 +
 src/webgpu/util/texture/base.ts               |   18 +
 src/webgpu/util/texture/texel_data.ts         |    2 +-
 src/webgpu/util/texture/texel_view.ts         |   41 +
 src/webgpu/util/texture/texture_ok.ts         |   14 +-
 6 files changed, 1207 insertions(+), 22 deletions(-)

diff --git a/src/webgpu/api/operation/sampling/filter_mode.spec.ts b/src/webgpu/api/operation/sampling/filter_mode.spec.ts
index cf1d7682e102..63f4409ca158 100644
--- a/src/webgpu/api/operation/sampling/filter_mode.spec.ts
+++ b/src/webgpu/api/operation/sampling/filter_mode.spec.ts
@@ -1,14 +1,1138 @@
 export const description = `
 Tests the behavior of different filtering modes in minFilter/magFilter/mipmapFilter.
-
-TODO:
-- Test exact sampling results with small tolerance. Tests should differentiate between different
-  values for all three filter modes to make sure none are missed or incorrect in implementations.
-- (Likely unnecessary with the above.) Test exactly the expected number of samples are used.
-  Test this by setting up a rendering and asserting how many different shades result.
 `;
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
-import { GPUTest } from '../../../gpu_test.js';
+import { kAddressModes, kMipmapFilterModes } from '../../../capability_info.js';
+import {
+  EncodableTextureFormat,
+  kRenderableColorTextureFormats,
+  kTextureFormatInfo,
+} from '../../../format_info.js';
+import { GPUTest, TextureTestMixin } from '../../../gpu_test.js';
+import { getTextureCopyLayout } from '../../../util/texture/layout.js';
+import { TexelView } from '../../../util/texture/texel_view.js';
+
+// Simple checkerboard 2x2 texture used as a base for the sampling.
+const kCheckerTextureSize = 2;
+const kCheckerTextureData = [
+  { R: 1.0, G: 1.0, B: 1.0, A: 1.0 },
+  { R: 0.0, G: 0.0, B: 0.0, A: 1.0 },
+  { R: 0.0, G: 0.0, B: 0.0, A: 1.0 },
+  { R: 1.0, G: 1.0, B: 1.0, A: 1.0 },
+];
+
+class FilterModeTest extends TextureTestMixin(GPUTest) {
+  runFilterRenderPipeline(
+    sampler: GPUSampler,
+    module: GPUShaderModule,
+    format: EncodableTextureFormat,
+    renderSize: number[],
+    vertexCount: number,
+    instanceCount: number
+  ) {
+    const sampleTexture = this.createTextureFromTexelView(
+      TexelView.fromTexelsAsColors(format, coord => {
+        const id = coord.x + coord.y * kCheckerTextureSize;
+        return kCheckerTextureData[id];
+      }),
+      {
+        size: [kCheckerTextureSize, kCheckerTextureSize],
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+      }
+    );
+    const renderTexture = this.device.createTexture({
+      format,
+      size: renderSize,
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
+    });
+    const pipeline = this.device.createRenderPipeline({
+      layout: 'auto',
+      vertex: {
+        module,
+        entryPoint: 'vs_main',
+      },
+      fragment: {
+        module,
+        entryPoint: 'fs_main',
+        targets: [{ format }],
+      },
+    });
+    const bindgroup = this.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: sampler },
+        { binding: 1, resource: sampleTexture.createView() },
+      ],
+    });
+    const commandEncoder = this.device.createCommandEncoder();
+    const renderPass = commandEncoder.beginRenderPass({
+      colorAttachments: [
+        {
+          view: renderTexture.createView(),
+          clearValue: [0, 0, 0, 0],
+          loadOp: 'clear',
+          storeOp: 'store',
+        },
+      ],
+    });
+    renderPass.setPipeline(pipeline);
+    renderPass.setBindGroup(0, bindgroup);
+    renderPass.draw(vertexCount, instanceCount);
+    renderPass.end();
+    this.device.queue.submit([commandEncoder.finish()]);
+    return renderTexture;
+  }
+}
+
+export const g = makeTestGroup(FilterModeTest);
+
+/* eslint-disable prettier/prettier */
+
+/* For filter mode 'nearest', we need to check a 6x6 of pixels because 4x4s are identical when using
+ * address mode 'clamp-to-edge' and 'mirror-repeat'. The minFilter and magFilter tests are setup so
+ * that they both render the same results. (See the respective test for details.) The following
+ * table shows the expected results:
+ *                                                u
+ *
+ *                               repeat     clamp-to-edge  mirror-repeat
+ *
+ *                           │█│ │█│ │█│ │  │█│█│█│ │ │ │  │ │█│█│ │ │█│
+ *                           │ │█│ │█│ │█│  │ │ │ │█│█│█│  │█│ │ │█│█│ │
+ *                           │█│ │█│ │█│ │  │█│█│█│ │ │ │  │ │█│█│ │ │█│
+ *             repeat        │ │█│ │█│ │█│  │ │ │ │█│█│█│  │█│ │ │█│█│ │
+ *                           │█│ │█│ │█│ │  │█│█│█│ │ │ │  │ │█│█│ │ │█│
+ *                           │ │█│ │█│ │█│  │ │ │ │█│█│█│  │█│ │ │█│█│ │
+ *
+ *                           │█│ │█│ │█│ │  │█│█│█│ │ │ │  │ │█│█│ │ │█│
+ *                           │█│ │█│ │█│ │  │█│█│█│ │ │ │  │ │█│█│ │ │█│
+ *                           │█│ │█│ │█│ │  │█│█│█│ │ │ │  │ │█│█│ │ │█│
+ *  v       clamp-to-edge    │ │█│ │█│ │█│  │ │ │ │█│█│█│  │█│ │ │█│█│ │
+ *                           │ │█│ │█│ │█│  │ │ │ │█│█│█│  │█│ │ │█│█│ │
+ *                           │ │█│ │█│ │█│  │ │ │ │█│█│█│  │█│ │ │█│█│ │
+ *
+ *                           │ │█│ │█│ │█│  │ │ │ │█│█│█│  │█│ │ │█│█│ │
+ *                           │█│ │█│ │█│ │  │█│█│█│ │ │ │  │ │█│█│ │ │█│
+ *                           │█│ │█│ │█│ │  │█│█│█│ │ │ │  │ │█│█│ │ │█│
+ *          mirror-repeat    │ │█│ │█│ │█│  │ │ │ │█│█│█│  │█│ │ │█│█│ │
+ *                           │ │█│ │█│ │█│  │ │ │ │█│█│█│  │█│ │ │█│█│ │
+ *                           │█│ │█│ │█│ │  │█│█│█│ │ │ │  │ │█│█│ │ │█│
+*/
+const kNearestRenderSize = 6;
+const kNearestRenderDim = [kNearestRenderSize, kNearestRenderSize];
+const kNearestURepeatVRepeat = [
+  [1, 0, 1, 0, 1, 0],
+  [0, 1, 0, 1, 0, 1],
+  [1, 0, 1, 0, 1, 0],
+  [0, 1, 0, 1, 0, 1],
+  [1, 0, 1, 0, 1, 0],
+  [0, 1, 0, 1, 0, 1],
+];
+const kNearestURepeatVClamped = [
+  [1, 0, 1, 0, 1, 0],
+  [1, 0, 1, 0, 1, 0],
+  [1, 0, 1, 0, 1, 0],
+  [0, 1, 0, 1, 0, 1],
+  [0, 1, 0, 1, 0, 1],
+  [0, 1, 0, 1, 0, 1],
+];
+const kNearestURepeatVMirror = [
+  [0, 1, 0, 1, 0, 1],
+  [1, 0, 1, 0, 1, 0],
+  [1, 0, 1, 0, 1, 0],
+  [0, 1, 0, 1, 0, 1],
+  [0, 1, 0, 1, 0, 1],
+  [1, 0, 1, 0, 1, 0],
+];
+const kNearestUClampedVRepeat = [
+  [1, 1, 1, 0, 0, 0],
+  [0, 0, 0, 1, 1, 1],
+  [1, 1, 1, 0, 0, 0],
+  [0, 0, 0, 1, 1, 1],
+  [1, 1, 1, 0, 0, 0],
+  [0, 0, 0, 1, 1, 1],
+];
+const kNearestUClampedVClamped = [
+  [1, 1, 1, 0, 0, 0],
+  [1, 1, 1, 0, 0, 0],
+  [1, 1, 1, 0, 0, 0],
+  [0, 0, 0, 1, 1, 1],
+  [0, 0, 0, 1, 1, 1],
+  [0, 0, 0, 1, 1, 1],
+];
+const kNearestUClampedVMirror = [
+  [0, 0, 0, 1, 1, 1],
+  [1, 1, 1, 0, 0, 0],
+  [1, 1, 1, 0, 0, 0],
+  [0, 0, 0, 1, 1, 1],
+  [0, 0, 0, 1, 1, 1],
+  [1, 1, 1, 0, 0, 0],
+];
+const kNearestUMirrorVRepeat = [
+  [0, 1, 1, 0, 0, 1],
+  [1, 0, 0, 1, 1, 0],
+  [0, 1, 1, 0, 0, 1],
+  [1, 0, 0, 1, 1, 0],
+  [0, 1, 1, 0, 0, 1],
+  [1, 0, 0, 1, 1, 0],
+];
+const kNearestUMirrorVClamped = [
+  [0, 1, 1, 0, 0, 1],
+  [0, 1, 1, 0, 0, 1],
+  [0, 1, 1, 0, 0, 1],
+  [1, 0, 0, 1, 1, 0],
+  [1, 0, 0, 1, 1, 0],
+  [1, 0, 0, 1, 1, 0],
+];
+const kNearestUMirrorVMirror = [
+  [1, 0, 0, 1, 1, 0],
+  [0, 1, 1, 0, 0, 1],
+  [0, 1, 1, 0, 0, 1],
+  [1, 0, 0, 1, 1, 0],
+  [1, 0, 0, 1, 1, 0],
+  [0, 1, 1, 0, 0, 1],
+];
+
+/* For filter mode 'linear', the tests samples 16 points (to create a 4x4) on what the effective 8x8
+ * expanded texture via the address modes looks like (see table below for what those look like). The
+ * sample points are selected such that no combination of address modes result in the same render.
+ * There is exactly one sample point in each sub 2x2 of the 8x8 texture, thereby yielding the 4x4
+ * result. Note that sampling from the 8x8 texture instead of the 6x6 texture is necessary because
+ * that allows us to keep the results in powers of 2 to minimize floating point errors on different
+ * backends.
+ *
+ * The 8x8 effective textures:
+ *                                                  u
+ *
+ *                                repeat          clamp-to-edge      mirror-repeat
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *             repeat        │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *
+ *                           │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *                           │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *                           │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *  v       clamp-to-edge    │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *          mirror-repeat    │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │█│ │█│ │█│ │█│ │  │ │ │ │ │█│█│█│█│  │█│█│ │ │█│█│ │ │
+ *                           │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *                           │ │█│ │█│ │█│ │█│  │█│█│█│█│ │ │ │ │  │ │ │█│█│ │ │█│█│
+ *
+ *
+ * Sample points:
+ *   The sample points are always at a 25% corner of a pixel such that the contributions come from
+ *   the 2x2 (doubly outlined) with ratios 1/16, 3/16, or 9/16.
+ *                                    ╔══╤══╦══╤══╦══╤══╦══╤══╗
+ *                                    ║  │  ║  │  ║  │  ║  │  ║
+ *                                    ╟──┼──╫──┼──╫──┼──╫──┼──╢
+ *                                    ║  │▘ ║ ▝│  ║  │▘ ║ ▝│  ║
+ *                                    ╠══╪══╬══╪══╬══╪══╬══╪══╣
+ *                                    ║  │  ║  │  ║  │  ║  │  ║
+ *                                    ╟──┼──╫──┼──╫──┼──╫──┼──╢
+ *                                    ║  │▘ ║ ▝│  ║  │▘ ║ ▝│  ║
+ *                                    ╠══╪══╬══╪══╬══╪══╬══╪══╣
+ *                                    ║  │▖ ║ ▗│  ║  │▖ ║ ▗│  ║
+ *                                    ╟──┼──╫──┼──╫──┼──╫──┼──╢
+ *                                    ║  │  ║  │  ║  │  ║  │  ║
+ *                                    ╠══╪══╬══╪══╬══╪══╬══╪══╣
+ *                                    ║  │▖ ║ ▗│  ║  │▖ ║ ▗│  ║
+ *                                    ╟──┼──╫──┼──╫──┼──╫──┼──╢
+ *                                    ║  │  ║  │  ║  │  ║  │  ║
+ *                                    ╚══╧══╩══╧══╩══╧══╩══╧══╝
+ */
+const kLinearRenderSize = 4;
+const kLinearRenderDim = [kLinearRenderSize, kLinearRenderSize];
+const kLinearURepeatVRepeat = [
+  [10, 6, 10, 6],
+  [10, 6, 10, 6],
+  [6, 10, 6, 10],
+  [6, 10, 6, 10],
+];
+const kLinearURepeatVClamped = [
+  [12, 4, 12, 4],
+  [12, 4, 12, 4],
+  [4, 12, 4, 12],
+  [4, 12, 4, 12],
+];
+const kLinearURepeatVMirror = [
+  [4, 12, 4, 12],
+  [12, 4, 12, 4],
+  [4, 12, 4, 12],
+  [12, 4, 12, 4],
+];
+const kLinearUClampedVRepeat = [
+  [12, 12, 4, 4],
+  [12, 12, 4, 4],
+  [4, 4, 12, 12],
+  [4, 4, 12, 12],
+];
+const kLinearUClampedVClamped = [
+  [16, 16, 0, 0],
+  [16, 16, 0, 0],
+  [0, 0, 16, 16],
+  [0, 0, 16, 16],
+];
+const kLinearUClampedVMirror = [
+  [0, 0, 16, 16],
+  [16, 16, 0, 0],
+  [0, 0, 16, 16],
+  [16, 16, 0, 0],
+];
+const kLinearUMirrorVRepeat = [
+  [4, 12, 4, 12],
+  [4, 12, 4, 12],
+  [12, 4, 12, 4],
+  [12, 4, 12, 4],
+];
+const kLinearUMirrorVClamped = [
+  [0, 16, 0, 16],
+  [0, 16, 0, 16],
+  [16, 0, 16, 0],
+  [16, 0, 16, 0],
+];
+const kLinearUMirrorVMirror = [
+  [16, 0, 16, 0],
+  [0, 16, 0, 16],
+  [16, 0, 16, 0],
+  [0, 16, 0, 16],
+];
+
+/* eslint-enable prettier/prettier */
+
+function expectedNearestColors(
+  format: EncodableTextureFormat,
+  addressModeU: GPUAddressMode,
+  addressModeV: GPUAddressMode
+): TexelView {
+  let expectedColors: number[][];
+  switch (addressModeU) {
+    case 'clamp-to-edge': {
+      switch (addressModeV) {
+        case 'clamp-to-edge':
+          expectedColors = kNearestUClampedVClamped;
+          break;
+        case 'repeat':
+          expectedColors = kNearestUClampedVRepeat;
+          break;
+        case 'mirror-repeat':
+          expectedColors = kNearestUClampedVMirror;
+          break;
+      }
+      break;
+    }
+    case 'repeat':
+      switch (addressModeV) {
+        case 'clamp-to-edge':
+          expectedColors = kNearestURepeatVClamped;
+          break;
+        case 'repeat':
+          expectedColors = kNearestURepeatVRepeat;
+          break;
+        case 'mirror-repeat':
+          expectedColors = kNearestURepeatVMirror;
+          break;
+      }
+      break;
+    case 'mirror-repeat':
+      switch (addressModeV) {
+        case 'clamp-to-edge':
+          expectedColors = kNearestUMirrorVClamped;
+          break;
+        case 'repeat':
+          expectedColors = kNearestUMirrorVRepeat;
+          break;
+        case 'mirror-repeat':
+          expectedColors = kNearestUMirrorVMirror;
+          break;
+      }
+      break;
+  }
+  return TexelView.fromTexelsAsColors(format, coord => {
+    const c = expectedColors[coord.y][coord.x];
+    return { R: c, G: c, B: c, A: 1.0 };
+  });
+}
+function expectedLinearColors(
+  format: EncodableTextureFormat,
+  addressModeU: GPUAddressMode,
+  addressModeV: GPUAddressMode
+): TexelView {
+  let expectedColors: number[][];
+  switch (addressModeU) {
+    case 'clamp-to-edge': {
+      switch (addressModeV) {
+        case 'clamp-to-edge':
+          expectedColors = kLinearUClampedVClamped;
+          break;
+        case 'repeat':
+          expectedColors = kLinearUClampedVRepeat;
+          break;
+        case 'mirror-repeat':
+          expectedColors = kLinearUClampedVMirror;
+          break;
+      }
+      break;
+    }
+    case 'repeat':
+      switch (addressModeV) {
+        case 'clamp-to-edge':
+          expectedColors = kLinearURepeatVClamped;
+          break;
+        case 'repeat':
+          expectedColors = kLinearURepeatVRepeat;
+          break;
+        case 'mirror-repeat':
+          expectedColors = kLinearURepeatVMirror;
+          break;
+      }
+      break;
+    case 'mirror-repeat':
+      switch (addressModeV) {
+        case 'clamp-to-edge':
+          expectedColors = kLinearUMirrorVClamped;
+          break;
+        case 'repeat':
+          expectedColors = kLinearUMirrorVRepeat;
+          break;
+        case 'mirror-repeat':
+          expectedColors = kLinearUMirrorVMirror;
+          break;
+      }
+      break;
+  }
+  return TexelView.fromTexelsAsColors(format, coord => {
+    const c = expectedColors[coord.y][coord.x];
+    return { R: c / 16, G: c / 16, B: c / 16, A: 1.0 };
+  });
+}
+function expectedColors(
+  format: EncodableTextureFormat,
+  filterMode: GPUFilterMode,
+  addressModeU: GPUAddressMode,
+  addressModeV: GPUAddressMode
+): TexelView {
+  switch (filterMode) {
+    case 'nearest':
+      return expectedNearestColors(format, addressModeU, addressModeV);
+    case 'linear':
+      return expectedLinearColors(format, addressModeU, addressModeV);
+  }
+}
+
+/* For the magFilter tests, each rendered pixel is an instanced quad such that the center of the
+ * quad coincides with the center of the pixel. The uv coordinates for each quad are shifted
+ * according to the test so that the center of the quad is at the point we want to sample.
+ *
+ * For the grid offset logic, see this codelab for reference:
+ *   https://codelabs.developers.google.com/your-first-webgpu-app#4
+ */
+
+/* The following diagram shows the UV shift (almost to scale) for what the pixel at cell (0,0) looks
+ * like w.r.t the UV of the texture if we just mapped the entire 2x2 texture to the quad. Note that
+ * the square representing the mapped location on the bottom left is actually slighly smaller than a
+ * pixel in order to ensure that we are magnifying the texture and hence using the magFilter. It
+ * should be fairly straightforwards to derive that for each pixel, we are shifting (.5, -.5) from
+ * the picture.
+ *
+ *                    ┌─┬─┬─┬─┬─┬─┐
+ *                    ├─┼─┼─┼─┼─┼─┤ (0,0) (1,0)
+ *                    ├─┼─╔═╪═╗─┼─┤    ╔═══╗
+ *                    ├─┼─╫─┼─╫─┼─┤    ║─┼─║
+ *                    ├─┼─╚═╪═╝─┼─┤    ╚═══╝       (-.875,1.625) (-.625,1.625)
+ *                    ╔═╗─┼─┼─┼─┼─┤ (0,1) (1,1)                ╔═╗
+ *                    ╚═╝─┴─┴─┴─┴─┘                            ╚═╝
+ *                                                 (-.875,1.875) (-.625,1.875)
+ */
+g.test('magFilter,nearest')
+  .desc(
+    `
+  Test that for filterable formats, magFilter 'nearest' mode correctly modifies the sampling.
+    - format= {<filterable formats>}
+    - addressModeU= {'clamp-to-edge', 'repeat', 'mirror-repeat'}
+    - addressModeV= {'clamp-to-edge', 'repeat', 'mirror-repeat'}
+  `
+  )
+  .params(u =>
+    u
+      .combine('format', kRenderableColorTextureFormats)
+      .filter(t => {
+        return (
+          kTextureFormatInfo[t.format].color.type === 'float' ||
+          kTextureFormatInfo[t.format].color.type === 'unfilterable-float'
+        );
+      })
+      .beginSubcases()
+      .combine('addressModeU', kAddressModes)
+      .combine('addressModeV', kAddressModes)
+  )
+  .beforeAllSubcases(t => {
+    if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
+      t.selectDeviceOrSkipTestCase('float32-filterable');
+    }
+  })
+  .fn(t => {
+    const { format, addressModeU, addressModeV } = t.params;
+    const sampler = t.device.createSampler({
+      addressModeU,
+      addressModeV,
+      magFilter: 'nearest',
+    });
+    const module = t.device.createShaderModule({
+      code: `
+      @group(0) @binding(0) var s : sampler;
+      @group(0) @binding(1) var t : texture_2d<f32>;
+
+      struct VertexOut {
+        @builtin(position) pos: vec4f,
+        @location(0) uv: vec2f,
+      };
+
+      @vertex
+      fn vs_main(@builtin(vertex_index) vi : u32,
+                 @builtin(instance_index) ii: u32) -> VertexOut {
+        const grid = vec2f(${kNearestRenderSize}, ${kNearestRenderSize});
+        const posBases = array(
+          vec2f(1, 1), vec2f(1, -1), vec2f(-1, -1),
+          vec2f(1, 1), vec2f(-1, -1), vec2f(-1, 1),
+        );
+        const uvBases = array(
+          vec2f(1., 0.), vec2f(1., 1.), vec2f(0., 1.),
+          vec2f(1., 0.), vec2f(0., 1.), vec2f(0., 0.),
+        );
+
+        // Compute the offset of instance plane.
+        let cell = vec2f(f32(ii) % grid.x, floor(f32(ii) / grid.y));
+        let cellOffset = cell / grid * 2;
+        let pos = (posBases[vi] + 1) / grid - 1 + cellOffset;
+
+        // Compute the offset of the UVs.
+        let uvBase = uvBases[vi] * 0.25 + vec2f(-0.875, 1.625);
+        const uvPerPixelOffset = vec2f(0.5, -0.5);
+        return VertexOut(vec4f(pos, 0.0, 1.0), uvBase + uvPerPixelOffset * cell);
+      }
+
+      @fragment
+      fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+        return textureSample(t, s, uv);
+      }
+      `,
+    });
+    const vertexCount = 6;
+    const instanceCount = kNearestRenderDim.reduce((sink, current) => sink * current);
+    const render = t.runFilterRenderPipeline(
+      sampler,
+      module,
+      format,
+      kNearestRenderDim,
+      vertexCount,
+      instanceCount
+    );
+    t.expectTexelViewComparisonIsOkInTexture(
+      { texture: render },
+      expectedColors(format, 'nearest', addressModeU, addressModeV),
+      kNearestRenderDim
+    );
+  });
+
+/* The following diagram shows the UV shift (almost to scale) for what the pixel at cell (0,0) (the
+ * dark square) looks like w.r.t the UV of the texture if we just mapped the entire 2x2 texture to
+ * the quad. The other small squares represent the other locations that we are sampling the texture
+ * at. The offsets are defined in the shader.
+ *
+ *             ┌────┬────┬────┬────┬────┬────┬────┬────┐
+ *             │    │    │    │    │    │    │    │    │
+ *             │    │    │    │    │    │    │    │    │
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤
+ *             │    │□   │   □│    │    │□   │   □│    │
+ *             │    │    │    │    │    │    │    │    │
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤
+ *             │    │    │    │    │    │    │    │    │
+ *             │    │    │    │    │    │    │    │    │       (0,0)     (1,0)
+ *             ├────┼────┼────╔════╪════╗────┼────┼────┤         ╔═════════╗
+ *             │    │□   │   □║    │    ║□   │   □│    │         ║    │    ║
+ *             │    │    │    ║    │    ║    │    │    │         ║    │    ║
+ *             ├────┼────┼────╫────┼────╫────┼────┼────┤         ║────┼────║
+ *             │    │    │    ║    │    ║    │    │    │         ║    │    ║
+ *             │    │□   │   □║    │    ║□   │   □│    │         ║    │    ║
+ *             ├────┼────┼────╚════╪════╝────┼────┼────┤         ╚═════════╝
+ *             │    │    │    │    │    │    │    │    │       (0,1)     (1,1)
+ *             │    │    │    │    │    │    │    │    │
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤
+ *             │    │    │    │    │    │    │    │    │    (-1,1.75) (-.75,1.75)
+ *             │    │■   │   □│    │    │□   │   □│    │             ■
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤       (-1,2) (-.75,2)
+ *             │    │    │    │    │    │    │    │    │
+ *             │    │    │    │    │    │    │    │    │
+ *             └────┴────┴────┴────┴────┴────┴────┴────┘
+ */
+g.test('magFilter,linear')
+  .desc(
+    `
+  Test that for filterable formats, magFilter 'linear' mode correctly modifies the sampling.
+    - format= {<filterable formats>}
+    - addressModeU= {'clamp-to-edge', 'repeat', 'mirror-repeat'}
+    - addressModeV= {'clamp-to-edge', 'repeat', 'mirror-repeat'}
+  `
+  )
+  .params(u =>
+    u
+      .combine('format', kRenderableColorTextureFormats)
+      .filter(t => {
+        return (
+          kTextureFormatInfo[t.format].color.type === 'float' ||
+          kTextureFormatInfo[t.format].color.type === 'unfilterable-float'
+        );
+      })
+      .beginSubcases()
+      .combine('addressModeU', kAddressModes)
+      .combine('addressModeV', kAddressModes)
+  )
+  .beforeAllSubcases(t => {
+    if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
+      t.selectDeviceOrSkipTestCase('float32-filterable');
+    }
+  })
+  .fn(t => {
+    const { format, addressModeU, addressModeV } = t.params;
+    const sampler = t.device.createSampler({
+      addressModeU,
+      addressModeV,
+      magFilter: 'linear',
+    });
+    const module = t.device.createShaderModule({
+      code: `
+      @group(0) @binding(0) var s : sampler;
+      @group(0) @binding(1) var t : texture_2d<f32>;
+
+      struct VertexOut {
+        @builtin(position) pos: vec4f,
+        @location(0) uv: vec2f,
+      };
+
+      @vertex
+      fn vs_main(@builtin(vertex_index) vi : u32,
+                 @builtin(instance_index) ii: u32) -> VertexOut {
+        const grid = vec2f(${kLinearRenderSize}, ${kLinearRenderSize});
+        const posBases = array(
+          vec2f(1, 1), vec2f(1, -1), vec2f(-1, -1),
+          vec2f(1, 1), vec2f(-1, -1), vec2f(-1, 1),
+        );
+        const uvBases = array(
+          vec2f(1., 0.), vec2f(1., 1.), vec2f(0., 1.),
+          vec2f(1., 0.), vec2f(0., 1.), vec2f(0., 0.),
+        );
+
+        // Compute the offset of instance plane.
+        let cell = vec2f(f32(ii) % grid.x, floor(f32(ii) / grid.y));
+        let cellOffset = cell / grid * 2;
+        let pos = (posBases[vi] + 1) / grid - 1 + cellOffset;
+
+        // Compute the offset of the UVs.
+        const uOffsets = array(0., 0.75, 2., 2.75);
+        const vOffsets = array(0., 1., 1.75, 2.75);
+        let uvBase = uvBases[vi] * 0.25 + vec2f(-1., 1.75);
+        let uvPixelOffset = vec2f(uOffsets[u32(cell.x)], -vOffsets[u32(cell.y)]);
+        return VertexOut(vec4f(pos, 0.0, 1.0), uvBase + uvPixelOffset);
+      }
+
+      @fragment
+      fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+        return textureSample(t, s, uv);
+      }
+      `,
+    });
+    const vertexCount = 6;
+    const instanceCount = kLinearRenderDim.reduce((sink, current) => sink * current);
+    const render = t.runFilterRenderPipeline(
+      sampler,
+      module,
+      format,
+      kLinearRenderDim,
+      vertexCount,
+      instanceCount
+    );
+    t.expectTexelViewComparisonIsOkInTexture(
+      { texture: render },
+      expectedColors(format, 'linear', addressModeU, addressModeV),
+      kLinearRenderDim
+    );
+  });
+
+/* For the minFilter tests, each rendered pixel is a small instanced quad that is UV mapped such
+ * that it is either the 6x6 or 8x8 textures from above. Each quad in each cell is then offsetted
+ * and scaled so that the target sample point coincides with the center of the pixel and the texture
+ * is significantly smaller than the pixel to force minFilter mode.
+ *
+ * For the grid offset logic, see this codelab for reference:
+ *   https://codelabs.developers.google.com/your-first-webgpu-app#4
+ */
+
+/* The following diagram depicts a single pixel and the sub-pixel sized 6x6 textured quad. The
+ * distances shown in the diagram are pre-grid transformation and relative to the quad. Notice that
+ * for cell (0,0) marked with an x, we need to offset the center by (5/12,5/12), and per cell, the
+ * offset is (-1/6, -1/6).
+ *
+ *
+ *              ┌───────────────────────────────────────────────┐
+ *              │                                               │
+ *              │                                               │
+ *              │                                               │
+ *              │                                               │
+ *              │                                               │
+ *              │           ┌───┬───┬───┬───┬───┬───┐           │
+ *              │           │   │   │   │   │   │   │           │
+ *              │           ├───┼───┼───┼───┼───┼───┤           │
+ *              │           │   │   │   │   │   │   │           │
+ *              │           ├───┼───┼───┼───┼───┼───┤           │
+ *              │           │   │   │   │   │   │   │           │
+ *              │           ├───┼───┼───x───┼───┼───┤           │         ┐
+ *              │           │   │   │   │   │   │   │           │         │
+ *              │           ├───┼───┼───┼───┼───┼───┤           │         │ 5/12
+ *              │           │   │   │   │   │   │   │           │ ┐       │
+ *              │           ├───┼───┼───┼───┼───┼───┤           │ │ 1/6   │
+ *              │           │ x │   │   │   │   │   │           │ ┘       ┘
+ *              │           └───┴───┴───┴───┴───┴───┘           │
+ *              │                                               │
+ *              │                                               │
+ *              │                                               │
+ *              │                                               │
+ *              │                                               │
+ *              └───────────────────────────────────────────────┘
+ */
+g.test('minFilter,nearest')
+  .desc(
+    `
+  Test that for filterable formats, minFilter 'nearest' mode correctly modifies the sampling.
+    - format= {<filterable formats>}
+    - addressModeU= {'clamp-to-edge', 'repeat', 'mirror-repeat'}
+    - addressModeV= {'clamp-to-edge', 'repeat', 'mirror-repeat'}
+  `
+  )
+  .params(u =>
+    u
+      .combine('format', kRenderableColorTextureFormats)
+      .filter(t => {
+        return (
+          kTextureFormatInfo[t.format].color.type === 'float' ||
+          kTextureFormatInfo[t.format].color.type === 'unfilterable-float'
+        );
+      })
+      .beginSubcases()
+      .combine('addressModeU', kAddressModes)
+      .combine('addressModeV', kAddressModes)
+  )
+  .beforeAllSubcases(t => {
+    if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
+      t.selectDeviceOrSkipTestCase('float32-filterable');
+    }
+  })
+  .fn(t => {
+    const { format, addressModeU, addressModeV } = t.params;
+    const sampler = t.device.createSampler({
+      addressModeU,
+      addressModeV,
+      minFilter: 'nearest',
+    });
+    const module = t.device.createShaderModule({
+      code: `
+      @group(0) @binding(0) var s : sampler;
+      @group(0) @binding(1) var t : texture_2d<f32>;
+
+      struct VertexOut {
+        @builtin(position) pos: vec4f,
+        @location(0) uv: vec2f,
+      };
+
+      @vertex
+      fn vs_main(@builtin(vertex_index) vi : u32,
+                 @builtin(instance_index) ii: u32) -> VertexOut {
+        const grid = vec2f(${kNearestRenderSize}, ${kNearestRenderSize});
+        const posBases = array(
+          vec2f(.5, .5), vec2f(.5, -.5), vec2f(-.5, -.5),
+          vec2f(.5, .5), vec2f(-.5, -.5), vec2f(-.5, .5),
+        );
+        // Choose UVs so that the quad ends up being the 6x6 texture.
+        const uvBases = array(
+          vec2f(2., -1.), vec2f(2., 2.), vec2f(-1., 2.),
+          vec2f(2., -1.), vec2f(-1., 2.), vec2f(-1., -1.),
+        );
+
+        let cell = vec2f(f32(ii) % grid.x, floor(f32(ii) / grid.y));
+
+        // Compute the offset of instance plane (pre-grid transformation).
+        const constantPlaneOffset = vec2f(5. / 12., 5. / 12.);
+        const perPixelOffset = vec2f(1. / 6., 1. / 6.);
+        let posBase = posBases[vi] + constantPlaneOffset - perPixelOffset * cell;
+
+        // Apply the grid transformation.
+        let cellOffset = cell / grid * 2;
+        let absPos = (posBase + 1) / grid - 1 + cellOffset;
+
+        return VertexOut(vec4f(absPos, 0.0, 1.0), uvBases[vi]);
+      }
+
+      @fragment
+      fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+        return textureSample(t, s, uv);
+      }
+      `,
+    });
+    const vertexCount = 6;
+    const instanceCount = kNearestRenderDim.reduce((sink, current) => sink * current);
+    const render = t.runFilterRenderPipeline(
+      sampler,
+      module,
+      format,
+      kNearestRenderDim,
+      vertexCount,
+      instanceCount
+    );
+    t.expectTexelViewComparisonIsOkInTexture(
+      { texture: render },
+      expectedColors(format, 'nearest', addressModeU, addressModeV),
+      kNearestRenderDim
+    );
+  });
+
+/* The following diagram shows the sub-pixel quad and the relative distances between the sample
+ * points and the origin. The pixel is not shown in this diagram but is a 2x bounding box around the
+ * quad similar to the one in the diagram for minFilter,nearest above. The dark square is where the
+ * cell (0,0) is, and the offsets are all relative to that point.
+ *
+ *                        11/32
+ *                   ┌─────────────┐
+ *
+ *                     3/16      5/16       3/16
+ *                   ┌───────┬───────────┬───────┐
+ *
+ *             ┌────┬────┬────┬────┬────┬────┬────┬────┐
+ *             │    │    │    │    │    │    │    │    │
+ *             │    │    │    │    │    │    │    │    │
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤
+ *             │    │□   │   □│    │    │□   │   □│    │  ┐
+ *             │    │    │    │    │    │    │    │    │  │
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤  │
+ *             │    │    │    │    │    │    │    │    │  │  1/4
+ *             │    │    │    │    │    │    │    │    │  │
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤  │
+ *             │    │□   │   □│    │    │□   │   □│    │  ┤
+ *             │    │    │    │    │    │    │    │    │  │
+ *             ├────┼────┼────┼────x────┼────┼────┼────┤  │  3/16    ┐
+ *             │    │    │    │    │    │    │    │    │  │          │
+ *             │    │□   │   □│    │    │□   │   □│    │  ┤          │
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤  │          │
+ *             │    │    │    │    │    │    │    │    │  │          │  11/32
+ *             │    │    │    │    │    │    │    │    │  │  1/4     │
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤  │          │
+ *             │    │    │    │    │    │    │    │    │  │          │
+ *             │    │■   │   □│    │    │□   │   □│    │  ┘          ┘
+ *             ├────┼────┼────┼────┼────┼────┼────┼────┤
+ *             │    │    │    │    │    │    │    │    │
+ *             │    │    │    │    │    │    │    │    │
+ *             └────┴────┴────┴────┴────┴────┴────┴────┘
+ */
+g.test('minFilter,linear')
+  .desc(
+    `
+  Test that for filterable formats, minFilter 'linear' mode correctly modifies the sampling.
+    - format= {<filterable formats>}
+    - addressModeU= {'clamp-to-edge', 'repeat', 'mirror-repeat'}
+    - addressModeV= {'clamp-to-edge', 'repeat', 'mirror-repeat'}
+  `
+  )
+  .params(u =>
+    u
+      .combine('format', kRenderableColorTextureFormats)
+      .filter(t => {
+        return (
+          kTextureFormatInfo[t.format].color.type === 'float' ||
+          kTextureFormatInfo[t.format].color.type === 'unfilterable-float'
+        );
+      })
+      .beginSubcases()
+      .combine('addressModeU', kAddressModes)
+      .combine('addressModeV', kAddressModes)
+  )
+  .beforeAllSubcases(t => {
+    if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
+      t.selectDeviceOrSkipTestCase('float32-filterable');
+    }
+  })
+  .fn(t => {
+    const { format, addressModeU, addressModeV } = t.params;
+    const sampler = t.device.createSampler({
+      addressModeU,
+      addressModeV,
+      minFilter: 'linear',
+    });
+    const module = t.device.createShaderModule({
+      code: `
+      @group(0) @binding(0) var s : sampler;
+      @group(0) @binding(1) var t : texture_2d<f32>;
+
+      struct VertexOut {
+        @builtin(position) pos: vec4f,
+        @location(0) uv: vec2f,
+      };
+
+      @vertex
+      fn vs_main(@builtin(vertex_index) vi : u32,
+                 @builtin(instance_index) ii: u32) -> VertexOut {
+        const grid = vec2f(${kLinearRenderSize}, ${kLinearRenderSize});
+        const posBases = array(
+          vec2f(.5, .5), vec2f(.5, -.5), vec2f(-.5, -.5),
+          vec2f(.5, .5), vec2f(-.5, -.5), vec2f(-.5, .5),
+        );
+        // Choose UVs so that the quad ends up being the 8x8 texture.
+        const uvBases = array(
+          vec2f(2.5, -1.5), vec2f(2.5, 2.5), vec2f(-1.5, 2.5),
+          vec2f(2.5, -1.5), vec2f(-1.5, 2.5), vec2f(-1.5, -1.5),
+        );
+
+        let cell = vec2f(f32(ii) % grid.x, floor(f32(ii) / grid.y));
+
+        // Compute the offset of instance plane (pre-grid transformation).
+        const constantPlaneOffset = vec2f(11. / 32., 11. / 32.);
+        const xOffsets = array(0., 3. / 16., 1. / 2., 11. / 16.);
+        const yOffsets = array(0., 1. / 4., 7. / 16., 11. / 16.);
+        let pixelOffset = vec2f(xOffsets[u32(cell.x)], yOffsets[u32(cell.y)]);
+        let posBase = posBases[vi] + constantPlaneOffset - pixelOffset;
+
+        // Compute the offset of instance plane.
+        let cellOffset = cell / grid * 2;
+        let absPos = (posBase + 1) / grid - 1 + cellOffset;
+
+        return VertexOut(vec4f(absPos, 0.0, 1.0), uvBases[vi]);
+      }
+
+      @fragment
+      fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+        return textureSample(t, s, uv);
+      }
+      `,
+    });
+    const vertexCount = 6;
+    const instanceCount = kLinearRenderDim.reduce((sink, current) => sink * current);
+    const render = t.runFilterRenderPipeline(
+      sampler,
+      module,
+      format,
+      kLinearRenderDim,
+      vertexCount,
+      instanceCount
+    );
+    t.expectTexelViewComparisonIsOkInTexture(
+      { texture: render },
+      expectedColors(format, 'linear', addressModeU, addressModeV),
+      kLinearRenderDim
+    );
+  });
+
+g.test('mipmapFilter')
+  .desc(
+    `
+  Test that for filterable formats, mipmapFilter modes correctly modifies the sampling.
+    - format= {<filterable formats>}
+    - filterMode= {'nearest', 'linear'}
+  `
+  )
+  .params(u =>
+    u
+      .combine('format', kRenderableColorTextureFormats)
+      .filter(t => {
+        return (
+          kTextureFormatInfo[t.format].color.type === 'float' ||
+          kTextureFormatInfo[t.format].color.type === 'unfilterable-float'
+        );
+      })
+      .beginSubcases()
+      .combine('filterMode', kMipmapFilterModes)
+  )
+  .beforeAllSubcases(t => {
+    if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
+      t.selectDeviceOrSkipTestCase('float32-filterable');
+    }
+  })
+  .fn(t => {
+    const { format, filterMode } = t.params;
+    // Takes a 8x8/4x4 mipmapped texture and renders it on multiple quads with different UVs such
+    // that each instanced quad from left to right emulates moving the quad further and further from
+    // the camera. Each quad is then rendered to a single pixel in a 1-dimensional texture. Since
+    // the 8x8 is fully black and the 4x4 is fully white, we should see the pixels increase in
+    // brightness from left to right when sampling linearly, and jump from black to white when
+    // sampling for the nearest mip level.
+    const kTextureSize = 8;
+    const kRenderSize = 8;
+
+    const sampler = t.device.createSampler({
+      mipmapFilter: filterMode,
+    });
+    const sampleTexture = t.createTextureFromTexelViewsMultipleMipmaps(
+      [
+        TexelView.fromTexelsAsColors(format, () => {
+          return { R: 0.0, G: 0.0, B: 0.0, A: 1.0 };
+        }),
+        TexelView.fromTexelsAsColors(format, coord => {
+          return { R: 1.0, G: 1.0, B: 1.0, A: 1.0 };
+        }),
+      ],
+      {
+        size: [kTextureSize, 1],
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+      }
+    );
+    const renderTexture = t.device.createTexture({
+      format,
+      size: [kRenderSize, 1],
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
+    });
+    const module = t.device.createShaderModule({
+      code: `
+      @group(0) @binding(0) var s : sampler;
+      @group(0) @binding(1) var t : texture_2d<f32>;
+
+      struct VertexOut {
+        @builtin(position) pos: vec4f,
+        @location(0) uv: vec2f,
+      };
+
+      @vertex
+      fn vs_main(@builtin(vertex_index) vi : u32,
+                 @builtin(instance_index) ii: u32) -> VertexOut {
+        const grid = vec2f(${kRenderSize}., 1.);
+        const pos = array(
+          vec2f( 1.0,  1.0), vec2f( 1.0, -1.0), vec2f(-1.0, -1.0),
+          vec2f( 1.0,  1.0), vec2f(-1.0, -1.0), vec2f(-1.0,  1.0),
+        );
+        const uv = array(
+          vec2f(1., 0.), vec2f(1., 1.), vec2f(0., 1.),
+          vec2f(1., 0.), vec2f(0., 1.), vec2f(0., 0.),
+        );
+
+        // Compute the offset of the plane.
+        let cell = vec2f(f32(ii) % grid.x, 0.);
+        let cellOffset = cell / grid * 2;
+        let absPos = (pos[vi] + 1) / grid - 1 + cellOffset;
+        let uvFactor = (1. / 8.) * (1 + (f32(ii) / (grid.x - 1)));
+        return VertexOut(vec4f(absPos, 0.0, 1.0), uv[vi] * uvFactor);
+      }
+
+      @fragment
+      fn fs_main(@location(0) uv : vec2f) -> @location(0) vec4f {
+        return textureSample(t, s, uv);
+      }
+      `,
+    });
+    const pipeline = t.device.createRenderPipeline({
+      layout: 'auto',
+      vertex: {
+        module,
+        entryPoint: 'vs_main',
+      },
+      fragment: {
+        module,
+        entryPoint: 'fs_main',
+        targets: [{ format }],
+      },
+    });
+    const bindgroup = t.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: sampler },
+        { binding: 1, resource: sampleTexture.createView() },
+      ],
+    });
+    const commandEncoder = t.device.createCommandEncoder();
+    const renderPass = commandEncoder.beginRenderPass({
+      colorAttachments: [
+        {
+          view: renderTexture.createView(),
+          clearValue: [0, 0, 0, 0],
+          loadOp: 'clear',
+          storeOp: 'store',
+        },
+      ],
+    });
+    renderPass.setPipeline(pipeline);
+    renderPass.setBindGroup(0, bindgroup);
+    renderPass.draw(6, kRenderSize);
+    renderPass.end();
+    t.device.queue.submit([commandEncoder.finish()]);
+
+    // Since mipmap filtering varies across different backends, we verify that the result exhibits
+    // filtered characteristics without strict value equalities via copies to a buffer.
+    const buffer = t.copyWholeTextureToNewBufferSimple(renderTexture, 0);
+    t.expectGPUBufferValuesPassCheck(
+      buffer,
+      actual => {
+        // Convert the buffer to texel view so we can do comparisons.
+        const layout = getTextureCopyLayout(format, '2d', [kRenderSize, 1, 1]);
+        const view = TexelView.fromTextureDataByReference(format, actual, {
+          bytesPerRow: layout.bytesPerRow,
+          rowsPerImage: layout.rowsPerImage,
+          subrectOrigin: [0, 0, 0],
+          subrectSize: [kRenderSize, 1, 1],
+        });
 
-export const g = makeTestGroup(GPUTest);
+        // We only check the R component for the conditions, since all components should be equal if
+        // specified in the format.
+        switch (filterMode) {
+          case 'linear': {
+            // For 'linear' mode, we check that the resulting 1d image is monotonically increasing.
+            for (let x = 1; x < kRenderSize; x++) {
+              const { R: Ri } = view.color({ x: x - 1, y: 0, z: 0 });
+              const { R: Rj } = view.color({ x, y: 0, z: 0 });
+              if (Ri! >= Rj!) {
+                return Error(
+                  'Linear filtering on mipmaps should be a monotonically increasing sequence:\n' +
+                    view.toString(
+                      { x: 0, y: 0, z: 0 },
+                      { width: kRenderSize, height: 1, depthOrArrayLayers: 1 }
+                    )
+                );
+              }
+            }
+            break;
+          }
+          case 'nearest': {
+            // For 'nearest' mode, we check that the resulting 1d image changes from 0.0 to 1.0
+            // exactly once.
+            let changes = 0;
+            for (let x = 1; x < kRenderSize; x++) {
+              const { R: Ri } = view.color({ x: x - 1, y: 0, z: 0 });
+              const { R: Rj } = view.color({ x, y: 0, z: 0 });
+              if (Ri! !== Rj!) {
+                changes++;
+              }
+            }
+            if (changes !== 1) {
+              return Error(
+                `Nearest filtering on mipmaps should change exacly once but found (${changes}):\n` +
+                  view.toString(
+                    { x: 0, y: 0, z: 0 },
+                    { width: kRenderSize, height: 1, depthOrArrayLayers: 1 }
+                  )
+              );
+            }
+            break;
+          }
+        }
+        return undefined;
+      },
+      { srcByteOffset: 0, type: Uint8Array, typedLength: buffer.size }
+    );
+  });
diff --git a/src/webgpu/capability_info.ts b/src/webgpu/capability_info.ts
index b99884836935..4da0efb1fde6 100644
--- a/src/webgpu/capability_info.ts
+++ b/src/webgpu/capability_info.ts
@@ -586,6 +586,20 @@ export const kShaderStageCombinationsWithStage: readonly GPUShaderStageFlags[] =
  */
 export const kTextureSampleCounts = [1, 4] as const;
 
+// Sampler info
+
+/** List of all mipmap filter modes. */
+export const kMipmapFilterModes: readonly GPUMipmapFilterMode[] = ['nearest', 'linear'];
+assertTypeTrue<TypeEqual<GPUMipmapFilterMode, typeof kMipmapFilterModes[number]>>();
+
+/** List of address modes. */
+export const kAddressModes: readonly GPUAddressMode[] = [
+  'clamp-to-edge',
+  'repeat',
+  'mirror-repeat',
+];
+assertTypeTrue<TypeEqual<GPUAddressMode, typeof kAddressModes[number]>>();
+
 // Blend factors and Blend components
 
 /** List of all GPUBlendFactor values. */
diff --git a/src/webgpu/util/texture/base.ts b/src/webgpu/util/texture/base.ts
index 15a645d5e129..67b4fc715627 100644
--- a/src/webgpu/util/texture/base.ts
+++ b/src/webgpu/util/texture/base.ts
@@ -223,3 +223,21 @@ export function reifyTextureViewDescriptor(
     arrayLayerCount,
   };
 }
+
+/**
+ * Get generator of all the coordinates in a subrect.
+ * @param subrectOrigin - Subrect origin
+ * @param subrectSize - Subrect size
+ */
+export function* fullSubrectCoordinates(
+  subrectOrigin: Required<GPUOrigin3DDict>,
+  subrectSize: Required<GPUExtent3DDict>
+): Generator<Required<GPUOrigin3DDict>> {
+  for (let z = subrectOrigin.z; z < subrectOrigin.z + subrectSize.depthOrArrayLayers; ++z) {
+    for (let y = subrectOrigin.y; y < subrectOrigin.y + subrectSize.height; ++y) {
+      for (let x = subrectOrigin.x; x < subrectOrigin.x + subrectSize.width; ++x) {
+        yield { x, y, z };
+      }
+    }
+  }
+}
diff --git a/src/webgpu/util/texture/texel_data.ts b/src/webgpu/util/texture/texel_data.ts
index fda2207faca6..602b68db353d 100644
--- a/src/webgpu/util/texture/texel_data.ts
+++ b/src/webgpu/util/texture/texel_data.ts
@@ -898,7 +898,7 @@ export function getSingleDataType(format: UncompressedTextureFormat): ComponentD
 }
 
 /**
- *  Get traits for generating code to readback data from a component.
+ * Get traits for generating code to readback data from a component.
  * @param {ComponentDataType} dataType - The input component data type.
  * @returns A dictionary containing the respective `ReadbackTypedArray` and `shaderType`.
  */
diff --git a/src/webgpu/util/texture/texel_view.ts b/src/webgpu/util/texture/texel_view.ts
index aa452de1c948..fea23b674e50 100644
--- a/src/webgpu/util/texture/texel_view.ts
+++ b/src/webgpu/util/texture/texel_view.ts
@@ -1,7 +1,9 @@
 import { assert, memcpy } from '../../../common/util/util.js';
 import { kTextureFormatInfo, EncodableTextureFormat } from '../../format_info.js';
+import { generatePrettyTable } from '../pretty_diff_tables.js';
 import { reifyExtent3D, reifyOrigin3D } from '../unions.js';
 
+import { fullSubrectCoordinates } from './base.js';
 import { kTexelRepresentationInfo, makeClampToRange, PerTexelComponent } from './texel_data.js';
 
 /** Function taking some x,y,z coordinates and returning `Readonly<T>`. */
@@ -157,4 +159,43 @@ export class TexelView {
       }
     }
   }
+
+  /** Returns a pretty table string of the given coordinates and their values. */
+  // MAINTENANCE_TODO: Unify some internal helpers with those in texture_ok.ts.
+  toString(subrectOrigin: Required<GPUOrigin3DDict>, subrectSize: Required<GPUExtent3DDict>) {
+    const info = kTextureFormatInfo[this.format];
+    const repr = kTexelRepresentationInfo[this.format];
+
+    const integerSampleType = info.sampleType === 'uint' || info.sampleType === 'sint';
+    const numberToString = integerSampleType
+      ? (n: number) => n.toFixed()
+      : (n: number) => n.toPrecision(6);
+
+    const componentOrderStr = repr.componentOrder.join(',') + ':';
+    const subrectCoords = [...fullSubrectCoordinates(subrectOrigin, subrectSize)];
+
+    const printCoords = (function* () {
+      yield* [' coords', '==', 'X,Y,Z:'];
+      for (const coords of subrectCoords) yield `${coords.x},${coords.y},${coords.z}`;
+    })();
+    const printActualBytes = (function* (t: TexelView) {
+      yield* [' act. texel bytes (little-endian)', '==', '0x:'];
+      for (const coords of subrectCoords) {
+        yield Array.from(t.bytes(coords), b => b.toString(16).padStart(2, '0')).join(' ');
+      }
+    })(this);
+    const printActualColors = (function* (t: TexelView) {
+      yield* [' act. colors', '==', componentOrderStr];
+      for (const coords of subrectCoords) {
+        const pixel = t.color(coords);
+        yield `${repr.componentOrder.map(ch => numberToString(pixel[ch]!)).join(',')}`;
+      }
+    })(this);
+
+    const opts = {
+      fillToWidth: 120,
+      numberToString,
+    };
+    return `${generatePrettyTable(opts, [printCoords, printActualBytes, printActualColors])}`;
+  }
 }
diff --git a/src/webgpu/util/texture/texture_ok.ts b/src/webgpu/util/texture/texture_ok.ts
index d2fb8d9a2ef2..7b85489246a7 100644
--- a/src/webgpu/util/texture/texture_ok.ts
+++ b/src/webgpu/util/texture/texture_ok.ts
@@ -5,6 +5,7 @@ import { numbersApproximatelyEqual } from '../conversion.js';
 import { generatePrettyTable } from '../pretty_diff_tables.js';
 import { reifyExtent3D, reifyOrigin3D } from '../unions.js';
 
+import { fullSubrectCoordinates } from './base.js';
 import { getTextureSubCopyLayout } from './layout.js';
 import { kTexelRepresentationInfo, PerTexelComponent, TexelComponent } from './texel_data.js';
 import { TexelView } from './texel_view.js';
@@ -187,19 +188,6 @@ function createTextureCopyForMapRead(
   return { buffer, bytesPerRow, rowsPerImage };
 }
 
-function* fullSubrectCoordinates(
-  subrectOrigin: Required<GPUOrigin3DDict>,
-  subrectSize: Required<GPUExtent3DDict>
-): Generator<Required<GPUOrigin3DDict>> {
-  for (let z = subrectOrigin.z; z < subrectOrigin.z + subrectSize.depthOrArrayLayers; ++z) {
-    for (let y = subrectOrigin.y; y < subrectOrigin.y + subrectSize.height; ++y) {
-      for (let x = subrectOrigin.x; x < subrectOrigin.x + subrectSize.width; ++x) {
-        yield { x, y, z };
-      }
-    }
-  }
-}
-
 export function findFailedPixels(
   format: EncodableTextureFormat,
   subrectOrigin: Required<GPUOrigin3DDict>,

From a8f254a08954557a80c6f2ff9422c36fadcac039 Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Fri, 16 Jun 2023 16:50:06 -0700
Subject: [PATCH 018/166] Allow unused variables starting with underscore

---
 .eslintrc.json | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.eslintrc.json b/.eslintrc.json
index 96d88695f3a1..14c03a55e481 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -52,7 +52,10 @@
     "@typescript-eslint/no-this-alias": "warn",
     "@typescript-eslint/no-unnecessary-type-assertion": "warn",
     "@typescript-eslint/no-unnecessary-type-constraint": "warn",
-    "@typescript-eslint/no-unused-vars": ["warn", { "vars": "all", "args": "none" }],
+    "@typescript-eslint/no-unused-vars": [
+      "warn",
+      { "vars": "all", "args": "none", "varsIgnorePattern": "^_" }
+    ],
     "@typescript-eslint/prefer-as-const": "warn",
     "@typescript-eslint/prefer-for-of": "warn",
     "@typescript-eslint/prefer-namespace-keyword": "warn",

From da1527dba015b610c46ba523312b462e532adca8 Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Fri, 16 Jun 2023 16:51:45 -0700
Subject: [PATCH 019/166] websocket-logger tool

---
 src/common/internal/websocket_logger.ts  | 52 ++++++++++++++++++++++++
 tools/websocket-logger/.gitignore        |  1 +
 tools/websocket-logger/README.md         |  9 ++++
 tools/websocket-logger/main.js           | 25 ++++++++++++
 tools/websocket-logger/package-lock.json | 39 ++++++++++++++++++
 tools/websocket-logger/package.json      | 14 +++++++
 6 files changed, 140 insertions(+)
 create mode 100644 src/common/internal/websocket_logger.ts
 create mode 100644 tools/websocket-logger/.gitignore
 create mode 100644 tools/websocket-logger/README.md
 create mode 100755 tools/websocket-logger/main.js
 create mode 100644 tools/websocket-logger/package-lock.json
 create mode 100644 tools/websocket-logger/package.json

diff --git a/src/common/internal/websocket_logger.ts b/src/common/internal/websocket_logger.ts
new file mode 100644
index 000000000000..30246df843e4
--- /dev/null
+++ b/src/common/internal/websocket_logger.ts
@@ -0,0 +1,52 @@
+/**
+ * - 'uninitialized' means we haven't tried to connect yet
+ * - Promise means it's pending
+ * - 'failed' means it failed (this is the most common case, where the logger isn't running)
+ * - WebSocket means it succeeded
+ */
+let connection: Promise<WebSocket | 'failed'> | WebSocket | 'failed' | 'uninitialized' =
+  'uninitialized';
+
+/**
+ * Log a string to a websocket at `localhost:59497`. See `tools/websocket-logger`.
+ *
+ * This does nothing if a connection couldn't be established on the first call.
+ */
+export function logToWebsocket(msg: string) {
+  if (connection === 'failed') {
+    return;
+  }
+
+  if (connection === 'uninitialized') {
+    connection = new Promise(resolve => {
+      if (typeof WebSocket === 'undefined') {
+        resolve('failed');
+        return;
+      }
+
+      const ws = new WebSocket('ws://localhost:59497/optional_cts_websocket_logger');
+      ws.onopen = () => {
+        resolve(ws);
+      };
+      ws.onerror = () => {
+        connection = 'failed';
+        resolve('failed');
+      };
+      ws.onclose = () => {
+        connection = 'failed';
+        resolve('failed');
+      };
+    });
+    void connection.then(resolved => {
+      connection = resolved;
+    });
+  }
+
+  void (async () => {
+    // connection may be a promise or a value here. Either is OK to await.
+    const ws = await connection;
+    if (ws !== 'failed') {
+      ws.send(msg);
+    }
+  })();
+}
diff --git a/tools/websocket-logger/.gitignore b/tools/websocket-logger/.gitignore
new file mode 100644
index 000000000000..1c0f45a79cc2
--- /dev/null
+++ b/tools/websocket-logger/.gitignore
@@ -0,0 +1 @@
+/wslog-*.txt
diff --git a/tools/websocket-logger/README.md b/tools/websocket-logger/README.md
new file mode 100644
index 000000000000..ebd4e4f3076c
--- /dev/null
+++ b/tools/websocket-logger/README.md
@@ -0,0 +1,9 @@
+This simple utility receives messages via a WebSocket and writes them out to both the command line
+and a file called `wslog-TIMESTAMP.txt` in the working directory.
+
+It can be used to receive logs from CTS in a way that's resistant to test crashes and totally
+independent of which runtime is being used (e.g. standalone, WPT, Node).
+It's used in particular to capture timing results for predefining "chunking" of the CTS for WPT.
+
+To set up, use `npm install`.
+To launch, use `npm start`.
diff --git a/tools/websocket-logger/main.js b/tools/websocket-logger/main.js
new file mode 100755
index 000000000000..4a5a89e7620a
--- /dev/null
+++ b/tools/websocket-logger/main.js
@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import fs from 'fs/promises';
+import { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 59497 });
+
+const timestamp = new Date().toISOString().slice(0, 19).replace(/[:]/g, '-')
+const filename = `wslog-${timestamp}.txt`
+const f = await fs.open(filename, 'w');
+console.log(`Writing to ${filename}`);
+console.log('Ctrl-C to stop');
+
+process.on('SIGINT', () => {
+  console.log(`\nWritten to ${filename}`);
+  process.exit();
+});
+
+wss.on('connection', async ws => {
+  ws.on('message', data => {
+    const s = data.toString();
+    f.write(s + '\n');
+    console.log(s);
+  });
+});
diff --git a/tools/websocket-logger/package-lock.json b/tools/websocket-logger/package-lock.json
new file mode 100644
index 000000000000..b43ae34804e4
--- /dev/null
+++ b/tools/websocket-logger/package-lock.json
@@ -0,0 +1,39 @@
+{
+  "name": "websocket-logger",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "websocket-logger",
+      "version": "0.0.0",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "ws": "^8.13.0"
+      },
+      "bin": {
+        "websocket-logger": "main.js"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.13.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.13.0.tgz",
+      "integrity": "sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}
diff --git a/tools/websocket-logger/package.json b/tools/websocket-logger/package.json
new file mode 100644
index 000000000000..66585968bd5f
--- /dev/null
+++ b/tools/websocket-logger/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "websocket-logger",
+  "version": "0.0.0",
+  "author": "WebGPU CTS Contributors",
+  "private": true,
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "scripts": {
+    "start": "node main.js"
+  },
+  "dependencies": {
+    "ws": "^8.13.0"
+  }
+}

From f42aeb4d43526482a59e2b49533520ebd03dec63 Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Fri, 16 Jun 2023 17:00:57 -0700
Subject: [PATCH 020/166] Check that if the test is skipped, all subcases are
 skipped

And fix state tracking so that subcases are actually marked skipped in
the logger
---
 src/common/internal/logging/test_case_recorder.ts | 14 ++++++++++++--
 src/common/internal/test_group.ts                 |  2 +-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/common/internal/logging/test_case_recorder.ts b/src/common/internal/logging/test_case_recorder.ts
index 7507bbdec647..f1923d43d425 100644
--- a/src/common/internal/logging/test_case_recorder.ts
+++ b/src/common/internal/logging/test_case_recorder.ts
@@ -19,7 +19,8 @@ const kMinSeverityForStack = LogSeverity.Warn;
 
 /** Holds onto a LiveTestCaseResult owned by the Logger, and writes the results into it. */
 export class TestCaseRecorder {
-  private result: LiveTestCaseResult;
+  readonly result: LiveTestCaseResult;
+  public unskippedSubcaseCount: number = 0;
   private inSubCase: boolean = false;
   private subCaseStatus = LogSeverity.Pass;
   private finalCaseStatus = LogSeverity.Pass;
@@ -42,12 +43,18 @@ export class TestCaseRecorder {
   }
 
   finish(): void {
-    assert(this.startTime >= 0, 'finish() before start()');
+    // This is a framework error. If this assert is hit, it won't be localized
+    // to a test. The whole test run will fail out.
+    assert(this.startTime >= 0, 'internal error: finish() before start()');
 
     const timeMilliseconds = now() - this.startTime;
     // Round to next microsecond to avoid storing useless .xxxx00000000000002 in results.
     this.result.timems = Math.ceil(timeMilliseconds * 1000) / 1000;
 
+    if (this.finalCaseStatus === LogSeverity.Skip && this.unskippedSubcaseCount !== 0) {
+      this.threw(new Error('internal error: case is "skip" but has unskipped subcases'));
+    }
+
     // Convert numeric enum back to string (but expose 'exception' as 'fail')
     this.result.status =
       this.finalCaseStatus === LogSeverity.Pass
@@ -67,6 +74,9 @@ export class TestCaseRecorder {
   }
 
   endSubCase(expectedStatus: Expectation) {
+    if (this.subCaseStatus !== LogSeverity.Skip) {
+      this.unskippedSubcaseCount++;
+    }
     try {
       if (expectedStatus === 'fail') {
         if (this.subCaseStatus <= LogSeverity.Warn) {
diff --git a/src/common/internal/test_group.ts b/src/common/internal/test_group.ts
index bf5c67e4abdf..c85b195f5ec9 100644
--- a/src/common/internal/test_group.ts
+++ b/src/common/internal/test_group.ts
@@ -460,10 +460,10 @@ class RunCaseSpecific implements RunCase {
       // An error from init or test may have been a SkipTestCase.
       // An error from finalize may have been an eventualAsyncExpectation failure
       // or unexpected validation/OOM error from the GPUDevice.
+      rec.threw(ex);
       if (throwSkip && ex instanceof SkipTestCase) {
         throw ex;
       }
-      rec.threw(ex);
     } finally {
       try {
         rec.endSubCase(expectedStatus);

From 691e6b4606de182dadedf6eacab09b5e9ab2836a Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Fri, 8 Sep 2023 00:24:03 -0700
Subject: [PATCH 021/166] Tools for generating timing metadata and
 auto-chunking WPT

---
 Gruntfile.js                                  |   7 +-
 src/common/framework/metadata.ts              |  28 +++
 src/common/internal/file_loader.ts            |  19 +-
 .../internal/logging/test_case_recorder.ts    |   8 +-
 src/common/internal/test_group.ts             |  58 +++++
 src/common/internal/tree.ts                   |  83 ++++++-
 src/common/tools/checklist.ts                 |   8 +-
 src/common/tools/crawl.ts                     |  71 +++++-
 src/common/tools/gen_wpt_cts_html.ts          | 226 ++++++++++++++----
 src/common/tools/merge_listing_times.ts       | 177 ++++++++++++++
 src/unittests/loaders_and_trees.spec.ts       |   4 +-
 tools/gen_wpt_cfg_chunked2sec.json            |   6 +
 tools/gen_wpt_cfg_unchunked.json              |   5 +
 tools/merge_listing_times                     |  35 +++
 14 files changed, 654 insertions(+), 81 deletions(-)
 create mode 100644 src/common/framework/metadata.ts
 create mode 100644 src/common/tools/merge_listing_times.ts
 create mode 100644 tools/gen_wpt_cfg_chunked2sec.json
 create mode 100644 tools/gen_wpt_cfg_unchunked.json
 create mode 100755 tools/merge_listing_times

diff --git a/Gruntfile.js b/Gruntfile.js
index 05d70074afc3..a3d42a91ab31 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -28,7 +28,11 @@ module.exports = function (grunt) {
       },
       'generate-wpt-cts-html': {
         cmd: 'node',
-        args: ['tools/gen_wpt_cts_html', 'out-wpt/cts.https.html', 'src/common/templates/cts.https.html'],
+        args: ['tools/gen_wpt_cts_html', 'tools/gen_wpt_cfg_unchunked.json'],
+      },
+      'generate-wpt-cts-html-chunked2sec': {
+        cmd: 'node',
+        args: ['tools/gen_wpt_cts_html', 'tools/gen_wpt_cfg_chunked2sec.json'],
       },
       'generate-cache': {
         cmd: 'node',
@@ -181,6 +185,7 @@ module.exports = function (grunt) {
     'copy:out-wpt-generated',
     'copy:out-wpt-htmlfiles',
     'run:generate-wpt-cts-html',
+    'run:generate-wpt-cts-html-chunked2sec',
   ]);
   grunt.registerTask('build-done-message', () => {
     process.stderr.write('\nBuild completed! Running checks/tests');
diff --git a/src/common/framework/metadata.ts b/src/common/framework/metadata.ts
new file mode 100644
index 000000000000..2c2a1ef79478
--- /dev/null
+++ b/src/common/framework/metadata.ts
@@ -0,0 +1,28 @@
+import { assert } from '../util/util.js';
+
+/** Metadata about tests (that can't be derived at runtime). */
+export type TestMetadata = {
+  /**
+   * Estimated average time-per-subcase, in milliseconds.
+   * This is used to determine chunking granularity when exporting to WPT with
+   * chunking enabled (like out-wpt/cts-chunked2sec.https.html).
+   */
+  subcaseMS: number;
+};
+
+export type TestMetadataListing = {
+  [testQuery: string]: TestMetadata;
+};
+
+export function loadMetadataForSuite(suiteDir: string): TestMetadataListing | null {
+  assert(typeof require !== 'undefined', 'loadMetadataForSuite is only implemented on Node');
+  const fs = require('fs');
+
+  const metadataFile = `${suiteDir}/listing_meta.json`;
+  if (!fs.existsSync(metadataFile)) {
+    return null;
+  }
+
+  const metadata: TestMetadataListing = JSON.parse(fs.readFileSync(metadataFile, 'utf8'));
+  return metadata;
+}
diff --git a/src/common/internal/file_loader.ts b/src/common/internal/file_loader.ts
index 3b6afef7ac78..dddedf768830 100644
--- a/src/common/internal/file_loader.ts
+++ b/src/common/internal/file_loader.ts
@@ -69,16 +69,21 @@ export abstract class TestFileLoader extends EventTarget {
     return ret;
   }
 
-  async loadTree(query: TestQuery, subqueriesToExpand: string[] = []): Promise<TestTree> {
-    const tree = await loadTreeForQuery(
-      this,
-      query,
-      subqueriesToExpand.map(s => {
+  async loadTree(
+    query: TestQuery,
+    {
+      subqueriesToExpand = [],
+      maxChunkTime = Infinity,
+    }: { subqueriesToExpand?: string[]; maxChunkTime?: number } = {}
+  ): Promise<TestTree> {
+    const tree = await loadTreeForQuery(this, query, {
+      subqueriesToExpand: subqueriesToExpand.map(s => {
         const q = parseQuery(s);
         assert(q.level >= 2, () => `subqueriesToExpand entries should not be multi-file:\n  ${q}`);
         return q;
-      })
-    );
+      }),
+      maxChunkTime,
+    });
     this.dispatchEvent(new MessageEvent<void>('finish'));
     return tree;
   }
diff --git a/src/common/internal/logging/test_case_recorder.ts b/src/common/internal/logging/test_case_recorder.ts
index f1923d43d425..ca37ba4b0287 100644
--- a/src/common/internal/logging/test_case_recorder.ts
+++ b/src/common/internal/logging/test_case_recorder.ts
@@ -20,7 +20,7 @@ const kMinSeverityForStack = LogSeverity.Warn;
 /** Holds onto a LiveTestCaseResult owned by the Logger, and writes the results into it. */
 export class TestCaseRecorder {
   readonly result: LiveTestCaseResult;
-  public unskippedSubcaseCount: number = 0;
+  public nonskippedSubcaseCount: number = 0;
   private inSubCase: boolean = false;
   private subCaseStatus = LogSeverity.Pass;
   private finalCaseStatus = LogSeverity.Pass;
@@ -51,8 +51,8 @@ export class TestCaseRecorder {
     // Round to next microsecond to avoid storing useless .xxxx00000000000002 in results.
     this.result.timems = Math.ceil(timeMilliseconds * 1000) / 1000;
 
-    if (this.finalCaseStatus === LogSeverity.Skip && this.unskippedSubcaseCount !== 0) {
-      this.threw(new Error('internal error: case is "skip" but has unskipped subcases'));
+    if (this.finalCaseStatus === LogSeverity.Skip && this.nonskippedSubcaseCount !== 0) {
+      this.threw(new Error('internal error: case is "skip" but has nonskipped subcases'));
     }
 
     // Convert numeric enum back to string (but expose 'exception' as 'fail')
@@ -75,7 +75,7 @@ export class TestCaseRecorder {
 
   endSubCase(expectedStatus: Expectation) {
     if (this.subCaseStatus !== LogSeverity.Skip) {
-      this.unskippedSubcaseCount++;
+      this.nonskippedSubcaseCount++;
     }
     try {
       if (expectedStatus === 'fail') {
diff --git a/src/common/internal/test_group.ts b/src/common/internal/test_group.ts
index c85b195f5ec9..e446628bc0b0 100644
--- a/src/common/internal/test_group.ts
+++ b/src/common/internal/test_group.ts
@@ -28,6 +28,8 @@ import {
 import { validQueryPart } from '../internal/query/validQueryPart.js';
 import { assert, unreachable } from '../util/util.js';
 
+import { logToWebsocket } from './websocket_logger.js';
+
 export type RunFn = (
   rec: TestCaseRecorder,
   expectations?: TestQueryWithExpectation[]
@@ -41,6 +43,7 @@ export interface TestCaseID {
 export interface RunCase {
   readonly id: TestCaseID;
   readonly isUnimplemented: boolean;
+  computeSubcaseCount(): number;
   run(
     rec: TestCaseRecorder,
     selfQuery: TestQuerySingleCase,
@@ -60,6 +63,8 @@ export function makeTestGroup<F extends Fixture>(fixture: FixtureClass<F>): Test
 export interface IterableTestGroup {
   iterate(): Iterable<IterableTest>;
   validate(): void;
+  /** Returns the file-relative test paths of tests which have >0 cases. */
+  collectNonEmptyTests(): { testPath: string[] }[];
 }
 export interface IterableTest {
   testPath: string[];
@@ -127,6 +132,16 @@ export class TestGroup<F extends Fixture> implements TestGroupBuilder<F> {
       test.validate();
     }
   }
+
+  collectNonEmptyTests(): { testPath: string[] }[] {
+    const testPaths = [];
+    for (const test of this.tests) {
+      if (test.computeCaseCount() > 0) {
+        testPaths.push({ testPath: test.testPath });
+      }
+    }
+    return testPaths;
+  }
 }
 
 interface TestBuilderWithName<F extends Fixture> extends TestBuilderWithParams<F, {}, {}> {
@@ -268,6 +283,7 @@ class TestBuilder<S extends SubcaseBatchState, F extends Fixture> {
     };
   }
 
+  /** Perform various validation/"lint" chenks. */
   validate(): void {
     const testPathString = this.testPath.join(kPathSeparator);
     assert(this.testFn !== undefined, () => {
@@ -307,6 +323,18 @@ class TestBuilder<S extends SubcaseBatchState, F extends Fixture> {
     }
   }
 
+  computeCaseCount(): number {
+    if (this.testCases === undefined) {
+      return 1;
+    }
+
+    let caseCount = 0;
+    for (const [_caseParams, _subcases] of builderIterateCasesWithSubcases(this.testCases, null)) {
+      caseCount++;
+    }
+    return caseCount;
+  }
+
   params(
     cases: ((unit: CaseParamsBuilder<{}>) => ParamsBuilderBase<{}, {}>) | ParamsBuilderBase<{}, {}>
   ): TestBuilder<S, F> {
@@ -434,6 +462,18 @@ class RunCaseSpecific implements RunCase {
     this.testCreationStack = testCreationStack;
   }
 
+  computeSubcaseCount(): number {
+    if (this.subcases) {
+      let count = 0;
+      for (const _subcase of this.subcases) {
+        count++;
+      }
+      return count;
+    } else {
+      return 1;
+    }
+  }
+
   async runTest(
     rec: TestCaseRecorder,
     sharedState: SubcaseBatchState,
@@ -656,6 +696,24 @@ class RunCaseSpecific implements RunCase {
       rec.threw(ex);
     } finally {
       rec.finish();
+
+      const msg: CaseTimingLogLine = {
+        q: selfQuery.toString(),
+        timems: rec.result.timems,
+        nonskippedSubcaseCount: rec.nonskippedSubcaseCount,
+      };
+      logToWebsocket(JSON.stringify(msg));
     }
   }
 }
+
+export type CaseTimingLogLine = {
+  q: string;
+  /** Total time it took to execute the case. */
+  timems: number;
+  /**
+   * Number of subcases that ran in the case (excluding skipped subcases, so
+   * they don't dilute the average per-subcase time.
+   */
+  nonskippedSubcaseCount: number;
+};
diff --git a/src/common/internal/tree.ts b/src/common/internal/tree.ts
index 6cdce2d39a60..594837059ca7 100644
--- a/src/common/internal/tree.ts
+++ b/src/common/internal/tree.ts
@@ -1,3 +1,4 @@
+import { loadMetadataForSuite, TestMetadataListing } from '../framework/metadata.js';
 import { globalTestConfig } from '../framework/test_config.js';
 import { RunCase, RunFn } from '../internal/test_group.js';
 import { assert, now } from '../util/util.js';
@@ -48,12 +49,13 @@ interface TestTreeNodeBase<T extends TestQuery> {
    * one (e.g. s:f:* relative to s:f,*), but something that is readable.
    */
   readonly readableRelativeName: string;
-  subtreeCounts?: { tests: number; nodesWithTODO: number };
+  subtreeCounts?: { tests: number; nodesWithTODO: number; totalTimeMS: number };
+  subcaseCount?: number;
 }
 
 export interface TestSubtree<T extends TestQuery = TestQuery> extends TestTreeNodeBase<T> {
   readonly children: Map<string, TestTreeNode>;
-  readonly collapsible: boolean;
+  collapsible: boolean;
   description?: string;
   readonly testCreationStack?: Error;
 }
@@ -62,6 +64,7 @@ export interface TestTreeLeaf extends TestTreeNodeBase<TestQuerySingleCase> {
   readonly run: RunFn;
   readonly isUnimplemented?: boolean;
   subtreeCounts?: undefined;
+  subcaseCount: number;
 }
 
 export type TestTreeNode = TestSubtree | TestTreeLeaf;
@@ -89,9 +92,8 @@ export class TestTree {
   readonly forQuery: TestQuery;
   readonly root: TestSubtree;
 
-  constructor(forQuery: TestQuery, root: TestSubtree) {
+  private constructor(forQuery: TestQuery, root: TestSubtree) {
     this.forQuery = forQuery;
-    TestTree.propagateCounts(root);
     this.root = root;
     assert(
       root.query.level === 1 && root.query.depthInLevel === 0,
@@ -99,6 +101,24 @@ export class TestTree {
     );
   }
 
+  static async create(
+    forQuery: TestQuery,
+    root: TestSubtree,
+    maxChunkTime: number
+  ): Promise<TestTree> {
+    const suite = forQuery.suite;
+
+    let chunking = undefined;
+    if (Number.isFinite(maxChunkTime)) {
+      const metadata = loadMetadataForSuite(`./src/${suite}`);
+      assert(metadata !== null, `metadata for ${suite} is missing, but maxChunkTime was requested`);
+      chunking = { metadata, maxChunkTime };
+    }
+    await TestTree.propagateCounts(root, chunking);
+
+    return new TestTree(forQuery, root);
+  }
+
   /**
    * Iterate through the leaves of a version of the tree which has been pruned to exclude
    * subtrees which:
@@ -185,16 +205,51 @@ export class TestTree {
   }
 
   /** Propagate the subtreeTODOs/subtreeTests state upward from leaves to parent nodes. */
-  static propagateCounts(subtree: TestSubtree): { tests: number; nodesWithTODO: number } {
-    subtree.subtreeCounts ??= { tests: 0, nodesWithTODO: 0 };
+  static async propagateCounts(
+    subtree: TestSubtree,
+    chunking: { metadata: TestMetadataListing; maxChunkTime: number } | undefined
+  ): Promise<{ tests: number; nodesWithTODO: number; totalTimeMS: number; subcaseCount: number }> {
+    subtree.subtreeCounts ??= { tests: 0, nodesWithTODO: 0, totalTimeMS: 0 };
+    subtree.subcaseCount = 0;
     for (const [, child] of subtree.children) {
       if ('children' in child) {
-        const counts = TestTree.propagateCounts(child);
+        const counts = await TestTree.propagateCounts(child, chunking);
         subtree.subtreeCounts.tests += counts.tests;
         subtree.subtreeCounts.nodesWithTODO += counts.nodesWithTODO;
+        subtree.subtreeCounts.totalTimeMS += counts.totalTimeMS;
+        subtree.subcaseCount += counts.subcaseCount;
+      } else {
+        subtree.subcaseCount = child.subcaseCount;
       }
     }
-    return subtree.subtreeCounts;
+
+    // If we're chunking based on a maxChunkTime, then at each
+    // TestQueryMultiCase node of the tree we look at its total time. If the
+    // total time is larger than the maxChunkTime, we set collapsible=false to
+    // make sure it gets split up in the output. Note:
+    // - TestQueryMultiTest and higher nodes are never set to collapsible anyway, so we ignore them.
+    // - TestQuerySingleCase nodes can't be collapsed, so we ignore them.
+    if (chunking && subtree.query instanceof TestQueryMultiCase) {
+      const testLevelQuery = new TestQueryMultiCase(
+        subtree.query.suite,
+        subtree.query.filePathParts,
+        subtree.query.testPathParts,
+        {}
+      ).toString();
+
+      const metadata = chunking.metadata;
+
+      const subcaseTiming: number | undefined = metadata[testLevelQuery]?.subcaseMS;
+      if (subcaseTiming !== undefined) {
+        const totalTiming = subcaseTiming * subtree.subcaseCount;
+        subtree.subtreeCounts.totalTimeMS = totalTiming;
+        if (totalTiming > chunking.maxChunkTime) {
+          subtree.collapsible = false;
+        }
+      }
+    }
+
+    return { ...subtree.subtreeCounts, subcaseCount: subtree.subcaseCount ?? 0 };
   }
 
   /** Displays counts in the format `(Nodes with TODOs) / (Total test count)`. */
@@ -229,7 +284,10 @@ export class TestTree {
 export async function loadTreeForQuery(
   loader: TestFileLoader,
   queryToLoad: TestQuery,
-  subqueriesToExpand: TestQuery[]
+  {
+    subqueriesToExpand,
+    maxChunkTime = Infinity,
+  }: { subqueriesToExpand: TestQuery[]; maxChunkTime?: number }
 ): Promise<TestTree> {
   const suite = queryToLoad.suite;
   const specs = await loader.listing(suite);
@@ -347,7 +405,7 @@ export async function loadTreeForQuery(
         isCollapsible
       );
       // This is 1 test. Set tests=1 then count TODOs.
-      subtreeL2.subtreeCounts ??= { tests: 1, nodesWithTODO: 0 };
+      subtreeL2.subtreeCounts ??= { tests: 1, nodesWithTODO: 0, totalTimeMS: 0 };
       if (t.description) setSubtreeDescriptionAndCountTODOs(subtreeL2, t.description);
 
       let caseFilter = null;
@@ -391,7 +449,7 @@ export async function loadTreeForQuery(
   }
   assert(foundCase, `Query \`${queryToLoad.toString()}\` does not match any cases`);
 
-  return new TestTree(queryToLoad, subtreeL0);
+  return TestTree.create(queryToLoad, subtreeL0, maxChunkTime);
 }
 
 function setSubtreeDescriptionAndCountTODOs(
@@ -400,7 +458,7 @@ function setSubtreeDescriptionAndCountTODOs(
 ) {
   assert(subtree.description === undefined);
   subtree.description = description.trim();
-  subtree.subtreeCounts ??= { tests: 0, nodesWithTODO: 0 };
+  subtree.subtreeCounts ??= { tests: 0, nodesWithTODO: 0, totalTimeMS: 0 };
   if (subtree.description.indexOf('TODO') !== -1) {
     subtree.subtreeCounts.nodesWithTODO++;
   }
@@ -569,6 +627,7 @@ function insertLeaf(parent: TestSubtree, query: TestQuerySingleCase, t: RunCase)
     query,
     run: (rec, expectations) => t.run(rec, query, expectations || []),
     isUnimplemented: t.isUnimplemented,
+    subcaseCount: t.computeSubcaseCount(),
   };
 
   // This is a leaf (e.g. s:f:t:x=1;* -> s:f:t:x=1). The key is always ''.
diff --git a/src/common/tools/checklist.ts b/src/common/tools/checklist.ts
index 393990e26f99..e301cfb2c82b 100644
--- a/src/common/tools/checklist.ts
+++ b/src/common/tools/checklist.ts
@@ -122,11 +122,9 @@ function checkForUnmatchedSubtreesAndDoneness(
     checkForOverlappingQueries(queriesInSuite);
     const suiteQuery = new TestQueryMultiFile(suite, []);
     console.log(`  Loading tree ${suiteQuery}...`);
-    const tree = await loadTreeForQuery(
-      loader,
-      suiteQuery,
-      queriesInSuite.map(q => q.query)
-    );
+    const tree = await loadTreeForQuery(loader, suiteQuery, {
+      subqueriesToExpand: queriesInSuite.map(q => q.query),
+    });
     console.log('  Found no invalid queries in the checklist. Checking for unmatched tests...');
     const subtreeCount = checkForUnmatchedSubtreesAndDoneness(tree, queriesInSuite);
     console.log(`  No unmatched tests or done/todo mismatches among ${subtreeCount} subtrees!`);
diff --git a/src/common/tools/crawl.ts b/src/common/tools/crawl.ts
index 0381e0835151..eadabe4f77f2 100644
--- a/src/common/tools/crawl.ts
+++ b/src/common/tools/crawl.ts
@@ -5,7 +5,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
+import { loadMetadataForSuite } from '../framework/metadata.js';
 import { SpecFile } from '../internal/file_loader.js';
+import { TestQueryMultiCase } from '../internal/query/query.js';
 import { validQueryPart } from '../internal/query/validQueryPart.js';
 import { TestSuiteListingEntry, TestSuiteListing } from '../internal/test_suite_listing.js';
 import { assert, unreachable } from '../util/util.js';
@@ -48,6 +50,17 @@ export async function crawl(suiteDir: string, validate: boolean): Promise<TestSu
     throw new Error(`Could not find suite: ${suiteDir}`);
   }
 
+  let validateTimingsEntries;
+  if (validate) {
+    const metadata = loadMetadataForSuite(suiteDir);
+    if (metadata) {
+      validateTimingsEntries = {
+        metadata,
+        testsFoundInFiles: new Set<string>(),
+      };
+    }
+  }
+
   // Crawl files and convert paths to be POSIX-style, relative to suiteDir.
   const filesToEnumerate = (await crawlFilesRecursively(suiteDir))
     .map(f => path.relative(suiteDir, f).replace(/\\/g, '/'))
@@ -58,6 +71,7 @@ export async function crawl(suiteDir: string, validate: boolean): Promise<TestSu
     // |file| is the suite-relative file path.
     if (file.endsWith(specFileSuffix)) {
       const filepathWithoutExtension = file.substring(0, file.length - specFileSuffix.length);
+      const pathSegments = filepathWithoutExtension.split('/');
 
       const suite = path.basename(suiteDir);
 
@@ -69,10 +83,14 @@ export async function crawl(suiteDir: string, validate: boolean): Promise<TestSu
         assert(mod.description !== undefined, 'Test spec file missing description: ' + filename);
         assert(mod.g !== undefined, 'Test spec file missing TestGroup definition: ' + filename);
 
-        mod.g.validate();
+        for (const { testPath } of mod.g.collectNonEmptyTests()) {
+          const testQuery = new TestQueryMultiCase(suite, pathSegments, testPath, {}).toString();
+          if (validateTimingsEntries) {
+            validateTimingsEntries.testsFoundInFiles.add(testQuery);
+          }
+        }
       }
 
-      const pathSegments = filepathWithoutExtension.split('/');
       for (const p of pathSegments) {
         assert(validQueryPart.test(p), `Invalid directory name ${p}; must match ${validQueryPart}`);
       }
@@ -88,6 +106,55 @@ export async function crawl(suiteDir: string, validate: boolean): Promise<TestSu
     }
   }
 
+  if (validateTimingsEntries) {
+    let failed = false;
+
+    const zeroEntries = [];
+    const staleEntries = [];
+    for (const [metadataKey, metadataValue] of Object.entries(validateTimingsEntries.metadata)) {
+      if (metadataKey.startsWith('_')) {
+        // Ignore json "_comments".
+        continue;
+      }
+      if (metadataValue.subcaseMS <= 0) {
+        zeroEntries.push(metadataKey);
+      }
+      if (!validateTimingsEntries.testsFoundInFiles.has(metadataKey)) {
+        staleEntries.push(metadataKey);
+      }
+    }
+    if (zeroEntries.length) {
+      console.warn('WARNING: subcaseMS≤0 found in listing_meta.json (allowed, but try to avoid):');
+      for (const metadataKey of zeroEntries) {
+        console.warn(`  ${metadataKey}`);
+      }
+    }
+    if (staleEntries.length) {
+      console.error('ERROR: Non-existent tests found in listing_meta.json:');
+      for (const metadataKey of staleEntries) {
+        console.error(`  ${metadataKey}`);
+      }
+      failed = true;
+    }
+
+    const missingEntries = [];
+    for (const metadataKey of validateTimingsEntries.testsFoundInFiles) {
+      if (!(metadataKey in validateTimingsEntries.metadata)) {
+        missingEntries.push(metadataKey);
+      }
+    }
+    if (missingEntries.length) {
+      console.error(
+        'ERROR: Tests missing from listing_meta.json. Please add the new tests (set subcaseMS to 0 if you cannot estimate it):'
+      );
+      for (const metadataKey of missingEntries) {
+        console.error(`  ${metadataKey}`);
+        failed = true;
+      }
+    }
+    assert(!failed);
+  }
+
   return entries;
 }
 
diff --git a/src/common/tools/gen_wpt_cts_html.ts b/src/common/tools/gen_wpt_cts_html.ts
index 3a70cd0e912b..e8161304e90f 100644
--- a/src/common/tools/gen_wpt_cts_html.ts
+++ b/src/common/tools/gen_wpt_cts_html.ts
@@ -1,14 +1,34 @@
 import { promises as fs } from 'fs';
+import * as path from 'path';
 
 import { DefaultTestFileLoader } from '../internal/file_loader.js';
-import { TestQueryMultiFile } from '../internal/query/query.js';
+import {
+  TestQueryMultiCase,
+  TestQueryMultiFile,
+  TestQueryMultiTest,
+} from '../internal/query/query.js';
 import { assert } from '../util/util.js';
 
-function printUsageAndExit(rc: number): void {
+function printUsageAndExit(rc: number): never {
   console.error(`\
-Usage:
-  tools/gen_wpt_cts_html OUTPUT_FILE TEMPLATE_FILE [ARGUMENTS_PREFIXES_FILE EXPECTATIONS_FILE EXPECTATIONS_PREFIX [SUITE]]
+Usage (simple, for webgpu:* suite only):
+  tools/gen_wpt_cts_html OUTPUT_FILE TEMPLATE_FILE
   tools/gen_wpt_cts_html out-wpt/cts.https.html templates/cts.https.html
+
+Usage (config file):
+  tools/gen_wpt_cts_html CONFIG_JSON_FILE
+
+where CONFIG_JSON_FILE is a JSON file in the format documented in the code of
+gen_wpt_cts_html.ts. Example:
+  {
+    "suite": "webgpu",
+    "out": "path/to/output/cts.https.html",
+    "template": "path/to/template/cts.https.html",
+    "maxChunkTimeMS": 2000
+  }
+
+Usage (advanced) (deprecated, use config file):
+  tools/gen_wpt_cts_html OUTPUT_FILE TEMPLATE_FILE ARGUMENTS_PREFIXES_FILE EXPECTATIONS_FILE EXPECTATIONS_PREFIX [SUITE]
   tools/gen_wpt_cts_html my/path/to/cts.https.html templates/cts.https.html arguments.txt myexpectations.txt 'path/to/cts.https.html' cts
 
 where arguments.txt is a file containing a list of arguments prefixes to both generate and expect
@@ -28,48 +48,127 @@ and myexpectations.txt is a file containing a list of WPT paths to suppress, e.g
   process.exit(rc);
 }
 
-if (process.argv.length !== 4 && process.argv.length !== 7 && process.argv.length !== 8) {
-  console.error('incorrect number of arguments!');
-  printUsageAndExit(1);
+interface ConfigJSON {
+  /** Test suite to generate from. */
+  suite: string;
+  /** Output filename, relative to JSON file. */
+  out: string;
+  /** Input template filename, relative to JSON file. */
+  template: string;
+  /**
+   * Maximum time for a single WPT "variant" chunk, in milliseconds. Defaults to infinity.
+   *
+   * This data is typically captured by developers on higher-end computers, so typical test
+   * machines might execute more slowly. For this reason, use a time much less than 5 seconds
+   * (a typical default time limit in WPT test executors).
+   */
+  maxChunkTimeMS?: number;
+  /** List of argument prefixes (what comes before the test query). Defaults to `['?q=']`. */
+  argumentsPrefixes?: string[];
+  expectations?: {
+    /** File containing a list of WPT paths to suppress. */
+    file: string;
+    /** The prefix to trim from every line of the expectations_file. */
+    prefix: string;
+  };
+}
+
+interface Config {
+  suite: string;
+  out: string;
+  template: string;
+  maxChunkTimeMS: number;
+  argumentsPrefixes: string[];
+  expectations?: {
+    file: string;
+    prefix: string;
+  };
 }
 
-// prettier-ignore
-const [
-  , // `node` binary
-  , // this script
-  outFile,
-  templateFile,
-  argsPrefixesFile,
-  expectationsFile,
-  expectationsPrefix,
-  suite = 'webgpu',
-] = process.argv;
+let config: Config;
 
 (async () => {
-  let argsPrefixes = ['?q='];
-  let expectationLines = new Set<string>();
+  // Load the config
+  switch (process.argv.length) {
+    case 3: {
+      const configFile = process.argv[2];
+      const configJSON: ConfigJSON = JSON.parse(await fs.readFile(configFile, 'utf8'));
+      const jsonFileDir = path.dirname(configFile);
+
+      config = {
+        suite: configJSON.suite,
+        out: path.resolve(jsonFileDir, configJSON.out),
+        template: path.resolve(jsonFileDir, configJSON.template),
+        maxChunkTimeMS: configJSON.maxChunkTimeMS ?? Infinity,
+        argumentsPrefixes: configJSON.argumentsPrefixes ?? ['?q='],
+      };
+      if (configJSON.expectations) {
+        config.expectations = {
+          file: path.resolve(jsonFileDir, configJSON.expectations.file),
+          prefix: configJSON.expectations.prefix,
+        };
+      }
+      break;
+    }
+    case 4:
+    case 7:
+    case 8: {
+      const [
+        _nodeBinary,
+        _thisScript,
+        outFile,
+        templateFile,
+        argsPrefixesFile,
+        expectationsFile,
+        expectationsPrefix,
+        suite = 'webgpu',
+      ] = process.argv;
+
+      config = {
+        out: outFile,
+        template: templateFile,
+        suite,
+        maxChunkTimeMS: Infinity,
+        argumentsPrefixes: ['?q='],
+      };
+      if (process.argv.length >= 7) {
+        config.argumentsPrefixes = (await fs.readFile(argsPrefixesFile, 'utf8'))
+          .split(/\r?\n/)
+          .filter(a => a.length);
+        config.expectations = {
+          file: expectationsFile,
+          prefix: expectationsPrefix,
+        };
+      }
+      break;
+    }
+    default:
+      console.error('incorrect number of arguments!');
+      printUsageAndExit(1);
+  }
+
+  const useChunking = Number.isFinite(config.maxChunkTimeMS);
 
-  if (process.argv.length >= 7) {
-    // Prefixes sorted from longest to shortest
-    const argsPrefixesFromFile = (await fs.readFile(argsPrefixesFile, 'utf8'))
-      .split(/\r?\n/)
-      .filter(a => a.length)
-      .sort((a, b) => b.length - a.length);
-    if (argsPrefixesFromFile.length) argsPrefixes = argsPrefixesFromFile;
+  // Sort prefixes from longest to shortest
+  config.argumentsPrefixes.sort((a, b) => b.length - a.length);
+
+  // Load expectations (if any)
+  let expectationLines = new Set<string>();
+  if (config.expectations) {
     expectationLines = new Set(
-      (await fs.readFile(expectationsFile, 'utf8')).split(/\r?\n/).filter(l => l.length)
+      (await fs.readFile(config.expectations.file, 'utf8')).split(/\r?\n/).filter(l => l.length)
     );
   }
 
   const expectations: Map<string, string[]> = new Map();
-  for (const prefix of argsPrefixes) {
+  for (const prefix of config.argumentsPrefixes) {
     expectations.set(prefix, []);
   }
 
   expLoop: for (const exp of expectationLines) {
     // Take each expectation for the longest prefix it matches.
-    for (const argsPrefix of argsPrefixes) {
-      const prefix = expectationsPrefix + argsPrefix;
+    for (const argsPrefix of config.argumentsPrefixes) {
+      const prefix = config.expectations!.prefix + argsPrefix;
       if (exp.startsWith(prefix)) {
         expectations.get(argsPrefix)!.push(exp.substring(prefix.length));
         continue expLoop;
@@ -79,26 +178,53 @@ const [
   }
 
   const loader = new DefaultTestFileLoader();
-  const lines: Array<string | undefined> = [];
-  for (const prefix of argsPrefixes) {
-    const rootQuery = new TestQueryMultiFile(suite, []);
-    const tree = await loader.loadTree(rootQuery, expectations.get(prefix));
+  const lines = [];
+  for (const prefix of config.argumentsPrefixes) {
+    const rootQuery = new TestQueryMultiFile(config.suite, []);
+    const tree = await loader.loadTree(rootQuery, {
+      subqueriesToExpand: expectations.get(prefix),
+      maxChunkTime: config.maxChunkTimeMS,
+    });
 
     lines.push(undefined); // output blank line between prefixes
+    const prefixComment = { comment: `Prefix: "${prefix}"` }; // contents will be updated later
+    if (useChunking) lines.push(prefixComment);
+
+    const filesSeen = new Set<string>();
+    const testsSeen = new Set<string>();
+    let variantCount = 0;
+
     const alwaysExpandThroughLevel = 2; // expand to, at minimum, every test.
-    for (const { query } of tree.iterateCollapsedNodes({ alwaysExpandThroughLevel })) {
-      const urlQueryString = prefix + query.toString(); // "?worker=0&q=..."
+    for (const { query, subtreeCounts } of tree.iterateCollapsedNodes({
+      alwaysExpandThroughLevel,
+    })) {
+      assert(query instanceof TestQueryMultiCase);
+      const queryString = query.toString();
       // Check for a safe-ish path length limit. Filename must be <= 255, and on Windows the whole
       // path must be <= 259. Leave room for e.g.:
       // 'c:\b\s\w\xxxxxxxx\layout-test-results\external\wpt\webgpu\cts_worker=0_q=...-actual.txt'
       assert(
-        urlQueryString.length < 185,
-        'Generated test variant would produce too-long -actual.txt filename. \
-Try broadening suppressions to avoid long test variant names. ' +
-          urlQueryString
+        queryString.length < 185,
+        `Generated test variant would produce too-long -actual.txt filename. Possible solutions:
+- Reduce the length of the parts of the test query
+- Reduce the parameterization of the test
+- Make the test function faster and regenerate the listing_meta entry
+- Reduce the specificity of test expectations (if you're using them)
+${queryString}`
+      );
+
+      lines.push({
+        urlQueryString: prefix + query.toString(), // "?worker=0&q=..."
+        comment: useChunking ? `estimated: ${subtreeCounts?.totalTimeMS.toFixed(3)} ms` : undefined,
+      });
+
+      variantCount++;
+      filesSeen.add(new TestQueryMultiTest(query.suite, query.filePathParts, []).toString());
+      testsSeen.add(
+        new TestQueryMultiCase(query.suite, query.filePathParts, query.testPathParts, {}).toString()
       );
-      lines.push(urlQueryString);
     }
+    prefixComment.comment += `; ${variantCount} variants generated from ${testsSeen.size} tests in ${filesSeen.size} files`;
   }
   await generateFile(lines);
 })().catch(ex => {
@@ -106,19 +232,21 @@ Try broadening suppressions to avoid long test variant names. ' +
   process.exit(1);
 });
 
-async function generateFile(lines: Array<string | undefined>): Promise<void> {
+async function generateFile(
+  lines: Array<{ urlQueryString?: string; comment?: string } | undefined>
+): Promise<void> {
   let result = '';
   result += '<!-- AUTO-GENERATED - DO NOT EDIT. See WebGPU CTS: tools/gen_wpt_cts_html. -->\n';
 
-  result += await fs.readFile(templateFile, 'utf8');
+  result += await fs.readFile(config.template, 'utf8');
 
   for (const line of lines) {
-    if (line === undefined) {
-      result += '\n';
-    } else {
-      result += `<meta name=variant content='${line}'>\n`;
+    if (line !== undefined) {
+      if (line.urlQueryString) result += `<meta name=variant content='${line.urlQueryString}'>`;
+      if (line.comment) result += `<!-- ${line.comment} -->`;
     }
+    result += '\n';
   }
 
-  await fs.writeFile(outFile, result);
+  await fs.writeFile(config.out, result);
 }
diff --git a/src/common/tools/merge_listing_times.ts b/src/common/tools/merge_listing_times.ts
new file mode 100644
index 000000000000..0a32b3c520be
--- /dev/null
+++ b/src/common/tools/merge_listing_times.ts
@@ -0,0 +1,177 @@
+import * as fs from 'fs';
+import * as process from 'process';
+import * as readline from 'readline';
+
+import { TestMetadataListing } from '../framework/metadata.js';
+import { parseQuery } from '../internal/query/parseQuery.js';
+import { TestQueryMultiCase, TestQuerySingleCase } from '../internal/query/query.js';
+import { CaseTimingLogLine } from '../internal/test_group.js';
+import { assert } from '../util/util.js';
+
+// For information on listing_meta.json file maintenance, please read
+// tools/merge_listing_times first.
+
+function usage(rc: number): never {
+  console.error(`Usage: tools/merge_listing_times [options] SUITES... -- [TIMING_LOG_FILES...]
+
+Options:
+  --help          Print this message and exit.
+
+Reads raw case timing data for each suite in SUITES, from all TIMING_LOG_FILES
+(see below), and merges it into the src/*/listing_meta.json files checked into
+the repository. The timing data in the listing_meta.json files is updated with
+the newly-observed timing data *if the new timing is slower*. That is, it will
+only increase the values in the listing_meta.json file, and will only cause WPT
+chunks to become smaller.
+
+If there are no TIMING_LOG_FILES, this just regenerates (reformats) the file
+using the data already present.
+
+In more detail:
+
+- Reads per-case timing data in any of the SUITES, from all TIMING_LOG_FILES
+  (ignoring skipped cases), and averages it over the number of subcases.
+  In the case of cases that have run multiple times, takes the max of each.
+- Compiles the average time-per-subcase for each test seen.
+- For each suite seen, loads its listing_meta.json, takes the max of the old and
+  new data, and writes it back out.
+
+How to generate TIMING_LOG_FILES files:
+
+- Launch the 'websocket-logger' tool (see its README.md), which listens for
+  log messages on localhost:59497.
+- Run the tests you want to capture data for, on the same system. Since
+  logging is done through the websocket side-channel, you can run the tests
+  under any runtime (standalone, WPT, etc.) as long as WebSocket support is
+  available (always true in browsers).
+- Run \`tools/merge_listing_times webgpu -- tools/websocket-logger/wslog-*.txt\`
+`);
+  process.exit(rc);
+}
+
+const kHeader = `{
+  "_comment": "SEMI AUTO-GENERATED: Please read tools/merge_listing_times.",
+`;
+const kFooter = `\
+  "_end": ""
+}
+`;
+
+const argv = process.argv;
+if (argv.some(v => v.startsWith('-') && v !== '--') || argv.every(v => v !== '--')) {
+  usage(0);
+}
+const suites = [];
+const timingLogFilenames = [];
+let seenDashDash = false;
+for (const arg of argv.slice(2)) {
+  if (arg === '--') {
+    seenDashDash = true;
+    continue;
+  } else if (arg.startsWith('-')) {
+    usage(0);
+  }
+
+  if (seenDashDash) {
+    timingLogFilenames.push(arg);
+  } else {
+    suites.push(arg);
+  }
+}
+if (!seenDashDash) {
+  usage(0);
+}
+
+void (async () => {
+  // Read the log files to find the log line for each *case* query. If a case
+  // ran multiple times, take the one with the largest average subcase time.
+  const caseTimes = new Map<string, CaseTimingLogLine>();
+  for (const timingLogFilename of timingLogFilenames) {
+    const rl = readline.createInterface({
+      input: fs.createReadStream(timingLogFilename),
+      crlfDelay: Infinity,
+    });
+
+    for await (const line of rl) {
+      const parsed: CaseTimingLogLine = JSON.parse(line);
+
+      const prev = caseTimes.get(parsed.q);
+      if (prev !== undefined) {
+        const timePerSubcase = parsed.timems / Math.max(1, parsed.nonskippedSubcaseCount);
+        const prevTimePerSubcase = prev.timems / Math.max(1, prev.nonskippedSubcaseCount);
+
+        if (timePerSubcase > prevTimePerSubcase) {
+          caseTimes.set(parsed.q, parsed);
+        }
+      } else {
+        caseTimes.set(parsed.q, parsed);
+      }
+    }
+  }
+
+  // Accumulate total times per test. Map of suite -> query -> {totalTimeMS, caseCount}.
+  const testTimes = new Map<string, Map<string, { totalTimeMS: number; subcaseCount: number }>>();
+  for (const suite of suites) {
+    testTimes.set(suite, new Map());
+  }
+  for (const [caseQString, caseTime] of caseTimes) {
+    const caseQ = parseQuery(caseQString);
+    assert(caseQ instanceof TestQuerySingleCase);
+    const suite = caseQ.suite;
+    const suiteTestTimes = testTimes.get(suite);
+    if (suiteTestTimes === undefined) {
+      continue;
+    }
+
+    const testQ = new TestQueryMultiCase(suite, caseQ.filePathParts, caseQ.testPathParts, {});
+    const testQString = testQ.toString();
+
+    const prev = suiteTestTimes.get(testQString);
+    if (prev !== undefined) {
+      prev.totalTimeMS += caseTime.timems;
+      prev.subcaseCount += caseTime.nonskippedSubcaseCount;
+    } else {
+      suiteTestTimes.set(testQString, {
+        totalTimeMS: caseTime.timems,
+        subcaseCount: caseTime.nonskippedSubcaseCount,
+      });
+    }
+  }
+
+  for (const suite of suites) {
+    const currentMetadata: TestMetadataListing = JSON.parse(
+      fs.readFileSync(`./src/${suite}/listing_meta.json`, 'utf8')
+    );
+
+    const metadata = { ...currentMetadata };
+    for (const [testQString, { totalTimeMS, subcaseCount }] of testTimes.get(suite)!) {
+      const avgTime = totalTimeMS / Math.max(1, subcaseCount);
+      if (testQString in metadata) {
+        metadata[testQString].subcaseMS = Math.max(metadata[testQString].subcaseMS, avgTime);
+      } else {
+        metadata[testQString] = { subcaseMS: avgTime };
+      }
+    }
+
+    writeListings(suite, metadata);
+  }
+})();
+
+function writeListings(suite: string, metadata: TestMetadataListing) {
+  const output = fs.createWriteStream(`./src/${suite}/listing_meta.json`);
+  try {
+    output.write(kHeader);
+    const keys = Object.keys(metadata).sort();
+    for (const k of keys) {
+      if (k.startsWith('_')) {
+        // Ignore json "_comments".
+        continue;
+      }
+      assert(k.indexOf('"') === -1);
+      output.write(`  "${k}": { "subcaseMS": ${metadata[k].subcaseMS.toFixed(3)} },\n`);
+    }
+    output.write(kFooter);
+  } finally {
+    output.close();
+  }
+}
diff --git a/src/unittests/loaders_and_trees.spec.ts b/src/unittests/loaders_and_trees.spec.ts
index 080fa762a5fd..c7ff1fa43a84 100644
--- a/src/unittests/loaders_and_trees.spec.ts
+++ b/src/unittests/loaders_and_trees.spec.ts
@@ -699,7 +699,9 @@ async function testIterateCollapsed(
   includeEmptySubtrees = false
 ) {
   t.debug(`expandThrough=${alwaysExpandThroughLevel} expectations=${expectations}`);
-  const treePromise = t.loader.loadTree(new TestQueryMultiFile('suite1', []), expectations);
+  const treePromise = t.loader.loadTree(new TestQueryMultiFile('suite1', []), {
+    subqueriesToExpand: expectations,
+  });
   if (expectedResult === 'throws') {
     t.shouldReject('Error', treePromise, 'loadTree should have thrown Error');
     return;
diff --git a/tools/gen_wpt_cfg_chunked2sec.json b/tools/gen_wpt_cfg_chunked2sec.json
new file mode 100644
index 000000000000..1d13e85c5846
--- /dev/null
+++ b/tools/gen_wpt_cfg_chunked2sec.json
@@ -0,0 +1,6 @@
+{
+  "suite": "webgpu",
+  "out": "../out-wpt/cts-chunked2sec.https.html",
+  "template": "../src/common/templates/cts.https.html",
+  "maxChunkTimeMS": 2000
+}
diff --git a/tools/gen_wpt_cfg_unchunked.json b/tools/gen_wpt_cfg_unchunked.json
new file mode 100644
index 000000000000..ffe06d5633c5
--- /dev/null
+++ b/tools/gen_wpt_cfg_unchunked.json
@@ -0,0 +1,5 @@
+{
+  "suite": "webgpu",
+  "out": "../out-wpt/cts.https.html",
+  "template": "../src/common/templates/cts.https.html"
+}
diff --git a/tools/merge_listing_times b/tools/merge_listing_times
new file mode 100755
index 000000000000..4d33fe69b383
--- /dev/null
+++ b/tools/merge_listing_times
@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+require('../src/common/tools/setup-ts-in-node.js');
+
+// See help message in this file for info on how to use the tool.
+require('../src/common/tools/merge_listing_times.ts');
+
+// ## listing_meta.json File Maintenance ##
+//
+// listing_meta.json files are SEMI AUTO-GENERATED.
+//
+// The raw data may be edited manually, to add entries or change timing values.
+// This is a complete listing of tests in the CTS, which can be used for other
+// scripting purposes too. Presubmit checks will fail when it gets out of sync.
+//
+// The subcaseMS values are estimates. They can be set to 0 if for some reason
+// you can't estimate the time (or there's an existing test with a long name and
+// slow subcases that would result in query strings that are too long).
+//
+// If you're developing new tests and need to update this file, it may be
+// easiest to do so manually. Run your tests in your development environment and
+// see how long they take. Record the average time per *subcase* into the
+// listing_meta.json file.
+//
+// Timing data can also be captured in bulk and "merged" into this file using
+// the 'merge_listing_times' tool. This is useful when a large number of tests
+// change or otherwise a lot of tests need to be updated. It can also be used
+// without any inputs to reformat the listing_meta.json file. Please read the
+// documentation of the tool (see above) for more information.
+//
+// Finally, note this data is typically captured by developers using higher-end
+// computers, so typical test machines might execute more slowly. For this
+// reason, the WPT chunking should be configured to generate chunks much shorter
+// than 5 seconds (a typical default time limit in WPT test executors) so they
+// should still execute in under 5 seconds on lower-end computers.

From 76e56df43e92187f9961679a35b254dc65432235 Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Fri, 8 Sep 2023 00:24:15 -0700
Subject: [PATCH 022/166] Add generated metadata for webgpu:*

---
 src/webgpu/listing_meta.json | 1902 ++++++++++++++++++++++++++++++++++
 1 file changed, 1902 insertions(+)
 create mode 100644 src/webgpu/listing_meta.json

diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
new file mode 100644
index 000000000000..ae925f390019
--- /dev/null
+++ b/src/webgpu/listing_meta.json
@@ -0,0 +1,1902 @@
+{
+  "_comment": "SEMI AUTO-GENERATED: Please read tools/merge_listing_times.",
+  "webgpu:api,operation,adapter,requestAdapter:requestAdapter:*": { "subcaseMS": 152.083 },
+  "webgpu:api,operation,adapter,requestAdapter:requestAdapter_no_parameters:*": { "subcaseMS": 384.601 },
+  "webgpu:api,operation,adapter,requestAdapterInfo:adapter_info:*": { "subcaseMS": 136.601 },
+  "webgpu:api,operation,adapter,requestAdapterInfo:adapter_info_with_hints:*": { "subcaseMS": 0.101 },
+  "webgpu:api,operation,adapter,requestDevice:default:*": { "subcaseMS": 19.450 },
+  "webgpu:api,operation,adapter,requestDevice:features,known:*": { "subcaseMS": 9.637 },
+  "webgpu:api,operation,adapter,requestDevice:features,unknown:*": { "subcaseMS": 13.600 },
+  "webgpu:api,operation,adapter,requestDevice:invalid:*": { "subcaseMS": 27.801 },
+  "webgpu:api,operation,adapter,requestDevice:limit,better_than_supported:*": { "subcaseMS": 3.614 },
+  "webgpu:api,operation,adapter,requestDevice:limit,worse_than_default:*": { "subcaseMS": 6.711 },
+  "webgpu:api,operation,adapter,requestDevice:limits,supported:*": { "subcaseMS": 4.579 },
+  "webgpu:api,operation,adapter,requestDevice:limits,unknown:*": { "subcaseMS": 0.601 },
+  "webgpu:api,operation,adapter,requestDevice:stale:*": { "subcaseMS": 3.590 },
+  "webgpu:api,operation,buffers,map:mapAsync,mapState:*": { "subcaseMS": 6.178 },
+  "webgpu:api,operation,buffers,map:mapAsync,read,typedArrayAccess:*": { "subcaseMS": 10.759 },
+  "webgpu:api,operation,buffers,map:mapAsync,read:*": { "subcaseMS": 8.996 },
+  "webgpu:api,operation,buffers,map:mapAsync,write,unchanged_ranges_preserved:*": { "subcaseMS": 13.050 },
+  "webgpu:api,operation,buffers,map:mapAsync,write:*": { "subcaseMS": 3.944 },
+  "webgpu:api,operation,buffers,map:mappedAtCreation,mapState:*": { "subcaseMS": 4.626 },
+  "webgpu:api,operation,buffers,map:mappedAtCreation:*": { "subcaseMS": 1.039 },
+  "webgpu:api,operation,buffers,map:remapped_for_write:*": { "subcaseMS": 0.930 },
+  "webgpu:api,operation,buffers,map_ArrayBuffer:postMessage:*": { "subcaseMS": 64.775 },
+  "webgpu:api,operation,buffers,map_detach:while_mapped:*": { "subcaseMS": 1.386 },
+  "webgpu:api,operation,buffers,map_oom:mappedAtCreation:*": { "subcaseMS": 0.827 },
+  "webgpu:api,operation,buffers,threading:destroyed:*": { "subcaseMS": 0.700 },
+  "webgpu:api,operation,buffers,threading:serialize:*": { "subcaseMS": 0.900 },
+  "webgpu:api,operation,command_buffer,basic:b2t2b:*": { "subcaseMS": 16.801 },
+  "webgpu:api,operation,command_buffer,basic:b2t2t2b:*": { "subcaseMS": 16.101 },
+  "webgpu:api,operation,command_buffer,basic:empty:*": { "subcaseMS": 14.000 },
+  "webgpu:api,operation,command_buffer,clearBuffer:clear:*": { "subcaseMS": 0.538 },
+  "webgpu:api,operation,command_buffer,copyBufferToBuffer:copy_order:*": { "subcaseMS": 13.401 },
+  "webgpu:api,operation,command_buffer,copyBufferToBuffer:single:*": { "subcaseMS": 0.195 },
+  "webgpu:api,operation,command_buffer,copyBufferToBuffer:state_transitions:*": { "subcaseMS": 19.600 },
+  "webgpu:api,operation,command_buffer,copyTextureToTexture:color_textures,compressed,array:*": { "subcaseMS": 0.382 },
+  "webgpu:api,operation,command_buffer,copyTextureToTexture:color_textures,compressed,non_array:*": { "subcaseMS": 0.281 },
+  "webgpu:api,operation,command_buffer,copyTextureToTexture:color_textures,non_compressed,array:*": { "subcaseMS": 1.607 },
+  "webgpu:api,operation,command_buffer,copyTextureToTexture:color_textures,non_compressed,non_array:*": { "subcaseMS": 0.477 },
+  "webgpu:api,operation,command_buffer,copyTextureToTexture:copy_depth_stencil:*": { "subcaseMS": 0.983 },
+  "webgpu:api,operation,command_buffer,copyTextureToTexture:copy_multisampled_color:*": { "subcaseMS": 21.700 },
+  "webgpu:api,operation,command_buffer,copyTextureToTexture:copy_multisampled_depth:*": { "subcaseMS": 5.901 },
+  "webgpu:api,operation,command_buffer,copyTextureToTexture:zero_sized:*": { "subcaseMS": 0.741 },
+  "webgpu:api,operation,command_buffer,image_copy:mip_levels:*": { "subcaseMS": 1.244 },
+  "webgpu:api,operation,command_buffer,image_copy:offsets_and_sizes:*": { "subcaseMS": 0.960 },
+  "webgpu:api,operation,command_buffer,image_copy:offsets_and_sizes_copy_depth_stencil:*": { "subcaseMS": 1.502 },
+  "webgpu:api,operation,command_buffer,image_copy:origins_and_extents:*": { "subcaseMS": 0.618 },
+  "webgpu:api,operation,command_buffer,image_copy:rowsPerImage_and_bytesPerRow:*": { "subcaseMS": 1.001 },
+  "webgpu:api,operation,command_buffer,image_copy:rowsPerImage_and_bytesPerRow_depth_stencil:*": { "subcaseMS": 1.863 },
+  "webgpu:api,operation,command_buffer,image_copy:undefined_params:*": { "subcaseMS": 3.144 },
+  "webgpu:api,operation,command_buffer,programmable,state_tracking:bind_group_before_pipeline:*": { "subcaseMS": 3.375 },
+  "webgpu:api,operation,command_buffer,programmable,state_tracking:bind_group_indices:*": { "subcaseMS": 2.872 },
+  "webgpu:api,operation,command_buffer,programmable,state_tracking:bind_group_multiple_sets:*": { "subcaseMS": 12.300 },
+  "webgpu:api,operation,command_buffer,programmable,state_tracking:bind_group_order:*": { "subcaseMS": 4.428 },
+  "webgpu:api,operation,command_buffer,programmable,state_tracking:compatible_pipelines:*": { "subcaseMS": 12.334 },
+  "webgpu:api,operation,command_buffer,programmable,state_tracking:one_bind_group_multiple_slots:*": { "subcaseMS": 9.734 },
+  "webgpu:api,operation,command_buffer,queries,occlusionQuery:occlusion_query,alpha_to_coverage:*": { "subcaseMS": 12.125 },
+  "webgpu:api,operation,command_buffer,queries,occlusionQuery:occlusion_query,basic:*": { "subcaseMS": 13.125 },
+  "webgpu:api,operation,command_buffer,queries,occlusionQuery:occlusion_query,depth:*": { "subcaseMS": 14.407 },
+  "webgpu:api,operation,command_buffer,queries,occlusionQuery:occlusion_query,empty:*": { "subcaseMS": 16.801 },
+  "webgpu:api,operation,command_buffer,queries,occlusionQuery:occlusion_query,initial:*": { "subcaseMS": 40.000 },
+  "webgpu:api,operation,command_buffer,queries,occlusionQuery:occlusion_query,multi_resolve:*": { "subcaseMS": 15.900 },
+  "webgpu:api,operation,command_buffer,queries,occlusionQuery:occlusion_query,sample_mask:*": { "subcaseMS": 13.352 },
+  "webgpu:api,operation,command_buffer,queries,occlusionQuery:occlusion_query,scissor:*": { "subcaseMS": 13.138 },
+  "webgpu:api,operation,command_buffer,queries,occlusionQuery:occlusion_query,stencil:*": { "subcaseMS": 10.300 },
+  "webgpu:api,operation,command_buffer,render,state_tracking:change_pipeline_before_and_after_vertex_buffer:*": { "subcaseMS": 14.900 },
+  "webgpu:api,operation,command_buffer,render,state_tracking:set_index_buffer_before_non_indexed_draw:*": { "subcaseMS": 16.301 },
+  "webgpu:api,operation,command_buffer,render,state_tracking:set_index_buffer_without_changing_buffer:*": { "subcaseMS": 16.601 },
+  "webgpu:api,operation,command_buffer,render,state_tracking:set_vertex_buffer_but_not_used_in_draw:*": { "subcaseMS": 17.300 },
+  "webgpu:api,operation,command_buffer,render,state_tracking:set_vertex_buffer_without_changing_buffer:*": { "subcaseMS": 16.400 },
+  "webgpu:api,operation,compute,basic:large_dispatch:*": { "subcaseMS": 9.237 },
+  "webgpu:api,operation,compute,basic:memcpy:*": { "subcaseMS": 16.901 },
+  "webgpu:api,operation,compute_pipeline,overrides:basic:*": { "subcaseMS": 15.100 },
+  "webgpu:api,operation,compute_pipeline,overrides:multi_entry_points:*": { "subcaseMS": 15.900 },
+  "webgpu:api,operation,compute_pipeline,overrides:numeric_id:*": { "subcaseMS": 14.300 },
+  "webgpu:api,operation,compute_pipeline,overrides:precision:*": { "subcaseMS": 16.151 },
+  "webgpu:api,operation,compute_pipeline,overrides:shared_shader_module:*": { "subcaseMS": 14.951 },
+  "webgpu:api,operation,compute_pipeline,overrides:workgroup_size:*": { "subcaseMS": 13.184 },
+  "webgpu:api,operation,device,lost:lost_on_destroy:*": { "subcaseMS": 37.500 },
+  "webgpu:api,operation,device,lost:not_lost_on_gc:*": { "subcaseMS": 2066.500 },
+  "webgpu:api,operation,device,lost:same_object:*": { "subcaseMS": 16.601 },
+  "webgpu:api,operation,labels:object_has_descriptor_label:*": { "subcaseMS": 1.942 },
+  "webgpu:api,operation,labels:wrappers_do_not_share_labels:*": { "subcaseMS": 13.701 },
+  "webgpu:api,operation,memory_sync,buffer,multiple_buffers:multiple_pairs_of_dispatches_in_one_compute_pass:*": { "subcaseMS": 28.701 },
+  "webgpu:api,operation,memory_sync,buffer,multiple_buffers:multiple_pairs_of_draws_in_one_render_bundle:*": { "subcaseMS": 30.200 },
+  "webgpu:api,operation,memory_sync,buffer,multiple_buffers:multiple_pairs_of_draws_in_one_render_pass:*": { "subcaseMS": 11.900 },
+  "webgpu:api,operation,memory_sync,buffer,multiple_buffers:rw:*": { "subcaseMS": 30.427 },
+  "webgpu:api,operation,memory_sync,buffer,multiple_buffers:wr:*": { "subcaseMS": 30.007 },
+  "webgpu:api,operation,memory_sync,buffer,multiple_buffers:ww:*": { "subcaseMS": 25.575 },
+  "webgpu:api,operation,memory_sync,buffer,single_buffer:rw:*": { "subcaseMS": 18.337 },
+  "webgpu:api,operation,memory_sync,buffer,single_buffer:two_dispatches_in_the_same_compute_pass:*": { "subcaseMS": 17.500 },
+  "webgpu:api,operation,memory_sync,buffer,single_buffer:two_draws_in_the_same_render_bundle:*": { "subcaseMS": 18.100 },
+  "webgpu:api,operation,memory_sync,buffer,single_buffer:two_draws_in_the_same_render_pass:*": { "subcaseMS": 4.925 },
+  "webgpu:api,operation,memory_sync,buffer,single_buffer:wr:*": { "subcaseMS": 18.296 },
+  "webgpu:api,operation,memory_sync,buffer,single_buffer:ww:*": { "subcaseMS": 18.802 },
+  "webgpu:api,operation,memory_sync,texture,same_subresource:rw,single_pass,load_resolve:*": { "subcaseMS": 1.200 },
+  "webgpu:api,operation,memory_sync,texture,same_subresource:rw,single_pass,load_store:*": { "subcaseMS": 14.200 },
+  "webgpu:api,operation,memory_sync,texture,same_subresource:rw:*": { "subcaseMS": 10.908 },
+  "webgpu:api,operation,memory_sync,texture,same_subresource:wr:*": { "subcaseMS": 10.684 },
+  "webgpu:api,operation,memory_sync,texture,same_subresource:ww:*": { "subcaseMS": 11.198 },
+  "webgpu:api,operation,onSubmittedWorkDone:many,parallel:*": { "subcaseMS": 111.601 },
+  "webgpu:api,operation,onSubmittedWorkDone:many,parallel_order:*": { "subcaseMS": 33.000 },
+  "webgpu:api,operation,onSubmittedWorkDone:many,serial:*": { "subcaseMS": 254.400 },
+  "webgpu:api,operation,onSubmittedWorkDone:with_work:*": { "subcaseMS": 12.400 },
+  "webgpu:api,operation,onSubmittedWorkDone:without_work:*": { "subcaseMS": 10.901 },
+  "webgpu:api,operation,pipeline,default_layout:getBindGroupLayout_js_object:*": { "subcaseMS": 1.300 },
+  "webgpu:api,operation,pipeline,default_layout:incompatible_with_explicit:*": { "subcaseMS": 1.101 },
+  "webgpu:api,operation,pipeline,default_layout:layout:*": { "subcaseMS": 11.500 },
+  "webgpu:api,operation,queue,writeBuffer:array_types:*": { "subcaseMS": 12.032 },
+  "webgpu:api,operation,queue,writeBuffer:multiple_writes_at_different_offsets_and_sizes:*": { "subcaseMS": 2.087 },
+  "webgpu:api,operation,reflection:buffer_reflection_attributes:*": { "subcaseMS": 0.800 },
+  "webgpu:api,operation,reflection:query_set_reflection_attributes:*": { "subcaseMS": 0.634 },
+  "webgpu:api,operation,reflection:texture_reflection_attributes:*": { "subcaseMS": 1.829 },
+  "webgpu:api,operation,render_pass,clear_value:layout:*": { "subcaseMS": 1.401 },
+  "webgpu:api,operation,render_pass,clear_value:loaded:*": { "subcaseMS": 14.300 },
+  "webgpu:api,operation,render_pass,clear_value:srgb:*": { "subcaseMS": 5.601 },
+  "webgpu:api,operation,render_pass,clear_value:stencil_clear_value:*": { "subcaseMS": 12.660 },
+  "webgpu:api,operation,render_pass,clear_value:stored:*": { "subcaseMS": 12.100 },
+  "webgpu:api,operation,render_pass,resolve:render_pass_resolve:*": { "subcaseMS": 1.029 },
+  "webgpu:api,operation,render_pass,storeOp:render_pass_store_op,color_attachment_only:*": { "subcaseMS": 3.607 },
+  "webgpu:api,operation,render_pass,storeOp:render_pass_store_op,color_attachment_with_depth_stencil_attachment:*": { "subcaseMS": 10.125 },
+  "webgpu:api,operation,render_pass,storeOp:render_pass_store_op,depth_stencil_attachment_only:*": { "subcaseMS": 3.754 },
+  "webgpu:api,operation,render_pass,storeOp:render_pass_store_op,multiple_color_attachments:*": { "subcaseMS": 4.263 },
+  "webgpu:api,operation,render_pass,storeop2:storeOp_controls_whether_1x1_drawn_quad_is_stored:*": { "subcaseMS": 17.500 },
+  "webgpu:api,operation,render_pipeline,culling_tests:culling:*": { "subcaseMS": 2.346 },
+  "webgpu:api,operation,render_pipeline,overrides:basic:*": { "subcaseMS": 3.075 },
+  "webgpu:api,operation,render_pipeline,overrides:multi_entry_points:*": { "subcaseMS": 5.400 },
+  "webgpu:api,operation,render_pipeline,overrides:precision:*": { "subcaseMS": 7.675 },
+  "webgpu:api,operation,render_pipeline,overrides:shared_shader_module:*": { "subcaseMS": 5.683 },
+  "webgpu:api,operation,render_pipeline,pipeline_output_targets:color,attachments:*": { "subcaseMS": 1.984 },
+  "webgpu:api,operation,render_pipeline,pipeline_output_targets:color,component_count,blend:*": { "subcaseMS": 1.731 },
+  "webgpu:api,operation,render_pipeline,pipeline_output_targets:color,component_count:*": { "subcaseMS": 6.284 },
+  "webgpu:api,operation,render_pipeline,primitive_topology:basic:*": { "subcaseMS": 11.822 },
+  "webgpu:api,operation,render_pipeline,primitive_topology:unaligned_vertex_count:*": { "subcaseMS": 10.851 },
+  "webgpu:api,operation,render_pipeline,sample_mask:alpha_to_coverage_mask:*": { "subcaseMS": 68.512 },
+  "webgpu:api,operation,render_pipeline,sample_mask:fragment_output_mask:*": { "subcaseMS": 6.154 },
+  "webgpu:api,operation,render_pipeline,vertex_only_render_pipeline:draw_depth_and_stencil_with_vertex_only_pipeline:*": { "subcaseMS": 14.100 },
+  "webgpu:api,operation,rendering,basic:clear:*": { "subcaseMS": 3.700 },
+  "webgpu:api,operation,rendering,basic:fullscreen_quad:*": { "subcaseMS": 16.601 },
+  "webgpu:api,operation,rendering,basic:large_draw:*": { "subcaseMS": 2335.425 },
+  "webgpu:api,operation,rendering,color_target_state:blend_constant,initial:*": { "subcaseMS": 33.901 },
+  "webgpu:api,operation,rendering,color_target_state:blend_constant,not_inherited:*": { "subcaseMS": 41.601 },
+  "webgpu:api,operation,rendering,color_target_state:blend_constant,setting:*": { "subcaseMS": 12.434 },
+  "webgpu:api,operation,rendering,color_target_state:blending,GPUBlendComponent:*": { "subcaseMS": 6.454 },
+  "webgpu:api,operation,rendering,color_target_state:blending,clamping:*": { "subcaseMS": 22.669 },
+  "webgpu:api,operation,rendering,color_target_state:blending,formats:*": { "subcaseMS": 10.350 },
+  "webgpu:api,operation,rendering,color_target_state:color_write_mask,blending_disabled:*": { "subcaseMS": 11.450 },
+  "webgpu:api,operation,rendering,color_target_state:color_write_mask,channel_work:*": { "subcaseMS": 24.850 },
+  "webgpu:api,operation,rendering,depth:depth_compare_func:*": { "subcaseMS": 10.123 },
+  "webgpu:api,operation,rendering,depth:depth_disabled:*": { "subcaseMS": 19.801 },
+  "webgpu:api,operation,rendering,depth:depth_test_fail:*": { "subcaseMS": 13.434 },
+  "webgpu:api,operation,rendering,depth:depth_write_disabled:*": { "subcaseMS": 13.050 },
+  "webgpu:api,operation,rendering,depth:reverse_depth:*": { "subcaseMS": 14.100 },
+  "webgpu:api,operation,rendering,depth_bias:depth_bias:*": { "subcaseMS": 12.386 },
+  "webgpu:api,operation,rendering,depth_bias:depth_bias_24bit_format:*": { "subcaseMS": 9.934 },
+  "webgpu:api,operation,rendering,depth_clip_clamp:depth_clamp_and_clip:*": { "subcaseMS": 13.807 },
+  "webgpu:api,operation,rendering,depth_clip_clamp:depth_test_input_clamped:*": { "subcaseMS": 13.005 },
+  "webgpu:api,operation,rendering,draw:arguments:*": { "subcaseMS": 11.174 },
+  "webgpu:api,operation,rendering,draw:default_arguments:*": { "subcaseMS": 4.446 },
+  "webgpu:api,operation,rendering,draw:largeish_buffer:*": { "subcaseMS": 0.601 },
+  "webgpu:api,operation,rendering,draw:vertex_attributes,basic:*": { "subcaseMS": 21.049 },
+  "webgpu:api,operation,rendering,draw:vertex_attributes,formats:*": { "subcaseMS": 0.901 },
+  "webgpu:api,operation,rendering,indirect_draw:basics:*": { "subcaseMS": 2.138 },
+  "webgpu:api,operation,rendering,stencil:stencil_compare_func:*": { "subcaseMS": 10.328 },
+  "webgpu:api,operation,rendering,stencil:stencil_depthFailOp_operation:*": { "subcaseMS": 10.323 },
+  "webgpu:api,operation,rendering,stencil:stencil_failOp_operation:*": { "subcaseMS": 11.108 },
+  "webgpu:api,operation,rendering,stencil:stencil_passOp_operation:*": { "subcaseMS": 11.123 },
+  "webgpu:api,operation,rendering,stencil:stencil_read_write_mask:*": { "subcaseMS": 11.492 },
+  "webgpu:api,operation,rendering,stencil:stencil_reference_initialized:*": { "subcaseMS": 13.234 },
+  "webgpu:api,operation,resource_init,buffer:copy_buffer_to_buffer_copy_source:*": { "subcaseMS": 15.500 },
+  "webgpu:api,operation,resource_init,buffer:copy_buffer_to_texture:*": { "subcaseMS": 8.350 },
+  "webgpu:api,operation,resource_init,buffer:copy_texture_to_partial_buffer:*": { "subcaseMS": 0.960 },
+  "webgpu:api,operation,resource_init,buffer:index_buffer:*": { "subcaseMS": 7.950 },
+  "webgpu:api,operation,resource_init,buffer:indirect_buffer_for_dispatch_indirect:*": { "subcaseMS": 8.850 },
+  "webgpu:api,operation,resource_init,buffer:indirect_buffer_for_draw_indirect:*": { "subcaseMS": 7.050 },
+  "webgpu:api,operation,resource_init,buffer:map_partial_buffer:*": { "subcaseMS": 5.250 },
+  "webgpu:api,operation,resource_init,buffer:map_whole_buffer:*": { "subcaseMS": 15.550 },
+  "webgpu:api,operation,resource_init,buffer:mapped_at_creation_partial_buffer:*": { "subcaseMS": 3.300 },
+  "webgpu:api,operation,resource_init,buffer:mapped_at_creation_whole_buffer:*": { "subcaseMS": 6.467 },
+  "webgpu:api,operation,resource_init,buffer:partial_write_buffer:*": { "subcaseMS": 5.167 },
+  "webgpu:api,operation,resource_init,buffer:readonly_storage_buffer:*": { "subcaseMS": 8.100 },
+  "webgpu:api,operation,resource_init,buffer:resolve_query_set_to_partial_buffer:*": { "subcaseMS": 6.401 },
+  "webgpu:api,operation,resource_init,buffer:storage_buffer:*": { "subcaseMS": 8.750 },
+  "webgpu:api,operation,resource_init,buffer:uniform_buffer:*": { "subcaseMS": 7.250 },
+  "webgpu:api,operation,resource_init,buffer:vertex_buffer:*": { "subcaseMS": 17.100 },
+  "webgpu:api,operation,resource_init,texture_zero:uninitialized_texture_is_zero:*": { "subcaseMS": 3.578 },
+  "webgpu:api,operation,sampling,anisotropy:anisotropic_filter_checkerboard:*": { "subcaseMS": 24.900 },
+  "webgpu:api,operation,sampling,anisotropy:anisotropic_filter_mipmap_color:*": { "subcaseMS": 11.550 },
+  "webgpu:api,operation,sampling,filter_mode:magFilter,linear:*": { "subcaseMS": 1.138 },
+  "webgpu:api,operation,sampling,filter_mode:magFilter,nearest:*": { "subcaseMS": 1.283 },
+  "webgpu:api,operation,sampling,filter_mode:minFilter,linear:*": { "subcaseMS": 1.146 },
+  "webgpu:api,operation,sampling,filter_mode:minFilter,nearest:*": { "subcaseMS": 1.057 },
+  "webgpu:api,operation,sampling,filter_mode:mipmapFilter:*": { "subcaseMS": 3.445 },
+  "webgpu:api,operation,shader_module,compilation_info:getCompilationInfo_returns:*": { "subcaseMS": 0.284 },
+  "webgpu:api,operation,shader_module,compilation_info:line_number_and_position:*": { "subcaseMS": 1.867 },
+  "webgpu:api,operation,shader_module,compilation_info:offset_and_length:*": { "subcaseMS": 1.648 },
+  "webgpu:api,operation,texture_view,format_reinterpretation:render_and_resolve_attachment:*": { "subcaseMS": 14.488 },
+  "webgpu:api,operation,texture_view,format_reinterpretation:texture_binding:*": { "subcaseMS": 17.225 },
+  "webgpu:api,operation,texture_view,read:aspect:*": { "subcaseMS": 0.601 },
+  "webgpu:api,operation,texture_view,read:dimension:*": { "subcaseMS": 0.701 },
+  "webgpu:api,operation,texture_view,read:format:*": { "subcaseMS": 1.100 },
+  "webgpu:api,operation,texture_view,write:aspect:*": { "subcaseMS": 0.700 },
+  "webgpu:api,operation,texture_view,write:dimension:*": { "subcaseMS": 0.601 },
+  "webgpu:api,operation,texture_view,write:format:*": { "subcaseMS": 0.600 },
+  "webgpu:api,operation,uncapturederror:constructor:*": { "subcaseMS": 0.200 },
+  "webgpu:api,operation,uncapturederror:iff_uncaptured:*": { "subcaseMS": 0.101 },
+  "webgpu:api,operation,uncapturederror:only_original_device_is_event_target:*": { "subcaseMS": 0.101 },
+  "webgpu:api,operation,uncapturederror:uncapturederror_from_non_originating_thread:*": { "subcaseMS": 0.201 },
+  "webgpu:api,operation,vertex_state,correctness:array_stride_zero:*": { "subcaseMS": 4.246 },
+  "webgpu:api,operation,vertex_state,correctness:buffers_with_varying_step_mode:*": { "subcaseMS": 6.100 },
+  "webgpu:api,operation,vertex_state,correctness:discontiguous_location_and_attribs:*": { "subcaseMS": 15.100 },
+  "webgpu:api,operation,vertex_state,correctness:max_buffers_and_attribs:*": { "subcaseMS": 18.577 },
+  "webgpu:api,operation,vertex_state,correctness:non_zero_array_stride_and_attribute_offset:*": { "subcaseMS": 3.816 },
+  "webgpu:api,operation,vertex_state,correctness:overlapping_attributes:*": { "subcaseMS": 17.470 },
+  "webgpu:api,operation,vertex_state,correctness:setVertexBuffer_offset_and_attribute_offset:*": { "subcaseMS": 2.848 },
+  "webgpu:api,operation,vertex_state,correctness:vertex_buffer_used_multiple_times_interleaved:*": { "subcaseMS": 5.398 },
+  "webgpu:api,operation,vertex_state,correctness:vertex_buffer_used_multiple_times_overlapped:*": { "subcaseMS": 5.388 },
+  "webgpu:api,operation,vertex_state,correctness:vertex_format_to_shader_format_conversion:*": { "subcaseMS": 3.697 },
+  "webgpu:api,operation,vertex_state,index_format:index_format,change_pipeline_after_setIndexBuffer:*": { "subcaseMS": 12.550 },
+  "webgpu:api,operation,vertex_state,index_format:index_format,setIndexBuffer_before_setPipeline:*": { "subcaseMS": 13.300 },
+  "webgpu:api,operation,vertex_state,index_format:index_format,setIndexBuffer_different_formats:*": { "subcaseMS": 12.601 },
+  "webgpu:api,operation,vertex_state,index_format:index_format,uint16:*": { "subcaseMS": 5.300 },
+  "webgpu:api,operation,vertex_state,index_format:index_format,uint32:*": { "subcaseMS": 5.900 },
+  "webgpu:api,operation,vertex_state,index_format:primitive_restart:*": { "subcaseMS": 12.080 },
+  "webgpu:api,validation,buffer,create:createBuffer_invalid_and_oom:*": { "subcaseMS": 1.500 },
+  "webgpu:api,validation,buffer,create:limit:*": { "subcaseMS": 31.433 },
+  "webgpu:api,validation,buffer,create:size:*": { "subcaseMS": 5.570 },
+  "webgpu:api,validation,buffer,create:usage:*": { "subcaseMS": 3.971 },
+  "webgpu:api,validation,buffer,destroy:all_usages:*": { "subcaseMS": 3.250 },
+  "webgpu:api,validation,buffer,destroy:error_buffer:*": { "subcaseMS": 29.700 },
+  "webgpu:api,validation,buffer,destroy:twice:*": { "subcaseMS": 5.367 },
+  "webgpu:api,validation,buffer,destroy:while_mapped:*": { "subcaseMS": 1.150 },
+  "webgpu:api,validation,buffer,mapping:gc_behavior,mapAsync:*": { "subcaseMS": 32.200 },
+  "webgpu:api,validation,buffer,mapping:gc_behavior,mappedAtCreation:*": { "subcaseMS": 76.200 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,disjoinRanges_many:*": { "subcaseMS": 73.700 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,disjointRanges:*": { "subcaseMS": 2.257 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,offsetAndSizeAlignment,mapped:*": { "subcaseMS": 3.119 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,offsetAndSizeAlignment,mappedAtCreation:*": { "subcaseMS": 5.611 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,sizeAndOffsetOOB,mapped:*": { "subcaseMS": 0.886 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,sizeAndOffsetOOB,mappedAtCreation:*": { "subcaseMS": 4.415 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,state,destroyed:*": { "subcaseMS": 61.301 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,state,invalid_mappedAtCreation:*": { "subcaseMS": 12.401 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,state,mapped:*": { "subcaseMS": 8.200 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,state,mappedAgain:*": { "subcaseMS": 8.150 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,state,mappedAtCreation:*": { "subcaseMS": 2.960 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,state,mappingPending:*": { "subcaseMS": 28.600 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,state,unmapped:*": { "subcaseMS": 16.000 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,subrange,mapped:*": { "subcaseMS": 63.150 },
+  "webgpu:api,validation,buffer,mapping:getMappedRange,subrange,mappedAtCreation:*": { "subcaseMS": 1.500 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,abort_over_invalid_error:*": { "subcaseMS": 3.725 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,earlyRejection:*": { "subcaseMS": 12.900 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,invalidBuffer:*": { "subcaseMS": 18.000 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,offsetAndSizeAlignment:*": { "subcaseMS": 1.794 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,offsetAndSizeOOB:*": { "subcaseMS": 0.953 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,sizeUnspecifiedOOB:*": { "subcaseMS": 2.212 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,state,destroyed:*": { "subcaseMS": 15.450 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,state,mapped:*": { "subcaseMS": 16.050 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,state,mappedAtCreation:*": { "subcaseMS": 15.900 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,state,mappingPending:*": { "subcaseMS": 16.700 },
+  "webgpu:api,validation,buffer,mapping:mapAsync,usage:*": { "subcaseMS": 1.203 },
+  "webgpu:api,validation,buffer,mapping:unmap,state,destroyed:*": { "subcaseMS": 12.701 },
+  "webgpu:api,validation,buffer,mapping:unmap,state,mapped:*": { "subcaseMS": 9.600 },
+  "webgpu:api,validation,buffer,mapping:unmap,state,mappedAtCreation:*": { "subcaseMS": 8.950 },
+  "webgpu:api,validation,buffer,mapping:unmap,state,mappingPending:*": { "subcaseMS": 22.951 },
+  "webgpu:api,validation,buffer,mapping:unmap,state,unmapped:*": { "subcaseMS": 74.200 },
+  "webgpu:api,validation,capability_checks,features,query_types:createQuerySet:*": { "subcaseMS": 10.451 },
+  "webgpu:api,validation,capability_checks,features,query_types:writeTimestamp:*": { "subcaseMS": 1.200 },
+  "webgpu:api,validation,capability_checks,features,texture_formats:canvas_configuration:*": { "subcaseMS": 4.339 },
+  "webgpu:api,validation,capability_checks,features,texture_formats:canvas_configuration_view_formats:*": { "subcaseMS": 4.522 },
+  "webgpu:api,validation,capability_checks,features,texture_formats:depth_stencil_state:*": { "subcaseMS": 15.701 },
+  "webgpu:api,validation,capability_checks,features,texture_formats:render_bundle_encoder_descriptor_depth_stencil_format:*": { "subcaseMS": 0.800 },
+  "webgpu:api,validation,capability_checks,features,texture_formats:texture_descriptor:*": { "subcaseMS": 3.830 },
+  "webgpu:api,validation,capability_checks,features,texture_formats:texture_descriptor_view_formats:*": { "subcaseMS": 5.734 },
+  "webgpu:api,validation,capability_checks,features,texture_formats:texture_view_descriptor:*": { "subcaseMS": 4.113 },
+  "webgpu:api,validation,capability_checks,limits,maxBindGroups:createPipeline,at_over:*": { "subcaseMS": 10.990 },
+  "webgpu:api,validation,capability_checks,limits,maxBindGroups:createPipelineLayout,at_over:*": { "subcaseMS": 9.310 },
+  "webgpu:api,validation,capability_checks,limits,maxBindGroups:setBindGroup,at_over:*": { "subcaseMS": 9.984 },
+  "webgpu:api,validation,capability_checks,limits,maxBindingsPerBindGroup:createBindGroupLayout,at_over:*": { "subcaseMS": 12.441 },
+  "webgpu:api,validation,capability_checks,limits,maxBindingsPerBindGroup:createPipeline,at_over:*": { "subcaseMS": 11.179 },
+  "webgpu:api,validation,capability_checks,limits,maxBindingsPerBindGroup:validate:*": { "subcaseMS": 12.401 },
+  "webgpu:api,validation,capability_checks,limits,maxBufferSize:createBuffer,at_over:*": { "subcaseMS": 146.130 },
+  "webgpu:api,validation,capability_checks,limits,maxColorAttachmentBytesPerSample:beginRenderPass,at_over:*": { "subcaseMS": 9.396 },
+  "webgpu:api,validation,capability_checks,limits,maxColorAttachmentBytesPerSample:createRenderBundle,at_over:*": { "subcaseMS": 12.093 },
+  "webgpu:api,validation,capability_checks,limits,maxColorAttachmentBytesPerSample:createRenderPipeline,at_over:*": { "subcaseMS": 11.818 },
+  "webgpu:api,validation,capability_checks,limits,maxColorAttachments:beginRenderPass,at_over:*": { "subcaseMS": 10.320 },
+  "webgpu:api,validation,capability_checks,limits,maxColorAttachments:createRenderBundle,at_over:*": { "subcaseMS": 12.681 },
+  "webgpu:api,validation,capability_checks,limits,maxColorAttachments:createRenderPipeline,at_over:*": { "subcaseMS": 10.450 },
+  "webgpu:api,validation,capability_checks,limits,maxColorAttachments:validate,maxColorAttachmentBytesPerSample:*": { "subcaseMS": 1.101 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeInvocationsPerWorkgroup:createComputePipeline,at_over:*": { "subcaseMS": 13.735 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeX:createComputePipeline,at_over:*": { "subcaseMS": 14.465 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeY:createComputePipeline,at_over:*": { "subcaseMS": 14.131 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeZ:createComputePipeline,at_over:*": { "subcaseMS": 14.920 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupStorageSize:createComputePipeline,at_over:*": { "subcaseMS": 12.009 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupsPerDimension:dispatchWorkgroups,at_over:*": { "subcaseMS": 13.310 },
+  "webgpu:api,validation,capability_checks,limits,maxDynamicStorageBuffersPerPipelineLayout:createBindGroupLayout,at_over:*": { "subcaseMS": 15.680 },
+  "webgpu:api,validation,capability_checks,limits,maxDynamicUniformBuffersPerPipelineLayout:createBindGroupLayout,at_over:*": { "subcaseMS": 10.268 },
+  "webgpu:api,validation,capability_checks,limits,maxInterStageShaderComponents:createRenderPipeline,at_over:*": { "subcaseMS": 12.916 },
+  "webgpu:api,validation,capability_checks,limits,maxInterStageShaderVariables:createRenderPipeline,at_over:*": { "subcaseMS": 13.700 },
+  "webgpu:api,validation,capability_checks,limits,maxSampledTexturesPerShaderStage:createBindGroupLayout,at_over:*": { "subcaseMS": 47.857 },
+  "webgpu:api,validation,capability_checks,limits,maxSampledTexturesPerShaderStage:createPipeline,at_over:*": { "subcaseMS": 45.611 },
+  "webgpu:api,validation,capability_checks,limits,maxSampledTexturesPerShaderStage:createPipelineLayout,at_over:*": { "subcaseMS": 26.153 },
+  "webgpu:api,validation,capability_checks,limits,maxSamplersPerShaderStage:createBindGroupLayout,at_over:*": { "subcaseMS": 9.645 },
+  "webgpu:api,validation,capability_checks,limits,maxSamplersPerShaderStage:createPipeline,at_over:*": { "subcaseMS": 11.959 },
+  "webgpu:api,validation,capability_checks,limits,maxSamplersPerShaderStage:createPipelineLayout,at_over:*": { "subcaseMS": 10.427 },
+  "webgpu:api,validation,capability_checks,limits,maxStorageBufferBindingSize:createBindGroup,at_over:*": { "subcaseMS": 51.810 },
+  "webgpu:api,validation,capability_checks,limits,maxStorageBufferBindingSize:validate,maxBufferSize:*": { "subcaseMS": 0.900 },
+  "webgpu:api,validation,capability_checks,limits,maxStorageBuffersPerShaderStage:createBindGroupLayout,at_over:*": { "subcaseMS": 4.565 },
+  "webgpu:api,validation,capability_checks,limits,maxStorageBuffersPerShaderStage:createPipeline,at_over:*": { "subcaseMS": 7.884 },
+  "webgpu:api,validation,capability_checks,limits,maxStorageBuffersPerShaderStage:createPipelineLayout,at_over:*": { "subcaseMS": 5.007 },
+  "webgpu:api,validation,capability_checks,limits,maxStorageTexturesPerShaderStage:createBindGroupLayout,at_over:*": { "subcaseMS": 5.147 },
+  "webgpu:api,validation,capability_checks,limits,maxStorageTexturesPerShaderStage:createPipeline,at_over:*": { "subcaseMS": 6.804 },
+  "webgpu:api,validation,capability_checks,limits,maxStorageTexturesPerShaderStage:createPipelineLayout,at_over:*": { "subcaseMS": 5.457 },
+  "webgpu:api,validation,capability_checks,limits,maxTextureArrayLayers:createTexture,at_over:*": { "subcaseMS": 13.651 },
+  "webgpu:api,validation,capability_checks,limits,maxTextureDimension1D:createTexture,at_over:*": { "subcaseMS": 23.431 },
+  "webgpu:api,validation,capability_checks,limits,maxTextureDimension2D:configure,at_over:*": { "subcaseMS": 8.280 },
+  "webgpu:api,validation,capability_checks,limits,maxTextureDimension2D:createTexture,at_over:*": { "subcaseMS": 8.981 },
+  "webgpu:api,validation,capability_checks,limits,maxTextureDimension2D:getCurrentTexture,at_over:*": { "subcaseMS": 21.886 },
+  "webgpu:api,validation,capability_checks,limits,maxTextureDimension3D:createTexture,at_over:*": { "subcaseMS": 9.410 },
+  "webgpu:api,validation,capability_checks,limits,maxUniformBufferBindingSize:createBindGroup,at_over:*": { "subcaseMS": 6.785 },
+  "webgpu:api,validation,capability_checks,limits,maxUniformBufferBindingSize:validate,maxBufferSize:*": { "subcaseMS": 1.700 },
+  "webgpu:api,validation,capability_checks,limits,maxUniformBuffersPerShaderStage:createBindGroupLayout,at_over:*": { "subcaseMS": 5.858 },
+  "webgpu:api,validation,capability_checks,limits,maxUniformBuffersPerShaderStage:createPipeline,at_over:*": { "subcaseMS": 9.105 },
+  "webgpu:api,validation,capability_checks,limits,maxUniformBuffersPerShaderStage:createPipelineLayout,at_over:*": { "subcaseMS": 6.109 },
+  "webgpu:api,validation,capability_checks,limits,maxVertexAttributes:createRenderPipeline,at_over:*": { "subcaseMS": 9.090 },
+  "webgpu:api,validation,capability_checks,limits,maxVertexBufferArrayStride:createRenderPipeline,at_over:*": { "subcaseMS": 10.060 },
+  "webgpu:api,validation,capability_checks,limits,maxVertexBuffers:createRenderPipeline,at_over:*": { "subcaseMS": 8.903 },
+  "webgpu:api,validation,capability_checks,limits,maxVertexBuffers:setVertexBuffer,at_over:*": { "subcaseMS": 7.695 },
+  "webgpu:api,validation,capability_checks,limits,minStorageBufferOffsetAlignment:createBindGroup,at_over:*": { "subcaseMS": 9.650 },
+  "webgpu:api,validation,capability_checks,limits,minStorageBufferOffsetAlignment:setBindGroup,at_over:*": { "subcaseMS": 8.931 },
+  "webgpu:api,validation,capability_checks,limits,minStorageBufferOffsetAlignment:validate,greaterThanOrEqualTo32:*": { "subcaseMS": 31.801 },
+  "webgpu:api,validation,capability_checks,limits,minStorageBufferOffsetAlignment:validate,powerOf2:*": { "subcaseMS": 2.400 },
+  "webgpu:api,validation,capability_checks,limits,minUniformBufferOffsetAlignment:createBindGroup,at_over:*": { "subcaseMS": 9.301 },
+  "webgpu:api,validation,capability_checks,limits,minUniformBufferOffsetAlignment:setBindGroup,at_over:*": { "subcaseMS": 10.341 },
+  "webgpu:api,validation,capability_checks,limits,minUniformBufferOffsetAlignment:validate,greaterThanOrEqualTo32:*": { "subcaseMS": 2.400 },
+  "webgpu:api,validation,capability_checks,limits,minUniformBufferOffsetAlignment:validate,powerOf2:*": { "subcaseMS": 2.301 },
+  "webgpu:api,validation,compute_pipeline:basic:*": { "subcaseMS": 28.050 },
+  "webgpu:api,validation,compute_pipeline:limits,invocations_per_workgroup,each_component:*": { "subcaseMS": 6.582 },
+  "webgpu:api,validation,compute_pipeline:limits,invocations_per_workgroup:*": { "subcaseMS": 8.092 },
+  "webgpu:api,validation,compute_pipeline:limits,workgroup_storage_size:*": { "subcaseMS": 4.025 },
+  "webgpu:api,validation,compute_pipeline:overrides,identifier:*": { "subcaseMS": 5.312 },
+  "webgpu:api,validation,compute_pipeline:overrides,uninitialized:*": { "subcaseMS": 7.801 },
+  "webgpu:api,validation,compute_pipeline:overrides,value,type_error:*": { "subcaseMS": 9.675 },
+  "webgpu:api,validation,compute_pipeline:overrides,value,validation_error,f16:*": { "subcaseMS": 5.908 },
+  "webgpu:api,validation,compute_pipeline:overrides,value,validation_error:*": { "subcaseMS": 13.918 },
+  "webgpu:api,validation,compute_pipeline:overrides,workgroup_size,limits,workgroup_storage_size:*": { "subcaseMS": 10.800 },
+  "webgpu:api,validation,compute_pipeline:overrides,workgroup_size,limits:*": { "subcaseMS": 14.751 },
+  "webgpu:api,validation,compute_pipeline:overrides,workgroup_size:*": { "subcaseMS": 6.376 },
+  "webgpu:api,validation,compute_pipeline:pipeline_layout,device_mismatch:*": { "subcaseMS": 1.175 },
+  "webgpu:api,validation,compute_pipeline:shader_module,compute:*": { "subcaseMS": 6.867 },
+  "webgpu:api,validation,compute_pipeline:shader_module,device_mismatch:*": { "subcaseMS": 15.350 },
+  "webgpu:api,validation,compute_pipeline:shader_module,invalid:*": { "subcaseMS": 2.500 },
+  "webgpu:api,validation,createBindGroup:bind_group_layout,device_mismatch:*": { "subcaseMS": 15.800 },
+  "webgpu:api,validation,createBindGroup:binding_count_mismatch:*": { "subcaseMS": 1.822 },
+  "webgpu:api,validation,createBindGroup:binding_must_be_present_in_layout:*": { "subcaseMS": 3.311 },
+  "webgpu:api,validation,createBindGroup:binding_must_contain_resource_defined_in_layout:*": { "subcaseMS": 0.340 },
+  "webgpu:api,validation,createBindGroup:binding_resources,device_mismatch:*": { "subcaseMS": 4.850 },
+  "webgpu:api,validation,createBindGroup:buffer,effective_buffer_binding_size:*": { "subcaseMS": 0.263 },
+  "webgpu:api,validation,createBindGroup:buffer,resource_binding_size:*": { "subcaseMS": 0.845 },
+  "webgpu:api,validation,createBindGroup:buffer,resource_offset:*": { "subcaseMS": 4.558 },
+  "webgpu:api,validation,createBindGroup:buffer,resource_state:*": { "subcaseMS": 0.301 },
+  "webgpu:api,validation,createBindGroup:buffer,usage:*": { "subcaseMS": 0.525 },
+  "webgpu:api,validation,createBindGroup:buffer_offset_and_size_for_bind_groups_match:*": { "subcaseMS": 1.871 },
+  "webgpu:api,validation,createBindGroup:minBindingSize:*": { "subcaseMS": 3.391 },
+  "webgpu:api,validation,createBindGroup:multisampled_validation:*": { "subcaseMS": 13.325 },
+  "webgpu:api,validation,createBindGroup:sampler,compare_function_with_binding_type:*": { "subcaseMS": 0.702 },
+  "webgpu:api,validation,createBindGroup:sampler,device_mismatch:*": { "subcaseMS": 1.750 },
+  "webgpu:api,validation,createBindGroup:storage_texture,format:*": { "subcaseMS": 5.045 },
+  "webgpu:api,validation,createBindGroup:storage_texture,mip_level_count:*": { "subcaseMS": 8.426 },
+  "webgpu:api,validation,createBindGroup:storage_texture,usage:*": { "subcaseMS": 3.817 },
+  "webgpu:api,validation,createBindGroup:texture,resource_state:*": { "subcaseMS": 2.542 },
+  "webgpu:api,validation,createBindGroup:texture_binding_must_have_correct_usage:*": { "subcaseMS": 1.150 },
+  "webgpu:api,validation,createBindGroup:texture_must_have_correct_component_type:*": { "subcaseMS": 10.767 },
+  "webgpu:api,validation,createBindGroup:texture_must_have_correct_dimension:*": { "subcaseMS": 3.288 },
+  "webgpu:api,validation,createBindGroupLayout:duplicate_bindings:*": { "subcaseMS": 1.200 },
+  "webgpu:api,validation,createBindGroupLayout:max_dynamic_buffers:*": { "subcaseMS": 2.800 },
+  "webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:*": { "subcaseMS": 0.915 },
+  "webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:*": { "subcaseMS": 0.682 },
+  "webgpu:api,validation,createBindGroupLayout:maximum_binding_limit:*": { "subcaseMS": 0.400 },
+  "webgpu:api,validation,createBindGroupLayout:multisampled_validation:*": { "subcaseMS": 0.452 },
+  "webgpu:api,validation,createBindGroupLayout:storage_texture,formats:*": { "subcaseMS": 4.996 },
+  "webgpu:api,validation,createBindGroupLayout:storage_texture,layout_dimension:*": { "subcaseMS": 3.829 },
+  "webgpu:api,validation,createBindGroupLayout:visibility,VERTEX_shader_stage_buffer_type:*": { "subcaseMS": 1.342 },
+  "webgpu:api,validation,createBindGroupLayout:visibility,VERTEX_shader_stage_storage_texture_access:*": { "subcaseMS": 4.394 },
+  "webgpu:api,validation,createBindGroupLayout:visibility:*": { "subcaseMS": 1.926 },
+  "webgpu:api,validation,createPipelineLayout:bind_group_layouts,device_mismatch:*": { "subcaseMS": 1.200 },
+  "webgpu:api,validation,createPipelineLayout:number_of_bind_group_layouts_exceeds_the_maximum_value:*": { "subcaseMS": 3.500 },
+  "webgpu:api,validation,createPipelineLayout:number_of_dynamic_buffers_exceeds_the_maximum_value:*": { "subcaseMS": 2.658 },
+  "webgpu:api,validation,createSampler:lodMinAndMaxClamp:*": { "subcaseMS": 0.610 },
+  "webgpu:api,validation,createSampler:maxAnisotropy:*": { "subcaseMS": 0.979 },
+  "webgpu:api,validation,createTexture:dimension_type_and_format_compatibility:*": { "subcaseMS": 4.062 },
+  "webgpu:api,validation,createTexture:mipLevelCount,bound_check,bigger_than_integer_bit_width:*": { "subcaseMS": 2.301 },
+  "webgpu:api,validation,createTexture:mipLevelCount,bound_check:*": { "subcaseMS": 0.801 },
+  "webgpu:api,validation,createTexture:mipLevelCount,format:*": { "subcaseMS": 1.258 },
+  "webgpu:api,validation,createTexture:sampleCount,valid_sampleCount_with_other_parameter_varies:*": { "subcaseMS": 0.525 },
+  "webgpu:api,validation,createTexture:sampleCount,various_sampleCount_with_all_formats:*": { "subcaseMS": 2.336 },
+  "webgpu:api,validation,createTexture:sample_count,1d_2d_array_3d:*": { "subcaseMS": 2.480 },
+  "webgpu:api,validation,createTexture:texture_size,1d_texture:*": { "subcaseMS": 1.372 },
+  "webgpu:api,validation,createTexture:texture_size,2d_texture,compressed_format:*": { "subcaseMS": 4.108 },
+  "webgpu:api,validation,createTexture:texture_size,2d_texture,uncompressed_format:*": { "subcaseMS": 4.729 },
+  "webgpu:api,validation,createTexture:texture_size,3d_texture,compressed_format:*": { "subcaseMS": 4.322 },
+  "webgpu:api,validation,createTexture:texture_size,3d_texture,uncompressed_format:*": { "subcaseMS": 2.039 },
+  "webgpu:api,validation,createTexture:texture_size,default_value_and_smallest_size,compressed_format:*": { "subcaseMS": 1.863 },
+  "webgpu:api,validation,createTexture:texture_size,default_value_and_smallest_size,uncompressed_format:*": { "subcaseMS": 1.694 },
+  "webgpu:api,validation,createTexture:texture_usage:*": { "subcaseMS": 0.870 },
+  "webgpu:api,validation,createTexture:viewFormats:*": { "subcaseMS": 0.632 },
+  "webgpu:api,validation,createTexture:zero_size_and_usage:*": { "subcaseMS": 3.250 },
+  "webgpu:api,validation,createView:array_layers:*": { "subcaseMS": 0.491 },
+  "webgpu:api,validation,createView:aspect:*": { "subcaseMS": 5.556 },
+  "webgpu:api,validation,createView:cube_faces_square:*": { "subcaseMS": 19.340 },
+  "webgpu:api,validation,createView:dimension:*": { "subcaseMS": 9.291 },
+  "webgpu:api,validation,createView:format:*": { "subcaseMS": 0.742 },
+  "webgpu:api,validation,createView:mip_levels:*": { "subcaseMS": 0.436 },
+  "webgpu:api,validation,createView:texture_state:*": { "subcaseMS": 0.400 },
+  "webgpu:api,validation,debugMarker:push_pop_call_count_unbalance,command_encoder:*": { "subcaseMS": 1.522 },
+  "webgpu:api,validation,debugMarker:push_pop_call_count_unbalance,render_compute_pass:*": { "subcaseMS": 0.601 },
+  "webgpu:api,validation,encoding,beginComputePass:timestampWrites,invalid_query_set:*": { "subcaseMS": 0.201 },
+  "webgpu:api,validation,encoding,beginComputePass:timestampWrites,query_index:*": { "subcaseMS": 0.201 },
+  "webgpu:api,validation,encoding,beginComputePass:timestampWrites,query_set_type:*": { "subcaseMS": 0.401 },
+  "webgpu:api,validation,encoding,beginComputePass:timestamp_query_set,device_mismatch:*": { "subcaseMS": 0.301 },
+  "webgpu:api,validation,encoding,beginRenderPass:color_attachments,device_mismatch:*": { "subcaseMS": 10.750 },
+  "webgpu:api,validation,encoding,beginRenderPass:depth_stencil_attachment,device_mismatch:*": { "subcaseMS": 26.100 },
+  "webgpu:api,validation,encoding,beginRenderPass:occlusion_query_set,device_mismatch:*": { "subcaseMS": 0.850 },
+  "webgpu:api,validation,encoding,beginRenderPass:timestamp_query_set,device_mismatch:*": { "subcaseMS": 0.301 },
+  "webgpu:api,validation,encoding,cmds,clearBuffer:buffer,device_mismatch:*": { "subcaseMS": 7.350 },
+  "webgpu:api,validation,encoding,cmds,clearBuffer:buffer_state:*": { "subcaseMS": 44.500 },
+  "webgpu:api,validation,encoding,cmds,clearBuffer:buffer_usage:*": { "subcaseMS": 4.000 },
+  "webgpu:api,validation,encoding,cmds,clearBuffer:default_args:*": { "subcaseMS": 0.233 },
+  "webgpu:api,validation,encoding,cmds,clearBuffer:offset_alignment:*": { "subcaseMS": 2.086 },
+  "webgpu:api,validation,encoding,cmds,clearBuffer:out_of_bounds:*": { "subcaseMS": 0.213 },
+  "webgpu:api,validation,encoding,cmds,clearBuffer:overflow:*": { "subcaseMS": 0.350 },
+  "webgpu:api,validation,encoding,cmds,clearBuffer:size_alignment:*": { "subcaseMS": 0.300 },
+  "webgpu:api,validation,encoding,cmds,compute_pass:dispatch_sizes:*": { "subcaseMS": 4.062 },
+  "webgpu:api,validation,encoding,cmds,compute_pass:indirect_dispatch_buffer,device_mismatch:*": { "subcaseMS": 21.050 },
+  "webgpu:api,validation,encoding,cmds,compute_pass:indirect_dispatch_buffer,usage:*": { "subcaseMS": 0.534 },
+  "webgpu:api,validation,encoding,cmds,compute_pass:indirect_dispatch_buffer_state:*": { "subcaseMS": 2.093 },
+  "webgpu:api,validation,encoding,cmds,compute_pass:pipeline,device_mismatch:*": { "subcaseMS": 7.600 },
+  "webgpu:api,validation,encoding,cmds,compute_pass:set_pipeline:*": { "subcaseMS": 1.000 },
+  "webgpu:api,validation,encoding,cmds,copyBufferToBuffer:buffer,device_mismatch:*": { "subcaseMS": 0.500 },
+  "webgpu:api,validation,encoding,cmds,copyBufferToBuffer:buffer_state:*": { "subcaseMS": 3.178 },
+  "webgpu:api,validation,encoding,cmds,copyBufferToBuffer:buffer_usage:*": { "subcaseMS": 0.591 },
+  "webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_offset_alignment:*": { "subcaseMS": 0.400 },
+  "webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_out_of_bounds:*": { "subcaseMS": 0.200 },
+  "webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_overflow:*": { "subcaseMS": 0.301 },
+  "webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_size_alignment:*": { "subcaseMS": 0.680 },
+  "webgpu:api,validation,encoding,cmds,copyBufferToBuffer:copy_within_same_buffer:*": { "subcaseMS": 0.401 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:copy_aspects:*": { "subcaseMS": 2.182 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:copy_ranges:*": { "subcaseMS": 11.442 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:copy_ranges_with_compressed_texture_formats:*": { "subcaseMS": 0.334 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:copy_with_invalid_or_destroyed_texture:*": { "subcaseMS": 4.844 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:copy_within_same_texture:*": { "subcaseMS": 0.301 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:depth_stencil_copy_restrictions:*": { "subcaseMS": 0.480 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:mipmap_level:*": { "subcaseMS": 0.879 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:multisampled_copy_restrictions:*": { "subcaseMS": 0.301 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:sample_count:*": { "subcaseMS": 4.125 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:texture,device_mismatch:*": { "subcaseMS": 0.567 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:texture_format_compatibility:*": { "subcaseMS": 0.341 },
+  "webgpu:api,validation,encoding,cmds,copyTextureToTexture:texture_usage:*": { "subcaseMS": 2.308 },
+  "webgpu:api,validation,encoding,cmds,debug:debug_group:*": { "subcaseMS": 3.640 },
+  "webgpu:api,validation,encoding,cmds,debug:debug_group_balanced:*": { "subcaseMS": 1.978 },
+  "webgpu:api,validation,encoding,cmds,debug:debug_marker:*": { "subcaseMS": 0.960 },
+  "webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:*": { "subcaseMS": 7.139 },
+  "webgpu:api,validation,encoding,cmds,index_access:out_of_bounds_zero_sized_index_buffer:*": { "subcaseMS": 12.400 },
+  "webgpu:api,validation,encoding,cmds,render,draw:buffer_binding_overlap:*": { "subcaseMS": 0.446 },
+  "webgpu:api,validation,encoding,cmds,render,draw:index_buffer_OOB:*": { "subcaseMS": 5.825 },
+  "webgpu:api,validation,encoding,cmds,render,draw:last_buffer_setting_take_account:*": { "subcaseMS": 30.801 },
+  "webgpu:api,validation,encoding,cmds,render,draw:max_draw_count:*": { "subcaseMS": 3.521 },
+  "webgpu:api,validation,encoding,cmds,render,draw:unused_buffer_bound:*": { "subcaseMS": 1.413 },
+  "webgpu:api,validation,encoding,cmds,render,draw:vertex_buffer_OOB:*": { "subcaseMS": 0.767 },
+  "webgpu:api,validation,encoding,cmds,render,dynamic_state:setBlendConstant:*": { "subcaseMS": 0.367 },
+  "webgpu:api,validation,encoding,cmds,render,dynamic_state:setScissorRect,x_y_width_height_nonnegative:*": { "subcaseMS": 2.900 },
+  "webgpu:api,validation,encoding,cmds,render,dynamic_state:setScissorRect,xy_rect_contained_in_attachment:*": { "subcaseMS": 1.325 },
+  "webgpu:api,validation,encoding,cmds,render,dynamic_state:setStencilReference:*": { "subcaseMS": 3.450 },
+  "webgpu:api,validation,encoding,cmds,render,dynamic_state:setViewport,depth_rangeAndOrder:*": { "subcaseMS": 1.667 },
+  "webgpu:api,validation,encoding,cmds,render,dynamic_state:setViewport,x_y_width_height_nonnegative:*": { "subcaseMS": 0.400 },
+  "webgpu:api,validation,encoding,cmds,render,dynamic_state:setViewport,xy_rect_contained_in_attachment:*": { "subcaseMS": 0.200 },
+  "webgpu:api,validation,encoding,cmds,render,indirect_draw:indirect_buffer,device_mismatch:*": { "subcaseMS": 2.000 },
+  "webgpu:api,validation,encoding,cmds,render,indirect_draw:indirect_buffer_state:*": { "subcaseMS": 2.708 },
+  "webgpu:api,validation,encoding,cmds,render,indirect_draw:indirect_buffer_usage:*": { "subcaseMS": 2.733 },
+  "webgpu:api,validation,encoding,cmds,render,indirect_draw:indirect_offset_alignment:*": { "subcaseMS": 2.758 },
+  "webgpu:api,validation,encoding,cmds,render,indirect_draw:indirect_offset_oob:*": { "subcaseMS": 0.725 },
+  "webgpu:api,validation,encoding,cmds,render,setIndexBuffer:index_buffer,device_mismatch:*": { "subcaseMS": 7.800 },
+  "webgpu:api,validation,encoding,cmds,render,setIndexBuffer:index_buffer_state:*": { "subcaseMS": 5.200 },
+  "webgpu:api,validation,encoding,cmds,render,setIndexBuffer:index_buffer_usage:*": { "subcaseMS": 2.467 },
+  "webgpu:api,validation,encoding,cmds,render,setIndexBuffer:offset_alignment:*": { "subcaseMS": 2.642 },
+  "webgpu:api,validation,encoding,cmds,render,setIndexBuffer:offset_and_size_oob:*": { "subcaseMS": 1.067 },
+  "webgpu:api,validation,encoding,cmds,render,setPipeline:invalid_pipeline:*": { "subcaseMS": 0.525 },
+  "webgpu:api,validation,encoding,cmds,render,setPipeline:pipeline,device_mismatch:*": { "subcaseMS": 8.500 },
+  "webgpu:api,validation,encoding,cmds,render,setVertexBuffer:offset_alignment:*": { "subcaseMS": 2.550 },
+  "webgpu:api,validation,encoding,cmds,render,setVertexBuffer:offset_and_size_oob:*": { "subcaseMS": 0.200 },
+  "webgpu:api,validation,encoding,cmds,render,setVertexBuffer:slot:*": { "subcaseMS": 5.300 },
+  "webgpu:api,validation,encoding,cmds,render,setVertexBuffer:vertex_buffer,device_mismatch:*": { "subcaseMS": 7.850 },
+  "webgpu:api,validation,encoding,cmds,render,setVertexBuffer:vertex_buffer_state:*": { "subcaseMS": 5.200 },
+  "webgpu:api,validation,encoding,cmds,render,setVertexBuffer:vertex_buffer_usage:*": { "subcaseMS": 0.301 },
+  "webgpu:api,validation,encoding,cmds,render,state_tracking:all_needed_index_buffer_should_be_bound:*": { "subcaseMS": 14.101 },
+  "webgpu:api,validation,encoding,cmds,render,state_tracking:all_needed_vertex_buffer_should_be_bound:*": { "subcaseMS": 31.900 },
+  "webgpu:api,validation,encoding,cmds,render,state_tracking:vertex_buffers_do_not_inherit_between_render_passes:*": { "subcaseMS": 3.400 },
+  "webgpu:api,validation,encoding,cmds,render,state_tracking:vertex_buffers_inherit_from_previous_pipeline:*": { "subcaseMS": 31.701 },
+  "webgpu:api,validation,encoding,cmds,setBindGroup:bind_group,device_mismatch:*": { "subcaseMS": 6.975 },
+  "webgpu:api,validation,encoding,cmds,setBindGroup:buffer_dynamic_offsets:*": { "subcaseMS": 1.990 },
+  "webgpu:api,validation,encoding,cmds,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:*": { "subcaseMS": 3.949 },
+  "webgpu:api,validation,encoding,cmds,setBindGroup:dynamic_offsets_passed_but_not_expected:*": { "subcaseMS": 0.900 },
+  "webgpu:api,validation,encoding,cmds,setBindGroup:state_and_binding_index:*": { "subcaseMS": 5.417 },
+  "webgpu:api,validation,encoding,cmds,setBindGroup:u32array_start_and_length:*": { "subcaseMS": 3.020 },
+  "webgpu:api,validation,encoding,createRenderBundleEncoder:attachment_state,empty_color_formats:*": { "subcaseMS": 0.450 },
+  "webgpu:api,validation,encoding,createRenderBundleEncoder:attachment_state,limits,maxColorAttachmentBytesPerSample,aligned:*": { "subcaseMS": 2.641 },
+  "webgpu:api,validation,encoding,createRenderBundleEncoder:attachment_state,limits,maxColorAttachmentBytesPerSample,unaligned:*": { "subcaseMS": 0.750 },
+  "webgpu:api,validation,encoding,createRenderBundleEncoder:attachment_state,limits,maxColorAttachments:*": { "subcaseMS": 0.145 },
+  "webgpu:api,validation,encoding,createRenderBundleEncoder:depth_stencil_readonly:*": { "subcaseMS": 1.804 },
+  "webgpu:api,validation,encoding,createRenderBundleEncoder:depth_stencil_readonly_with_undefined_depth:*": { "subcaseMS": 14.825 },
+  "webgpu:api,validation,encoding,createRenderBundleEncoder:valid_texture_formats:*": { "subcaseMS": 2.130 },
+  "webgpu:api,validation,encoding,encoder_open_state:compute_pass_commands:*": { "subcaseMS": 4.208 },
+  "webgpu:api,validation,encoding,encoder_open_state:non_pass_commands:*": { "subcaseMS": 26.191 },
+  "webgpu:api,validation,encoding,encoder_open_state:render_bundle_commands:*": { "subcaseMS": 2.850 },
+  "webgpu:api,validation,encoding,encoder_open_state:render_pass_commands:*": { "subcaseMS": 3.620 },
+  "webgpu:api,validation,encoding,encoder_state:call_after_successful_finish:*": { "subcaseMS": 0.800 },
+  "webgpu:api,validation,encoding,encoder_state:pass_end_invalid_order:*": { "subcaseMS": 1.303 },
+  "webgpu:api,validation,encoding,encoder_state:pass_end_none:*": { "subcaseMS": 8.150 },
+  "webgpu:api,validation,encoding,encoder_state:pass_end_twice,basic:*": { "subcaseMS": 0.300 },
+  "webgpu:api,validation,encoding,encoder_state:pass_end_twice,render_pass_invalid:*": { "subcaseMS": 15.850 },
+  "webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bgl_binding_mismatch:*": { "subcaseMS": 1.301 },
+  "webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bgl_resource_type_mismatch:*": { "subcaseMS": 0.977 },
+  "webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bgl_visibility_mismatch:*": { "subcaseMS": 0.608 },
+  "webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bind_groups_and_pipeline_layout_mismatch:*": { "subcaseMS": 1.535 },
+  "webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:buffer_binding,render_pipeline:*": { "subcaseMS": 1.734 },
+  "webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:empty_bind_group_layouts_requires_empty_bind_groups,compute_pass:*": { "subcaseMS": 2.325 },
+  "webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:empty_bind_group_layouts_requires_empty_bind_groups,render_pass:*": { "subcaseMS": 10.838 },
+  "webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:sampler_binding,render_pipeline:*": { "subcaseMS": 10.523 },
+  "webgpu:api,validation,encoding,queries,begin_end:nesting:*": { "subcaseMS": 1.101 },
+  "webgpu:api,validation,encoding,queries,begin_end:occlusion_query,begin_end_balance:*": { "subcaseMS": 0.820 },
+  "webgpu:api,validation,encoding,queries,begin_end:occlusion_query,begin_end_invalid_nesting:*": { "subcaseMS": 1.000 },
+  "webgpu:api,validation,encoding,queries,begin_end:occlusion_query,disjoint_queries_with_same_query_index:*": { "subcaseMS": 0.550 },
+  "webgpu:api,validation,encoding,queries,general:occlusion_query,invalid_query_set:*": { "subcaseMS": 1.651 },
+  "webgpu:api,validation,encoding,queries,general:occlusion_query,query_index:*": { "subcaseMS": 0.500 },
+  "webgpu:api,validation,encoding,queries,general:occlusion_query,query_type:*": { "subcaseMS": 4.702 },
+  "webgpu:api,validation,encoding,queries,general:timestamp_query,device_mismatch:*": { "subcaseMS": 0.101 },
+  "webgpu:api,validation,encoding,queries,general:timestamp_query,invalid_query_set:*": { "subcaseMS": 0.101 },
+  "webgpu:api,validation,encoding,queries,general:timestamp_query,query_type_and_index:*": { "subcaseMS": 0.301 },
+  "webgpu:api,validation,encoding,queries,resolveQuerySet:destination_buffer_usage:*": { "subcaseMS": 16.050 },
+  "webgpu:api,validation,encoding,queries,resolveQuerySet:destination_offset_alignment:*": { "subcaseMS": 0.325 },
+  "webgpu:api,validation,encoding,queries,resolveQuerySet:first_query_and_query_count:*": { "subcaseMS": 0.250 },
+  "webgpu:api,validation,encoding,queries,resolveQuerySet:query_set_buffer,device_mismatch:*": { "subcaseMS": 1.000 },
+  "webgpu:api,validation,encoding,queries,resolveQuerySet:queryset_and_destination_buffer_state:*": { "subcaseMS": 9.078 },
+  "webgpu:api,validation,encoding,queries,resolveQuerySet:resolve_buffer_oob:*": { "subcaseMS": 6.300 },
+  "webgpu:api,validation,encoding,render_bundle:color_formats_mismatch:*": { "subcaseMS": 10.940 },
+  "webgpu:api,validation,encoding,render_bundle:depth_stencil_formats_mismatch:*": { "subcaseMS": 4.050 },
+  "webgpu:api,validation,encoding,render_bundle:depth_stencil_readonly_mismatch:*": { "subcaseMS": 4.488 },
+  "webgpu:api,validation,encoding,render_bundle:device_mismatch:*": { "subcaseMS": 0.633 },
+  "webgpu:api,validation,encoding,render_bundle:empty_bundle_list:*": { "subcaseMS": 30.301 },
+  "webgpu:api,validation,encoding,render_bundle:sample_count_mismatch:*": { "subcaseMS": 8.325 },
+  "webgpu:api,validation,error_scope:balanced_nesting:*": { "subcaseMS": 56.817 },
+  "webgpu:api,validation,error_scope:balanced_siblings:*": { "subcaseMS": 95.950 },
+  "webgpu:api,validation,error_scope:current_scope:*": { "subcaseMS": 1177.650 },
+  "webgpu:api,validation,error_scope:empty:*": { "subcaseMS": 0.801 },
+  "webgpu:api,validation,error_scope:parent_scope:*": { "subcaseMS": 11.601 },
+  "webgpu:api,validation,error_scope:simple:*": { "subcaseMS": 10.317 },
+  "webgpu:api,validation,getBindGroupLayout:index_range,auto_layout:*": { "subcaseMS": 6.300 },
+  "webgpu:api,validation,getBindGroupLayout:index_range,explicit_layout:*": { "subcaseMS": 30.334 },
+  "webgpu:api,validation,getBindGroupLayout:unique_js_object,auto_layout:*": { "subcaseMS": 1.601 },
+  "webgpu:api,validation,getBindGroupLayout:unique_js_object,explicit_layout:*": { "subcaseMS": 0.900 },
+  "webgpu:api,validation,gpu_external_texture_expiration:import_and_use_in_different_microtask:*": { "subcaseMS": 40.700 },
+  "webgpu:api,validation,gpu_external_texture_expiration:import_and_use_in_different_task:*": { "subcaseMS": 41.901 },
+  "webgpu:api,validation,gpu_external_texture_expiration:import_from_different_video_frame:*": { "subcaseMS": 82.101 },
+  "webgpu:api,validation,gpu_external_texture_expiration:import_multiple_times_in_same_task_scope:*": { "subcaseMS": 130.150 },
+  "webgpu:api,validation,gpu_external_texture_expiration:use_import_to_refresh:*": { "subcaseMS": 48.700 },
+  "webgpu:api,validation,gpu_external_texture_expiration:webcodec_video_frame_close_expire_immediately:*": { "subcaseMS": 48.801 },
+  "webgpu:api,validation,image_copy,buffer_related:buffer,device_mismatch:*": { "subcaseMS": 0.400 },
+  "webgpu:api,validation,image_copy,buffer_related:buffer_state:*": { "subcaseMS": 1.034 },
+  "webgpu:api,validation,image_copy,buffer_related:bytes_per_row_alignment:*": { "subcaseMS": 2.635 },
+  "webgpu:api,validation,image_copy,buffer_related:usage:*": { "subcaseMS": 0.384 },
+  "webgpu:api,validation,image_copy,buffer_texture_copies:depth_stencil_format,copy_buffer_offset:*": { "subcaseMS": 4.996 },
+  "webgpu:api,validation,image_copy,buffer_texture_copies:depth_stencil_format,copy_buffer_size:*": { "subcaseMS": 1.728 },
+  "webgpu:api,validation,image_copy,buffer_texture_copies:depth_stencil_format,copy_usage_and_aspect:*": { "subcaseMS": 6.467 },
+  "webgpu:api,validation,image_copy,buffer_texture_copies:device_mismatch:*": { "subcaseMS": 2.767 },
+  "webgpu:api,validation,image_copy,buffer_texture_copies:sample_count:*": { "subcaseMS": 14.575 },
+  "webgpu:api,validation,image_copy,buffer_texture_copies:texture_buffer_usages:*": { "subcaseMS": 1.001 },
+  "webgpu:api,validation,image_copy,layout_related:bound_on_bytes_per_row:*": { "subcaseMS": 1.133 },
+  "webgpu:api,validation,image_copy,layout_related:bound_on_offset:*": { "subcaseMS": 0.833 },
+  "webgpu:api,validation,image_copy,layout_related:bound_on_rows_per_image:*": { "subcaseMS": 2.666 },
+  "webgpu:api,validation,image_copy,layout_related:copy_end_overflows_u64:*": { "subcaseMS": 0.567 },
+  "webgpu:api,validation,image_copy,layout_related:offset_alignment:*": { "subcaseMS": 1.107 },
+  "webgpu:api,validation,image_copy,layout_related:required_bytes_in_copy:*": { "subcaseMS": 1.051 },
+  "webgpu:api,validation,image_copy,layout_related:rows_per_image_alignment:*": { "subcaseMS": 2.239 },
+  "webgpu:api,validation,image_copy,texture_related:copy_rectangle:*": { "subcaseMS": 0.599 },
+  "webgpu:api,validation,image_copy,texture_related:format:*": { "subcaseMS": 4.790 },
+  "webgpu:api,validation,image_copy,texture_related:mip_level:*": { "subcaseMS": 2.632 },
+  "webgpu:api,validation,image_copy,texture_related:origin_alignment:*": { "subcaseMS": 1.252 },
+  "webgpu:api,validation,image_copy,texture_related:sample_count:*": { "subcaseMS": 5.717 },
+  "webgpu:api,validation,image_copy,texture_related:size_alignment:*": { "subcaseMS": 1.076 },
+  "webgpu:api,validation,image_copy,texture_related:texture,device_mismatch:*": { "subcaseMS": 5.417 },
+  "webgpu:api,validation,image_copy,texture_related:usage:*": { "subcaseMS": 1.224 },
+  "webgpu:api,validation,image_copy,texture_related:valid:*": { "subcaseMS": 3.678 },
+  "webgpu:api,validation,query_set,create:count:*": { "subcaseMS": 0.967 },
+  "webgpu:api,validation,query_set,destroy:invalid_queryset:*": { "subcaseMS": 0.801 },
+  "webgpu:api,validation,query_set,destroy:twice:*": { "subcaseMS": 0.700 },
+  "webgpu:api,validation,queue,buffer_mapped:copyBufferToBuffer:*": { "subcaseMS": 36.601 },
+  "webgpu:api,validation,queue,buffer_mapped:copyBufferToTexture:*": { "subcaseMS": 33.000 },
+  "webgpu:api,validation,queue,buffer_mapped:copyTextureToBuffer:*": { "subcaseMS": 32.301 },
+  "webgpu:api,validation,queue,buffer_mapped:map_command_recording_order:*": { "subcaseMS": 3.091 },
+  "webgpu:api,validation,queue,buffer_mapped:writeBuffer:*": { "subcaseMS": 34.901 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:OOB,destination:*": { "subcaseMS": 0.512 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:OOB,source:*": { "subcaseMS": 0.389 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:destination_texture,device_mismatch:*": { "subcaseMS": 35.550 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:destination_texture,format:*": { "subcaseMS": 2.180 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:destination_texture,mipLevel:*": { "subcaseMS": 5.834 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:destination_texture,sample_count:*": { "subcaseMS": 35.500 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:destination_texture,state:*": { "subcaseMS": 26.667 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:destination_texture,usage:*": { "subcaseMS": 22.760 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:source_canvas,state:*": { "subcaseMS": 10.250 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:source_image,crossOrigin:*": { "subcaseMS": 15.435 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:source_imageBitmap,state:*": { "subcaseMS": 9.100 },
+  "webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:source_offscreenCanvas,state:*": { "subcaseMS": 11.334 },
+  "webgpu:api,validation,queue,destroyed,buffer:copyBufferToBuffer:*": { "subcaseMS": 0.800 },
+  "webgpu:api,validation,queue,destroyed,buffer:copyBufferToTexture:*": { "subcaseMS": 1.401 },
+  "webgpu:api,validation,queue,destroyed,buffer:copyTextureToBuffer:*": { "subcaseMS": 1.500 },
+  "webgpu:api,validation,queue,destroyed,buffer:resolveQuerySet:*": { "subcaseMS": 16.550 },
+  "webgpu:api,validation,queue,destroyed,buffer:setBindGroup:*": { "subcaseMS": 2.983 },
+  "webgpu:api,validation,queue,destroyed,buffer:setIndexBuffer:*": { "subcaseMS": 8.150 },
+  "webgpu:api,validation,queue,destroyed,buffer:setVertexBuffer:*": { "subcaseMS": 8.550 },
+  "webgpu:api,validation,queue,destroyed,buffer:writeBuffer:*": { "subcaseMS": 2.151 },
+  "webgpu:api,validation,queue,destroyed,query_set:beginOcclusionQuery:*": { "subcaseMS": 17.401 },
+  "webgpu:api,validation,queue,destroyed,query_set:resolveQuerySet:*": { "subcaseMS": 16.401 },
+  "webgpu:api,validation,queue,destroyed,query_set:writeTimestamp:*": { "subcaseMS": 0.901 },
+  "webgpu:api,validation,queue,destroyed,texture:beginRenderPass:*": { "subcaseMS": 0.350 },
+  "webgpu:api,validation,queue,destroyed,texture:copyBufferToTexture:*": { "subcaseMS": 16.550 },
+  "webgpu:api,validation,queue,destroyed,texture:copyTextureToBuffer:*": { "subcaseMS": 15.900 },
+  "webgpu:api,validation,queue,destroyed,texture:copyTextureToTexture:*": { "subcaseMS": 8.500 },
+  "webgpu:api,validation,queue,destroyed,texture:setBindGroup:*": { "subcaseMS": 5.783 },
+  "webgpu:api,validation,queue,destroyed,texture:writeTexture:*": { "subcaseMS": 16.601 },
+  "webgpu:api,validation,queue,submit:command_buffer,device_mismatch:*": { "subcaseMS": 0.467 },
+  "webgpu:api,validation,queue,writeBuffer:buffer,device_mismatch:*": { "subcaseMS": 16.000 },
+  "webgpu:api,validation,queue,writeBuffer:buffer_state:*": { "subcaseMS": 6.201 },
+  "webgpu:api,validation,queue,writeBuffer:ranges:*": { "subcaseMS": 17.600 },
+  "webgpu:api,validation,queue,writeBuffer:usages:*": { "subcaseMS": 8.525 },
+  "webgpu:api,validation,queue,writeTexture:sample_count:*": { "subcaseMS": 2.050 },
+  "webgpu:api,validation,queue,writeTexture:texture,device_mismatch:*": { "subcaseMS": 7.850 },
+  "webgpu:api,validation,queue,writeTexture:texture_state:*": { "subcaseMS": 18.567 },
+  "webgpu:api,validation,queue,writeTexture:usages:*": { "subcaseMS": 0.700 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_and_bundle,color_count:*": { "subcaseMS": 0.627 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_and_bundle,color_format:*": { "subcaseMS": 0.200 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_and_bundle,color_sparse:*": { "subcaseMS": 0.784 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_and_bundle,depth_format:*": { "subcaseMS": 1.000 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_and_bundle,device_mismatch:*": { "subcaseMS": 0.650 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_and_bundle,sample_count:*": { "subcaseMS": 0.775 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_or_bundle_and_pipeline,color_count:*": { "subcaseMS": 0.543 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_or_bundle_and_pipeline,color_format:*": { "subcaseMS": 0.400 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_or_bundle_and_pipeline,color_sparse:*": { "subcaseMS": 0.511 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_or_bundle_and_pipeline,depth_format:*": { "subcaseMS": 0.840 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_or_bundle_and_pipeline,depth_stencil_read_only_write_state:*": { "subcaseMS": 0.361 },
+  "webgpu:api,validation,render_pass,attachment_compatibility:render_pass_or_bundle_and_pipeline,sample_count:*": { "subcaseMS": 0.456 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:attachments,color_depth_mismatch:*": { "subcaseMS": 33.000 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:attachments,layer_count:*": { "subcaseMS": 18.667 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:attachments,mip_level_count:*": { "subcaseMS": 5.468 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:attachments,one_color_attachment:*": { "subcaseMS": 33.401 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:attachments,one_depth_stencil_attachment:*": { "subcaseMS": 15.301 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:attachments,same_size:*": { "subcaseMS": 33.400 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,empty:*": { "subcaseMS": 0.400 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,limits,maxColorAttachmentBytesPerSample,aligned:*": { "subcaseMS": 1.825 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,limits,maxColorAttachmentBytesPerSample,unaligned:*": { "subcaseMS": 17.151 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,limits,maxColorAttachments:*": { "subcaseMS": 0.950 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,non_multisampled:*": { "subcaseMS": 32.601 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,sample_count:*": { "subcaseMS": 33.600 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:depth_stencil_attachment,depth_clear_value:*": { "subcaseMS": 39.956 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:depth_stencil_attachment,loadOp_storeOp_match_depthReadOnly_stencilReadOnly:*": { "subcaseMS": 1.701 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:depth_stencil_attachment,sample_counts_mismatch:*": { "subcaseMS": 15.801 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:occlusionQuerySet,query_set_type:*": { "subcaseMS": 32.400 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,array_layer_count:*": { "subcaseMS": 32.200 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,different_format:*": { "subcaseMS": 1.500 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,different_size:*": { "subcaseMS": 0.901 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,error_state:*": { "subcaseMS": 1.101 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,format_supports_resolve:*": { "subcaseMS": 3.370 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,mipmap_level_count:*": { "subcaseMS": 33.201 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,sample_count:*": { "subcaseMS": 32.500 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,single_sample_count:*": { "subcaseMS": 0.601 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,usage:*": { "subcaseMS": 15.125 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:timestampWrite,query_index:*": { "subcaseMS": 0.200 },
+  "webgpu:api,validation,render_pass,render_pass_descriptor:timestampWrites,query_set_type:*": { "subcaseMS": 0.501 },
+  "webgpu:api,validation,render_pass,resolve:resolve_attachment:*": { "subcaseMS": 6.205 },
+  "webgpu:api,validation,render_pipeline,depth_stencil_state:depth_test:*": { "subcaseMS": 3.407 },
+  "webgpu:api,validation,render_pipeline,depth_stencil_state:depth_write,frag_depth:*": { "subcaseMS": 6.465 },
+  "webgpu:api,validation,render_pipeline,depth_stencil_state:depth_write:*": { "subcaseMS": 4.113 },
+  "webgpu:api,validation,render_pipeline,depth_stencil_state:format:*": { "subcaseMS": 3.521 },
+  "webgpu:api,validation,render_pipeline,depth_stencil_state:stencil_test:*": { "subcaseMS": 3.124 },
+  "webgpu:api,validation,render_pipeline,depth_stencil_state:stencil_write:*": { "subcaseMS": 3.183 },
+  "webgpu:api,validation,render_pipeline,fragment_state:color_target_exists:*": { "subcaseMS": 29.150 },
+  "webgpu:api,validation,render_pipeline,fragment_state:limits,maxColorAttachmentBytesPerSample,aligned:*": { "subcaseMS": 0.991 },
+  "webgpu:api,validation,render_pipeline,fragment_state:limits,maxColorAttachmentBytesPerSample,unaligned:*": { "subcaseMS": 14.750 },
+  "webgpu:api,validation,render_pipeline,fragment_state:limits,maxColorAttachments:*": { "subcaseMS": 9.351 },
+  "webgpu:api,validation,render_pipeline,fragment_state:pipeline_output_targets,blend:*": { "subcaseMS": 0.551 },
+  "webgpu:api,validation,render_pipeline,fragment_state:pipeline_output_targets:*": { "subcaseMS": 0.497 },
+  "webgpu:api,validation,render_pipeline,fragment_state:targets_blend:*": { "subcaseMS": 1.203 },
+  "webgpu:api,validation,render_pipeline,fragment_state:targets_format_filterable:*": { "subcaseMS": 2.143 },
+  "webgpu:api,validation,render_pipeline,fragment_state:targets_format_renderable:*": { "subcaseMS": 3.339 },
+  "webgpu:api,validation,render_pipeline,fragment_state:targets_write_mask:*": { "subcaseMS": 12.272 },
+  "webgpu:api,validation,render_pipeline,inter_stage:interpolation_sampling:*": { "subcaseMS": 3.126 },
+  "webgpu:api,validation,render_pipeline,inter_stage:interpolation_type:*": { "subcaseMS": 4.071 },
+  "webgpu:api,validation,render_pipeline,inter_stage:location,mismatch:*": { "subcaseMS": 7.280 },
+  "webgpu:api,validation,render_pipeline,inter_stage:location,subset:*": { "subcaseMS": 1.250 },
+  "webgpu:api,validation,render_pipeline,inter_stage:location,superset:*": { "subcaseMS": 0.901 },
+  "webgpu:api,validation,render_pipeline,inter_stage:max_components_count,input:*": { "subcaseMS": 6.560 },
+  "webgpu:api,validation,render_pipeline,inter_stage:max_components_count,output:*": { "subcaseMS": 8.426 },
+  "webgpu:api,validation,render_pipeline,inter_stage:max_shader_variable_location:*": { "subcaseMS": 11.050 },
+  "webgpu:api,validation,render_pipeline,inter_stage:type:*": { "subcaseMS": 6.170 },
+  "webgpu:api,validation,render_pipeline,misc:basic:*": { "subcaseMS": 0.901 },
+  "webgpu:api,validation,render_pipeline,misc:pipeline_layout,device_mismatch:*": { "subcaseMS": 8.700 },
+  "webgpu:api,validation,render_pipeline,misc:vertex_state_only:*": { "subcaseMS": 1.125 },
+  "webgpu:api,validation,render_pipeline,multisample_state:alpha_to_coverage,count:*": { "subcaseMS": 3.200 },
+  "webgpu:api,validation,render_pipeline,multisample_state:alpha_to_coverage,sample_mask:*": { "subcaseMS": 0.725 },
+  "webgpu:api,validation,render_pipeline,multisample_state:count:*": { "subcaseMS": 2.325 },
+  "webgpu:api,validation,render_pipeline,overrides:identifier,fragment:*": { "subcaseMS": 6.330 },
+  "webgpu:api,validation,render_pipeline,overrides:identifier,vertex:*": { "subcaseMS": 4.784 },
+  "webgpu:api,validation,render_pipeline,overrides:uninitialized,fragment:*": { "subcaseMS": 11.525 },
+  "webgpu:api,validation,render_pipeline,overrides:uninitialized,vertex:*": { "subcaseMS": 5.513 },
+  "webgpu:api,validation,render_pipeline,overrides:value,type_error,fragment:*": { "subcaseMS": 7.700 },
+  "webgpu:api,validation,render_pipeline,overrides:value,type_error,vertex:*": { "subcaseMS": 5.200 },
+  "webgpu:api,validation,render_pipeline,overrides:value,validation_error,f16,fragment:*": { "subcaseMS": 4.708 },
+  "webgpu:api,validation,render_pipeline,overrides:value,validation_error,f16,vertex:*": { "subcaseMS": 5.610 },
+  "webgpu:api,validation,render_pipeline,overrides:value,validation_error,fragment:*": { "subcaseMS": 6.840 },
+  "webgpu:api,validation,render_pipeline,overrides:value,validation_error,vertex:*": { "subcaseMS": 6.022 },
+  "webgpu:api,validation,render_pipeline,primitive_state:strip_index_format:*": { "subcaseMS": 5.267 },
+  "webgpu:api,validation,render_pipeline,primitive_state:unclipped_depth:*": { "subcaseMS": 1.025 },
+  "webgpu:api,validation,render_pipeline,shader_module:device_mismatch:*": { "subcaseMS": 0.700 },
+  "webgpu:api,validation,render_pipeline,shader_module:invalid,fragment:*": { "subcaseMS": 5.800 },
+  "webgpu:api,validation,render_pipeline,shader_module:invalid,vertex:*": { "subcaseMS": 15.151 },
+  "webgpu:api,validation,render_pipeline,vertex_state:many_attributes_overlapping:*": { "subcaseMS": 2.000 },
+  "webgpu:api,validation,render_pipeline,vertex_state:max_vertex_attribute_limit:*": { "subcaseMS": 2.817 },
+  "webgpu:api,validation,render_pipeline,vertex_state:max_vertex_buffer_array_stride_limit:*": { "subcaseMS": 1.972 },
+  "webgpu:api,validation,render_pipeline,vertex_state:max_vertex_buffer_limit:*": { "subcaseMS": 4.550 },
+  "webgpu:api,validation,render_pipeline,vertex_state:vertex_attribute_contained_in_stride:*": { "subcaseMS": 0.244 },
+  "webgpu:api,validation,render_pipeline,vertex_state:vertex_attribute_offset_alignment:*": { "subcaseMS": 1.213 },
+  "webgpu:api,validation,render_pipeline,vertex_state:vertex_attribute_shaderLocation_limit:*": { "subcaseMS": 0.649 },
+  "webgpu:api,validation,render_pipeline,vertex_state:vertex_attribute_shaderLocation_unique:*": { "subcaseMS": 0.200 },
+  "webgpu:api,validation,render_pipeline,vertex_state:vertex_buffer_array_stride_limit_alignment:*": { "subcaseMS": 0.300 },
+  "webgpu:api,validation,render_pipeline,vertex_state:vertex_shader_input_location_in_vertex_state:*": { "subcaseMS": 0.819 },
+  "webgpu:api,validation,render_pipeline,vertex_state:vertex_shader_input_location_limit:*": { "subcaseMS": 7.000 },
+  "webgpu:api,validation,render_pipeline,vertex_state:vertex_shader_type_matches_attribute_format:*": { "subcaseMS": 1.647 },
+  "webgpu:api,validation,resource_usages,buffer,in_pass_encoder:subresources,buffer_usage_in_compute_pass_with_two_dispatches:*": { "subcaseMS": 2.950 },
+  "webgpu:api,validation,resource_usages,buffer,in_pass_encoder:subresources,buffer_usage_in_one_compute_pass_with_no_dispatch:*": { "subcaseMS": 1.913 },
+  "webgpu:api,validation,resource_usages,buffer,in_pass_encoder:subresources,buffer_usage_in_one_compute_pass_with_one_dispatch:*": { "subcaseMS": 0.834 },
+  "webgpu:api,validation,resource_usages,buffer,in_pass_encoder:subresources,buffer_usage_in_one_render_pass_with_no_draw:*": { "subcaseMS": 1.458 },
+  "webgpu:api,validation,resource_usages,buffer,in_pass_encoder:subresources,buffer_usage_in_one_render_pass_with_one_draw:*": { "subcaseMS": 0.987 },
+  "webgpu:api,validation,resource_usages,buffer,in_pass_encoder:subresources,buffer_usage_in_one_render_pass_with_two_draws:*": { "subcaseMS": 2.027 },
+  "webgpu:api,validation,resource_usages,buffer,in_pass_misc:subresources,buffer_usages_in_copy_and_pass:*": { "subcaseMS": 7.673 },
+  "webgpu:api,validation,resource_usages,buffer,in_pass_misc:subresources,reset_buffer_usage_before_dispatch:*": { "subcaseMS": 8.242 },
+  "webgpu:api,validation,resource_usages,buffer,in_pass_misc:subresources,reset_buffer_usage_before_draw:*": { "subcaseMS": 4.953 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:bindings_in_bundle:*": { "subcaseMS": 3.281 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:replaced_binding:*": { "subcaseMS": 0.888 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:scope,basic,render:*": { "subcaseMS": 8.500 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:scope,dispatch:*": { "subcaseMS": 12.034 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:scope,pass_boundary,compute:*": { "subcaseMS": 16.550 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:scope,pass_boundary,render:*": { "subcaseMS": 8.700 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:shader_stages_and_visibility,attachment_write:*": { "subcaseMS": 4.425 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:shader_stages_and_visibility,storage_write:*": { "subcaseMS": 1.415 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:subresources_and_binding_types_combination_for_aspect:*": { "subcaseMS": 1.152 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:subresources_and_binding_types_combination_for_color:*": { "subcaseMS": 2.052 },
+  "webgpu:api,validation,resource_usages,texture,in_pass_encoder:unused_bindings_in_pipeline:*": { "subcaseMS": 4.219 },
+  "webgpu:api,validation,resource_usages,texture,in_render_common:subresources,color_attachment_and_bind_group:*": { "subcaseMS": 3.042 },
+  "webgpu:api,validation,resource_usages,texture,in_render_common:subresources,color_attachments:*": { "subcaseMS": 3.175 },
+  "webgpu:api,validation,resource_usages,texture,in_render_common:subresources,depth_stencil_attachment_and_bind_group:*": { "subcaseMS": 1.667 },
+  "webgpu:api,validation,resource_usages,texture,in_render_common:subresources,depth_stencil_texture_in_bind_groups:*": { "subcaseMS": 3.050 },
+  "webgpu:api,validation,resource_usages,texture,in_render_common:subresources,multiple_bind_groups:*": { "subcaseMS": 3.045 },
+  "webgpu:api,validation,resource_usages,texture,in_render_misc:subresources,set_bind_group_on_same_index_color_texture:*": { "subcaseMS": 4.541 },
+  "webgpu:api,validation,resource_usages,texture,in_render_misc:subresources,set_bind_group_on_same_index_depth_stencil_texture:*": { "subcaseMS": 0.925 },
+  "webgpu:api,validation,resource_usages,texture,in_render_misc:subresources,set_unused_bind_group:*": { "subcaseMS": 6.200 },
+  "webgpu:api,validation,resource_usages,texture,in_render_misc:subresources,texture_usages_in_copy_and_render_pass:*": { "subcaseMS": 4.763 },
+  "webgpu:api,validation,shader_module,entry_point:compute:*": { "subcaseMS": 4.439 },
+  "webgpu:api,validation,shader_module,entry_point:fragment:*": { "subcaseMS": 5.865 },
+  "webgpu:api,validation,shader_module,entry_point:vertex:*": { "subcaseMS": 5.803 },
+  "webgpu:api,validation,shader_module,overrides:id_conflict:*": { "subcaseMS": 36.700 },
+  "webgpu:api,validation,shader_module,overrides:name_conflict:*": { "subcaseMS": 1.500 },
+  "webgpu:api,validation,state,device_lost,destroy:command,clearBuffer:*": { "subcaseMS": 11.826 },
+  "webgpu:api,validation,state,device_lost,destroy:command,computePass,dispatch:*": { "subcaseMS": 75.850 },
+  "webgpu:api,validation,state,device_lost,destroy:command,copyBufferToBuffer:*": { "subcaseMS": 32.100 },
+  "webgpu:api,validation,state,device_lost,destroy:command,copyBufferToTexture:*": { "subcaseMS": 1.450 },
+  "webgpu:api,validation,state,device_lost,destroy:command,copyTextureToBuffer:*": { "subcaseMS": 32.400 },
+  "webgpu:api,validation,state,device_lost,destroy:command,copyTextureToTexture:*": { "subcaseMS": 9.650 },
+  "webgpu:api,validation,state,device_lost,destroy:command,renderPass,draw:*": { "subcaseMS": 26.526 },
+  "webgpu:api,validation,state,device_lost,destroy:command,renderPass,renderBundle:*": { "subcaseMS": 21.125 },
+  "webgpu:api,validation,state,device_lost,destroy:command,resolveQuerySet:*": { "subcaseMS": 32.725 },
+  "webgpu:api,validation,state,device_lost,destroy:command,writeTimestamp:*": { "subcaseMS": 0.704 },
+  "webgpu:api,validation,state,device_lost,destroy:createBindGroup:*": { "subcaseMS": 91.575 },
+  "webgpu:api,validation,state,device_lost,destroy:createBindGroupLayout:*": { "subcaseMS": 22.984 },
+  "webgpu:api,validation,state,device_lost,destroy:createBuffer:*": { "subcaseMS": 5.030 },
+  "webgpu:api,validation,state,device_lost,destroy:createCommandEncoder:*": { "subcaseMS": 35.100 },
+  "webgpu:api,validation,state,device_lost,destroy:createComputePipeline:*": { "subcaseMS": 39.750 },
+  "webgpu:api,validation,state,device_lost,destroy:createComputePipelineAsync:*": { "subcaseMS": 11.476 },
+  "webgpu:api,validation,state,device_lost,destroy:createPipelineLayout:*": { "subcaseMS": 22.145 },
+  "webgpu:api,validation,state,device_lost,destroy:createQuerySet:*": { "subcaseMS": 30.001 },
+  "webgpu:api,validation,state,device_lost,destroy:createRenderBundleEncoder:*": { "subcaseMS": 13.350 },
+  "webgpu:api,validation,state,device_lost,destroy:createRenderPipeline:*": { "subcaseMS": 39.450 },
+  "webgpu:api,validation,state,device_lost,destroy:createRenderPipelineAsync:*": { "subcaseMS": 19.025 },
+  "webgpu:api,validation,state,device_lost,destroy:createSampler:*": { "subcaseMS": 31.401 },
+  "webgpu:api,validation,state,device_lost,destroy:createShaderModule:*": { "subcaseMS": 19.750 },
+  "webgpu:api,validation,state,device_lost,destroy:createTexture,2d,compressed_format:*": { "subcaseMS": 14.241 },
+  "webgpu:api,validation,state,device_lost,destroy:createTexture,2d,uncompressed_format:*": { "subcaseMS": 7.622 },
+  "webgpu:api,validation,state,device_lost,destroy:createView,2d,compressed_format:*": { "subcaseMS": 19.612 },
+  "webgpu:api,validation,state,device_lost,destroy:createView,2d,uncompressed_format:*": { "subcaseMS": 19.895 },
+  "webgpu:api,validation,state,device_lost,destroy:importExternalTexture:*": { "subcaseMS": 92.051 },
+  "webgpu:api,validation,state,device_lost,destroy:queue,copyExternalImageToTexture,canvas:*": { "subcaseMS": 28.596 },
+  "webgpu:api,validation,state,device_lost,destroy:queue,copyExternalImageToTexture,imageBitmap:*": { "subcaseMS": 31.950 },
+  "webgpu:api,validation,state,device_lost,destroy:queue,writeBuffer:*": { "subcaseMS": 18.851 },
+  "webgpu:api,validation,state,device_lost,destroy:queue,writeTexture,2d,compressed_format:*": { "subcaseMS": 18.115 },
+  "webgpu:api,validation,state,device_lost,destroy:queue,writeTexture,2d,uncompressed_format:*": { "subcaseMS": 17.620 },
+  "webgpu:api,validation,texture,bgra8unorm_storage:configure_storage_usage_on_canvas_context_with_bgra8unorm_storage:*": { "subcaseMS": 3.230 },
+  "webgpu:api,validation,texture,bgra8unorm_storage:configure_storage_usage_on_canvas_context_without_bgra8unorm_storage:*": { "subcaseMS": 1.767 },
+  "webgpu:api,validation,texture,bgra8unorm_storage:create_bind_group_layout:*": { "subcaseMS": 21.500 },
+  "webgpu:api,validation,texture,bgra8unorm_storage:create_shader_module_with_bgra8unorm_storage:*": { "subcaseMS": 11.201 },
+  "webgpu:api,validation,texture,bgra8unorm_storage:create_shader_module_without_bgra8unorm_storage:*": { "subcaseMS": 1.601 },
+  "webgpu:api,validation,texture,bgra8unorm_storage:create_texture:*": { "subcaseMS": 22.900 },
+  "webgpu:api,validation,texture,destroy:base:*": { "subcaseMS": 4.000 },
+  "webgpu:api,validation,texture,destroy:invalid_texture:*": { "subcaseMS": 27.200 },
+  "webgpu:api,validation,texture,destroy:submit_a_destroyed_texture_as_attachment:*": { "subcaseMS": 11.812 },
+  "webgpu:api,validation,texture,destroy:twice:*": { "subcaseMS": 1.400 },
+  "webgpu:api,validation,texture,float32_filterable:create_bind_group:*": { "subcaseMS": 0.901 },
+  "webgpu:api,validation,texture,rg11b10ufloat_renderable:begin_render_bundle_encoder:*": { "subcaseMS": 1.101 },
+  "webgpu:api,validation,texture,rg11b10ufloat_renderable:begin_render_pass_msaa_and_resolve:*": { "subcaseMS": 0.900 },
+  "webgpu:api,validation,texture,rg11b10ufloat_renderable:begin_render_pass_single_sampled:*": { "subcaseMS": 1.200 },
+  "webgpu:api,validation,texture,rg11b10ufloat_renderable:create_render_pipeline:*": { "subcaseMS": 2.400 },
+  "webgpu:api,validation,texture,rg11b10ufloat_renderable:create_texture:*": { "subcaseMS": 12.700 },
+  "webgpu:compat,api,validation,encoding,cmds,copyTextureToBuffer:compressed:*": { "subcaseMS": 202.929 },
+  "webgpu:compat,api,validation,encoding,programmable,pipeline_bind_group_compat:twoDifferentTextureViews,compute_pass,unused:*": { "subcaseMS": 1.501 },
+  "webgpu:compat,api,validation,encoding,programmable,pipeline_bind_group_compat:twoDifferentTextureViews,compute_pass,used:*": { "subcaseMS": 49.405 },
+  "webgpu:compat,api,validation,encoding,programmable,pipeline_bind_group_compat:twoDifferentTextureViews,render_pass,unused:*": { "subcaseMS": 16.002 },
+  "webgpu:compat,api,validation,encoding,programmable,pipeline_bind_group_compat:twoDifferentTextureViews,render_pass,used:*": { "subcaseMS": 0.000 },
+  "webgpu:compat,api,validation,render_pipeline,fragment_state:colorState:*": { "subcaseMS": 32.604 },
+  "webgpu:compat,api,validation,render_pipeline,shader_module:sample_mask:*": { "subcaseMS": 14.801 },
+  "webgpu:compat,api,validation,texture,createTexture:unsupportedTextureFormats:*": { "subcaseMS": 0.700 },
+  "webgpu:compat,api,validation,texture,createTexture:unsupportedTextureViewFormats:*": { "subcaseMS": 0.601 },
+  "webgpu:compat,api,validation,texture,cubeArray:cube_array:*": { "subcaseMS": 13.701 },
+  "webgpu:examples:basic,async:*": { "subcaseMS": 16.401 },
+  "webgpu:examples:basic,builder_cases:*": { "subcaseMS": 7.275 },
+  "webgpu:examples:basic,builder_cases_subcases:*": { "subcaseMS": 0.425 },
+  "webgpu:examples:basic,builder_subcases:*": { "subcaseMS": 0.175 },
+  "webgpu:examples:basic,builder_subcases_short:*": { "subcaseMS": 3.300 },
+  "webgpu:examples:basic,plain_cases:*": { "subcaseMS": 8.450 },
+  "webgpu:examples:basic,plain_cases_private:*": { "subcaseMS": 9.850 },
+  "webgpu:examples:basic:*": { "subcaseMS": 0.901 },
+  "webgpu:examples:gpu,async:*": { "subcaseMS": 1.600 },
+  "webgpu:examples:gpu,buffers:*": { "subcaseMS": 17.301 },
+  "webgpu:examples:gpu,with_texture_compression,bc:*": { "subcaseMS": 7.500 },
+  "webgpu:examples:gpu,with_texture_compression,etc2:*": { "subcaseMS": 0.750 },
+  "webgpu:examples:not_implemented_yet,with_plan:*": { "subcaseMS": 0.500 },
+  "webgpu:examples:not_implemented_yet,without_plan:*": { "subcaseMS": 0.701 },
+  "webgpu:examples:test_name:*": { "subcaseMS": 14.601 },
+  "webgpu:idl,constants,flags:BufferUsage,count:*": { "subcaseMS": 0.301 },
+  "webgpu:idl,constants,flags:BufferUsage,values:*": { "subcaseMS": 0.120 },
+  "webgpu:idl,constants,flags:ColorWrite,count:*": { "subcaseMS": 0.101 },
+  "webgpu:idl,constants,flags:ColorWrite,values:*": { "subcaseMS": 0.101 },
+  "webgpu:idl,constants,flags:ShaderStage,count:*": { "subcaseMS": 0.101 },
+  "webgpu:idl,constants,flags:ShaderStage,values:*": { "subcaseMS": 0.034 },
+  "webgpu:idl,constants,flags:TextureUsage,count:*": { "subcaseMS": 0.101 },
+  "webgpu:idl,constants,flags:TextureUsage,values:*": { "subcaseMS": 0.040 },
+  "webgpu:shader,execution,expression,binary,af_addition:scalar:*": { "subcaseMS": 290.000 },
+  "webgpu:shader,execution,expression,binary,af_addition:scalar_vector:*": { "subcaseMS": 665.234 },
+  "webgpu:shader,execution,expression,binary,af_addition:vector_scalar:*": { "subcaseMS": 664.434 },
+  "webgpu:shader,execution,expression,binary,af_comparison:equals:*": { "subcaseMS": 23.000 },
+  "webgpu:shader,execution,expression,binary,af_comparison:greater_equals:*": { "subcaseMS": 20.651 },
+  "webgpu:shader,execution,expression,binary,af_comparison:greater_than:*": { "subcaseMS": 19.901 },
+  "webgpu:shader,execution,expression,binary,af_comparison:less_equals:*": { "subcaseMS": 19.651 },
+  "webgpu:shader,execution,expression,binary,af_comparison:less_than:*": { "subcaseMS": 19.975 },
+  "webgpu:shader,execution,expression,binary,af_comparison:not_equals:*": { "subcaseMS": 19.651 },
+  "webgpu:shader,execution,expression,binary,bitwise:bitwise_and:*": { "subcaseMS": 20.982 },
+  "webgpu:shader,execution,expression,binary,bitwise:bitwise_and_compound:*": { "subcaseMS": 22.513 },
+  "webgpu:shader,execution,expression,binary,bitwise:bitwise_exclusive_or:*": { "subcaseMS": 21.294 },
+  "webgpu:shader,execution,expression,binary,bitwise:bitwise_exclusive_or_compound:*": { "subcaseMS": 21.326 },
+  "webgpu:shader,execution,expression,binary,bitwise:bitwise_or:*": { "subcaseMS": 23.782 },
+  "webgpu:shader,execution,expression,binary,bitwise:bitwise_or_compound:*": { "subcaseMS": 27.088 },
+  "webgpu:shader,execution,expression,binary,bitwise_shift:shift_left_concrete:*": { "subcaseMS": 10.466 },
+  "webgpu:shader,execution,expression,binary,bitwise_shift:shift_left_concrete_compound:*": { "subcaseMS": 9.657 },
+  "webgpu:shader,execution,expression,binary,bitwise_shift:shift_right_concrete:*": { "subcaseMS": 11.744 },
+  "webgpu:shader,execution,expression,binary,bitwise_shift:shift_right_concrete_compound:*": { "subcaseMS": 11.097 },
+  "webgpu:shader,execution,expression,binary,bool_logical:and:*": { "subcaseMS": 7.325 },
+  "webgpu:shader,execution,expression,binary,bool_logical:and_compound:*": { "subcaseMS": 8.044 },
+  "webgpu:shader,execution,expression,binary,bool_logical:and_short_circuit:*": { "subcaseMS": 8.950 },
+  "webgpu:shader,execution,expression,binary,bool_logical:equals:*": { "subcaseMS": 7.075 },
+  "webgpu:shader,execution,expression,binary,bool_logical:not_equals:*": { "subcaseMS": 8.800 },
+  "webgpu:shader,execution,expression,binary,bool_logical:or:*": { "subcaseMS": 6.663 },
+  "webgpu:shader,execution,expression,binary,bool_logical:or_compound:*": { "subcaseMS": 7.407 },
+  "webgpu:shader,execution,expression,binary,bool_logical:or_short_circuit:*": { "subcaseMS": 10.050 },
+  "webgpu:shader,execution,expression,binary,f16_addition:scalar:*": { "subcaseMS": 6.807 },
+  "webgpu:shader,execution,expression,binary,f16_addition:scalar_compound:*": { "subcaseMS": 4.010 },
+  "webgpu:shader,execution,expression,binary,f16_addition:scalar_vector:*": { "subcaseMS": 2.606 },
+  "webgpu:shader,execution,expression,binary,f16_addition:vector_scalar:*": { "subcaseMS": 3.006 },
+  "webgpu:shader,execution,expression,binary,f16_addition:vector_scalar_compound:*": { "subcaseMS": 2.503 },
+  "webgpu:shader,execution,expression,binary,f16_comparison:equals:*": { "subcaseMS": 3.907 },
+  "webgpu:shader,execution,expression,binary,f16_comparison:greater_equals:*": { "subcaseMS": 3.507 },
+  "webgpu:shader,execution,expression,binary,f16_comparison:greater_than:*": { "subcaseMS": 3.908 },
+  "webgpu:shader,execution,expression,binary,f16_comparison:less_equals:*": { "subcaseMS": 3.108 },
+  "webgpu:shader,execution,expression,binary,f16_comparison:less_than:*": { "subcaseMS": 3.508 },
+  "webgpu:shader,execution,expression,binary,f16_comparison:not_equals:*": { "subcaseMS": 3.405 },
+  "webgpu:shader,execution,expression,binary,f16_division:scalar:*": { "subcaseMS": 3.105 },
+  "webgpu:shader,execution,expression,binary,f16_division:scalar_compound:*": { "subcaseMS": 4.011 },
+  "webgpu:shader,execution,expression,binary,f16_division:scalar_vector:*": { "subcaseMS": 2.406 },
+  "webgpu:shader,execution,expression,binary,f16_division:vector_scalar:*": { "subcaseMS": 3.006 },
+  "webgpu:shader,execution,expression,binary,f16_division:vector_scalar_compound:*": { "subcaseMS": 3.005 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:scalar:*": { "subcaseMS": 4.010 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:scalar_compound:*": { "subcaseMS": 3.906 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:scalar_vector:*": { "subcaseMS": 2.708 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:vector_scalar:*": { "subcaseMS": 3.306 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:vector_scalar_compound:*": { "subcaseMS": 2.501 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:scalar:*": { "subcaseMS": 3.406 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:scalar_compound:*": { "subcaseMS": 4.203 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:scalar_vector:*": { "subcaseMS": 2.602 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:vector_scalar:*": { "subcaseMS": 2.605 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:vector_scalar_compound:*": { "subcaseMS": 2.604 },
+  "webgpu:shader,execution,expression,binary,f32_addition:scalar:*": { "subcaseMS": 17.788 },
+  "webgpu:shader,execution,expression,binary,f32_addition:scalar_compound:*": { "subcaseMS": 9.919 },
+  "webgpu:shader,execution,expression,binary,f32_addition:scalar_vector:*": { "subcaseMS": 12.600 },
+  "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar:*": { "subcaseMS": 12.550 },
+  "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar_compound:*": { "subcaseMS": 12.142 },
+  "webgpu:shader,execution,expression,binary,f32_comparison:equals:*": { "subcaseMS": 9.638 },
+  "webgpu:shader,execution,expression,binary,f32_comparison:greater_equals:*": { "subcaseMS": 7.882 },
+  "webgpu:shader,execution,expression,binary,f32_comparison:greater_than:*": { "subcaseMS": 7.388 },
+  "webgpu:shader,execution,expression,binary,f32_comparison:less_equals:*": { "subcaseMS": 6.632 },
+  "webgpu:shader,execution,expression,binary,f32_comparison:less_than:*": { "subcaseMS": 6.969 },
+  "webgpu:shader,execution,expression,binary,f32_comparison:not_equals:*": { "subcaseMS": 6.819 },
+  "webgpu:shader,execution,expression,binary,f32_division:scalar:*": { "subcaseMS": 19.688 },
+  "webgpu:shader,execution,expression,binary,f32_division:scalar_compound:*": { "subcaseMS": 8.294 },
+  "webgpu:shader,execution,expression,binary,f32_division:scalar_vector:*": { "subcaseMS": 19.142 },
+  "webgpu:shader,execution,expression,binary,f32_division:vector_scalar:*": { "subcaseMS": 17.900 },
+  "webgpu:shader,execution,expression,binary,f32_division:vector_scalar_compound:*": { "subcaseMS": 9.859 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_addition:matrix:*": { "subcaseMS": 35.020 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_addition:matrix_compound:*": { "subcaseMS": 27.534 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_matrix_multiplication:matrix_matrix:*": { "subcaseMS": 134.680 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_matrix_multiplication:matrix_matrix_compound:*": { "subcaseMS": 24.848 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_scalar_multiplication:matrix_scalar:*": { "subcaseMS": 96.756 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_scalar_multiplication:matrix_scalar_compound:*": { "subcaseMS": 21.181 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_scalar_multiplication:scalar_matrix:*": { "subcaseMS": 21.600 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_subtraction:matrix:*": { "subcaseMS": 34.489 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_subtraction:matrix_compound:*": { "subcaseMS": 27.645 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_vector_multiplication:matrix_vector:*": { "subcaseMS": 105.139 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_vector_multiplication:vector_matrix:*": { "subcaseMS": 22.501 },
+  "webgpu:shader,execution,expression,binary,f32_matrix_vector_multiplication:vector_matrix_compound:*": { "subcaseMS": 16.217 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:scalar:*": { "subcaseMS": 26.382 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:scalar_compound:*": { "subcaseMS": 10.250 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:scalar_vector:*": { "subcaseMS": 35.359 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:vector_scalar:*": { "subcaseMS": 34.834 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:vector_scalar_compound:*": { "subcaseMS": 11.609 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:scalar:*": { "subcaseMS": 21.982 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:scalar_compound:*": { "subcaseMS": 8.844 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:scalar_vector:*": { "subcaseMS": 10.650 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:vector_scalar:*": { "subcaseMS": 9.525 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:vector_scalar_compound:*": { "subcaseMS": 9.925 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:scalar:*": { "subcaseMS": 12.813 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:scalar_compound:*": { "subcaseMS": 9.213 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:scalar_vector:*": { "subcaseMS": 14.125 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:vector_scalar:*": { "subcaseMS": 13.292 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:vector_scalar_compound:*": { "subcaseMS": 13.150 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:addition:*": { "subcaseMS": 23.975 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:addition_compound:*": { "subcaseMS": 9.219 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:addition_scalar_vector:*": { "subcaseMS": 33.059 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:addition_vector_scalar:*": { "subcaseMS": 32.475 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:addition_vector_scalar_compound:*": { "subcaseMS": 30.875 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:division:*": { "subcaseMS": 8.444 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:division_compound:*": { "subcaseMS": 8.407 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:division_scalar_vector:*": { "subcaseMS": 27.809 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:division_vector_scalar:*": { "subcaseMS": 28.550 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:division_vector_scalar_compound:*": { "subcaseMS": 28.950 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:multiplication:*": { "subcaseMS": 8.976 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:multiplication_compound:*": { "subcaseMS": 9.601 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:multiplication_scalar_vector:*": { "subcaseMS": 33.742 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:multiplication_vector_scalar:*": { "subcaseMS": 33.042 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:multiplication_vector_scalar_compound:*": { "subcaseMS": 31.425 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:remainder:*": { "subcaseMS": 8.600 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:remainder_compound:*": { "subcaseMS": 9.119 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:remainder_scalar_vector:*": { "subcaseMS": 27.192 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:remainder_vector_scalar:*": { "subcaseMS": 27.284 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:remainder_vector_scalar_compound:*": { "subcaseMS": 29.875 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:subtraction:*": { "subcaseMS": 9.513 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:subtraction_compound:*": { "subcaseMS": 7.994 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:subtraction_scalar_vector:*": { "subcaseMS": 34.034 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:subtraction_vector_scalar:*": { "subcaseMS": 32.642 },
+  "webgpu:shader,execution,expression,binary,i32_arithmetic:subtraction_vector_scalar_compound:*": { "subcaseMS": 30.400 },
+  "webgpu:shader,execution,expression,binary,i32_comparison:equals:*": { "subcaseMS": 9.544 },
+  "webgpu:shader,execution,expression,binary,i32_comparison:greater_equals:*": { "subcaseMS": 7.657 },
+  "webgpu:shader,execution,expression,binary,i32_comparison:greater_than:*": { "subcaseMS": 7.169 },
+  "webgpu:shader,execution,expression,binary,i32_comparison:less_equals:*": { "subcaseMS": 8.063 },
+  "webgpu:shader,execution,expression,binary,i32_comparison:less_than:*": { "subcaseMS": 7.894 },
+  "webgpu:shader,execution,expression,binary,i32_comparison:not_equals:*": { "subcaseMS": 7.588 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:addition:*": { "subcaseMS": 9.806 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:addition_compound:*": { "subcaseMS": 8.494 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:addition_scalar_vector:*": { "subcaseMS": 10.409 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:addition_vector_scalar:*": { "subcaseMS": 9.676 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:addition_vector_scalar_compound:*": { "subcaseMS": 9.925 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:division:*": { "subcaseMS": 7.138 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:division_compound:*": { "subcaseMS": 7.544 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:division_scalar_vector:*": { "subcaseMS": 9.959 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:division_vector_scalar:*": { "subcaseMS": 9.767 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:division_vector_scalar_compound:*": { "subcaseMS": 10.167 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:multiplication:*": { "subcaseMS": 7.544 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:multiplication_compound:*": { "subcaseMS": 7.332 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:multiplication_scalar_vector:*": { "subcaseMS": 9.867 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:multiplication_vector_scalar:*": { "subcaseMS": 9.159 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:multiplication_vector_scalar_compound:*": { "subcaseMS": 9.667 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:remainder:*": { "subcaseMS": 8.188 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:remainder_compound:*": { "subcaseMS": 7.994 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:remainder_scalar_vector:*": { "subcaseMS": 9.842 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:remainder_vector_scalar:*": { "subcaseMS": 10.292 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:remainder_vector_scalar_compound:*": { "subcaseMS": 9.617 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:subtraction:*": { "subcaseMS": 16.119 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:subtraction_compound:*": { "subcaseMS": 7.982 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:subtraction_scalar_vector:*": { "subcaseMS": 9.842 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:subtraction_vector_scalar:*": { "subcaseMS": 9.667 },
+  "webgpu:shader,execution,expression,binary,u32_arithmetic:subtraction_vector_scalar_compound:*": { "subcaseMS": 10.859 },
+  "webgpu:shader,execution,expression,binary,u32_comparison:equals:*": { "subcaseMS": 8.938 },
+  "webgpu:shader,execution,expression,binary,u32_comparison:greater_equals:*": { "subcaseMS": 6.732 },
+  "webgpu:shader,execution,expression,binary,u32_comparison:greater_than:*": { "subcaseMS": 7.232 },
+  "webgpu:shader,execution,expression,binary,u32_comparison:less_equals:*": { "subcaseMS": 7.844 },
+  "webgpu:shader,execution,expression,binary,u32_comparison:less_than:*": { "subcaseMS": 6.700 },
+  "webgpu:shader,execution,expression,binary,u32_comparison:not_equals:*": { "subcaseMS": 6.850 },
+  "webgpu:shader,execution,expression,call,builtin,abs:abstract_float:*": { "subcaseMS": 16.809 },
+  "webgpu:shader,execution,expression,call,builtin,abs:abstract_int:*": { "subcaseMS": 16.810 },
+  "webgpu:shader,execution,expression,call,builtin,abs:f16:*": { "subcaseMS": 22.910 },
+  "webgpu:shader,execution,expression,call,builtin,abs:f32:*": { "subcaseMS": 9.844 },
+  "webgpu:shader,execution,expression,call,builtin,abs:i32:*": { "subcaseMS": 7.088 },
+  "webgpu:shader,execution,expression,call,builtin,abs:u32:*": { "subcaseMS": 7.513 },
+  "webgpu:shader,execution,expression,call,builtin,acos:abstract_float:*": { "subcaseMS": 15.505 },
+  "webgpu:shader,execution,expression,call,builtin,acos:f16:*": { "subcaseMS": 26.005 },
+  "webgpu:shader,execution,expression,call,builtin,acos:f32:*": { "subcaseMS": 33.063 },
+  "webgpu:shader,execution,expression,call,builtin,acosh:abstract_float:*": { "subcaseMS": 17.210 },
+  "webgpu:shader,execution,expression,call,builtin,acosh:f16:*": { "subcaseMS": 23.306 },
+  "webgpu:shader,execution,expression,call,builtin,acosh:f32:*": { "subcaseMS": 12.588 },
+  "webgpu:shader,execution,expression,call,builtin,all:bool:*": { "subcaseMS": 6.938 },
+  "webgpu:shader,execution,expression,call,builtin,any:bool:*": { "subcaseMS": 6.475 },
+  "webgpu:shader,execution,expression,call,builtin,arrayLength:binding_subregion:*": { "subcaseMS": 19.900 },
+  "webgpu:shader,execution,expression,call,builtin,arrayLength:multiple_elements:*": { "subcaseMS": 6.261 },
+  "webgpu:shader,execution,expression,call,builtin,arrayLength:read_only:*": { "subcaseMS": 4.500 },
+  "webgpu:shader,execution,expression,call,builtin,arrayLength:single_element:*": { "subcaseMS": 6.569 },
+  "webgpu:shader,execution,expression,call,builtin,arrayLength:struct_member:*": { "subcaseMS": 6.819 },
+  "webgpu:shader,execution,expression,call,builtin,asin:abstract_float:*": { "subcaseMS": 16.606 },
+  "webgpu:shader,execution,expression,call,builtin,asin:f16:*": { "subcaseMS": 6.708 },
+  "webgpu:shader,execution,expression,call,builtin,asin:f32:*": { "subcaseMS": 33.969 },
+  "webgpu:shader,execution,expression,call,builtin,asinh:abstract_float:*": { "subcaseMS": 23.305 },
+  "webgpu:shader,execution,expression,call,builtin,asinh:f16:*": { "subcaseMS": 16.509 },
+  "webgpu:shader,execution,expression,call,builtin,asinh:f32:*": { "subcaseMS": 9.731 },
+  "webgpu:shader,execution,expression,call,builtin,atan2:abstract_float:*": { "subcaseMS": 24.705 },
+  "webgpu:shader,execution,expression,call,builtin,atan2:f16:*": { "subcaseMS": 32.506 },
+  "webgpu:shader,execution,expression,call,builtin,atan2:f32:*": { "subcaseMS": 25.938 },
+  "webgpu:shader,execution,expression,call,builtin,atan:abstract_float:*": { "subcaseMS": 32.408 },
+  "webgpu:shader,execution,expression,call,builtin,atan:f16:*": { "subcaseMS": 21.106 },
+  "webgpu:shader,execution,expression,call,builtin,atan:f32:*": { "subcaseMS": 10.251 },
+  "webgpu:shader,execution,expression,call,builtin,atanh:abstract_float:*": { "subcaseMS": 16.807 },
+  "webgpu:shader,execution,expression,call,builtin,atanh:f16:*": { "subcaseMS": 26.507 },
+  "webgpu:shader,execution,expression,call,builtin,atanh:f32:*": { "subcaseMS": 12.332 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicAdd:add_storage:*": { "subcaseMS": 6.482 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicAdd:add_workgroup:*": { "subcaseMS": 7.222 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicAnd:and_storage:*": { "subcaseMS": 6.711 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicAnd:and_workgroup:*": { "subcaseMS": 8.028 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicCompareExchangeWeak:compare_exchange_weak_storage_advanced:*": { "subcaseMS": 10.090 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicCompareExchangeWeak:compare_exchange_weak_storage_basic:*": { "subcaseMS": 9.529 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicCompareExchangeWeak:compare_exchange_weak_workgroup_advanced:*": { "subcaseMS": 10.012 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicCompareExchangeWeak:compare_exchange_weak_workgroup_basic:*": { "subcaseMS": 10.368 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicExchange:exchange_storage_advanced:*": { "subcaseMS": 8.755 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicExchange:exchange_storage_basic:*": { "subcaseMS": 5.725 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicExchange:exchange_workgroup_advanced:*": { "subcaseMS": 9.885 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicExchange:exchange_workgroup_basic:*": { "subcaseMS": 6.966 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicLoad:load_storage:*": { "subcaseMS": 5.354 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicLoad:load_workgroup:*": { "subcaseMS": 6.269 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicMax:max_storage:*": { "subcaseMS": 6.116 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicMax:max_workgroup:*": { "subcaseMS": 7.010 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicMin:min_storage:*": { "subcaseMS": 6.235 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicMin:min_workgroup:*": { "subcaseMS": 7.307 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicOr:or_storage:*": { "subcaseMS": 6.791 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicOr:or_workgroup:*": { "subcaseMS": 7.814 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicStore:store_storage_advanced:*": { "subcaseMS": 5.707 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicStore:store_storage_basic:*": { "subcaseMS": 5.524 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicStore:store_workgroup_advanced:*": { "subcaseMS": 6.029 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicStore:store_workgroup_basic:*": { "subcaseMS": 6.632 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicSub:sub_storage:*": { "subcaseMS": 5.757 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicSub:sub_workgroup:*": { "subcaseMS": 7.238 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicXor:xor_storage:*": { "subcaseMS": 6.807 },
+  "webgpu:shader,execution,expression,call,builtin,atomics,atomicXor:xor_workgroup:*": { "subcaseMS": 7.821 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:f16_to_f16:*": { "subcaseMS": 21.112 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:f32_to_f32:*": { "subcaseMS": 8.625 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:f32_to_i32:*": { "subcaseMS": 8.175 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:f32_to_u32:*": { "subcaseMS": 8.016 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:f32_to_vec2h:*": { "subcaseMS": 22.212 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:i32_to_f32:*": { "subcaseMS": 31.814 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:i32_to_i32:*": { "subcaseMS": 23.863 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:i32_to_u32:*": { "subcaseMS": 7.263 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:i32_to_vec2h:*": { "subcaseMS": 28.214 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:u32_to_f32:*": { "subcaseMS": 20.716 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:u32_to_i32:*": { "subcaseMS": 6.982 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:u32_to_u32:*": { "subcaseMS": 6.907 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:u32_to_vec2h:*": { "subcaseMS": 22.210 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:vec2f_to_vec4h:*": { "subcaseMS": 24.015 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:vec2h_to_f32:*": { "subcaseMS": 21.412 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:vec2h_to_i32:*": { "subcaseMS": 38.312 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:vec2h_to_u32:*": { "subcaseMS": 23.711 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:vec2i_to_vec4h:*": { "subcaseMS": 23.211 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:vec2u_to_vec4h:*": { "subcaseMS": 23.010 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:vec4h_to_vec2f:*": { "subcaseMS": 22.812 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:vec4h_to_vec2i:*": { "subcaseMS": 20.915 },
+  "webgpu:shader,execution,expression,call,builtin,bitcast:vec4h_to_vec2u:*": { "subcaseMS": 29.514 },
+  "webgpu:shader,execution,expression,call,builtin,ceil:abstract_float:*": { "subcaseMS": 23.611 },
+  "webgpu:shader,execution,expression,call,builtin,ceil:f16:*": { "subcaseMS": 29.209 },
+  "webgpu:shader,execution,expression,call,builtin,ceil:f32:*": { "subcaseMS": 11.132 },
+  "webgpu:shader,execution,expression,call,builtin,clamp:abstract_float:*": { "subcaseMS": 28.706 },
+  "webgpu:shader,execution,expression,call,builtin,clamp:abstract_int:*": { "subcaseMS": 18.104 },
+  "webgpu:shader,execution,expression,call,builtin,clamp:f16:*": { "subcaseMS": 32.809 },
+  "webgpu:shader,execution,expression,call,builtin,clamp:f32:*": { "subcaseMS": 159.926 },
+  "webgpu:shader,execution,expression,call,builtin,clamp:i32:*": { "subcaseMS": 54.200 },
+  "webgpu:shader,execution,expression,call,builtin,clamp:u32:*": { "subcaseMS": 272.419 },
+  "webgpu:shader,execution,expression,call,builtin,cos:abstract_float:*": { "subcaseMS": 16.706 },
+  "webgpu:shader,execution,expression,call,builtin,cos:f16:*": { "subcaseMS": 23.905 },
+  "webgpu:shader,execution,expression,call,builtin,cos:f32:*": { "subcaseMS": 25.275 },
+  "webgpu:shader,execution,expression,call,builtin,cosh:abstract_float:*": { "subcaseMS": 22.909 },
+  "webgpu:shader,execution,expression,call,builtin,cosh:f16:*": { "subcaseMS": 17.409 },
+  "webgpu:shader,execution,expression,call,builtin,cosh:f32:*": { "subcaseMS": 9.694 },
+  "webgpu:shader,execution,expression,call,builtin,countLeadingZeros:i32:*": { "subcaseMS": 7.494 },
+  "webgpu:shader,execution,expression,call,builtin,countLeadingZeros:u32:*": { "subcaseMS": 8.088 },
+  "webgpu:shader,execution,expression,call,builtin,countOneBits:i32:*": { "subcaseMS": 7.400 },
+  "webgpu:shader,execution,expression,call,builtin,countOneBits:u32:*": { "subcaseMS": 8.644 },
+  "webgpu:shader,execution,expression,call,builtin,countTrailingZeros:i32:*": { "subcaseMS": 7.844 },
+  "webgpu:shader,execution,expression,call,builtin,countTrailingZeros:u32:*": { "subcaseMS": 7.851 },
+  "webgpu:shader,execution,expression,call,builtin,cross:abstract_float:*": { "subcaseMS": 3.002 },
+  "webgpu:shader,execution,expression,call,builtin,cross:f16:*": { "subcaseMS": 16.101 },
+  "webgpu:shader,execution,expression,call,builtin,cross:f32:*": { "subcaseMS": 664.926 },
+  "webgpu:shader,execution,expression,call,builtin,degrees:abstract_float:*": { "subcaseMS": 43.808 },
+  "webgpu:shader,execution,expression,call,builtin,degrees:f16:*": { "subcaseMS": 29.308 },
+  "webgpu:shader,execution,expression,call,builtin,degrees:f32:*": { "subcaseMS": 23.894 },
+  "webgpu:shader,execution,expression,call,builtin,determinant:abstract_float:*": { "subcaseMS": 15.306 },
+  "webgpu:shader,execution,expression,call,builtin,determinant:f16:*": { "subcaseMS": 22.806 },
+  "webgpu:shader,execution,expression,call,builtin,determinant:f32:*": { "subcaseMS": 10.742 },
+  "webgpu:shader,execution,expression,call,builtin,distance:abstract_float:*": { "subcaseMS": 14.503 },
+  "webgpu:shader,execution,expression,call,builtin,distance:f16:*": { "subcaseMS": 24.508 },
+  "webgpu:shader,execution,expression,call,builtin,distance:f32:*": { "subcaseMS": 875.325 },
+  "webgpu:shader,execution,expression,call,builtin,distance:f32_vec2:*": { "subcaseMS": 9.826 },
+  "webgpu:shader,execution,expression,call,builtin,distance:f32_vec3:*": { "subcaseMS": 10.901 },
+  "webgpu:shader,execution,expression,call,builtin,distance:f32_vec4:*": { "subcaseMS": 12.700 },
+  "webgpu:shader,execution,expression,call,builtin,dot:abstract_float:*": { "subcaseMS": 8.902 },
+  "webgpu:shader,execution,expression,call,builtin,dot:abstract_int:*": { "subcaseMS": 2.902 },
+  "webgpu:shader,execution,expression,call,builtin,dot:f16:*": { "subcaseMS": 3.102 },
+  "webgpu:shader,execution,expression,call,builtin,dot:f32_vec2:*": { "subcaseMS": 210.350 },
+  "webgpu:shader,execution,expression,call,builtin,dot:f32_vec3:*": { "subcaseMS": 11.176 },
+  "webgpu:shader,execution,expression,call,builtin,dot:f32_vec4:*": { "subcaseMS": 11.876 },
+  "webgpu:shader,execution,expression,call,builtin,dot:i32:*": { "subcaseMS": 3.103 },
+  "webgpu:shader,execution,expression,call,builtin,dot:u32:*": { "subcaseMS": 3.101 },
+  "webgpu:shader,execution,expression,call,builtin,dpdx:f32:*": { "subcaseMS": 22.804 },
+  "webgpu:shader,execution,expression,call,builtin,dpdxCoarse:f32:*": { "subcaseMS": 22.404 },
+  "webgpu:shader,execution,expression,call,builtin,dpdxFine:f32:*": { "subcaseMS": 17.708 },
+  "webgpu:shader,execution,expression,call,builtin,dpdy:f32:*": { "subcaseMS": 17.006 },
+  "webgpu:shader,execution,expression,call,builtin,dpdyCoarse:f32:*": { "subcaseMS": 17.909 },
+  "webgpu:shader,execution,expression,call,builtin,dpdyFine:f32:*": { "subcaseMS": 16.806 },
+  "webgpu:shader,execution,expression,call,builtin,exp2:abstract_float:*": { "subcaseMS": 22.705 },
+  "webgpu:shader,execution,expression,call,builtin,exp2:f16:*": { "subcaseMS": 23.908 },
+  "webgpu:shader,execution,expression,call,builtin,exp2:f32:*": { "subcaseMS": 12.169 },
+  "webgpu:shader,execution,expression,call,builtin,exp:abstract_float:*": { "subcaseMS": 17.210 },
+  "webgpu:shader,execution,expression,call,builtin,exp:f16:*": { "subcaseMS": 17.605 },
+  "webgpu:shader,execution,expression,call,builtin,exp:f32:*": { "subcaseMS": 12.557 },
+  "webgpu:shader,execution,expression,call,builtin,extractBits:i32:*": { "subcaseMS": 8.125 },
+  "webgpu:shader,execution,expression,call,builtin,extractBits:u32:*": { "subcaseMS": 7.838 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:abstract_float:*": { "subcaseMS": 14.306 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f16:*": { "subcaseMS": 7.906 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f32_vec2:*": { "subcaseMS": 1054.800 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f32_vec3:*": { "subcaseMS": 162.675 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f32_vec4:*": { "subcaseMS": 180.325 },
+  "webgpu:shader,execution,expression,call,builtin,firstLeadingBit:i32:*": { "subcaseMS": 20.613 },
+  "webgpu:shader,execution,expression,call,builtin,firstLeadingBit:u32:*": { "subcaseMS": 9.363 },
+  "webgpu:shader,execution,expression,call,builtin,firstTrailingBit:i32:*": { "subcaseMS": 8.132 },
+  "webgpu:shader,execution,expression,call,builtin,firstTrailingBit:u32:*": { "subcaseMS": 9.047 },
+  "webgpu:shader,execution,expression,call,builtin,floor:abstract_float:*": { "subcaseMS": 34.108 },
+  "webgpu:shader,execution,expression,call,builtin,floor:f16:*": { "subcaseMS": 30.708 },
+  "webgpu:shader,execution,expression,call,builtin,floor:f32:*": { "subcaseMS": 10.119 },
+  "webgpu:shader,execution,expression,call,builtin,fma:abstract_float:*": { "subcaseMS": 18.208 },
+  "webgpu:shader,execution,expression,call,builtin,fma:f16:*": { "subcaseMS": 27.805 },
+  "webgpu:shader,execution,expression,call,builtin,fma:f32:*": { "subcaseMS": 80.388 },
+  "webgpu:shader,execution,expression,call,builtin,fract:abstract_float:*": { "subcaseMS": 17.408 },
+  "webgpu:shader,execution,expression,call,builtin,fract:f16:*": { "subcaseMS": 17.106 },
+  "webgpu:shader,execution,expression,call,builtin,fract:f32:*": { "subcaseMS": 12.269 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f16_exp:*": { "subcaseMS": 8.503 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f16_fract:*": { "subcaseMS": 17.900 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f16_vec2_exp:*": { "subcaseMS": 1.801 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f16_vec2_fract:*": { "subcaseMS": 2.802 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f16_vec3_exp:*": { "subcaseMS": 1.701 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f16_vec3_fract:*": { "subcaseMS": 1.702 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f16_vec4_exp:*": { "subcaseMS": 1.603 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f16_vec4_fract:*": { "subcaseMS": 1.503 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f32_exp:*": { "subcaseMS": 8.501 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f32_fract:*": { "subcaseMS": 27.475 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f32_vec2_exp:*": { "subcaseMS": 8.300 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f32_vec2_fract:*": { "subcaseMS": 8.876 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f32_vec3_exp:*": { "subcaseMS": 8.975 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f32_vec3_fract:*": { "subcaseMS": 9.700 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f32_vec4_exp:*": { "subcaseMS": 10.250 },
+  "webgpu:shader,execution,expression,call,builtin,frexp:f32_vec4_fract:*": { "subcaseMS": 11.800 },
+  "webgpu:shader,execution,expression,call,builtin,fwidth:f32:*": { "subcaseMS": 29.807 },
+  "webgpu:shader,execution,expression,call,builtin,fwidthCoarse:f32:*": { "subcaseMS": 17.110 },
+  "webgpu:shader,execution,expression,call,builtin,fwidthFine:f32:*": { "subcaseMS": 16.906 },
+  "webgpu:shader,execution,expression,call,builtin,insertBits:integer:*": { "subcaseMS": 9.569 },
+  "webgpu:shader,execution,expression,call,builtin,inversesqrt:abstract_float:*": { "subcaseMS": 24.310 },
+  "webgpu:shader,execution,expression,call,builtin,inversesqrt:f16:*": { "subcaseMS": 21.411 },
+  "webgpu:shader,execution,expression,call,builtin,inversesqrt:f32:*": { "subcaseMS": 50.125 },
+  "webgpu:shader,execution,expression,call,builtin,ldexp:abstract_float:*": { "subcaseMS": 32.909 },
+  "webgpu:shader,execution,expression,call,builtin,ldexp:f16:*": { "subcaseMS": 36.705 },
+  "webgpu:shader,execution,expression,call,builtin,ldexp:f32:*": { "subcaseMS": 66.419 },
+  "webgpu:shader,execution,expression,call,builtin,length:abstract_float:*": { "subcaseMS": 31.303 },
+  "webgpu:shader,execution,expression,call,builtin,length:f16:*": { "subcaseMS": 28.405 },
+  "webgpu:shader,execution,expression,call,builtin,length:f32:*": { "subcaseMS": 107.275 },
+  "webgpu:shader,execution,expression,call,builtin,length:f32_vec2:*": { "subcaseMS": 9.751 },
+  "webgpu:shader,execution,expression,call,builtin,length:f32_vec3:*": { "subcaseMS": 10.825 },
+  "webgpu:shader,execution,expression,call,builtin,length:f32_vec4:*": { "subcaseMS": 9.476 },
+  "webgpu:shader,execution,expression,call,builtin,log2:abstract_float:*": { "subcaseMS": 23.607 },
+  "webgpu:shader,execution,expression,call,builtin,log2:f16:*": { "subcaseMS": 9.404 },
+  "webgpu:shader,execution,expression,call,builtin,log2:f32:*": { "subcaseMS": 27.838 },
+  "webgpu:shader,execution,expression,call,builtin,log:abstract_float:*": { "subcaseMS": 17.911 },
+  "webgpu:shader,execution,expression,call,builtin,log:f16:*": { "subcaseMS": 8.603 },
+  "webgpu:shader,execution,expression,call,builtin,log:f32:*": { "subcaseMS": 26.725 },
+  "webgpu:shader,execution,expression,call,builtin,max:abstract_float:*": { "subcaseMS": 25.508 },
+  "webgpu:shader,execution,expression,call,builtin,max:abstract_int:*": { "subcaseMS": 33.508 },
+  "webgpu:shader,execution,expression,call,builtin,max:f16:*": { "subcaseMS": 37.404 },
+  "webgpu:shader,execution,expression,call,builtin,max:f32:*": { "subcaseMS": 300.619 },
+  "webgpu:shader,execution,expression,call,builtin,max:i32:*": { "subcaseMS": 7.350 },
+  "webgpu:shader,execution,expression,call,builtin,max:u32:*": { "subcaseMS": 6.700 },
+  "webgpu:shader,execution,expression,call,builtin,min:abstract_float:*": { "subcaseMS": 30.405 },
+  "webgpu:shader,execution,expression,call,builtin,min:abstract_int:*": { "subcaseMS": 19.806 },
+  "webgpu:shader,execution,expression,call,builtin,min:f16:*": { "subcaseMS": 8.006 },
+  "webgpu:shader,execution,expression,call,builtin,min:f32:*": { "subcaseMS": 298.463 },
+  "webgpu:shader,execution,expression,call,builtin,min:i32:*": { "subcaseMS": 7.825 },
+  "webgpu:shader,execution,expression,call,builtin,min:u32:*": { "subcaseMS": 6.932 },
+  "webgpu:shader,execution,expression,call,builtin,mix:matching_abstract_float:*": { "subcaseMS": 23.706 },
+  "webgpu:shader,execution,expression,call,builtin,mix:matching_f16:*": { "subcaseMS": 21.910 },
+  "webgpu:shader,execution,expression,call,builtin,mix:matching_f32:*": { "subcaseMS": 100.907 },
+  "webgpu:shader,execution,expression,call,builtin,mix:monmatching_f16:*": { "subcaseMS": 10.408 },
+  "webgpu:shader,execution,expression,call,builtin,mix:nonmatching_abstract_float:*": { "subcaseMS": 24.605 },
+  "webgpu:shader,execution,expression,call,builtin,mix:nonmatching_f32:*": { "subcaseMS": 14.205 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_fract:*": { "subcaseMS": 4.202 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_fract:*": { "subcaseMS": 9.200 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_whole:*": { "subcaseMS": 8.404 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_vec3_fract:*": { "subcaseMS": 3.102 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_vec3_whole:*": { "subcaseMS": 7.202 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_vec4_fract:*": { "subcaseMS": 8.503 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_vec4_whole:*": { "subcaseMS": 3.001 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_whole:*": { "subcaseMS": 17.103 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_fract:*": { "subcaseMS": 22.850 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec2_fract:*": { "subcaseMS": 9.451 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec2_whole:*": { "subcaseMS": 10.950 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec3_fract:*": { "subcaseMS": 9.526 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec3_whole:*": { "subcaseMS": 14.950 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec4_fract:*": { "subcaseMS": 11.151 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec4_whole:*": { "subcaseMS": 13.550 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_whole:*": { "subcaseMS": 10.725 },
+  "webgpu:shader,execution,expression,call,builtin,normalize:abstract_float:*": { "subcaseMS": 28.508 },
+  "webgpu:shader,execution,expression,call,builtin,normalize:f16:*": { "subcaseMS": 24.205 },
+  "webgpu:shader,execution,expression,call,builtin,normalize:f32_vec2:*": { "subcaseMS": 65.975 },
+  "webgpu:shader,execution,expression,call,builtin,normalize:f32_vec3:*": { "subcaseMS": 12.825 },
+  "webgpu:shader,execution,expression,call,builtin,normalize:f32_vec4:*": { "subcaseMS": 14.500 },
+  "webgpu:shader,execution,expression,call,builtin,pack2x16float:pack:*": { "subcaseMS": 284.150 },
+  "webgpu:shader,execution,expression,call,builtin,pack2x16snorm:pack:*": { "subcaseMS": 9.925 },
+  "webgpu:shader,execution,expression,call,builtin,pack2x16unorm:pack:*": { "subcaseMS": 9.525 },
+  "webgpu:shader,execution,expression,call,builtin,pack4x8snorm:pack:*": { "subcaseMS": 14.751 },
+  "webgpu:shader,execution,expression,call,builtin,pack4x8unorm:pack:*": { "subcaseMS": 14.575 },
+  "webgpu:shader,execution,expression,call,builtin,pow:abstract_float:*": { "subcaseMS": 23.106 },
+  "webgpu:shader,execution,expression,call,builtin,pow:f16:*": { "subcaseMS": 18.407 },
+  "webgpu:shader,execution,expression,call,builtin,pow:f32:*": { "subcaseMS": 151.269 },
+  "webgpu:shader,execution,expression,call,builtin,quantizeToF16:f32:*": { "subcaseMS": 11.063 },
+  "webgpu:shader,execution,expression,call,builtin,radians:abstract_float:*": { "subcaseMS": 20.005 },
+  "webgpu:shader,execution,expression,call,builtin,radians:f16:*": { "subcaseMS": 18.707 },
+  "webgpu:shader,execution,expression,call,builtin,radians:f32:*": { "subcaseMS": 11.988 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:abstract_float:*": { "subcaseMS": 20.405 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f16:*": { "subcaseMS": 15.806 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec2:*": { "subcaseMS": 116.425 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec3:*": { "subcaseMS": 14.575 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec4:*": { "subcaseMS": 14.601 },
+  "webgpu:shader,execution,expression,call,builtin,refract:abstract_float:*": { "subcaseMS": 21.305 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f16:*": { "subcaseMS": 31.104 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f32_vec2:*": { "subcaseMS": 3235.401 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f32_vec3:*": { "subcaseMS": 228.150 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f32_vec4:*": { "subcaseMS": 235.700 },
+  "webgpu:shader,execution,expression,call,builtin,reverseBits:i32:*": { "subcaseMS": 9.594 },
+  "webgpu:shader,execution,expression,call,builtin,reverseBits:u32:*": { "subcaseMS": 7.969 },
+  "webgpu:shader,execution,expression,call,builtin,round:abstract_float:*": { "subcaseMS": 19.408 },
+  "webgpu:shader,execution,expression,call,builtin,round:f16:*": { "subcaseMS": 30.509 },
+  "webgpu:shader,execution,expression,call,builtin,round:f32:*": { "subcaseMS": 12.407 },
+  "webgpu:shader,execution,expression,call,builtin,saturate:abstract_float:*": { "subcaseMS": 24.607 },
+  "webgpu:shader,execution,expression,call,builtin,saturate:f16:*": { "subcaseMS": 23.407 },
+  "webgpu:shader,execution,expression,call,builtin,saturate:f32:*": { "subcaseMS": 12.444 },
+  "webgpu:shader,execution,expression,call,builtin,select:scalar:*": { "subcaseMS": 6.882 },
+  "webgpu:shader,execution,expression,call,builtin,select:vector:*": { "subcaseMS": 7.096 },
+  "webgpu:shader,execution,expression,call,builtin,sign:abstract_float:*": { "subcaseMS": 31.708 },
+  "webgpu:shader,execution,expression,call,builtin,sign:abstract_int:*": { "subcaseMS": 25.806 },
+  "webgpu:shader,execution,expression,call,builtin,sign:f16:*": { "subcaseMS": 25.103 },
+  "webgpu:shader,execution,expression,call,builtin,sign:f32:*": { "subcaseMS": 8.188 },
+  "webgpu:shader,execution,expression,call,builtin,sign:i32:*": { "subcaseMS": 10.225 },
+  "webgpu:shader,execution,expression,call,builtin,sin:abstract_float:*": { "subcaseMS": 19.206 },
+  "webgpu:shader,execution,expression,call,builtin,sin:f16:*": { "subcaseMS": 8.707 },
+  "webgpu:shader,execution,expression,call,builtin,sin:f32:*": { "subcaseMS": 26.826 },
+  "webgpu:shader,execution,expression,call,builtin,sinh:abstract_float:*": { "subcaseMS": 22.009 },
+  "webgpu:shader,execution,expression,call,builtin,sinh:f16:*": { "subcaseMS": 23.905 },
+  "webgpu:shader,execution,expression,call,builtin,sinh:f32:*": { "subcaseMS": 11.038 },
+  "webgpu:shader,execution,expression,call,builtin,smoothstep:abstract_float:*": { "subcaseMS": 23.807 },
+  "webgpu:shader,execution,expression,call,builtin,smoothstep:f16:*": { "subcaseMS": 23.404 },
+  "webgpu:shader,execution,expression,call,builtin,smoothstep:f32:*": { "subcaseMS": 88.063 },
+  "webgpu:shader,execution,expression,call,builtin,sqrt:abstract_float:*": { "subcaseMS": 19.004 },
+  "webgpu:shader,execution,expression,call,builtin,sqrt:f16:*": { "subcaseMS": 22.908 },
+  "webgpu:shader,execution,expression,call,builtin,sqrt:f32:*": { "subcaseMS": 10.813 },
+  "webgpu:shader,execution,expression,call,builtin,step:abstract_float:*": { "subcaseMS": 19.104 },
+  "webgpu:shader,execution,expression,call,builtin,step:f16:*": { "subcaseMS": 32.508 },
+  "webgpu:shader,execution,expression,call,builtin,step:f32:*": { "subcaseMS": 291.363 },
+  "webgpu:shader,execution,expression,call,builtin,storageBarrier:barrier:*": { "subcaseMS": 0.801 },
+  "webgpu:shader,execution,expression,call,builtin,storageBarrier:stage:*": { "subcaseMS": 2.402 },
+  "webgpu:shader,execution,expression,call,builtin,tan:abstract_float:*": { "subcaseMS": 31.007 },
+  "webgpu:shader,execution,expression,call,builtin,tan:f16:*": { "subcaseMS": 31.306 },
+  "webgpu:shader,execution,expression,call,builtin,tan:f32:*": { "subcaseMS": 13.532 },
+  "webgpu:shader,execution,expression,call,builtin,tanh:abstract_float:*": { "subcaseMS": 18.406 },
+  "webgpu:shader,execution,expression,call,builtin,tanh:f16:*": { "subcaseMS": 25.211 },
+  "webgpu:shader,execution,expression,call,builtin,tanh:f32:*": { "subcaseMS": 32.719 },
+  "webgpu:shader,execution,expression,call,builtin,textureDimension:depth:*": { "subcaseMS": 20.801 },
+  "webgpu:shader,execution,expression,call,builtin,textureDimension:external:*": { "subcaseMS": 1.700 },
+  "webgpu:shader,execution,expression,call,builtin,textureDimension:sampled:*": { "subcaseMS": 16.506 },
+  "webgpu:shader,execution,expression,call,builtin,textureDimension:storage:*": { "subcaseMS": 25.907 },
+  "webgpu:shader,execution,expression,call,builtin,textureGather:depth_2d_coords:*": { "subcaseMS": 11.601 },
+  "webgpu:shader,execution,expression,call,builtin,textureGather:depth_3d_coords:*": { "subcaseMS": 2.200 },
+  "webgpu:shader,execution,expression,call,builtin,textureGather:depth_array_2d_coords:*": { "subcaseMS": 23.801 },
+  "webgpu:shader,execution,expression,call,builtin,textureGather:depth_array_3d_coords:*": { "subcaseMS": 10.200 },
+  "webgpu:shader,execution,expression,call,builtin,textureGather:sampled_2d_coords:*": { "subcaseMS": 343.301 },
+  "webgpu:shader,execution,expression,call,builtin,textureGather:sampled_3d_coords:*": { "subcaseMS": 63.200 },
+  "webgpu:shader,execution,expression,call,builtin,textureGather:sampled_array_2d_coords:*": { "subcaseMS": 304.401 },
+  "webgpu:shader,execution,expression,call,builtin,textureGather:sampled_array_3d_coords:*": { "subcaseMS": 60.700 },
+  "webgpu:shader,execution,expression,call,builtin,textureGatherCompare:array_2d_coords:*": { "subcaseMS": 291.301 },
+  "webgpu:shader,execution,expression,call,builtin,textureGatherCompare:array_3d_coords:*": { "subcaseMS": 191.101 },
+  "webgpu:shader,execution,expression,call,builtin,textureGatherCompare:sampled_array_2d_coords:*": { "subcaseMS": 57.600 },
+  "webgpu:shader,execution,expression,call,builtin,textureGatherCompare:sampled_array_3d_coords:*": { "subcaseMS": 10.101 },
+  "webgpu:shader,execution,expression,call,builtin,textureLoad:arrayed:*": { "subcaseMS": 30.501 },
+  "webgpu:shader,execution,expression,call,builtin,textureLoad:depth:*": { "subcaseMS": 3.200 },
+  "webgpu:shader,execution,expression,call,builtin,textureLoad:external:*": { "subcaseMS": 1.401 },
+  "webgpu:shader,execution,expression,call,builtin,textureLoad:multisampled:*": { "subcaseMS": 11.601 },
+  "webgpu:shader,execution,expression,call,builtin,textureLoad:sampled_1d:*": { "subcaseMS": 83.312 },
+  "webgpu:shader,execution,expression,call,builtin,textureLoad:sampled_2d:*": { "subcaseMS": 96.737 },
+  "webgpu:shader,execution,expression,call,builtin,textureLoad:sampled_3d:*": { "subcaseMS": 158.534 },
+  "webgpu:shader,execution,expression,call,builtin,textureNumLayers:arrayed:*": { "subcaseMS": 8.102 },
+  "webgpu:shader,execution,expression,call,builtin,textureNumLayers:sampled:*": { "subcaseMS": 2.101 },
+  "webgpu:shader,execution,expression,call,builtin,textureNumLayers:storage:*": { "subcaseMS": 8.000 },
+  "webgpu:shader,execution,expression,call,builtin,textureNumLevels:depth:*": { "subcaseMS": 3.801 },
+  "webgpu:shader,execution,expression,call,builtin,textureNumLevels:sampled:*": { "subcaseMS": 6.201 },
+  "webgpu:shader,execution,expression,call,builtin,textureNumSamples:depth:*": { "subcaseMS": 1.101 },
+  "webgpu:shader,execution,expression,call,builtin,textureNumSamples:sampled:*": { "subcaseMS": 6.600 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:control_flow:*": { "subcaseMS": 2.801 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:depth_2d_coords:*": { "subcaseMS": 12.301 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:depth_3d_coords:*": { "subcaseMS": 2.101 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:depth_array_2d_coords:*": { "subcaseMS": 92.601 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:depth_array_3d_coords:*": { "subcaseMS": 20.301 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:sampled_1d_coords:*": { "subcaseMS": 1.200 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:sampled_2d_coords:*": { "subcaseMS": 12.500 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:sampled_3d_coords:*": { "subcaseMS": 36.002 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:sampled_array_2d_coords:*": { "subcaseMS": 92.500 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:sampled_array_3d_coords:*": { "subcaseMS": 20.200 },
+  "webgpu:shader,execution,expression,call,builtin,textureSample:stage:*": { "subcaseMS": 3.000 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleBias:arrayed_2d_coords:*": { "subcaseMS": 585.100 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleBias:arrayed_3d_coords:*": { "subcaseMS": 121.600 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleBias:control_flow:*": { "subcaseMS": 2.502 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleBias:sampled_2d_coords:*": { "subcaseMS": 48.601 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleBias:sampled_3d_coords:*": { "subcaseMS": 133.600 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleBias:stage:*": { "subcaseMS": 2.803 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompare:2d_coords:*": { "subcaseMS": 24.000 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompare:3d_coords:*": { "subcaseMS": 9.000 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompare:arrayed_2d_coords:*": { "subcaseMS": 295.601 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompare:arrayed_3d_coords:*": { "subcaseMS": 60.301 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompare:control_flow:*": { "subcaseMS": 2.702 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompare:stage:*": { "subcaseMS": 7.701 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompareLevel:2d_coords:*": { "subcaseMS": 30.401 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompareLevel:3d_coords:*": { "subcaseMS": 10.301 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompareLevel:arrayed_2d_coords:*": { "subcaseMS": 705.100 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompareLevel:arrayed_3d_coords:*": { "subcaseMS": 622.700 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompareLevel:control_flow:*": { "subcaseMS": 2.202 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleCompareLevel:stage:*": { "subcaseMS": 7.901 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleGrad:sampled_2d_coords:*": { "subcaseMS": 82.401 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleGrad:sampled_3d_coords:*": { "subcaseMS": 309.101 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleGrad:sampled_array_2d_coords:*": { "subcaseMS": 352.900 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleGrad:sampled_array_3d_coords:*": { "subcaseMS": 332.000 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleLevel:depth_2d_coords:*": { "subcaseMS": 545.401 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleLevel:depth_3d_coords:*": { "subcaseMS": 183.000 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleLevel:depth_array_2d_coords:*": { "subcaseMS": 547.500 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleLevel:sampled_2d_coords:*": { "subcaseMS": 35.601 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleLevel:sampled_3d_coords:*": { "subcaseMS": 118.901 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleLevel:sampled_array_2d_coords:*": { "subcaseMS": 822.400 },
+  "webgpu:shader,execution,expression,call,builtin,textureSampleLevel:sampled_array_3d_coords:*": { "subcaseMS": 817.200 },
+  "webgpu:shader,execution,expression,call,builtin,textureStore:store_1d_coords:*": { "subcaseMS": 19.907 },
+  "webgpu:shader,execution,expression,call,builtin,textureStore:store_2d_coords:*": { "subcaseMS": 28.809 },
+  "webgpu:shader,execution,expression,call,builtin,textureStore:store_3d_coords:*": { "subcaseMS": 37.206 },
+  "webgpu:shader,execution,expression,call,builtin,textureStore:store_array_2d_coords:*": { "subcaseMS": 98.804 },
+  "webgpu:shader,execution,expression,call,builtin,transpose:abstract_float:*": { "subcaseMS": 35.014 },
+  "webgpu:shader,execution,expression,call,builtin,transpose:f16:*": { "subcaseMS": 33.311 },
+  "webgpu:shader,execution,expression,call,builtin,transpose:f32:*": { "subcaseMS": 8.184 },
+  "webgpu:shader,execution,expression,call,builtin,trunc:abstract_float:*": { "subcaseMS": 16.007 },
+  "webgpu:shader,execution,expression,call,builtin,trunc:f16:*": { "subcaseMS": 16.705 },
+  "webgpu:shader,execution,expression,call,builtin,trunc:f32:*": { "subcaseMS": 9.376 },
+  "webgpu:shader,execution,expression,call,builtin,unpack2x16float:unpack:*": { "subcaseMS": 11.651 },
+  "webgpu:shader,execution,expression,call,builtin,unpack2x16snorm:unpack:*": { "subcaseMS": 9.275 },
+  "webgpu:shader,execution,expression,call,builtin,unpack2x16unorm:unpack:*": { "subcaseMS": 8.701 },
+  "webgpu:shader,execution,expression,call,builtin,unpack4x8snorm:unpack:*": { "subcaseMS": 12.275 },
+  "webgpu:shader,execution,expression,call,builtin,unpack4x8unorm:unpack:*": { "subcaseMS": 11.776 },
+  "webgpu:shader,execution,expression,call,builtin,workgroupBarrier:barrier:*": { "subcaseMS": 0.701 },
+  "webgpu:shader,execution,expression,call,builtin,workgroupBarrier:stage:*": { "subcaseMS": 1.801 },
+  "webgpu:shader,execution,expression,unary,af_arithmetic:negation:*": { "subcaseMS": 2165.950 },
+  "webgpu:shader,execution,expression,unary,af_assignment:abstract:*": { "subcaseMS": 788.400 },
+  "webgpu:shader,execution,expression,unary,af_assignment:f16:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,execution,expression,unary,af_assignment:f32:*": { "subcaseMS": 42.000 },
+  "webgpu:shader,execution,expression,unary,bool_conversion:bool:*": { "subcaseMS": 8.357 },
+  "webgpu:shader,execution,expression,unary,bool_conversion:f16:*": { "subcaseMS": 28.710 },
+  "webgpu:shader,execution,expression,unary,bool_conversion:f32:*": { "subcaseMS": 8.513 },
+  "webgpu:shader,execution,expression,unary,bool_conversion:i32:*": { "subcaseMS": 8.219 },
+  "webgpu:shader,execution,expression,unary,bool_conversion:u32:*": { "subcaseMS": 7.401 },
+  "webgpu:shader,execution,expression,unary,bool_logical:negation:*": { "subcaseMS": 6.413 },
+  "webgpu:shader,execution,expression,unary,f32_arithmetic:negation:*": { "subcaseMS": 16.400 },
+  "webgpu:shader,execution,expression,unary,f32_conversion:bool:*": { "subcaseMS": 7.182 },
+  "webgpu:shader,execution,expression,unary,f32_conversion:f16:*": { "subcaseMS": 15.908 },
+  "webgpu:shader,execution,expression,unary,f32_conversion:f32:*": { "subcaseMS": 7.538 },
+  "webgpu:shader,execution,expression,unary,f32_conversion:f32_mat:*": { "subcaseMS": 7.759 },
+  "webgpu:shader,execution,expression,unary,f32_conversion:i32:*": { "subcaseMS": 7.701 },
+  "webgpu:shader,execution,expression,unary,f32_conversion:u32:*": { "subcaseMS": 7.132 },
+  "webgpu:shader,execution,expression,unary,i32_arithmetic:negation:*": { "subcaseMS": 7.244 },
+  "webgpu:shader,execution,expression,unary,i32_complement:i32_complement:*": { "subcaseMS": 9.075 },
+  "webgpu:shader,execution,expression,unary,i32_conversion:bool:*": { "subcaseMS": 6.457 },
+  "webgpu:shader,execution,expression,unary,i32_conversion:f16:*": { "subcaseMS": 21.310 },
+  "webgpu:shader,execution,expression,unary,i32_conversion:f32:*": { "subcaseMS": 8.275 },
+  "webgpu:shader,execution,expression,unary,i32_conversion:i32:*": { "subcaseMS": 7.707 },
+  "webgpu:shader,execution,expression,unary,i32_conversion:u32:*": { "subcaseMS": 6.969 },
+  "webgpu:shader,execution,expression,unary,u32_complement:u32_complement:*": { "subcaseMS": 7.632 },
+  "webgpu:shader,execution,expression,unary,u32_conversion:abstract_int:*": { "subcaseMS": 20.406 },
+  "webgpu:shader,execution,expression,unary,u32_conversion:bool:*": { "subcaseMS": 7.713 },
+  "webgpu:shader,execution,expression,unary,u32_conversion:f16:*": { "subcaseMS": 14.705 },
+  "webgpu:shader,execution,expression,unary,u32_conversion:f32:*": { "subcaseMS": 7.913 },
+  "webgpu:shader,execution,expression,unary,u32_conversion:i32:*": { "subcaseMS": 8.319 },
+  "webgpu:shader,execution,expression,unary,u32_conversion:u32:*": { "subcaseMS": 7.057 },
+  "webgpu:shader,execution,float_parse:valid:*": { "subcaseMS": 6.801 },
+  "webgpu:shader,execution,flow_control,call:call_basic:*": { "subcaseMS": 4.901 },
+  "webgpu:shader,execution,flow_control,call:call_nested:*": { "subcaseMS": 5.500 },
+  "webgpu:shader,execution,flow_control,call:call_repeated:*": { "subcaseMS": 10.851 },
+  "webgpu:shader,execution,flow_control,complex:continue_in_switch_in_for_loop:*": { "subcaseMS": 13.650 },
+  "webgpu:shader,execution,flow_control,eval_order:1d_array_assignment:*": { "subcaseMS": 17.500 },
+  "webgpu:shader,execution,flow_control,eval_order:1d_array_compound_assignment:*": { "subcaseMS": 5.400 },
+  "webgpu:shader,execution,flow_control,eval_order:1d_array_constructor:*": { "subcaseMS": 5.600 },
+  "webgpu:shader,execution,flow_control,eval_order:1d_array_increment:*": { "subcaseMS": 5.500 },
+  "webgpu:shader,execution,flow_control,eval_order:2d_array_assignment:*": { "subcaseMS": 11.000 },
+  "webgpu:shader,execution,flow_control,eval_order:2d_array_compound_assignment:*": { "subcaseMS": 21.601 },
+  "webgpu:shader,execution,flow_control,eval_order:2d_array_constructor:*": { "subcaseMS": 11.101 },
+  "webgpu:shader,execution,flow_control,eval_order:2d_array_increment:*": { "subcaseMS": 10.601 },
+  "webgpu:shader,execution,flow_control,eval_order:array_index:*": { "subcaseMS": 5.700 },
+  "webgpu:shader,execution,flow_control,eval_order:array_index_lhs_assignment:*": { "subcaseMS": 11.301 },
+  "webgpu:shader,execution,flow_control,eval_order:array_index_lhs_member_assignment:*": { "subcaseMS": 17.101 },
+  "webgpu:shader,execution,flow_control,eval_order:array_index_via_ptrs:*": { "subcaseMS": 10.200 },
+  "webgpu:shader,execution,flow_control,eval_order:array_index_via_struct_members:*": { "subcaseMS": 6.000 },
+  "webgpu:shader,execution,flow_control,eval_order:binary_op:*": { "subcaseMS": 5.900 },
+  "webgpu:shader,execution,flow_control,eval_order:binary_op_chain:*": { "subcaseMS": 21.000 },
+  "webgpu:shader,execution,flow_control,eval_order:binary_op_chain_C_C_C_R:*": { "subcaseMS": 22.400 },
+  "webgpu:shader,execution,flow_control,eval_order:binary_op_chain_C_C_R_C:*": { "subcaseMS": 6.601 },
+  "webgpu:shader,execution,flow_control,eval_order:binary_op_chain_C_R_C_C:*": { "subcaseMS": 5.101 },
+  "webgpu:shader,execution,flow_control,eval_order:binary_op_chain_R_C_C_C:*": { "subcaseMS": 6.000 },
+  "webgpu:shader,execution,flow_control,eval_order:binary_op_lhs_const:*": { "subcaseMS": 5.401 },
+  "webgpu:shader,execution,flow_control,eval_order:binary_op_parenthesized_expr:*": { "subcaseMS": 11.000 },
+  "webgpu:shader,execution,flow_control,eval_order:binary_op_rhs_const:*": { "subcaseMS": 10.200 },
+  "webgpu:shader,execution,flow_control,eval_order:bitwise_and:*": { "subcaseMS": 5.500 },
+  "webgpu:shader,execution,flow_control,eval_order:bitwise_or:*": { "subcaseMS": 22.301 },
+  "webgpu:shader,execution,flow_control,eval_order:builtin_fn_args:*": { "subcaseMS": 20.000 },
+  "webgpu:shader,execution,flow_control,eval_order:logical_and:*": { "subcaseMS": 5.101 },
+  "webgpu:shader,execution,flow_control,eval_order:logical_or:*": { "subcaseMS": 6.801 },
+  "webgpu:shader,execution,flow_control,eval_order:matrix_index:*": { "subcaseMS": 9.900 },
+  "webgpu:shader,execution,flow_control,eval_order:matrix_index_via_ptr:*": { "subcaseMS": 19.000 },
+  "webgpu:shader,execution,flow_control,eval_order:nested_builtin_fn_args:*": { "subcaseMS": 10.500 },
+  "webgpu:shader,execution,flow_control,eval_order:nested_fn_args:*": { "subcaseMS": 11.100 },
+  "webgpu:shader,execution,flow_control,eval_order:nested_struct_constructor:*": { "subcaseMS": 10.500 },
+  "webgpu:shader,execution,flow_control,eval_order:nested_vec4_constructor:*": { "subcaseMS": 10.700 },
+  "webgpu:shader,execution,flow_control,eval_order:struct_constructor:*": { "subcaseMS": 5.701 },
+  "webgpu:shader,execution,flow_control,eval_order:user_fn_args:*": { "subcaseMS": 5.801 },
+  "webgpu:shader,execution,flow_control,eval_order:vec4_constructor:*": { "subcaseMS": 22.900 },
+  "webgpu:shader,execution,flow_control,for:for_basic:*": { "subcaseMS": 14.150 },
+  "webgpu:shader,execution,flow_control,for:for_break:*": { "subcaseMS": 5.700 },
+  "webgpu:shader,execution,flow_control,for:for_complex_condition:*": { "subcaseMS": 12.450 },
+  "webgpu:shader,execution,flow_control,for:for_complex_continuing:*": { "subcaseMS": 12.000 },
+  "webgpu:shader,execution,flow_control,for:for_complex_initalizer:*": { "subcaseMS": 11.700 },
+  "webgpu:shader,execution,flow_control,for:for_condition:*": { "subcaseMS": 6.050 },
+  "webgpu:shader,execution,flow_control,for:for_continue:*": { "subcaseMS": 10.601 },
+  "webgpu:shader,execution,flow_control,for:for_continuing:*": { "subcaseMS": 5.000 },
+  "webgpu:shader,execution,flow_control,for:for_initalizer:*": { "subcaseMS": 7.751 },
+  "webgpu:shader,execution,flow_control,for:nested_for_break:*": { "subcaseMS": 5.901 },
+  "webgpu:shader,execution,flow_control,for:nested_for_continue:*": { "subcaseMS": 12.851 },
+  "webgpu:shader,execution,flow_control,if:else_if:*": { "subcaseMS": 7.950 },
+  "webgpu:shader,execution,flow_control,if:if_false:*": { "subcaseMS": 11.201 },
+  "webgpu:shader,execution,flow_control,if:if_true:*": { "subcaseMS": 4.850 },
+  "webgpu:shader,execution,flow_control,if:nested_if_else:*": { "subcaseMS": 11.650 },
+  "webgpu:shader,execution,flow_control,loop:loop_break:*": { "subcaseMS": 6.000 },
+  "webgpu:shader,execution,flow_control,loop:loop_continue:*": { "subcaseMS": 11.200 },
+  "webgpu:shader,execution,flow_control,loop:loop_continuing_basic:*": { "subcaseMS": 12.450 },
+  "webgpu:shader,execution,flow_control,loop:nested_loops:*": { "subcaseMS": 12.900 },
+  "webgpu:shader,execution,flow_control,phony:phony_assign_call_basic:*": { "subcaseMS": 6.750 },
+  "webgpu:shader,execution,flow_control,phony:phony_assign_call_builtin:*": { "subcaseMS": 12.001 },
+  "webgpu:shader,execution,flow_control,phony:phony_assign_call_must_use:*": { "subcaseMS": 6.450 },
+  "webgpu:shader,execution,flow_control,phony:phony_assign_call_nested:*": { "subcaseMS": 12.300 },
+  "webgpu:shader,execution,flow_control,phony:phony_assign_call_nested_must_use:*": { "subcaseMS": 5.250 },
+  "webgpu:shader,execution,flow_control,return:return:*": { "subcaseMS": 4.250 },
+  "webgpu:shader,execution,flow_control,return:return_conditional_false:*": { "subcaseMS": 5.851 },
+  "webgpu:shader,execution,flow_control,return:return_conditional_true:*": { "subcaseMS": 12.650 },
+  "webgpu:shader,execution,flow_control,switch:switch:*": { "subcaseMS": 12.750 },
+  "webgpu:shader,execution,flow_control,switch:switch_default:*": { "subcaseMS": 5.400 },
+  "webgpu:shader,execution,flow_control,switch:switch_default_only:*": { "subcaseMS": 12.550 },
+  "webgpu:shader,execution,flow_control,switch:switch_multiple_case:*": { "subcaseMS": 5.550 },
+  "webgpu:shader,execution,flow_control,switch:switch_multiple_case_default:*": { "subcaseMS": 12.000 },
+  "webgpu:shader,execution,flow_control,while:while_basic:*": { "subcaseMS": 5.951 },
+  "webgpu:shader,execution,flow_control,while:while_break:*": { "subcaseMS": 12.450 },
+  "webgpu:shader,execution,flow_control,while:while_continue:*": { "subcaseMS": 5.650 },
+  "webgpu:shader,execution,flow_control,while:while_nested_break:*": { "subcaseMS": 12.701 },
+  "webgpu:shader,execution,flow_control,while:while_nested_continue:*": { "subcaseMS": 5.450 },
+  "webgpu:shader,execution,memory_model,atomicity:atomicity:*": { "subcaseMS": 77.201 },
+  "webgpu:shader,execution,memory_model,barrier:workgroup_barrier_load_store:*": { "subcaseMS": 65.850 },
+  "webgpu:shader,execution,memory_model,barrier:workgroup_barrier_store_load:*": { "subcaseMS": 78.800 },
+  "webgpu:shader,execution,memory_model,barrier:workgroup_barrier_store_store:*": { "subcaseMS": 61.701 },
+  "webgpu:shader,execution,memory_model,coherence:corr:*": { "subcaseMS": 238.167 },
+  "webgpu:shader,execution,memory_model,coherence:corw1:*": { "subcaseMS": 250.467 },
+  "webgpu:shader,execution,memory_model,coherence:corw2:*": { "subcaseMS": 244.384 },
+  "webgpu:shader,execution,memory_model,coherence:cowr:*": { "subcaseMS": 250.484 },
+  "webgpu:shader,execution,memory_model,coherence:coww:*": { "subcaseMS": 245.850 },
+  "webgpu:shader,execution,memory_model,weak:2_plus_2_write:*": { "subcaseMS": 185.150 },
+  "webgpu:shader,execution,memory_model,weak:load_buffer:*": { "subcaseMS": 184.900 },
+  "webgpu:shader,execution,memory_model,weak:message_passing:*": { "subcaseMS": 196.550 },
+  "webgpu:shader,execution,memory_model,weak:read:*": { "subcaseMS": 185.400 },
+  "webgpu:shader,execution,memory_model,weak:store:*": { "subcaseMS": 184.500 },
+  "webgpu:shader,execution,memory_model,weak:store_buffer:*": { "subcaseMS": 185.850 },
+  "webgpu:shader,execution,padding:array_of_matCx3:*": { "subcaseMS": 8.650 },
+  "webgpu:shader,execution,padding:array_of_struct:*": { "subcaseMS": 5.801 },
+  "webgpu:shader,execution,padding:array_of_vec3:*": { "subcaseMS": 10.500 },
+  "webgpu:shader,execution,padding:matCx3:*": { "subcaseMS": 10.050 },
+  "webgpu:shader,execution,padding:struct_explicit:*": { "subcaseMS": 12.000 },
+  "webgpu:shader,execution,padding:struct_implicit:*": { "subcaseMS": 33.201 },
+  "webgpu:shader,execution,padding:struct_nested:*": { "subcaseMS": 21.400 },
+  "webgpu:shader,execution,padding:vec3:*": { "subcaseMS": 8.700 },
+  "webgpu:shader,execution,robust_access:linear_memory:*": { "subcaseMS": 5.293 },
+  "webgpu:shader,execution,robust_access_vertex:vertex_buffer_access:*": { "subcaseMS": 6.487 },
+  "webgpu:shader,execution,shader_io,compute_builtins:inputs:*": { "subcaseMS": 19.342 },
+  "webgpu:shader,execution,shader_io,shared_structs:shared_between_stages:*": { "subcaseMS": 9.601 },
+  "webgpu:shader,execution,shader_io,shared_structs:shared_with_buffer:*": { "subcaseMS": 20.701 },
+  "webgpu:shader,execution,shader_io,shared_structs:shared_with_non_entry_point_function:*": { "subcaseMS": 6.801 },
+  "webgpu:shader,execution,shadow:builtin:*": { "subcaseMS": 4.700 },
+  "webgpu:shader,execution,shadow:declaration:*": { "subcaseMS": 9.700 },
+  "webgpu:shader,execution,shadow:for_loop:*": { "subcaseMS": 17.201 },
+  "webgpu:shader,execution,shadow:if:*": { "subcaseMS": 6.700 },
+  "webgpu:shader,execution,shadow:loop:*": { "subcaseMS": 4.901 },
+  "webgpu:shader,execution,shadow:switch:*": { "subcaseMS": 4.601 },
+  "webgpu:shader,execution,shadow:while:*": { "subcaseMS": 7.400 },
+  "webgpu:shader,execution,statement,increment_decrement:frexp_exp_increment:*": { "subcaseMS": 4.700 },
+  "webgpu:shader,execution,statement,increment_decrement:scalar_i32_decrement:*": { "subcaseMS": 20.301 },
+  "webgpu:shader,execution,statement,increment_decrement:scalar_i32_decrement_underflow:*": { "subcaseMS": 4.900 },
+  "webgpu:shader,execution,statement,increment_decrement:scalar_i32_increment:*": { "subcaseMS": 17.801 },
+  "webgpu:shader,execution,statement,increment_decrement:scalar_i32_increment_overflow:*": { "subcaseMS": 9.301 },
+  "webgpu:shader,execution,statement,increment_decrement:scalar_u32_decrement:*": { "subcaseMS": 4.800 },
+  "webgpu:shader,execution,statement,increment_decrement:scalar_u32_decrement_underflow:*": { "subcaseMS": 21.600 },
+  "webgpu:shader,execution,statement,increment_decrement:scalar_u32_increment:*": { "subcaseMS": 5.900 },
+  "webgpu:shader,execution,statement,increment_decrement:scalar_u32_increment_overflow:*": { "subcaseMS": 4.700 },
+  "webgpu:shader,execution,statement,increment_decrement:vec2_element_decrement:*": { "subcaseMS": 5.200 },
+  "webgpu:shader,execution,statement,increment_decrement:vec2_element_increment:*": { "subcaseMS": 5.000 },
+  "webgpu:shader,execution,statement,increment_decrement:vec3_element_decrement:*": { "subcaseMS": 17.700 },
+  "webgpu:shader,execution,statement,increment_decrement:vec3_element_increment:*": { "subcaseMS": 4.801 },
+  "webgpu:shader,execution,statement,increment_decrement:vec4_element_decrement:*": { "subcaseMS": 5.300 },
+  "webgpu:shader,execution,statement,increment_decrement:vec4_element_increment:*": { "subcaseMS": 6.300 },
+  "webgpu:shader,execution,zero_init:compute,zero_init:*": { "subcaseMS": 2.944 },
+  "webgpu:shader,validation,const_assert,const_assert:constant_expression_assert:*": { "subcaseMS": 1.456 },
+  "webgpu:shader,validation,const_assert,const_assert:constant_expression_logical_and_assert:*": { "subcaseMS": 1.493 },
+  "webgpu:shader,validation,const_assert,const_assert:constant_expression_logical_and_no_assert:*": { "subcaseMS": 1.339 },
+  "webgpu:shader,validation,const_assert,const_assert:constant_expression_logical_or_assert:*": { "subcaseMS": 1.501 },
+  "webgpu:shader,validation,const_assert,const_assert:constant_expression_logical_or_no_assert:*": { "subcaseMS": 1.373 },
+  "webgpu:shader,validation,const_assert,const_assert:constant_expression_no_assert:*": { "subcaseMS": 1.655 },
+  "webgpu:shader,validation,const_assert,const_assert:evaluation_stage:*": { "subcaseMS": 3.367 },
+  "webgpu:shader,validation,decl,const:no_direct_recursion:*": { "subcaseMS": 0.951 },
+  "webgpu:shader,validation,decl,const:no_indirect_recursion:*": { "subcaseMS": 0.950 },
+  "webgpu:shader,validation,decl,const:no_indirect_recursion_via_array_size:*": { "subcaseMS": 2.601 },
+  "webgpu:shader,validation,decl,const:no_indirect_recursion_via_struct_attribute:*": { "subcaseMS": 1.034 },
+  "webgpu:shader,validation,decl,override:no_direct_recursion:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,decl,override:no_indirect_recursion:*": { "subcaseMS": 0.951 },
+  "webgpu:shader,validation,decl,ptr_spelling:let_ptr_explicit_type_matches_var:*": { "subcaseMS": 1.500 },
+  "webgpu:shader,validation,decl,ptr_spelling:let_ptr_reads:*": { "subcaseMS": 1.216 },
+  "webgpu:shader,validation,decl,ptr_spelling:let_ptr_writes:*": { "subcaseMS": 1.250 },
+  "webgpu:shader,validation,decl,ptr_spelling:ptr_address_space_never_uses_access_mode:*": { "subcaseMS": 1.141 },
+  "webgpu:shader,validation,decl,ptr_spelling:ptr_bad_store_type:*": { "subcaseMS": 0.967 },
+  "webgpu:shader,validation,decl,ptr_spelling:ptr_handle_space_invalid:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,decl,ptr_spelling:ptr_not_instantiable:*": { "subcaseMS": 1.310 },
+  "webgpu:shader,validation,decl,var_access_mode:explicit_access_mode:*": { "subcaseMS": 1.373 },
+  "webgpu:shader,validation,decl,var_access_mode:implicit_access_mode:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,decl,var_access_mode:read_access:*": { "subcaseMS": 1.177 },
+  "webgpu:shader,validation,decl,var_access_mode:write_access:*": { "subcaseMS": 1.154 },
+  "webgpu:shader,validation,expression,access,vector:vector:*": { "subcaseMS": 1.407 },
+  "webgpu:shader,validation,expression,binary,bitwise_shift:shift_left_concrete:*": { "subcaseMS": 1.216 },
+  "webgpu:shader,validation,expression,binary,bitwise_shift:shift_left_vec_size_mismatch:*": { "subcaseMS": 1.367 },
+  "webgpu:shader,validation,expression,binary,bitwise_shift:shift_right_concrete:*": { "subcaseMS": 1.237 },
+  "webgpu:shader,validation,expression,binary,bitwise_shift:shift_right_vec_size_mismatch:*": { "subcaseMS": 1.334 },
+  "webgpu:shader,validation,expression,call,builtin,abs:values:*": { "subcaseMS": 0.391 },
+  "webgpu:shader,validation,expression,call,builtin,acos:integer_argument:*": { "subcaseMS": 1.512 },
+  "webgpu:shader,validation,expression,call,builtin,acos:values:*": { "subcaseMS": 0.342 },
+  "webgpu:shader,validation,expression,call,builtin,acosh:integer_argument:*": { "subcaseMS": 1.234 },
+  "webgpu:shader,validation,expression,call,builtin,acosh:values:*": { "subcaseMS": 0.217 },
+  "webgpu:shader,validation,expression,call,builtin,asin:integer_argument:*": { "subcaseMS": 0.878 },
+  "webgpu:shader,validation,expression,call,builtin,asin:values:*": { "subcaseMS": 0.359 },
+  "webgpu:shader,validation,expression,call,builtin,asinh:integer_argument:*": { "subcaseMS": 1.267 },
+  "webgpu:shader,validation,expression,call,builtin,asinh:values:*": { "subcaseMS": 0.372 },
+  "webgpu:shader,validation,expression,call,builtin,atan2:integer_argument_x:*": { "subcaseMS": 0.912 },
+  "webgpu:shader,validation,expression,call,builtin,atan2:integer_argument_y:*": { "subcaseMS": 0.867 },
+  "webgpu:shader,validation,expression,call,builtin,atan2:values:*": { "subcaseMS": 0.359 },
+  "webgpu:shader,validation,expression,call,builtin,atan:integer_argument:*": { "subcaseMS": 1.545 },
+  "webgpu:shader,validation,expression,call,builtin,atan:values:*": { "subcaseMS": 0.335 },
+  "webgpu:shader,validation,expression,call,builtin,atanh:integer_argument:*": { "subcaseMS": 0.912 },
+  "webgpu:shader,validation,expression,call,builtin,atanh:values:*": { "subcaseMS": 0.231 },
+  "webgpu:shader,validation,expression,call,builtin,atomics:stage:*": { "subcaseMS": 1.346 },
+  "webgpu:shader,validation,expression,call,builtin,bitcast:bad_const_to_f32:*": { "subcaseMS": 0.844 },
+  "webgpu:shader,validation,expression,call,builtin,bitcast:bad_to_f16:*": { "subcaseMS": 8.518 },
+  "webgpu:shader,validation,expression,call,builtin,bitcast:bad_to_vec3h:*": { "subcaseMS": 17.641 },
+  "webgpu:shader,validation,expression,call,builtin,bitcast:bad_type_constructible:*": { "subcaseMS": 1.214 },
+  "webgpu:shader,validation,expression,call,builtin,bitcast:bad_type_nonconstructible:*": { "subcaseMS": 1.425 },
+  "webgpu:shader,validation,expression,call,builtin,bitcast:valid_vec2h:*": { "subcaseMS": 3.405 },
+  "webgpu:shader,validation,expression,call,builtin,bitcast:valid_vec4h:*": { "subcaseMS": 5.610 },
+  "webgpu:shader,validation,expression,call,builtin,ceil:integer_argument:*": { "subcaseMS": 1.456 },
+  "webgpu:shader,validation,expression,call,builtin,ceil:values:*": { "subcaseMS": 1.539 },
+  "webgpu:shader,validation,expression,call,builtin,clamp:values:*": { "subcaseMS": 0.377 },
+  "webgpu:shader,validation,expression,call,builtin,cos:integer_argument:*": { "subcaseMS": 1.601 },
+  "webgpu:shader,validation,expression,call,builtin,cos:values:*": { "subcaseMS": 0.338 },
+  "webgpu:shader,validation,expression,call,builtin,cosh:integer_argument:*": { "subcaseMS": 0.889 },
+  "webgpu:shader,validation,expression,call,builtin,cosh:values:*": { "subcaseMS": 0.272 },
+  "webgpu:shader,validation,expression,call,builtin,degrees:integer_argument:*": { "subcaseMS": 1.311 },
+  "webgpu:shader,validation,expression,call,builtin,degrees:values:*": { "subcaseMS": 0.303 },
+  "webgpu:shader,validation,expression,call,builtin,exp2:integer_argument:*": { "subcaseMS": 0.967 },
+  "webgpu:shader,validation,expression,call,builtin,exp2:values:*": { "subcaseMS": 0.410 },
+  "webgpu:shader,validation,expression,call,builtin,exp:integer_argument:*": { "subcaseMS": 1.356 },
+  "webgpu:shader,validation,expression,call,builtin,exp:values:*": { "subcaseMS": 0.311 },
+  "webgpu:shader,validation,expression,call,builtin,inverseSqrt:integer_argument:*": { "subcaseMS": 1.356 },
+  "webgpu:shader,validation,expression,call,builtin,inverseSqrt:values:*": { "subcaseMS": 0.315 },
+  "webgpu:shader,validation,expression,call,builtin,length:integer_argument:*": { "subcaseMS": 2.011 },
+  "webgpu:shader,validation,expression,call,builtin,length:scalar:*": { "subcaseMS": 0.245 },
+  "webgpu:shader,validation,expression,call,builtin,length:vec2:*": { "subcaseMS": 0.319 },
+  "webgpu:shader,validation,expression,call,builtin,length:vec3:*": { "subcaseMS": 1.401 },
+  "webgpu:shader,validation,expression,call,builtin,length:vec4:*": { "subcaseMS": 1.301 },
+  "webgpu:shader,validation,expression,call,builtin,log2:integer_argument:*": { "subcaseMS": 1.034 },
+  "webgpu:shader,validation,expression,call,builtin,log2:values:*": { "subcaseMS": 0.398 },
+  "webgpu:shader,validation,expression,call,builtin,log:integer_argument:*": { "subcaseMS": 1.134 },
+  "webgpu:shader,validation,expression,call,builtin,log:values:*": { "subcaseMS": 0.291 },
+  "webgpu:shader,validation,expression,call,builtin,modf:integer_argument:*": { "subcaseMS": 1.089 },
+  "webgpu:shader,validation,expression,call,builtin,modf:values:*": { "subcaseMS": 1.866 },
+  "webgpu:shader,validation,expression,call,builtin,radians:integer_argument:*": { "subcaseMS": 1.811 },
+  "webgpu:shader,validation,expression,call,builtin,radians:values:*": { "subcaseMS": 0.382 },
+  "webgpu:shader,validation,expression,call,builtin,round:integer_argument:*": { "subcaseMS": 1.834 },
+  "webgpu:shader,validation,expression,call,builtin,round:values:*": { "subcaseMS": 0.382 },
+  "webgpu:shader,validation,expression,call,builtin,saturate:integer_argument:*": { "subcaseMS": 1.878 },
+  "webgpu:shader,validation,expression,call,builtin,saturate:values:*": { "subcaseMS": 0.317 },
+  "webgpu:shader,validation,expression,call,builtin,sign:unsigned_integer_argument:*": { "subcaseMS": 1.120 },
+  "webgpu:shader,validation,expression,call,builtin,sign:values:*": { "subcaseMS": 0.343 },
+  "webgpu:shader,validation,expression,call,builtin,sin:integer_argument:*": { "subcaseMS": 1.189 },
+  "webgpu:shader,validation,expression,call,builtin,sin:values:*": { "subcaseMS": 0.349 },
+  "webgpu:shader,validation,expression,call,builtin,sinh:integer_argument:*": { "subcaseMS": 1.078 },
+  "webgpu:shader,validation,expression,call,builtin,sinh:values:*": { "subcaseMS": 0.357 },
+  "webgpu:shader,validation,expression,call,builtin,sqrt:integer_argument:*": { "subcaseMS": 1.356 },
+  "webgpu:shader,validation,expression,call,builtin,sqrt:values:*": { "subcaseMS": 0.302 },
+  "webgpu:shader,validation,expression,call,builtin,tan:integer_argument:*": { "subcaseMS": 1.734 },
+  "webgpu:shader,validation,expression,call,builtin,tan:values:*": { "subcaseMS": 0.350 },
+  "webgpu:shader,validation,functions,alias_analysis:aliasing_inside_function:*": { "subcaseMS": 1.200 },
+  "webgpu:shader,validation,functions,alias_analysis:member_accessors:*": { "subcaseMS": 1.656 },
+  "webgpu:shader,validation,functions,alias_analysis:one_pointer_one_module_scope:*": { "subcaseMS": 1.598 },
+  "webgpu:shader,validation,functions,alias_analysis:same_pointer_read_and_write:*": { "subcaseMS": 1.301 },
+  "webgpu:shader,validation,functions,alias_analysis:subcalls:*": { "subcaseMS": 1.673 },
+  "webgpu:shader,validation,functions,alias_analysis:two_pointers:*": { "subcaseMS": 1.537 },
+  "webgpu:shader,validation,functions,restrictions:call_arg_types_match_params:*": { "subcaseMS": 1.518 },
+  "webgpu:shader,validation,functions,restrictions:entry_point_call_target:*": { "subcaseMS": 1.734 },
+  "webgpu:shader,validation,functions,restrictions:function_parameter_matching:*": { "subcaseMS": 1.953 },
+  "webgpu:shader,validation,functions,restrictions:function_parameter_types:*": { "subcaseMS": 1.520 },
+  "webgpu:shader,validation,functions,restrictions:function_return_types:*": { "subcaseMS": 1.535 },
+  "webgpu:shader,validation,functions,restrictions:no_direct_recursion:*": { "subcaseMS": 2.500 },
+  "webgpu:shader,validation,functions,restrictions:no_indirect_recursion:*": { "subcaseMS": 1.900 },
+  "webgpu:shader,validation,functions,restrictions:param_names_must_differ:*": { "subcaseMS": 1.722 },
+  "webgpu:shader,validation,functions,restrictions:param_number_matches_call:*": { "subcaseMS": 1.803 },
+  "webgpu:shader,validation,functions,restrictions:param_scope_is_function_body:*": { "subcaseMS": 1.340 },
+  "webgpu:shader,validation,functions,restrictions:vertex_returns_position:*": { "subcaseMS": 1.201 },
+  "webgpu:shader,validation,parse,align:multi_align:*": { "subcaseMS": 1.200 },
+  "webgpu:shader,validation,parse,align:parsing:*": { "subcaseMS": 1.272 },
+  "webgpu:shader,validation,parse,align:placement:*": { "subcaseMS": 2.423 },
+  "webgpu:shader,validation,parse,align:required_alignment:*": { "subcaseMS": 1.653 },
+  "webgpu:shader,validation,parse,attribute:expressions:*": { "subcaseMS": 1.410 },
+  "webgpu:shader,validation,parse,binary_ops:all:*": { "subcaseMS": 1.301 },
+  "webgpu:shader,validation,parse,blankspace:blankspace:*": { "subcaseMS": 1.391 },
+  "webgpu:shader,validation,parse,blankspace:bom:*": { "subcaseMS": 1.101 },
+  "webgpu:shader,validation,parse,blankspace:null_characters:*": { "subcaseMS": 3.217 },
+  "webgpu:shader,validation,parse,break:placement:*": { "subcaseMS": 1.254 },
+  "webgpu:shader,validation,parse,builtin:parse:*": { "subcaseMS": 3.277 },
+  "webgpu:shader,validation,parse,builtin:placement:*": { "subcaseMS": 1.267 },
+  "webgpu:shader,validation,parse,comments:comments:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,comments:line_comment_eof:*": { "subcaseMS": 4.500 },
+  "webgpu:shader,validation,parse,comments:line_comment_terminators:*": { "subcaseMS": 1.021 },
+  "webgpu:shader,validation,parse,comments:unterminated_block_comment:*": { "subcaseMS": 8.950 },
+  "webgpu:shader,validation,parse,const:placement:*": { "subcaseMS": 1.167 },
+  "webgpu:shader,validation,parse,const_assert:parse:*": { "subcaseMS": 1.400 },
+  "webgpu:shader,validation,parse,diagnostic:conflicting_attribute_different_location:*": { "subcaseMS": 2.257 },
+  "webgpu:shader,validation,parse,diagnostic:conflicting_attribute_same_location:*": { "subcaseMS": 1.400 },
+  "webgpu:shader,validation,parse,diagnostic:conflicting_directive:*": { "subcaseMS": 1.244 },
+  "webgpu:shader,validation,parse,diagnostic:invalid_locations:*": { "subcaseMS": 1.930 },
+  "webgpu:shader,validation,parse,diagnostic:invalid_severity:*": { "subcaseMS": 1.361 },
+  "webgpu:shader,validation,parse,diagnostic:valid_locations:*": { "subcaseMS": 1.368 },
+  "webgpu:shader,validation,parse,diagnostic:valid_params:*": { "subcaseMS": 1.475 },
+  "webgpu:shader,validation,parse,diagnostic:warning_unknown_rule:*": { "subcaseMS": 1.100 },
+  "webgpu:shader,validation,parse,discard:placement:*": { "subcaseMS": 3.357 },
+  "webgpu:shader,validation,parse,enable:enable:*": { "subcaseMS": 2.303 },
+  "webgpu:shader,validation,parse,identifiers:alias_name:*": { "subcaseMS": 1.262 },
+  "webgpu:shader,validation,parse,identifiers:function_const_name:*": { "subcaseMS": 1.298 },
+  "webgpu:shader,validation,parse,identifiers:function_let_name:*": { "subcaseMS": 1.299 },
+  "webgpu:shader,validation,parse,identifiers:function_name:*": { "subcaseMS": 1.242 },
+  "webgpu:shader,validation,parse,identifiers:function_param_name:*": { "subcaseMS": 1.219 },
+  "webgpu:shader,validation,parse,identifiers:function_var_name:*": { "subcaseMS": 1.326 },
+  "webgpu:shader,validation,parse,identifiers:module_const_name:*": { "subcaseMS": 1.211 },
+  "webgpu:shader,validation,parse,identifiers:module_var_name:*": { "subcaseMS": 1.218 },
+  "webgpu:shader,validation,parse,identifiers:non_normalized:*": { "subcaseMS": 1.101 },
+  "webgpu:shader,validation,parse,identifiers:override_name:*": { "subcaseMS": 1.228 },
+  "webgpu:shader,validation,parse,identifiers:struct_name:*": { "subcaseMS": 1.230 },
+  "webgpu:shader,validation,parse,literal:abstract_float:*": { "subcaseMS": 1.411 },
+  "webgpu:shader,validation,parse,literal:abstract_int:*": { "subcaseMS": 1.296 },
+  "webgpu:shader,validation,parse,literal:bools:*": { "subcaseMS": 2.901 },
+  "webgpu:shader,validation,parse,literal:f16:*": { "subcaseMS": 45.119 },
+  "webgpu:shader,validation,parse,literal:f32:*": { "subcaseMS": 1.393 },
+  "webgpu:shader,validation,parse,literal:i32:*": { "subcaseMS": 1.541 },
+  "webgpu:shader,validation,parse,literal:u32:*": { "subcaseMS": 1.379 },
+  "webgpu:shader,validation,parse,must_use:builtin_must_use:*": { "subcaseMS": 1.400 },
+  "webgpu:shader,validation,parse,must_use:builtin_no_must_use:*": { "subcaseMS": 1.206 },
+  "webgpu:shader,validation,parse,must_use:call:*": { "subcaseMS": 1.275 },
+  "webgpu:shader,validation,parse,must_use:declaration:*": { "subcaseMS": 1.523 },
+  "webgpu:shader,validation,parse,pipeline_stage:compute_parsing:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,pipeline_stage:duplicate_compute_on_function:*": { "subcaseMS": 2.651 },
+  "webgpu:shader,validation,parse,pipeline_stage:duplicate_fragment_on_function:*": { "subcaseMS": 1.001 },
+  "webgpu:shader,validation,parse,pipeline_stage:duplicate_vertex_on_function:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,pipeline_stage:fragment_parsing:*": { "subcaseMS": 2.600 },
+  "webgpu:shader,validation,parse,pipeline_stage:multiple_entry_points:*": { "subcaseMS": 1.100 },
+  "webgpu:shader,validation,parse,pipeline_stage:placement:*": { "subcaseMS": 1.388 },
+  "webgpu:shader,validation,parse,pipeline_stage:vertex_parsing:*": { "subcaseMS": 1.500 },
+  "webgpu:shader,validation,parse,semicolon:after_assignment:*": { "subcaseMS": 1.400 },
+  "webgpu:shader,validation,parse,semicolon:after_call:*": { "subcaseMS": 1.301 },
+  "webgpu:shader,validation,parse,semicolon:after_case:*": { "subcaseMS": 1.301 },
+  "webgpu:shader,validation,parse,semicolon:after_case_break:*": { "subcaseMS": 19.400 },
+  "webgpu:shader,validation,parse,semicolon:after_compound_statement:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,semicolon:after_continuing:*": { "subcaseMS": 0.900 },
+  "webgpu:shader,validation,parse,semicolon:after_default_case:*": { "subcaseMS": 3.100 },
+  "webgpu:shader,validation,parse,semicolon:after_default_case_break:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,semicolon:after_discard:*": { "subcaseMS": 4.400 },
+  "webgpu:shader,validation,parse,semicolon:after_enable:*": { "subcaseMS": 1.301 },
+  "webgpu:shader,validation,parse,semicolon:after_fn_const_assert:*": { "subcaseMS": 1.400 },
+  "webgpu:shader,validation,parse,semicolon:after_fn_const_decl:*": { "subcaseMS": 1.200 },
+  "webgpu:shader,validation,parse,semicolon:after_fn_var_decl:*": { "subcaseMS": 1.101 },
+  "webgpu:shader,validation,parse,semicolon:after_for:*": { "subcaseMS": 0.900 },
+  "webgpu:shader,validation,parse,semicolon:after_for_break:*": { "subcaseMS": 1.201 },
+  "webgpu:shader,validation,parse,semicolon:after_func_decl:*": { "subcaseMS": 1.200 },
+  "webgpu:shader,validation,parse,semicolon:after_if:*": { "subcaseMS": 1.100 },
+  "webgpu:shader,validation,parse,semicolon:after_if_else:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,semicolon:after_let_decl:*": { "subcaseMS": 1.401 },
+  "webgpu:shader,validation,parse,semicolon:after_loop:*": { "subcaseMS": 1.200 },
+  "webgpu:shader,validation,parse,semicolon:after_loop_break:*": { "subcaseMS": 1.301 },
+  "webgpu:shader,validation,parse,semicolon:after_loop_break_if:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,semicolon:after_loop_continue:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,semicolon:after_member:*": { "subcaseMS": 4.801 },
+  "webgpu:shader,validation,parse,semicolon:after_module_const_decl:*": { "subcaseMS": 1.400 },
+  "webgpu:shader,validation,parse,semicolon:after_module_var_decl:*": { "subcaseMS": 0.901 },
+  "webgpu:shader,validation,parse,semicolon:after_return:*": { "subcaseMS": 1.201 },
+  "webgpu:shader,validation,parse,semicolon:after_struct_decl:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,semicolon:after_switch:*": { "subcaseMS": 1.101 },
+  "webgpu:shader,validation,parse,semicolon:after_type_alias_decl:*": { "subcaseMS": 1.200 },
+  "webgpu:shader,validation,parse,semicolon:after_while:*": { "subcaseMS": 0.901 },
+  "webgpu:shader,validation,parse,semicolon:after_while_break:*": { "subcaseMS": 4.801 },
+  "webgpu:shader,validation,parse,semicolon:after_while_continue:*": { "subcaseMS": 1.200 },
+  "webgpu:shader,validation,parse,semicolon:compound_statement_multiple:*": { "subcaseMS": 0.800 },
+  "webgpu:shader,validation,parse,semicolon:compound_statement_single:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,semicolon:function_body_multiple:*": { "subcaseMS": 0.900 },
+  "webgpu:shader,validation,parse,semicolon:function_body_single:*": { "subcaseMS": 0.800 },
+  "webgpu:shader,validation,parse,semicolon:module_scope_multiple:*": { "subcaseMS": 0.900 },
+  "webgpu:shader,validation,parse,semicolon:module_scope_single:*": { "subcaseMS": 2.100 },
+  "webgpu:shader,validation,parse,source:empty:*": { "subcaseMS": 1.101 },
+  "webgpu:shader,validation,parse,source:invalid_source:*": { "subcaseMS": 1.100 },
+  "webgpu:shader,validation,parse,source:valid_source:*": { "subcaseMS": 1.101 },
+  "webgpu:shader,validation,parse,unary_ops:all:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,parse,var_and_let:initializer_type:*": { "subcaseMS": 0.900 },
+  "webgpu:shader,validation,parse,var_and_let:var_access_mode_bad_other_template_contents:*": { "subcaseMS": 4.071 },
+  "webgpu:shader,validation,parse,var_and_let:var_access_mode_bad_template_delim:*": { "subcaseMS": 1.088 },
+  "webgpu:shader,validation,shader_io,binding:binding:*": { "subcaseMS": 1.240 },
+  "webgpu:shader,validation,shader_io,binding:binding_f16:*": { "subcaseMS": 0.500 },
+  "webgpu:shader,validation,shader_io,binding:binding_without_group:*": { "subcaseMS": 0.901 },
+  "webgpu:shader,validation,shader_io,builtins:duplicates:*": { "subcaseMS": 1.913 },
+  "webgpu:shader,validation,shader_io,builtins:missing_vertex_position:*": { "subcaseMS": 0.975 },
+  "webgpu:shader,validation,shader_io,builtins:nesting:*": { "subcaseMS": 2.700 },
+  "webgpu:shader,validation,shader_io,builtins:reuse_builtin_name:*": { "subcaseMS": 1.202 },
+  "webgpu:shader,validation,shader_io,builtins:stage_inout:*": { "subcaseMS": 1.231 },
+  "webgpu:shader,validation,shader_io,builtins:type:*": { "subcaseMS": 1.314 },
+  "webgpu:shader,validation,shader_io,entry_point:missing_attribute_on_param:*": { "subcaseMS": 4.801 },
+  "webgpu:shader,validation,shader_io,entry_point:missing_attribute_on_param_struct:*": { "subcaseMS": 4.676 },
+  "webgpu:shader,validation,shader_io,entry_point:missing_attribute_on_return_type:*": { "subcaseMS": 2.367 },
+  "webgpu:shader,validation,shader_io,entry_point:missing_attribute_on_return_type_struct:*": { "subcaseMS": 1.101 },
+  "webgpu:shader,validation,shader_io,entry_point:no_entry_point_provided:*": { "subcaseMS": 0.801 },
+  "webgpu:shader,validation,shader_io,group:group:*": { "subcaseMS": 1.355 },
+  "webgpu:shader,validation,shader_io,group:group_f16:*": { "subcaseMS": 0.400 },
+  "webgpu:shader,validation,shader_io,group:group_without_binding:*": { "subcaseMS": 1.100 },
+  "webgpu:shader,validation,shader_io,group_and_binding:binding_attributes:*": { "subcaseMS": 1.280 },
+  "webgpu:shader,validation,shader_io,group_and_binding:different_entry_points:*": { "subcaseMS": 1.833 },
+  "webgpu:shader,validation,shader_io,group_and_binding:function_scope:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,shader_io,group_and_binding:function_scope_texture:*": { "subcaseMS": 0.801 },
+  "webgpu:shader,validation,shader_io,group_and_binding:private_function_scope:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,shader_io,group_and_binding:private_module_scope:*": { "subcaseMS": 1.301 },
+  "webgpu:shader,validation,shader_io,group_and_binding:single_entry_point:*": { "subcaseMS": 1.380 },
+  "webgpu:shader,validation,shader_io,id:id:*": { "subcaseMS": 1.132 },
+  "webgpu:shader,validation,shader_io,id:id_fp16:*": { "subcaseMS": 1.001 },
+  "webgpu:shader,validation,shader_io,id:id_in_function:*": { "subcaseMS": 0.750 },
+  "webgpu:shader,validation,shader_io,id:id_non_override:*": { "subcaseMS": 0.767 },
+  "webgpu:shader,validation,shader_io,id:id_struct_member:*": { "subcaseMS": 0.900 },
+  "webgpu:shader,validation,shader_io,interpolate:duplicate:*": { "subcaseMS": 9.350 },
+  "webgpu:shader,validation,shader_io,interpolate:integral_types:*": { "subcaseMS": 1.657 },
+  "webgpu:shader,validation,shader_io,interpolate:interpolation_validation:*": { "subcaseMS": 1.193 },
+  "webgpu:shader,validation,shader_io,interpolate:require_location:*": { "subcaseMS": 3.000 },
+  "webgpu:shader,validation,shader_io,interpolate:type_and_sampling:*": { "subcaseMS": 1.383 },
+  "webgpu:shader,validation,shader_io,invariant:not_valid_on_user_defined_io:*": { "subcaseMS": 1.100 },
+  "webgpu:shader,validation,shader_io,invariant:parsing:*": { "subcaseMS": 1.438 },
+  "webgpu:shader,validation,shader_io,invariant:valid_only_with_vertex_position_builtin:*": { "subcaseMS": 1.461 },
+  "webgpu:shader,validation,shader_io,locations:duplicates:*": { "subcaseMS": 1.906 },
+  "webgpu:shader,validation,shader_io,locations:location_fp16:*": { "subcaseMS": 0.501 },
+  "webgpu:shader,validation,shader_io,locations:nesting:*": { "subcaseMS": 0.967 },
+  "webgpu:shader,validation,shader_io,locations:stage_inout:*": { "subcaseMS": 1.850 },
+  "webgpu:shader,validation,shader_io,locations:type:*": { "subcaseMS": 1.332 },
+  "webgpu:shader,validation,shader_io,locations:validation:*": { "subcaseMS": 1.296 },
+  "webgpu:shader,validation,shader_io,size:size:*": { "subcaseMS": 1.218 },
+  "webgpu:shader,validation,shader_io,size:size_fp16:*": { "subcaseMS": 1.500 },
+  "webgpu:shader,validation,shader_io,size:size_non_struct:*": { "subcaseMS": 0.929 },
+  "webgpu:shader,validation,shader_io,workgroup_size:workgroup_size:*": { "subcaseMS": 1.227 },
+  "webgpu:shader,validation,shader_io,workgroup_size:workgroup_size_const:*": { "subcaseMS": 3.400 },
+  "webgpu:shader,validation,shader_io,workgroup_size:workgroup_size_fp16:*": { "subcaseMS": 0.700 },
+  "webgpu:shader,validation,shader_io,workgroup_size:workgroup_size_fragment_shader:*": { "subcaseMS": 1.301 },
+  "webgpu:shader,validation,shader_io,workgroup_size:workgroup_size_function:*": { "subcaseMS": 0.800 },
+  "webgpu:shader,validation,shader_io,workgroup_size:workgroup_size_var:*": { "subcaseMS": 2.101 },
+  "webgpu:shader,validation,shader_io,workgroup_size:workgroup_size_vertex_shader:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,types,alias:no_direct_recursion:*": { "subcaseMS": 1.450 },
+  "webgpu:shader,validation,types,alias:no_indirect_recursion:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,types,alias:no_indirect_recursion_via_array_element:*": { "subcaseMS": 1.050 },
+  "webgpu:shader,validation,types,alias:no_indirect_recursion_via_array_size:*": { "subcaseMS": 2.851 },
+  "webgpu:shader,validation,types,alias:no_indirect_recursion_via_atomic:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,types,alias:no_indirect_recursion_via_matrix_element:*": { "subcaseMS": 0.851 },
+  "webgpu:shader,validation,types,alias:no_indirect_recursion_via_ptr_store_type:*": { "subcaseMS": 1.050 },
+  "webgpu:shader,validation,types,alias:no_indirect_recursion_via_struct_attribute:*": { "subcaseMS": 1.584 },
+  "webgpu:shader,validation,types,alias:no_indirect_recursion_via_struct_member:*": { "subcaseMS": 1.000 },
+  "webgpu:shader,validation,types,alias:no_indirect_recursion_via_vector_element:*": { "subcaseMS": 1.050 },
+  "webgpu:shader,validation,types,struct:no_direct_recursion:*": { "subcaseMS": 0.951 },
+  "webgpu:shader,validation,types,struct:no_indirect_recursion:*": { "subcaseMS": 0.901 },
+  "webgpu:shader,validation,types,struct:no_indirect_recursion_via_array_element:*": { "subcaseMS": 0.901 },
+  "webgpu:shader,validation,types,struct:no_indirect_recursion_via_array_size:*": { "subcaseMS": 0.900 },
+  "webgpu:shader,validation,types,struct:no_indirect_recursion_via_struct_attribute:*": { "subcaseMS": 1.467 },
+  "webgpu:shader,validation,types,struct:no_indirect_recursion_via_struct_member_nested_in_alias:*": { "subcaseMS": 0.950 },
+  "webgpu:shader,validation,types,vector:vector:*": { "subcaseMS": 1.295 },
+  "webgpu:shader,validation,uniformity,uniformity:basics:*": { "subcaseMS": 1.467 },
+  "webgpu:shader,validation,uniformity,uniformity:binary_expressions:*": { "subcaseMS": 1.758 },
+  "webgpu:shader,validation,uniformity,uniformity:compute_builtin_values:*": { "subcaseMS": 2.500 },
+  "webgpu:shader,validation,uniformity,uniformity:fragment_builtin_values:*": { "subcaseMS": 1.300 },
+  "webgpu:shader,validation,uniformity,uniformity:function_pointer_parameters:*": { "subcaseMS": 1.546 },
+  "webgpu:shader,validation,uniformity,uniformity:function_variables:*": { "subcaseMS": 1.573 },
+  "webgpu:shader,validation,uniformity,uniformity:functions:*": { "subcaseMS": 1.303 },
+  "webgpu:shader,validation,uniformity,uniformity:pointers:*": { "subcaseMS": 1.738 },
+  "webgpu:shader,validation,uniformity,uniformity:short_circuit_expressions:*": { "subcaseMS": 1.401 },
+  "webgpu:shader,validation,uniformity,uniformity:unary_expressions:*": { "subcaseMS": 1.279 },
+  "webgpu:util,texture,texel_data:float_texel_data_in_shader:*": { "subcaseMS": 2.042 },
+  "webgpu:util,texture,texel_data:sint_texel_data_in_shader:*": { "subcaseMS": 2.573 },
+  "webgpu:util,texture,texel_data:snorm_texel_data_in_shader:*": { "subcaseMS": 4.645 },
+  "webgpu:util,texture,texel_data:ufloat_texel_data_in_shader:*": { "subcaseMS": 2.908 },
+  "webgpu:util,texture,texel_data:uint_texel_data_in_shader:*": { "subcaseMS": 4.106 },
+  "webgpu:util,texture,texel_data:unorm_texel_data_in_shader:*": { "subcaseMS": 5.179 },
+  "webgpu:util,texture,texture_ok:float32:*": { "subcaseMS": 1.655 },
+  "webgpu:util,texture,texture_ok:norm:*": { "subcaseMS": 4.019 },
+  "webgpu:util,texture,texture_ok:snorm_min:*": { "subcaseMS": 17.250 },
+  "webgpu:web_platform,canvas,configure:alpha_mode:*": { "subcaseMS": 4.075 },
+  "webgpu:web_platform,canvas,configure:defaults:*": { "subcaseMS": 8.800 },
+  "webgpu:web_platform,canvas,configure:device:*": { "subcaseMS": 14.800 },
+  "webgpu:web_platform,canvas,configure:format:*": { "subcaseMS": 5.455 },
+  "webgpu:web_platform,canvas,configure:size_zero_after_configure:*": { "subcaseMS": 4.425 },
+  "webgpu:web_platform,canvas,configure:size_zero_before_configure:*": { "subcaseMS": 8.400 },
+  "webgpu:web_platform,canvas,configure:usage:*": { "subcaseMS": 1.087 },
+  "webgpu:web_platform,canvas,configure:viewFormats:*": { "subcaseMS": 0.899 },
+  "webgpu:web_platform,canvas,context_creation:return_type:*": { "subcaseMS": 0.700 },
+  "webgpu:web_platform,canvas,getCurrentTexture:configured:*": { "subcaseMS": 13.000 },
+  "webgpu:web_platform,canvas,getCurrentTexture:expiry:*": { "subcaseMS": 2.925 },
+  "webgpu:web_platform,canvas,getCurrentTexture:multiple_frames:*": { "subcaseMS": 32.400 },
+  "webgpu:web_platform,canvas,getCurrentTexture:resize:*": { "subcaseMS": 16.601 },
+  "webgpu:web_platform,canvas,getCurrentTexture:single_frames:*": { "subcaseMS": 10.800 },
+  "webgpu:web_platform,canvas,getPreferredCanvasFormat:value:*": { "subcaseMS": 0.200 },
+  "webgpu:web_platform,canvas,readbackFromWebGPUCanvas:drawTo2DCanvas:*": { "subcaseMS": 12.963 },
+  "webgpu:web_platform,canvas,readbackFromWebGPUCanvas:offscreenCanvas,snapshot:*": { "subcaseMS": 27.148 },
+  "webgpu:web_platform,canvas,readbackFromWebGPUCanvas:onscreenCanvas,snapshot:*": { "subcaseMS": 36.364 },
+  "webgpu:web_platform,canvas,readbackFromWebGPUCanvas:onscreenCanvas,uploadToWebGL:*": { "subcaseMS": 15.859 },
+  "webgpu:web_platform,canvas,readbackFromWebGPUCanvas:transferToImageBitmap_huge_size:*": { "subcaseMS": 571.100 },
+  "webgpu:web_platform,canvas,readbackFromWebGPUCanvas:transferToImageBitmap_unconfigured_nonzero_size:*": { "subcaseMS": 3.200 },
+  "webgpu:web_platform,canvas,readbackFromWebGPUCanvas:transferToImageBitmap_zero_size:*": { "subcaseMS": 7.551 },
+  "webgpu:web_platform,copyToTexture,ImageBitmap:copy_subrect_from_2D_Canvas:*": { "subcaseMS": 5.329 },
+  "webgpu:web_platform,copyToTexture,ImageBitmap:copy_subrect_from_ImageData:*": { "subcaseMS": 3.295 },
+  "webgpu:web_platform,copyToTexture,ImageBitmap:from_ImageData:*": { "subcaseMS": 0.000 },
+  "webgpu:web_platform,copyToTexture,ImageBitmap:from_canvas:*": { "subcaseMS": 0.000 },
+  "webgpu:web_platform,copyToTexture,ImageData:copy_subrect_from_ImageData:*": { "subcaseMS": 3.167 },
+  "webgpu:web_platform,copyToTexture,ImageData:from_ImageData:*": { "subcaseMS": 27.268 },
+  "webgpu:web_platform,copyToTexture,canvas:color_space_conversion:*": { "subcaseMS": 15.391 },
+  "webgpu:web_platform,copyToTexture,canvas:copy_contents_from_2d_context_canvas:*": { "subcaseMS": 3.437 },
+  "webgpu:web_platform,copyToTexture,canvas:copy_contents_from_bitmaprenderer_context_canvas:*": { "subcaseMS": 3.504 },
+  "webgpu:web_platform,copyToTexture,canvas:copy_contents_from_gl_context_canvas:*": { "subcaseMS": 14.659 },
+  "webgpu:web_platform,copyToTexture,canvas:copy_contents_from_gpu_context_canvas:*": { "subcaseMS": 1.859 },
+  "webgpu:web_platform,copyToTexture,image:copy_subrect_from_2D_Canvas:*": { "subcaseMS": 8.754 },
+  "webgpu:web_platform,copyToTexture,image:from_image:*": { "subcaseMS": 21.869 },
+  "webgpu:web_platform,copyToTexture,video:copy_from_video:*": { "subcaseMS": 25.101 },
+  "webgpu:web_platform,external_texture,video:importExternalTexture,compute:*": { "subcaseMS": 36.270 },
+  "webgpu:web_platform,external_texture,video:importExternalTexture,sample:*": { "subcaseMS": 33.380 },
+  "webgpu:web_platform,external_texture,video:importExternalTexture,sampleWithRotationMetadata:*": { "subcaseMS": 34.968 },
+  "webgpu:web_platform,external_texture,video:importExternalTexture,sampleWithVideoFrameWithVisibleRectParam:*": { "subcaseMS": 29.160 },
+  "webgpu:web_platform,worker,worker:worker:*": { "subcaseMS": 245.901 },
+  "_end": ""
+}

From 05e32a688431ef43ede7cc2eadcc891f7be2cfca Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 11 Sep 2023 10:23:16 -0400
Subject: [PATCH 023/166] wgsl: Add f16 negation execution tests (#2927)

Issue #1626
---
 src/unittests/floating_point.spec.ts          | 23 +++++++++-
 .../expression/unary/f16_arithmetic.spec.ts   | 44 +++++++++++++++++++
 src/webgpu/util/floating_point.ts             |  2 +-
 3 files changed, 67 insertions(+), 2 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/unary/f16_arithmetic.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index a9a92e181c37..56c6598aa9e1 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3110,6 +3110,27 @@ const kNegationIntervalCases = {
     { input: kValue.f32.subnormal.negative.min, expected: [0, kValue.f32.subnormal.positive.max] },
     { input: kValue.f32.subnormal.negative.max, expected: [0, kValue.f32.subnormal.positive.min] },
   ] as ScalarToIntervalCase[],
+  f16: [
+    // Edge cases
+    { input: kValue.f16.infinity.positive, expected: kUnboundedBounds },
+    { input: kValue.f16.infinity.negative, expected: kUnboundedBounds },
+    { input: kValue.f16.positive.max, expected: kValue.f16.negative.min },
+    { input: kValue.f16.positive.min, expected: kValue.f16.negative.max },
+    { input: kValue.f16.negative.min, expected: kValue.f16.positive.max },
+    { input: kValue.f16.negative.max, expected: kValue.f16.positive.min },
+
+    // Normals
+    { input: 0.1, expected: [kMinusOneULPFunctions['f16'](reinterpretU16AsF16(0xae66)), reinterpretU16AsF16(0xae66)] }, // ~-0.1
+    { input: 1.9, expected: [reinterpretU16AsF16(0xbf9a), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xbf9a))] },  // ~-1.9
+    { input: -0.1, expected: [reinterpretU16AsF16(0x2e66), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66))] }, // ~0.1
+    { input: -1.9, expected: [kMinusOneULPFunctions['f16'](reinterpretU16AsF16(0x3f9a)), reinterpretU16AsF16(0x3f9a)] },  // ~1.9
+
+    // Subnormals
+    { input: kValue.f16.subnormal.positive.max, expected: [kValue.f16.subnormal.negative.min, 0] },
+    { input: kValue.f16.subnormal.positive.min, expected: [kValue.f16.subnormal.negative.max, 0] },
+    { input: kValue.f16.subnormal.negative.min, expected: [0, kValue.f16.subnormal.positive.max] },
+    { input: kValue.f16.subnormal.negative.max, expected: [0, kValue.f16.subnormal.positive.min] },
+  ] as ScalarToIntervalCase[],
   abstract: [
     // Edge cases
     { input: kValue.f64.infinity.positive, expected: kUnboundedBounds },
@@ -3136,7 +3157,7 @@ const kNegationIntervalCases = {
 g.test('negationInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'abstract'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarToIntervalCase>(p => {
         // prettier-ignore
diff --git a/src/webgpu/shader/execution/expression/unary/f16_arithmetic.spec.ts b/src/webgpu/shader/execution/expression/unary/f16_arithmetic.spec.ts
new file mode 100644
index 000000000000..83d7579c077d
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/unary/f16_arithmetic.spec.ts
@@ -0,0 +1,44 @@
+export const description = `
+Execution Tests for the f16 arithmetic unary expression operations
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeF16 } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { fullF16Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { allInputSources, run } from '../expression.js';
+
+import { unary } from './unary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+export const d = makeCaseCache('unary/f16_arithmetic', {
+  negation: () => {
+    return FP.f16.generateScalarToIntervalCases(
+      fullF16Range({ neg_norm: 250, neg_sub: 20, pos_sub: 20, pos_norm: 250 }),
+      'unfiltered',
+      FP.f16.negationInterval
+    );
+  },
+});
+
+g.test('negation')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: -x
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('negation');
+    await run(t, unary('-'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 9b2ec9bf5062..af28a4191ff9 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5171,7 +5171,7 @@ class F16Traits extends FPTraits {
   public readonly multiplicationVectorMatrixInterval = this.unimplementedVectorMatrixToVector.bind(
     this
   );
-  public readonly negationInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly negationInterval = this.negationIntervalImpl.bind(this);
   public readonly normalizeInterval = this.unimplementedVectorToVector.bind(this);
   public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this);
   public readonly quantizeToF16Interval = this.quantizeToF16IntervalNotAvailable.bind(this);

From 90edae12842f4b6cfeabf1e73d9a8770e2c20311 Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Mon, 11 Sep 2023 19:22:00 +0100
Subject: [PATCH 024/166] Fix presubmits (`npm test`)

Add missing entry to `listing_meta.json`
---
 src/webgpu/listing_meta.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index ae925f390019..db480c2c2b20 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1401,6 +1401,7 @@
   "webgpu:shader,execution,expression,unary,bool_conversion:i32:*": { "subcaseMS": 8.219 },
   "webgpu:shader,execution,expression,unary,bool_conversion:u32:*": { "subcaseMS": 7.401 },
   "webgpu:shader,execution,expression,unary,bool_logical:negation:*": { "subcaseMS": 6.413 },
+  "webgpu:shader,execution,expression,unary,f16_arithmetic:negation:*": { "subcaseMS": 4.0 },
   "webgpu:shader,execution,expression,unary,f32_arithmetic:negation:*": { "subcaseMS": 16.400 },
   "webgpu:shader,execution,expression,unary,f32_conversion:bool:*": { "subcaseMS": 7.182 },
   "webgpu:shader,execution,expression,unary,f32_conversion:f16:*": { "subcaseMS": 15.908 },

From f0044b916a5b5185b7ccf2cd6e57b8e4f329eaff Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Mon, 11 Sep 2023 15:52:23 -0700
Subject: [PATCH 025/166] Compat: Test vertex_index, instance_index limits
 (#2940)

@builtin(vertex_index) and @buildin(instance_index) each
take an attribute in compat mode
---
 .../render_pipeline/vertex_state.spec.ts      | 91 +++++++++++++++++++
 src/webgpu/listing_meta.json                  |  1 +
 2 files changed, 92 insertions(+)
 create mode 100644 src/webgpu/compat/api/validation/render_pipeline/vertex_state.spec.ts

diff --git a/src/webgpu/compat/api/validation/render_pipeline/vertex_state.spec.ts b/src/webgpu/compat/api/validation/render_pipeline/vertex_state.spec.ts
new file mode 100644
index 000000000000..ef72c50ce9b8
--- /dev/null
+++ b/src/webgpu/compat/api/validation/render_pipeline/vertex_state.spec.ts
@@ -0,0 +1,91 @@
+export const description = `
+Tests limitations of createRenderPipeline related to vertex state in compat mode.
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { range } from '../../../../../common/util/util.js';
+import { CompatibilityTest } from '../../../compatibility_test.js';
+
+export const g = makeTestGroup(CompatibilityTest);
+
+g.test('maxVertexAttributesVertexIndexInstanceIndex')
+  .desc(
+    `
+Tests @builtin(vertex_index) and @builtin(instance_index) each count as an attribute.
+
+- Test that you can use maxVertexAttributes
+- Test that you can not use maxVertexAttributes and @builtin(vertex_index)
+- Test that you can not use maxVertexAttributes and @builtin(instance_index)
+- Test that you can use maxVertexAttributes - 1 and @builtin(vertex_index)
+- Test that you can use maxVertexAttributes - 1 and @builtin(instance_index)
+- Test that you can not use maxVertexAttributes - 1 and both @builtin(vertex_index) and @builtin(instance_index)
+- Test that you can use maxVertexAttributes - 2 and both @builtin(vertex_index) and @builtin(instance_index)
+    `
+  )
+  .params(u =>
+    u
+      .combine('useVertexIndex', [false, true] as const)
+      .combine('useInstanceIndex', [false, true] as const)
+      .combine('numAttribsToReserve', [0, 1, 2] as const)
+      .combine('isAsync', [false, true] as const)
+  )
+  .fn(t => {
+    const { useVertexIndex, useInstanceIndex, numAttribsToReserve, isAsync } = t.params;
+    const numAttribs = t.device.limits.maxVertexAttributes - numAttribsToReserve;
+
+    const numBuiltinsUsed = (useVertexIndex ? 1 : 0) + (useInstanceIndex ? 1 : 0);
+    const isValid = numAttribs + numBuiltinsUsed <= t.device.limits.maxVertexAttributes;
+
+    const inputs = range(numAttribs, i => `@location(${i}) v${i}: vec4f`);
+    const outputs = range(numAttribs, i => `v${i}`);
+
+    if (useVertexIndex) {
+      inputs.push('@builtin(vertex_index) vNdx: u32');
+      outputs.push('vec4f(f32(vNdx))');
+    }
+
+    if (useInstanceIndex) {
+      inputs.push('@builtin(instance_index) iNdx: u32');
+      outputs.push('vec4f(f32(iNdx))');
+    }
+
+    const module = t.device.createShaderModule({
+      code: `
+        @fragment fn fs() -> @location(0) vec4f {
+            return vec4f(1);
+        }
+        @vertex fn vs(${inputs.join(', ')}) -> @builtin(position) vec4f {
+            return ${outputs.join(' + ')};
+        }
+      `,
+    });
+
+    const pipelineDescriptor: GPURenderPipelineDescriptor = {
+      layout: 'auto',
+      vertex: {
+        module,
+        entryPoint: 'vs',
+        buffers: [
+          {
+            arrayStride: 16,
+            attributes: range(numAttribs, i => ({
+              shaderLocation: i,
+              format: 'float32x4',
+              offset: 0,
+            })),
+          },
+        ],
+      },
+      fragment: {
+        module,
+        entryPoint: 'fs',
+        targets: [
+          {
+            format: 'rgba8unorm',
+          },
+        ],
+      },
+    };
+
+    t.doCreateRenderPipelineTest(isAsync, isValid, pipelineDescriptor);
+  });
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index db480c2c2b20..b43b94657c0d 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -823,6 +823,7 @@
   "webgpu:compat,api,validation,encoding,programmable,pipeline_bind_group_compat:twoDifferentTextureViews,render_pass,used:*": { "subcaseMS": 0.000 },
   "webgpu:compat,api,validation,render_pipeline,fragment_state:colorState:*": { "subcaseMS": 32.604 },
   "webgpu:compat,api,validation,render_pipeline,shader_module:sample_mask:*": { "subcaseMS": 14.801 },
+  "webgpu:compat,api,validation,render_pipeline,vertex_state:maxVertexAttributesVertexIndexInstanceIndex:*": { "subcaseMS": 3.7 },
   "webgpu:compat,api,validation,texture,createTexture:unsupportedTextureFormats:*": { "subcaseMS": 0.700 },
   "webgpu:compat,api,validation,texture,createTexture:unsupportedTextureViewFormats:*": { "subcaseMS": 0.601 },
   "webgpu:compat,api,validation,texture,cubeArray:cube_array:*": { "subcaseMS": 13.701 },

From 0b49ea79daf566e9a77dab4c627f6e12c58815ad Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 12 Sep 2023 11:02:29 -0400
Subject: [PATCH 026/166] wgsl: Add AbstractFloat matrix addition execution
 tests (#2926)

Issue #1626
---
 src/unittests/floating_point.spec.ts          | 375 +++++++++---------
 src/webgpu/listing_meta.json                  |   3 +-
 .../binary/af_matrix_addition.spec.ts         | 118 ++++++
 .../shader/execution/expression/expression.ts |  86 +++-
 src/webgpu/util/conversion.ts                 |   6 +-
 src/webgpu/util/floating_point.ts             |   2 +-
 src/webgpu/util/math.ts                       | 123 ++++++
 7 files changed, 513 insertions(+), 200 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/binary/af_matrix_addition.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 56c6598aa9e1..02239005c6ee 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5841,193 +5841,200 @@ interface MatrixPairToMatrixCase {
   expected: (number | IntervalBounds)[][];
 }
 
-g.test('additionMatrixMatrixInterval_f32')
-  .paramsSubcasesOnly<MatrixPairToMatrixCase>([
-    // Only testing that different shapes of matrices are handled correctly
-    // here, to reduce test duplication.
-    // additionMatrixMatrixInterval uses AdditionIntervalOp for calculating intervals,
-    // so the testing for additionInterval covers the actual interval
-    // calculations.
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-        ],
-        [
-          [10, 20],
-          [30, 40],
-        ],
-      ],
-      expected: [
-        [11, 22],
-        [33, 44],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-          [5, 6],
-        ],
-        [
-          [10, 20],
-          [30, 40],
-          [50, 60],
-        ],
-      ],
-      expected: [
-        [11, 22],
-        [33, 44],
-        [55, 66],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-          [5, 6],
-          [7, 8],
-        ],
-        [
-          [10, 20],
-          [30, 40],
-          [50, 60],
-          [70, 80],
-        ],
-      ],
-      expected: [
-        [11, 22],
-        [33, 44],
-        [55, 66],
-        [77, 88],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-        ],
-        [
-          [10, 20, 30],
-          [40, 50, 60],
-        ],
-      ],
-      expected: [
-        [11, 22, 33],
-        [44, 55, 66],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-        ],
-        [
-          [10, 20, 30],
-          [40, 50, 60],
-          [70, 80, 90],
-        ],
-      ],
-      expected: [
-        [11, 22, 33],
-        [44, 55, 66],
-        [77, 88, 99],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-          [10, 11, 12],
-        ],
-        [
-          [10, 20, 30],
-          [40, 50, 60],
-          [70, 80, 90],
-          [1000, 1100, 1200],
-        ],
-      ],
-      expected: [
-        [11, 22, 33],
-        [44, 55, 66],
-        [77, 88, 99],
-        [1010, 1111, 1212],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-        ],
-        [
-          [10, 20, 30, 40],
-          [50, 60, 70, 80],
-        ],
-      ],
-      expected: [
-        [11, 22, 33, 44],
-        [55, 66, 77, 88],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-          [9, 10, 11, 12],
-        ],
-        [
-          [10, 20, 30, 40],
-          [50, 60, 70, 80],
-          [90, 1000, 1100, 1200],
-        ],
-      ],
-      expected: [
-        [11, 22, 33, 44],
-        [55, 66, 77, 88],
-        [99, 1010, 1111, 1212],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-          [9, 10, 11, 12],
-          [13, 14, 15, 16],
-        ],
-        [
-          [10, 20, 30, 40],
-          [50, 60, 70, 80],
-          [90, 1000, 1100, 1200],
-          [1300, 1400, 1500, 1600],
-        ],
-      ],
-      expected: [
-        [11, 22, 33, 44],
-        [55, 66, 77, 88],
-        [99, 1010, 1111, 1212],
-        [1313, 1414, 1515, 1616],
-      ],
-    },
-  ])
+g.test('additionMatrixMatrixInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'abstract'] as const)
+      .beginSubcases()
+      .expandWithParams<MatrixPairToMatrixCase>(_ => {
+        // Only testing that different shapes of matrices are handled correctly
+        // here, to reduce test duplication.
+        // additionMatrixMatrixInterval uses AdditionIntervalOp for calculating intervals,
+        // so the testing for additionInterval covers the actual interval
+        // calculations.
+        return [
+          {
+            input: [
+              [
+                [1, 2],
+                [3, 4],
+              ],
+              [
+                [10, 20],
+                [30, 40],
+              ],
+            ],
+            expected: [
+              [11, 22],
+              [33, 44],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2],
+                [3, 4],
+                [5, 6],
+              ],
+              [
+                [10, 20],
+                [30, 40],
+                [50, 60],
+              ],
+            ],
+            expected: [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2],
+                [3, 4],
+                [5, 6],
+                [7, 8],
+              ],
+              [
+                [10, 20],
+                [30, 40],
+                [50, 60],
+                [70, 80],
+              ],
+            ],
+            expected: [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+              [77, 88],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3],
+                [4, 5, 6],
+              ],
+              [
+                [10, 20, 30],
+                [40, 50, 60],
+              ],
+            ],
+            expected: [
+              [11, 22, 33],
+              [44, 55, 66],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+              ],
+              [
+                [10, 20, 30],
+                [40, 50, 60],
+                [70, 80, 90],
+              ],
+            ],
+            expected: [
+              [11, 22, 33],
+              [44, 55, 66],
+              [77, 88, 99],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+                [10, 11, 12],
+              ],
+              [
+                [10, 20, 30],
+                [40, 50, 60],
+                [70, 80, 90],
+                [1000, 1100, 1200],
+              ],
+            ],
+            expected: [
+              [11, 22, 33],
+              [44, 55, 66],
+              [77, 88, 99],
+              [1010, 1111, 1212],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+              ],
+              [
+                [10, 20, 30, 40],
+                [50, 60, 70, 80],
+              ],
+            ],
+            expected: [
+              [11, 22, 33, 44],
+              [55, 66, 77, 88],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+              ],
+              [
+                [10, 20, 30, 40],
+                [50, 60, 70, 80],
+                [90, 1000, 1100, 1200],
+              ],
+            ],
+            expected: [
+              [11, 22, 33, 44],
+              [55, 66, 77, 88],
+              [99, 1010, 1111, 1212],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+              ],
+              [
+                [10, 20, 30, 40],
+                [50, 60, 70, 80],
+                [90, 1000, 1100, 1200],
+                [1300, 1400, 1500, 1600],
+              ],
+            ],
+            expected: [
+              [11, 22, 33, 44],
+              [55, 66, 77, 88],
+              [99, 1010, 1111, 1212],
+              [1313, 1414, 1515, 1616],
+            ],
+          },
+        ];
+      })
+  )
   .fn(t => {
-    const x = t.params.input[0];
-    const y = t.params.input[1];
-    const expected = FP.f32.toMatrix(t.params.expected);
-    const got = FP.f32.additionMatrixMatrixInterval(x, y);
+    const [x, y] = t.params.input;
+    const trait = FP[t.params.trait];
+    const expected = trait.toMatrix(t.params.expected);
+    const got = trait.additionMatrixMatrixInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `f32.additionMatrixMatrixInterval([${JSON.stringify(x)}], [${JSON.stringify(
+      `${t.params.trait}.additionMatrixMatrixInterval([${JSON.stringify(x)}], [${JSON.stringify(
         y
       )}]) returned '[${JSON.stringify(got)}]'. Expected '[${JSON.stringify(expected)}]'`
     );
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index b43b94657c0d..54dfc261ff34 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -859,6 +859,7 @@
   "webgpu:shader,execution,expression,binary,af_comparison:less_equals:*": { "subcaseMS": 19.651 },
   "webgpu:shader,execution,expression,binary,af_comparison:less_than:*": { "subcaseMS": 19.975 },
   "webgpu:shader,execution,expression,binary,af_comparison:not_equals:*": { "subcaseMS": 19.651 },
+  "webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*": { "subcaseMS": 11169.534 },
   "webgpu:shader,execution,expression,binary,bitwise:bitwise_and:*": { "subcaseMS": 20.982 },
   "webgpu:shader,execution,expression,binary,bitwise:bitwise_and_compound:*": { "subcaseMS": 22.513 },
   "webgpu:shader,execution,expression,binary,bitwise:bitwise_exclusive_or:*": { "subcaseMS": 21.294 },
@@ -1402,7 +1403,7 @@
   "webgpu:shader,execution,expression,unary,bool_conversion:i32:*": { "subcaseMS": 8.219 },
   "webgpu:shader,execution,expression,unary,bool_conversion:u32:*": { "subcaseMS": 7.401 },
   "webgpu:shader,execution,expression,unary,bool_logical:negation:*": { "subcaseMS": 6.413 },
-  "webgpu:shader,execution,expression,unary,f16_arithmetic:negation:*": { "subcaseMS": 4.0 },
+  "webgpu:shader,execution,expression,unary,f16_arithmetic:negation:*": { "subcaseMS": 117.604 },
   "webgpu:shader,execution,expression,unary,f32_arithmetic:negation:*": { "subcaseMS": 16.400 },
   "webgpu:shader,execution,expression,unary,f32_conversion:bool:*": { "subcaseMS": 7.182 },
   "webgpu:shader,execution,expression,unary,f32_conversion:f16:*": { "subcaseMS": 15.908 },
diff --git a/src/webgpu/shader/execution/expression/binary/af_matrix_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/af_matrix_addition.spec.ts
new file mode 100644
index 000000000000..2897168d7225
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/af_matrix_addition.spec.ts
@@ -0,0 +1,118 @@
+export const description = `
+Execution Tests for matrix AbstractFloat addition expressions
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractFloat, TypeMat } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { sparseMatrixF64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { abstractBinary } from './binary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+export const d = makeCaseCache('binary/af_matrix_addition', {
+  mat2x2: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(2, 2),
+      sparseMatrixF64Range(2, 2),
+      'finite',
+      FP.abstract.additionMatrixMatrixInterval
+    );
+  },
+  mat2x3: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(2, 3),
+      sparseMatrixF64Range(2, 3),
+      'finite',
+      FP.abstract.additionMatrixMatrixInterval
+    );
+  },
+  mat2x4: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(2, 4),
+      sparseMatrixF64Range(2, 4),
+      'finite',
+      FP.abstract.additionMatrixMatrixInterval
+    );
+  },
+  mat3x2: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(3, 2),
+      sparseMatrixF64Range(3, 2),
+      'finite',
+      FP.abstract.additionMatrixMatrixInterval
+    );
+  },
+  mat3x3: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(3, 3),
+      sparseMatrixF64Range(3, 3),
+      'finite',
+      FP.abstract.additionMatrixMatrixInterval
+    );
+  },
+  mat3x4: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(3, 4),
+      sparseMatrixF64Range(3, 4),
+      'finite',
+      FP.abstract.additionMatrixMatrixInterval
+    );
+  },
+  mat4x2: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(4, 2),
+      sparseMatrixF64Range(4, 2),
+      'finite',
+      FP.abstract.additionMatrixMatrixInterval
+    );
+  },
+  mat4x3: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(4, 3),
+      sparseMatrixF64Range(4, 3),
+      'finite',
+      FP.abstract.additionMatrixMatrixInterval
+    );
+  },
+  mat4x4: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(4, 4),
+      sparseMatrixF64Range(4, 4),
+      'finite',
+      FP.abstract.additionMatrixMatrixInterval
+    );
+  },
+});
+
+g.test('matrix')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x + y, where x and y are matrices
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(`mat${cols}x${rows}`);
+    await run(
+      t,
+      abstractBinary('+'),
+      [TypeMat(cols, rows, TypeAbstractFloat), TypeMat(cols, rows, TypeAbstractFloat)],
+      TypeMat(cols, rows, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/expression.ts b/src/webgpu/shader/execution/expression/expression.ts
index 8ff28c217fc4..aaa761a6fa88 100644
--- a/src/webgpu/shader/execution/expression/expression.ts
+++ b/src/webgpu/shader/execution/expression/expression.ts
@@ -101,7 +101,41 @@ function valueStride(ty: Type): number {
       // vec3s have padding to make them the same size as vec4s
       return 32;
     }
-    unreachable('Matrices of AbstractFloats have not yet been implemented');
+    if (ty instanceof MatrixType) {
+      switch (ty.cols) {
+        case 2:
+          switch (ty.rows) {
+            case 2:
+              return 32;
+            case 3:
+              return 64;
+            case 4:
+              return 64;
+          }
+          break;
+        case 3:
+          switch (ty.rows) {
+            case 2:
+              return 48;
+            case 3:
+              return 96;
+            case 4:
+              return 96;
+          }
+          break;
+        case 4:
+          switch (ty.rows) {
+            case 2:
+              return 64;
+            case 3:
+              return 128;
+            case 4:
+              return 128;
+          }
+          break;
+      }
+    }
+    unreachable(`AbstractFloats have not yet been implemented for ${ty.toString()}`);
   }
 
   if (ty instanceof MatrixType) {
@@ -486,9 +520,23 @@ struct Output {
   @size(${valueStride(resultType)}) value: array<AF, ${dim}>,
 };`;
     }
-    // TBD: Implement Matrix result support
+
+    if (resultType instanceof MatrixType) {
+      const cols = resultType.cols;
+      const rows = resultType.rows === 2 ? 2 : 4; // 3 element rows have a padding element
+      output_struct = `struct AF {
+  low: u32,
+  high: u32,
+};
+
+struct Output {
+   @size(${valueStride(resultType)}) value: array<array<AF, ${rows}>, ${cols}>,
+};`;
+    }
+
+    assert(output_struct !== undefined, `No implementation for result type '${resultType}'`);
   }
-  assert(output_struct !== undefined, `No implementation for result type '${resultType}'`);
+
   return `${output_struct}
 @group(0) @binding(0) var<storage, read_write> outputs : array<Output, ${count}>;
 `;
@@ -771,11 +819,14 @@ fn main() {
  *             matrices, this string needs to include indexing into the
  *             container.
  * @param case_idx index in the case output array to assign the result
- * @param accessor string representing how access the AF that needs to be extracted.
- *              For scalars this should be left as ''.
- *              For vectors and matrices this will be an indexing operation,
- *              i.e. '[i]'
- * */
+ * @param accessor string representing how access to the AF that needs to be
+ *                 operated on.
+ *                 For scalars this should be left as ''.
+ *                 For vectors this will be an indexing operation,
+ *                 i.e. '[i]'
+ *                 For matrices this will double indexing operation,
+ *                 i.e. '[c][r]'
+ */
 function abstractFloatSnippet(expr: string, case_idx: number, accessor: string = ''): string {
   // AbstractFloats are f64s under the hood. WebGPU does not support
   // putting f64s in buffers, so the result needs to be split up into u32s
@@ -875,10 +926,23 @@ function abstractFloatCaseBody(expr: string, resultType: Type, i: number): strin
 
   if (resultType instanceof VectorType) {
     return [...Array(resultType.width).keys()]
-      .map(dim_idx => abstractFloatSnippet(expr, i, `[${dim_idx}]`))
+      .map(idx => abstractFloatSnippet(expr, i, `[${idx}]`))
       .join('  \n');
   }
-  // TDB implement matrix support
+
+  if (resultType instanceof MatrixType) {
+    const cols = resultType.cols;
+    const rows = resultType.rows;
+    const results: String[] = [...Array(cols * rows)];
+
+    for (let c = 0; c < cols; c++) {
+      for (let r = 0; r < rows; r++) {
+        results[c * rows + r] = abstractFloatSnippet(expr, i, `[${c}][${r}]`);
+      }
+    }
+
+    return results.join('  \n');
+  }
 
   unreachable(`Results of type '${resultType}' not yet implemented`);
 }
@@ -912,8 +976,6 @@ ${wgslHeader(parameterTypes, resultType)}
 
 ${wgslOutputs(resultType, cases.length)}
 
-${wgslValuesArray(parameterTypes, resultType, cases, expressionBuilder)}
-
 @compute @workgroup_size(1)
 fn main() {
 ${body}
diff --git a/src/webgpu/util/conversion.ts b/src/webgpu/util/conversion.ts
index 8c22065ddad6..e1aa31566e38 100644
--- a/src/webgpu/util/conversion.ts
+++ b/src/webgpu/util/conversion.ts
@@ -714,8 +714,10 @@ export class MatrixType {
     this.cols = cols;
     this.rows = rows;
     assert(
-      elementType.kind === 'f32' || elementType.kind === 'f16',
-      "MatrixType can only have elementType of 'f32' or 'f16'"
+      elementType.kind === 'f32' ||
+        elementType.kind === 'f16' ||
+        elementType.kind === 'abstract-float',
+      "MatrixType can only have elementType of 'f32' or 'f16' or 'abstract-float'"
     );
     this.elementType = elementType;
   }
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index af28a4191ff9..7a0038f4b82e 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4835,7 +4835,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly acoshPrimaryInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly acoshIntervals = [this.acoshAlternativeInterval, this.acoshPrimaryInterval];
   public readonly additionInterval = this.additionIntervalImpl.bind(this);
-  public readonly additionMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(this);
+  public readonly additionMatrixMatrixInterval = this.additionMatrixMatrixIntervalImpl.bind(this);
   public readonly asinInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly asinhInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly atanInterval = this.unimplementedScalarToInterval.bind(this);
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 30733e5fc017..54bba7abfb71 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -1843,6 +1843,129 @@ export function sparseVectorF64Range(dim: number): number[][] {
   return kSparseVectorF64Values[dim];
 }
 
+const kSparseMatrixF64Values = {
+  2: {
+    2: kInterestingF64Values.map((f, idx) => [
+      [idx % 4 === 0 ? f : idx, idx % 4 === 1 ? f : -idx],
+      [idx % 4 === 2 ? f : -idx, idx % 4 === 3 ? f : idx],
+    ]),
+    3: kInterestingF64Values.map((f, idx) => [
+      [idx % 6 === 0 ? f : idx, idx % 6 === 1 ? f : -idx, idx % 6 === 2 ? f : idx],
+      [idx % 6 === 3 ? f : -idx, idx % 6 === 4 ? f : idx, idx % 6 === 5 ? f : -idx],
+    ]),
+    4: kInterestingF64Values.map((f, idx) => [
+      [
+        idx % 8 === 0 ? f : idx,
+        idx % 8 === 1 ? f : -idx,
+        idx % 8 === 2 ? f : idx,
+        idx % 8 === 3 ? f : -idx,
+      ],
+      [
+        idx % 8 === 4 ? f : -idx,
+        idx % 8 === 5 ? f : idx,
+        idx % 8 === 6 ? f : -idx,
+        idx % 8 === 7 ? f : idx,
+      ],
+    ]),
+  },
+  3: {
+    2: kInterestingF64Values.map((f, idx) => [
+      [idx % 6 === 0 ? f : idx, idx % 6 === 1 ? f : -idx],
+      [idx % 6 === 2 ? f : -idx, idx % 6 === 3 ? f : idx],
+      [idx % 6 === 4 ? f : idx, idx % 6 === 5 ? f : -idx],
+    ]),
+    3: kInterestingF64Values.map((f, idx) => [
+      [idx % 9 === 0 ? f : idx, idx % 9 === 1 ? f : -idx, idx % 9 === 2 ? f : idx],
+      [idx % 9 === 3 ? f : -idx, idx % 9 === 4 ? f : idx, idx % 9 === 5 ? f : -idx],
+      [idx % 9 === 6 ? f : idx, idx % 9 === 7 ? f : -idx, idx % 9 === 8 ? f : idx],
+    ]),
+    4: kInterestingF64Values.map((f, idx) => [
+      [
+        idx % 12 === 0 ? f : idx,
+        idx % 12 === 1 ? f : -idx,
+        idx % 12 === 2 ? f : idx,
+        idx % 12 === 3 ? f : -idx,
+      ],
+      [
+        idx % 12 === 4 ? f : -idx,
+        idx % 12 === 5 ? f : idx,
+        idx % 12 === 6 ? f : -idx,
+        idx % 12 === 7 ? f : idx,
+      ],
+      [
+        idx % 12 === 8 ? f : idx,
+        idx % 12 === 9 ? f : -idx,
+        idx % 12 === 10 ? f : idx,
+        idx % 12 === 11 ? f : -idx,
+      ],
+    ]),
+  },
+  4: {
+    2: kInterestingF64Values.map((f, idx) => [
+      [idx % 8 === 0 ? f : idx, idx % 8 === 1 ? f : -idx],
+      [idx % 8 === 2 ? f : -idx, idx % 8 === 3 ? f : idx],
+      [idx % 8 === 4 ? f : idx, idx % 8 === 5 ? f : -idx],
+      [idx % 8 === 6 ? f : -idx, idx % 8 === 7 ? f : idx],
+    ]),
+    3: kInterestingF64Values.map((f, idx) => [
+      [idx % 12 === 0 ? f : idx, idx % 12 === 1 ? f : -idx, idx % 12 === 2 ? f : idx],
+      [idx % 12 === 3 ? f : -idx, idx % 12 === 4 ? f : idx, idx % 12 === 5 ? f : -idx],
+      [idx % 12 === 6 ? f : idx, idx % 12 === 7 ? f : -idx, idx % 12 === 8 ? f : idx],
+      [idx % 12 === 9 ? f : -idx, idx % 12 === 10 ? f : idx, idx % 12 === 11 ? f : -idx],
+    ]),
+    4: kInterestingF64Values.map((f, idx) => [
+      [
+        idx % 16 === 0 ? f : idx,
+        idx % 16 === 1 ? f : -idx,
+        idx % 16 === 2 ? f : idx,
+        idx % 16 === 3 ? f : -idx,
+      ],
+      [
+        idx % 16 === 4 ? f : -idx,
+        idx % 16 === 5 ? f : idx,
+        idx % 16 === 6 ? f : -idx,
+        idx % 16 === 7 ? f : idx,
+      ],
+      [
+        idx % 16 === 8 ? f : idx,
+        idx % 16 === 9 ? f : -idx,
+        idx % 16 === 10 ? f : idx,
+        idx % 16 === 11 ? f : -idx,
+      ],
+      [
+        idx % 16 === 12 ? f : -idx,
+        idx % 16 === 13 ? f : idx,
+        idx % 16 === 14 ? f : -idx,
+        idx % 16 === 15 ? f : idx,
+      ],
+    ]),
+  },
+};
+
+/**
+ * Returns a minimal set of matrices, indexed by dimension containing interesting
+ * float values.
+ *
+ * This is the matrix analogue of `sparseVectorF64Range`, so it is producing a
+ * minimal coverage set of matrices that test all the interesting f64 values.
+ * There is not a more expansive set of matrices, since matrices are even more
+ * expensive than vectors for increasing runtime with coverage.
+ *
+ * All the interesting floats from sparseF64 are guaranteed to be tested, but
+ * not in every position.
+ */
+export function sparseMatrixF64Range(c: number, r: number): number[][][] {
+  assert(
+    c === 2 || c === 3 || c === 4,
+    'sparseMatrixF64Range only accepts column counts of 2, 3, and 4'
+  );
+  assert(
+    r === 2 || r === 3 || r === 4,
+    'sparseMatrixF64Range only accepts row counts of 2, 3, and 4'
+  );
+  return kSparseMatrixF64Values[c][r];
+}
+
 /**
  * @returns the result matrix in Array<Array<number>> type.
  *

From 7536133f8ce7b4bcc4640131a96b53aa311dbe50 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 12 Sep 2023 13:29:58 -0400
Subject: [PATCH 027/166] Add documentation for adding timing metadata (#2942)

Fixes #2938
---
 docs/adding_timing_metadata.md | 110 +++++++++++++++++++++++++++++++++
 src/common/tools/crawl.ts      |   2 +-
 tools/merge_listing_times      |   3 +
 3 files changed, 114 insertions(+), 1 deletion(-)
 create mode 100644 docs/adding_timing_metadata.md

diff --git a/docs/adding_timing_metadata.md b/docs/adding_timing_metadata.md
new file mode 100644
index 000000000000..617d5365526d
--- /dev/null
+++ b/docs/adding_timing_metadata.md
@@ -0,0 +1,110 @@
+## Problem
+
+When adding new tests to the CTS you may occasionally see an error like this
+when running `npm test` or `npm run standalone`
+
+```
+ERROR: Tests missing from listing_meta.json. Please add the new tests (set subcaseMS to 0 if you cannot estimate it):
+  webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*
+
+/home/runner/work/cts/cts/src/common/util/util.ts:38
+    throw new Error(msg && (typeof msg === 'string' ? msg : msg()));
+          ^
+Error: 
+    at assert (/home/runner/work/cts/cts/src/common/util/util.ts:38:11)
+    at crawl (/home/runner/work/cts/cts/src/common/tools/crawl.ts:155:11)
+Warning: non-zero exit code 1
+ Use --force to continue.
+
+Aborted due to warnings.
+```
+
+What this error message is trying to tell us, is that there is no entry for
+`webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*` in
+`src/webgpu/listing_meta.json`.
+
+These entries are estimates for the amount of time that subcases take to run,
+and are used as inputs into the WPT tooling to attempt to portion out tests into
+approximately same sized chunks.
+
+If a value has been defaulted to 0 by someone, you will see warnings like this
+```
+...
+WARNING: subcaseMS≤0 found in listing_meta.json (allowed, but try to avoid):
+  webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*
+...
+```
+
+These messages should be resolved by adding appropriate entries to the JSON
+file.
+
+## Solution
+
+There exists tooling in the CTS repo for generating appropriate estimates for
+these values, though they do require some manual intervention. The rest of this
+doc will be a walkthrough of running these tools.
+
+### Default Value
+
+The first step is to add a default value for entry to 
+`src/webgpu/listing_meta.json`, since there is a chicken-and-egg problem for 
+updating these values.
+
+```
+  "webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*": { "subcaseMS": 0 },
+```
+
+(It should have a value of 0, since later tooling updates the value if the newer
+value is higher)
+
+### Websocket Logger
+
+The first tool that needs to be run is `websocket-logger`, which uses a side
+channel from WPT to report timing data when CTS is run via a websocket. This
+should be run in a separate process/terminal, since it needs to stay running
+throughout the following steps.
+
+At `tools/websocket-logger/`
+```
+npm install
+npm run
+```
+
+The output from this command will indicate where the results are being logged,
+which will be needed later
+```
+...
+Writing to wslog-2023-09-11T18-57-34.txt
+...
+```
+
+### Running CTS
+
+Now we need to run the specific cases in CTS, which requires serving the CTS 
+locally.
+
+At project root
+```
+npm run standalone
+npm start
+```
+
+Once this is started you can then direct a WebGPU enabled browser to the
+specific CTS entry and run the tests, for example
+```
+http://127.0.0.1:8080/standalone/q?webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*
+```
+
+### Merging metadata
+
+The final step is to merge the new data that has been captured into the JSON
+file.
+
+This can be done using the following command
+```
+tools/merge_listing_times webgpu -- tools/websocket-logger/wslog-2023-09-11T18-57-34.txt
+```
+
+where the text file is the result file from websocket-logger.
+
+Now you just need to commit the pending diff in your repo.
diff --git a/src/common/tools/crawl.ts b/src/common/tools/crawl.ts
index eadabe4f77f2..cb1e5f6fc737 100644
--- a/src/common/tools/crawl.ts
+++ b/src/common/tools/crawl.ts
@@ -145,7 +145,7 @@ export async function crawl(suiteDir: string, validate: boolean): Promise<TestSu
     }
     if (missingEntries.length) {
       console.error(
-        'ERROR: Tests missing from listing_meta.json. Please add the new tests (set subcaseMS to 0 if you cannot estimate it):'
+        'ERROR: Tests missing from listing_meta.json. Please add the new tests (See docs/adding_timing_metadata.md):'
       );
       for (const metadataKey of missingEntries) {
         console.error(`  ${metadataKey}`);
diff --git a/tools/merge_listing_times b/tools/merge_listing_times
index 4d33fe69b383..f84bc9736310 100755
--- a/tools/merge_listing_times
+++ b/tools/merge_listing_times
@@ -5,6 +5,9 @@ require('../src/common/tools/setup-ts-in-node.js');
 // See help message in this file for info on how to use the tool.
 require('../src/common/tools/merge_listing_times.ts');
 
+// See docs/adding_timing_metadata.md for a basic walkthrough on adding entries
+// for new tests
+//
 // ## listing_meta.json File Maintenance ##
 //
 // listing_meta.json files are SEMI AUTO-GENERATED.

From 18468be4d3468440bba7ebf9dff41b203f175a6d Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 12 Sep 2023 14:21:33 -0400
Subject: [PATCH 028/166] wgsl: Add non-matrix AbstractFloat subtraction
 execution tests (#2928)

Issue #1626

Co-authored-by: jzm-intel <zhaoming.jiang@intel.com>
---
 src/unittests/floating_point.spec.ts          |  18 ++-
 src/webgpu/listing_meta.json                  |   5 +-
 .../expression/binary/af_subtraction.spec.ts  | 151 ++++++++++++++++++
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 173 insertions(+), 3 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 02239005c6ee..6fa4900225ce 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -4575,12 +4575,28 @@ const kSubtractionInterval64BitsNormalCases = {
     // Expect f16 interval [0xAE67-0x2E67, 0xAE66-0x2E66]
     { input: [-0.1, 0.1], expected: [reinterpretU16AsF16(0xae67)-reinterpretU16AsF16(0x2e67), reinterpretU16AsF16(0xae66)-reinterpretU16AsF16(0x2e66)] },
   ] as ScalarPairToIntervalCase[],
+  abstract: [
+    // 0.1 isn't exactly representable in f64, but will be quantized to an
+    // exact value when storing to a 'number' (0x3FB999999999999A).
+    // This is why below the expectations are not intervals.
+    { input: [0.1, 0], expected: [0.1] },
+    { input: [0, -0.1], expected: [0.1] },
+    { input: [-0.1, 0], expected: [-0.1] },
+    { input: [0, 0.1], expected: [-0.1] },
+
+    { input: [0.1, 0.1], expected: [0] },
+    { input: [-0.1, -0.1], expected: [0] },
+    // f64 0x3FB999999999999A - 0xBFB999999999999A = 0x3FC999999999999A
+    { input: [0.1, -0.1], expected: [reinterpretU64AsF64(0x3fc999999999999an)] },  // ~0.2
+    // f64 0xBFB999999999999A - 0x3FB999999999999A = 0xBFC999999999999A
+    { input: [-0.1, 0.1], expected: [reinterpretU64AsF64(0xbfc999999999999an) ] },  // ~-0.2,
+  ] as ScalarPairToIntervalCase[],
 } as const;
 
 g.test('subtractionInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarPairToIntervalCase>(p => {
         const trait = FP[p.trait];
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 54dfc261ff34..7f5d27da6242 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -823,7 +823,7 @@
   "webgpu:compat,api,validation,encoding,programmable,pipeline_bind_group_compat:twoDifferentTextureViews,render_pass,used:*": { "subcaseMS": 0.000 },
   "webgpu:compat,api,validation,render_pipeline,fragment_state:colorState:*": { "subcaseMS": 32.604 },
   "webgpu:compat,api,validation,render_pipeline,shader_module:sample_mask:*": { "subcaseMS": 14.801 },
-  "webgpu:compat,api,validation,render_pipeline,vertex_state:maxVertexAttributesVertexIndexInstanceIndex:*": { "subcaseMS": 3.7 },
+  "webgpu:compat,api,validation,render_pipeline,vertex_state:maxVertexAttributesVertexIndexInstanceIndex:*": { "subcaseMS": 3.700 },
   "webgpu:compat,api,validation,texture,createTexture:unsupportedTextureFormats:*": { "subcaseMS": 0.700 },
   "webgpu:compat,api,validation,texture,createTexture:unsupportedTextureViewFormats:*": { "subcaseMS": 0.601 },
   "webgpu:compat,api,validation,texture,cubeArray:cube_array:*": { "subcaseMS": 13.701 },
@@ -860,6 +860,9 @@
   "webgpu:shader,execution,expression,binary,af_comparison:less_than:*": { "subcaseMS": 19.975 },
   "webgpu:shader,execution,expression,binary,af_comparison:not_equals:*": { "subcaseMS": 19.651 },
   "webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*": { "subcaseMS": 11169.534 },
+  "webgpu:shader,execution,expression,binary,af_subtraction:scalar:*": { "subcaseMS": 960.626 },
+  "webgpu:shader,execution,expression,binary,af_subtraction:scalar_vector:*": { "subcaseMS": 2336.534 },
+  "webgpu:shader,execution,expression,binary,af_subtraction:vector_scalar:*": { "subcaseMS": 2437.701 },
   "webgpu:shader,execution,expression,binary,bitwise:bitwise_and:*": { "subcaseMS": 20.982 },
   "webgpu:shader,execution,expression,binary,bitwise:bitwise_and_compound:*": { "subcaseMS": 22.513 },
   "webgpu:shader,execution,expression,binary,bitwise:bitwise_exclusive_or:*": { "subcaseMS": 21.294 },
diff --git a/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
new file mode 100644
index 000000000000..4faa21de33fd
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
@@ -0,0 +1,151 @@
+export const description = `
+Execution Tests for non-matrix AbstractFloat subtraction expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractFloat, TypeVec } from '../../../../util/conversion.js';
+import { FP, FPVector } from '../../../../util/floating_point.js';
+import { sparseF64Range, sparseVectorF64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { abstractBinary } from './binary.js';
+
+const subtractionVectorScalarInterval = (v: number[], s: number): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.subtractionInterval(e, s)));
+};
+
+const subtractionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.subtractionInterval(s, e)));
+};
+
+export const g = makeTestGroup(GPUTest);
+
+export const d = makeCaseCache('abstractBinary/af_subtraction', {
+  scalar: () => {
+    return FP.abstract.generateScalarPairToIntervalCases(
+      sparseF64Range(),
+      sparseF64Range(),
+      'finite',
+      FP.abstract.subtractionInterval
+    );
+  },
+  vec2_scalar: () => {
+    return FP.abstract.generateVectorScalarToVectorCases(
+      sparseVectorF64Range(2),
+      sparseF64Range(),
+      'finite',
+      subtractionVectorScalarInterval
+    );
+  },
+  vec3_scalar: () => {
+    return FP.abstract.generateVectorScalarToVectorCases(
+      sparseVectorF64Range(3),
+      sparseF64Range(),
+      'finite',
+      subtractionVectorScalarInterval
+    );
+  },
+  vec4_scalar: () => {
+    return FP.abstract.generateVectorScalarToVectorCases(
+      sparseVectorF64Range(4),
+      sparseF64Range(),
+      'finite',
+      subtractionVectorScalarInterval
+    );
+  },
+  scalar_vec2: () => {
+    return FP.abstract.generateScalarVectorToVectorCases(
+      sparseF64Range(),
+      sparseVectorF64Range(2),
+      'finite',
+      subtractionScalarVectorInterval
+    );
+  },
+  scalar_vec3: () => {
+    return FP.abstract.generateScalarVectorToVectorCases(
+      sparseF64Range(),
+      sparseVectorF64Range(3),
+      'finite',
+      subtractionScalarVectorInterval
+    );
+  },
+  scalar_vec4: () => {
+    return FP.abstract.generateScalarVectorToVectorCases(
+      sparseF64Range(),
+      sparseVectorF64Range(4),
+      'finite',
+      subtractionScalarVectorInterval
+    );
+  },
+});
+
+g.test('scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x - y
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cases = await d.get('scalar');
+    await run(
+      t,
+      abstractBinary('-'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector_scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x - y, where x is a vector and y is a scalar
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`vec${dim}_scalar`);
+    await run(
+      t,
+      abstractBinary('-'),
+      [TypeVec(dim, TypeAbstractFloat), TypeAbstractFloat],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('scalar_vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x - y, where x is a scalar and y is a vector
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`scalar_vec${dim}`);
+    await run(
+      t,
+      abstractBinary('-'),
+      [TypeAbstractFloat, TypeVec(dim, TypeAbstractFloat)],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 7a0038f4b82e..99a54c4c5cf0 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4902,7 +4902,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly smoothStepInterval = this.unimplementedScalarTripleToInterval.bind(this);
   public readonly sqrtInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly stepInterval = this.unimplementedScalarPairToInterval.bind(this);
-  public readonly subtractionInterval = this.unimplementedScalarPairToInterval.bind(this);
+  public readonly subtractionInterval = this.subtractionIntervalImpl.bind(this);
   public readonly subtractionMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(this);
   public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this);

From fd0cf88ce7bfbf5466858bb142c8249d59b42069 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 12 Sep 2023 15:04:17 -0400
Subject: [PATCH 029/166] wgsl: Add AbstractFloat matrix subtraction execution
 tests (#2929)

Issue #1626
---
 src/unittests/floating_point.spec.ts          | 375 +++++++++---------
 src/webgpu/listing_meta.json                  |   1 +
 .../binary/af_matrix_subtraction.spec.ts      | 118 ++++++
 src/webgpu/util/floating_point.ts             |   4 +-
 4 files changed, 313 insertions(+), 185 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/binary/af_matrix_subtraction.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 6fa4900225ce..2874aca830f9 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -6056,193 +6056,200 @@ g.test('additionMatrixMatrixInterval')
     );
   });
 
-g.test('subtractionMatrixMatrixInterval_f32')
-  .paramsSubcasesOnly<MatrixPairToMatrixCase>([
-    // Only testing that different shapes of matrices are handled correctly
-    // here, to reduce test duplication.
-    // subtractionMatrixMatrixInterval uses SubtractionIntervalOp for calculating intervals,
-    // so the testing for subtractionInterval covers the actual interval
-    // calculations.
-    {
-      input: [
-        [
-          [-1, -2],
-          [-3, -4],
-        ],
-        [
-          [10, 20],
-          [30, 40],
-        ],
-      ],
-      expected: [
-        [-11, -22],
-        [-33, -44],
-      ],
-    },
-    {
-      input: [
-        [
-          [-1, -2],
-          [-3, -4],
-          [-5, -6],
-        ],
-        [
-          [10, 20],
-          [30, 40],
-          [50, 60],
-        ],
-      ],
-      expected: [
-        [-11, -22],
-        [-33, -44],
-        [-55, -66],
-      ],
-    },
-    {
-      input: [
-        [
-          [-1, -2],
-          [-3, -4],
-          [-5, -6],
-          [-7, -8],
-        ],
-        [
-          [10, 20],
-          [30, 40],
-          [50, 60],
-          [70, 80],
-        ],
-      ],
-      expected: [
-        [-11, -22],
-        [-33, -44],
-        [-55, -66],
-        [-77, -88],
-      ],
-    },
-    {
-      input: [
-        [
-          [-1, -2, -3],
-          [-4, -5, -6],
-        ],
-        [
-          [10, 20, 30],
-          [40, 50, 60],
-        ],
-      ],
-      expected: [
-        [-11, -22, -33],
-        [-44, -55, -66],
-      ],
-    },
-    {
-      input: [
-        [
-          [-1, -2, -3],
-          [-4, -5, -6],
-          [-7, -8, -9],
-        ],
-        [
-          [10, 20, 30],
-          [40, 50, 60],
-          [70, 80, 90],
-        ],
-      ],
-      expected: [
-        [-11, -22, -33],
-        [-44, -55, -66],
-        [-77, -88, -99],
-      ],
-    },
-    {
-      input: [
-        [
-          [-1, -2, -3],
-          [-4, -5, -6],
-          [-7, -8, -9],
-          [-10, -11, -12],
-        ],
-        [
-          [10, 20, 30],
-          [40, 50, 60],
-          [70, 80, 90],
-          [1000, 1100, 1200],
-        ],
-      ],
-      expected: [
-        [-11, -22, -33],
-        [-44, -55, -66],
-        [-77, -88, -99],
-        [-1010, -1111, -1212],
-      ],
-    },
-    {
-      input: [
-        [
-          [-1, -2, -3, -4],
-          [-5, -6, -7, -8],
-        ],
-        [
-          [10, 20, 30, 40],
-          [50, 60, 70, 80],
-        ],
-      ],
-      expected: [
-        [-11, -22, -33, -44],
-        [-55, -66, -77, -88],
-      ],
-    },
-    {
-      input: [
-        [
-          [-1, -2, -3, -4],
-          [-5, -6, -7, -8],
-          [-9, -10, -11, -12],
-        ],
-        [
-          [10, 20, 30, 40],
-          [50, 60, 70, 80],
-          [90, 1000, 1100, 1200],
-        ],
-      ],
-      expected: [
-        [-11, -22, -33, -44],
-        [-55, -66, -77, -88],
-        [-99, -1010, -1111, -1212],
-      ],
-    },
-    {
-      input: [
-        [
-          [-1, -2, -3, -4],
-          [-5, -6, -7, -8],
-          [-9, -10, -11, -12],
-          [-13, -14, -15, -16],
-        ],
-        [
-          [10, 20, 30, 40],
-          [50, 60, 70, 80],
-          [90, 1000, 1100, 1200],
-          [1300, 1400, 1500, 1600],
-        ],
-      ],
-      expected: [
-        [-11, -22, -33, -44],
-        [-55, -66, -77, -88],
-        [-99, -1010, -1111, -1212],
-        [-1313, -1414, -1515, -1616],
-      ],
-    },
-  ])
+g.test('subtractionMatrixMatrixInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'abstract'] as const)
+      .beginSubcases()
+      .expandWithParams<MatrixPairToMatrixCase>(_ => {
+        // Only testing that different shapes of matrices are handled correctly
+        // here, to reduce test duplication.
+        // subtractionMatrixMatrixInterval uses AdditionIntervalOp for calculating intervals,
+        // so the testing for subtractionInterval covers the actual interval
+        // calculations.
+        return [
+          {
+            input: [
+              [
+                [1, 2],
+                [3, 4],
+              ],
+              [
+                [-10, -20],
+                [-30, -40],
+              ],
+            ],
+            expected: [
+              [11, 22],
+              [33, 44],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2],
+                [3, 4],
+                [5, 6],
+              ],
+              [
+                [-10, -20],
+                [-30, -40],
+                [-50, -60],
+              ],
+            ],
+            expected: [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2],
+                [3, 4],
+                [5, 6],
+                [7, 8],
+              ],
+              [
+                [-10, -20],
+                [-30, -40],
+                [-50, -60],
+                [-70, -80],
+              ],
+            ],
+            expected: [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+              [77, 88],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3],
+                [4, 5, 6],
+              ],
+              [
+                [-10, -20, -30],
+                [-40, -50, -60],
+              ],
+            ],
+            expected: [
+              [11, 22, 33],
+              [44, 55, 66],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+              ],
+              [
+                [-10, -20, -30],
+                [-40, -50, -60],
+                [-70, -80, -90],
+              ],
+            ],
+            expected: [
+              [11, 22, 33],
+              [44, 55, 66],
+              [77, 88, 99],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+                [10, 11, 12],
+              ],
+              [
+                [-10, -20, -30],
+                [-40, -50, -60],
+                [-70, -80, -90],
+                [-1000, -1100, -1200],
+              ],
+            ],
+            expected: [
+              [11, 22, 33],
+              [44, 55, 66],
+              [77, 88, 99],
+              [1010, 1111, 1212],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+              ],
+              [
+                [-10, -20, -30, -40],
+                [-50, -60, -70, -80],
+              ],
+            ],
+            expected: [
+              [11, 22, 33, 44],
+              [55, 66, 77, 88],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+              ],
+              [
+                [-10, -20, -30, -40],
+                [-50, -60, -70, -80],
+                [-90, -1000, -1100, -1200],
+              ],
+            ],
+            expected: [
+              [11, 22, 33, 44],
+              [55, 66, 77, 88],
+              [99, 1010, 1111, 1212],
+            ],
+          },
+          {
+            input: [
+              [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+              ],
+              [
+                [-10, -20, -30, -40],
+                [-50, -60, -70, -80],
+                [-90, -1000, -1100, -1200],
+                [-1300, -1400, -1500, -1600],
+              ],
+            ],
+            expected: [
+              [11, 22, 33, 44],
+              [55, 66, 77, 88],
+              [99, 1010, 1111, 1212],
+              [1313, 1414, 1515, 1616],
+            ],
+          },
+        ];
+      })
+  )
   .fn(t => {
-    const x = t.params.input[0];
-    const y = t.params.input[1];
-    const expected = FP.f32.toMatrix(t.params.expected);
-    const got = FP.f32.subtractionMatrixMatrixInterval(x, y);
+    const [x, y] = t.params.input;
+    const trait = FP[t.params.trait];
+    const expected = trait.toMatrix(t.params.expected);
+    const got = trait.subtractionMatrixMatrixInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `f32.subtractionMatrixMatrixInterval([${JSON.stringify(x)}], [${JSON.stringify(
+      `${t.params.trait}.subtractionMatrixMatrixInterval([${JSON.stringify(x)}], [${JSON.stringify(
         y
       )}]) returned '[${JSON.stringify(got)}]'. Expected '[${JSON.stringify(expected)}]'`
     );
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 7f5d27da6242..b2430ae44361 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -860,6 +860,7 @@
   "webgpu:shader,execution,expression,binary,af_comparison:less_than:*": { "subcaseMS": 19.975 },
   "webgpu:shader,execution,expression,binary,af_comparison:not_equals:*": { "subcaseMS": 19.651 },
   "webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*": { "subcaseMS": 11169.534 },
+  "webgpu:shader,execution,expression,binary,af_matrix_subtraction:matrix:*": { "subcaseMS": 14060.956 },
   "webgpu:shader,execution,expression,binary,af_subtraction:scalar:*": { "subcaseMS": 960.626 },
   "webgpu:shader,execution,expression,binary,af_subtraction:scalar_vector:*": { "subcaseMS": 2336.534 },
   "webgpu:shader,execution,expression,binary,af_subtraction:vector_scalar:*": { "subcaseMS": 2437.701 },
diff --git a/src/webgpu/shader/execution/expression/binary/af_matrix_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/af_matrix_subtraction.spec.ts
new file mode 100644
index 000000000000..0837b05ff415
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/af_matrix_subtraction.spec.ts
@@ -0,0 +1,118 @@
+export const description = `
+Execution Tests for matrix AbstractFloat subtraction expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractFloat, TypeMat } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { sparseMatrixF64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { abstractBinary } from './binary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+export const d = makeCaseCache('abstractBinary/af_matrix_subtraction', {
+  mat2x2: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(2, 2),
+      sparseMatrixF64Range(2, 2),
+      'finite',
+      FP.abstract.subtractionMatrixMatrixInterval
+    );
+  },
+  mat2x3: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(2, 3),
+      sparseMatrixF64Range(2, 3),
+      'finite',
+      FP.abstract.subtractionMatrixMatrixInterval
+    );
+  },
+  mat2x4: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(2, 4),
+      sparseMatrixF64Range(2, 4),
+      'finite',
+      FP.abstract.subtractionMatrixMatrixInterval
+    );
+  },
+  mat3x2: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(3, 2),
+      sparseMatrixF64Range(3, 2),
+      'finite',
+      FP.abstract.subtractionMatrixMatrixInterval
+    );
+  },
+  mat3x3: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(3, 3),
+      sparseMatrixF64Range(3, 3),
+      'finite',
+      FP.abstract.subtractionMatrixMatrixInterval
+    );
+  },
+  mat3x4: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(3, 4),
+      sparseMatrixF64Range(3, 4),
+      'finite',
+      FP.abstract.subtractionMatrixMatrixInterval
+    );
+  },
+  mat4x2: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(4, 2),
+      sparseMatrixF64Range(4, 2),
+      'finite',
+      FP.abstract.subtractionMatrixMatrixInterval
+    );
+  },
+  mat4x3: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(4, 3),
+      sparseMatrixF64Range(4, 3),
+      'finite',
+      FP.abstract.subtractionMatrixMatrixInterval
+    );
+  },
+  mat4x4: () => {
+    return FP.abstract.generateMatrixPairToMatrixCases(
+      sparseMatrixF64Range(4, 4),
+      sparseMatrixF64Range(4, 4),
+      'finite',
+      FP.abstract.subtractionMatrixMatrixInterval
+    );
+  },
+});
+
+g.test('matrix')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x - y, where x and y are matrices
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(`mat${cols}x${rows}`);
+    await run(
+      t,
+      abstractBinary('-'),
+      [TypeMat(cols, rows, TypeAbstractFloat), TypeMat(cols, rows, TypeAbstractFloat)],
+      TypeMat(cols, rows, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 99a54c4c5cf0..d304071bffd5 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4903,7 +4903,9 @@ class FPAbstractTraits extends FPTraits {
   public readonly sqrtInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly stepInterval = this.unimplementedScalarPairToInterval.bind(this);
   public readonly subtractionInterval = this.subtractionIntervalImpl.bind(this);
-  public readonly subtractionMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(this);
+  public readonly subtractionMatrixMatrixInterval = this.subtractionMatrixMatrixIntervalImpl.bind(
+    this
+  );
   public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly transposeInterval = this.unimplementedMatrixToMatrix.bind(this);

From 69a2c926cf2de879f3e237b28e3e07143eb2f88c Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 12 Sep 2023 15:30:32 -0400
Subject: [PATCH 030/166] wgsl: Add AbstractFloat simple multiplication
 execution tests (#2930)

Covers scalar * scalar, scalar * vector, and vector * scalar

Issue #1626
---
 src/unittests/floating_point.spec.ts          |  53 ++++--
 src/webgpu/listing_meta.json                  |   3 +
 .../binary/af_multiplication.spec.ts          | 151 ++++++++++++++++++
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 191 insertions(+), 18 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 2874aca830f9..efefd36ce641 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3695,16 +3695,16 @@ const kAdditionInterval64BitsNormalCases = {
     // 0.1 isn't exactly representable in f64, but will be quantized to an
     // exact value when storing to a 'number' (0x3FB999999999999A).
     // This is why below the expectations are not intervals.
-    { input: [0.1, 0], expected: [0.1] },
-    { input: [0, 0.1], expected: [0.1] },
-    { input: [-0.1, 0], expected: [-0.1] },
-    { input: [0, -0.1], expected: [-0.1] },
+    { input: [0.1, 0], expected: 0.1 },
+    { input: [0, 0.1], expected: 0.1 },
+    { input: [-0.1, 0], expected: -0.1 },
+    { input: [0, -0.1], expected: -0.1 },
     // f64 0x3FB999999999999A+0x3FB999999999999A = 0x3FC999999999999A
-    { input: [0.1, 0.1], expected: [reinterpretU64AsF64(0x3FC999999999999An)] },  // ~0.2
+    { input: [0.1, 0.1], expected: reinterpretU64AsF64(0x3FC999999999999An) },  // ~0.2
     // f64 0xBFB999999999999A+0xBFB999999999999A = 0xBFC999999999999A
-    { input: [-0.1, -0.1], expected: [reinterpretU64AsF64(0xBFC999999999999An)] },  // ~-0.2
-    { input: [0.1, -0.1], expected: [0] },
-    { input: [-0.1, 0.1], expected: [0] },
+    { input: [-0.1, -0.1], expected: reinterpretU64AsF64(0xBFC999999999999An) },  // ~-0.2
+    { input: [0.1, -0.1], expected: 0 },
+    { input: [-0.1, 0.1], expected: 0 },
   ] as ScalarPairToIntervalCase[],
 } as const;
 
@@ -4310,12 +4310,31 @@ const kMultiplicationInterval64BitsNormalCases = {
     { input: [0.1, -0.1], expected: [reinterpretU16AsF16(0xa120), reinterpretU16AsF16(0xa11e)] },  // ~-0.01
     { input: [-0.1, 0.1], expected: [reinterpretU16AsF16(0xa120), reinterpretU16AsF16(0xa11e)] },  // ~-0.01
   ] as ScalarPairToIntervalCase[],
+  abstract: [
+    // 0.1 isn't exactly representable in f64, but will be quantized to an
+    // exact value when storing to a 'number' (0x3FB999999999999A).
+    // This is why below the expectations are not intervals.
+    // Finite values multiply zero result in zero
+    { input: [0.1, 0], expected: 0 },
+    { input: [0, 0.1], expected: 0 },
+    { input: [-0.1, 0], expected: 0 },
+    { input: [0, -0.1], expected: 0 },
+    { input: [0.1, 1], expected: 0.1 },
+    { input: [-1, -0.1], expected: 0.1 },
+    { input: [-0.1, 1], expected: -0.1 },
+    { input: [-1, 0.1], expected: -0.1 },
+    // f64 0.1 * 0.1 = 0x3f847ae147ae147c,
+    { input: [0.1, 0.1], expected: reinterpretU64AsF64(0x3f847ae147ae147cn) },  // ~0.01
+    { input: [-0.1, -0.1], expected: reinterpretU64AsF64(0x3f847ae147ae147cn) },  // ~0.01
+    { input: [0.1, -0.1], expected: reinterpretU64AsF64(0xbf847ae147ae147cn) },  // ~-0.01
+    { input: [-0.1, 0.1], expected: reinterpretU64AsF64(0xbf847ae147ae147cn) },  // ~-0.01
+  ] as ScalarPairToIntervalCase[],
 } as const;
 
 g.test('multiplicationInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarPairToIntervalCase>(p => {
         const trait = FP[p.trait];
@@ -4579,17 +4598,17 @@ const kSubtractionInterval64BitsNormalCases = {
     // 0.1 isn't exactly representable in f64, but will be quantized to an
     // exact value when storing to a 'number' (0x3FB999999999999A).
     // This is why below the expectations are not intervals.
-    { input: [0.1, 0], expected: [0.1] },
-    { input: [0, -0.1], expected: [0.1] },
-    { input: [-0.1, 0], expected: [-0.1] },
-    { input: [0, 0.1], expected: [-0.1] },
+    { input: [0.1, 0], expected: 0.1 },
+    { input: [0, -0.1], expected: 0.1 },
+    { input: [-0.1, 0], expected: -0.1 },
+    { input: [0, 0.1], expected: -0.1 },
 
-    { input: [0.1, 0.1], expected: [0] },
-    { input: [-0.1, -0.1], expected: [0] },
+    { input: [0.1, 0.1], expected: 0 },
+    { input: [-0.1, -0.1], expected: 0 },
     // f64 0x3FB999999999999A - 0xBFB999999999999A = 0x3FC999999999999A
-    { input: [0.1, -0.1], expected: [reinterpretU64AsF64(0x3fc999999999999an)] },  // ~0.2
+    { input: [0.1, -0.1], expected: reinterpretU64AsF64(0x3fc999999999999an) },  // ~0.2
     // f64 0xBFB999999999999A - 0x3FB999999999999A = 0xBFC999999999999A
-    { input: [-0.1, 0.1], expected: [reinterpretU64AsF64(0xbfc999999999999an) ] },  // ~-0.2,
+    { input: [-0.1, 0.1], expected: reinterpretU64AsF64(0xbfc999999999999an) },  // ~-0.2,
   ] as ScalarPairToIntervalCase[],
 } as const;
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index b2430ae44361..f33208436fa7 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -861,6 +861,9 @@
   "webgpu:shader,execution,expression,binary,af_comparison:not_equals:*": { "subcaseMS": 19.651 },
   "webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*": { "subcaseMS": 11169.534 },
   "webgpu:shader,execution,expression,binary,af_matrix_subtraction:matrix:*": { "subcaseMS": 14060.956 },
+  "webgpu:shader,execution,expression,binary,af_multiplication:scalar:*": { "subcaseMS": 907.726 },
+  "webgpu:shader,execution,expression,binary,af_multiplication:scalar_vector:*": { "subcaseMS": 2025.534 },
+  "webgpu:shader,execution,expression,binary,af_multiplication:vector_scalar:*": { "subcaseMS": 2085.300 },
   "webgpu:shader,execution,expression,binary,af_subtraction:scalar:*": { "subcaseMS": 960.626 },
   "webgpu:shader,execution,expression,binary,af_subtraction:scalar_vector:*": { "subcaseMS": 2336.534 },
   "webgpu:shader,execution,expression,binary,af_subtraction:vector_scalar:*": { "subcaseMS": 2437.701 },
diff --git a/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
new file mode 100644
index 000000000000..80a2aa23bdcd
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
@@ -0,0 +1,151 @@
+export const description = `
+Execution Tests for non-matrix AbstractFloat multiplication expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractFloat, TypeVec } from '../../../../util/conversion.js';
+import { FP, FPVector } from '../../../../util/floating_point.js';
+import { sparseF64Range, sparseVectorF64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { abstractBinary } from './binary.js';
+
+const multiplicationVectorScalarInterval = (v: number[], s: number): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.multiplicationInterval(e, s)));
+};
+
+const multiplicationScalarVectorInterval = (s: number, v: number[]): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.multiplicationInterval(s, e)));
+};
+
+export const g = makeTestGroup(GPUTest);
+
+export const d = makeCaseCache('abstractBinary/af_multiplication', {
+  scalar: () => {
+    return FP.abstract.generateScalarPairToIntervalCases(
+      sparseF64Range(),
+      sparseF64Range(),
+      'finite',
+      FP.abstract.multiplicationInterval
+    );
+  },
+  vec2_scalar: () => {
+    return FP.abstract.generateVectorScalarToVectorCases(
+      sparseVectorF64Range(2),
+      sparseF64Range(),
+      'finite',
+      multiplicationVectorScalarInterval
+    );
+  },
+  vec3_scalar: () => {
+    return FP.abstract.generateVectorScalarToVectorCases(
+      sparseVectorF64Range(3),
+      sparseF64Range(),
+      'finite',
+      multiplicationVectorScalarInterval
+    );
+  },
+  vec4_scalar: () => {
+    return FP.abstract.generateVectorScalarToVectorCases(
+      sparseVectorF64Range(4),
+      sparseF64Range(),
+      'finite',
+      multiplicationVectorScalarInterval
+    );
+  },
+  scalar_vec2: () => {
+    return FP.abstract.generateScalarVectorToVectorCases(
+      sparseF64Range(),
+      sparseVectorF64Range(2),
+      'finite',
+      multiplicationScalarVectorInterval
+    );
+  },
+  scalar_vec3: () => {
+    return FP.abstract.generateScalarVectorToVectorCases(
+      sparseF64Range(),
+      sparseVectorF64Range(3),
+      'finite',
+      multiplicationScalarVectorInterval
+    );
+  },
+  scalar_vec4: () => {
+    return FP.abstract.generateScalarVectorToVectorCases(
+      sparseF64Range(),
+      sparseVectorF64Range(4),
+      'finite',
+      multiplicationScalarVectorInterval
+    );
+  },
+});
+
+g.test('scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cases = await d.get('scalar');
+    await run(
+      t,
+      abstractBinary('*'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector_scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x is a vector and y is a scalar
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`vec${dim}_scalar`);
+    await run(
+      t,
+      abstractBinary('*'),
+      [TypeVec(dim, TypeAbstractFloat), TypeAbstractFloat],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('scalar_vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x is a scalar and y is a vector
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`scalar_vec${dim}`);
+    await run(
+      t,
+      abstractBinary('*'),
+      [TypeAbstractFloat, TypeVec(dim, TypeAbstractFloat)],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index d304071bffd5..8b385591dee6 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4870,7 +4870,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly mixPreciseInterval = this.unimplementedScalarTripleToInterval.bind(this);
   public readonly mixIntervals = [this.mixImpreciseInterval, this.mixPreciseInterval];
   public readonly modfInterval = this.unimplementedModf.bind(this);
-  public readonly multiplicationInterval = this.unimplementedScalarPairToInterval.bind(this);
+  public readonly multiplicationInterval = this.multiplicationIntervalImpl.bind(this);
   public readonly multiplicationMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(
     this
   );

From 679ea4c92a2b1a142dbae430bc3faa07ecbf5374 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 13 Sep 2023 10:16:10 -0400
Subject: [PATCH 031/166] wgsl: Add AbstractFloat `abs` execution tests (#2932)

Fixes #2931
---
 src/unittests/floating_point.spec.ts          | 10 ++++----
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/abs.spec.ts       | 23 +++++++++++++++----
 .../expression/call/builtin/builtin.ts        |  6 +++++
 src/webgpu/util/floating_point.ts             |  2 +-
 5 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index efefd36ce641..825078d680db 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -2168,6 +2168,7 @@ const kAbsIntervalCases = [
     expected: {
       f32: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)],
       f16: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)],
+      abstract: 0.1,
     },
   },
   {
@@ -2175,6 +2176,7 @@ const kAbsIntervalCases = [
     expected: {
       f32: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)],
       f16: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)],
+      abstract: 0.1,
     },
   },
 ] as const;
@@ -2182,7 +2184,7 @@ const kAbsIntervalCases = [
 g.test('absInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarToIntervalCase>(p => {
         const constants = FP[p.trait].constants();
@@ -2201,16 +2203,12 @@ g.test('absInterval')
           { input: constants.negative.min, expected: constants.positive.max },
           { input: constants.negative.max, expected: constants.positive.min },
 
-          // 32-bit subnormals
+          // Subnormals
           { input: constants.positive.subnormal.max, expected: [0, constants.positive.subnormal.max] },
           { input: constants.positive.subnormal.min, expected: [0, constants.positive.subnormal.min] },
           { input: constants.negative.subnormal.min, expected: [0, constants.positive.subnormal.max] },
           { input: constants.negative.subnormal.max, expected: [0, constants.positive.subnormal.min] },
 
-          // 64-bit subnormals
-          { input: reinterpretU64AsF64(0x0000_0000_0000_0001n), expected: [0, constants.positive.subnormal.min] },
-          { input: reinterpretU64AsF64(0x800f_ffff_ffff_ffffn), expected: [0, constants.positive.subnormal.min] },
-
           // Zero
           { input: 0, expected: 0 },
         ];
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index f33208436fa7..f9df1b1f52af 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1016,7 +1016,7 @@
   "webgpu:shader,execution,expression,binary,u32_comparison:less_equals:*": { "subcaseMS": 7.844 },
   "webgpu:shader,execution,expression,binary,u32_comparison:less_than:*": { "subcaseMS": 6.700 },
   "webgpu:shader,execution,expression,binary,u32_comparison:not_equals:*": { "subcaseMS": 6.850 },
-  "webgpu:shader,execution,expression,call,builtin,abs:abstract_float:*": { "subcaseMS": 16.809 },
+  "webgpu:shader,execution,expression,call,builtin,abs:abstract_float:*": { "subcaseMS": 464.126 },
   "webgpu:shader,execution,expression,call,builtin,abs:abstract_int:*": { "subcaseMS": 16.810 },
   "webgpu:shader,execution,expression,call,builtin,abs:f16:*": { "subcaseMS": 22.910 },
   "webgpu:shader,execution,expression,call,builtin,abs:f32:*": { "subcaseMS": 9.844 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/abs.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/abs.spec.ts
index c7ba2e498e04..05d5242f7354 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/abs.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/abs.spec.ts
@@ -25,13 +25,14 @@ import {
   TypeI32,
   TypeU32,
   u32Bits,
+  TypeAbstractFloat,
 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range, fullF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -42,6 +43,13 @@ export const d = makeCaseCache('abs', {
   f16: () => {
     return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'unfiltered', FP.f16.absInterval);
   },
+  abstract: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      fullF64Range(),
+      'unfiltered',
+      FP.abstract.absInterval
+    );
+  },
 });
 
 g.test('abstract_int')
@@ -153,9 +161,14 @@ g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(t, abstractBuiltin('abs'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases);
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/shader/execution/expression/call/builtin/builtin.ts b/src/webgpu/shader/execution/expression/call/builtin/builtin.ts
index 26424dd1ce6e..282feea70306 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/builtin.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/builtin.ts
@@ -1,4 +1,5 @@
 import {
+  abstractFloatShaderBuilder,
   basicExpressionBuilder,
   basicExpressionWithPredeclarationBuilder,
   ShaderBuilder,
@@ -9,6 +10,11 @@ export function builtin(name: string): ShaderBuilder {
   return basicExpressionBuilder(values => `${name}(${values.join(', ')})`);
 }
 
+/* @returns a ShaderBuilder that calls the builtin with the given name that returns AbstractFloats */
+export function abstractBuiltin(name: string): ShaderBuilder {
+  return abstractFloatShaderBuilder(values => `${name}(${values.join(', ')})`);
+}
+
 /* @returns a ShaderBuilder that calls the builtin with the given name and has given predeclaration */
 export function builtinWithPredeclaration(name: string, predeclaration: string): ShaderBuilder {
   return basicExpressionWithPredeclarationBuilder(
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 8b385591dee6..a9689494f00f 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4829,7 +4829,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly ulpInterval = this.unboundedUlpInterval.bind(this);
 
   // Framework - API - Overrides
-  public readonly absInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly absInterval = this.absIntervalImpl.bind(this);
   public readonly acosInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly acoshAlternativeInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly acoshPrimaryInterval = this.unimplementedScalarToInterval.bind(this);

From 04cd7b8fcf163c734bd93ce54d68640a95b88e61 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 13 Sep 2023 14:53:22 -0400
Subject: [PATCH 032/166] Update websocket-logger instructions to use `npm ci`
 (#2947)

Changing to using `npm ci` instead of `npm install` to avoid potentially
pulling in unvetted dependencies.

Fixes #2945
---
 docs/adding_timing_metadata.md   | 4 ++--
 tools/websocket-logger/README.md | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/adding_timing_metadata.md b/docs/adding_timing_metadata.md
index 617d5365526d..056d0fb06271 100644
--- a/docs/adding_timing_metadata.md
+++ b/docs/adding_timing_metadata.md
@@ -66,8 +66,8 @@ throughout the following steps.
 
 At `tools/websocket-logger/`
 ```
-npm install
-npm run
+npm ci
+npm start
 ```
 
 The output from this command will indicate where the results are being logged,
diff --git a/tools/websocket-logger/README.md b/tools/websocket-logger/README.md
index ebd4e4f3076c..1328f12e9706 100644
--- a/tools/websocket-logger/README.md
+++ b/tools/websocket-logger/README.md
@@ -5,5 +5,5 @@ It can be used to receive logs from CTS in a way that's resistant to test crashe
 independent of which runtime is being used (e.g. standalone, WPT, Node).
 It's used in particular to capture timing results for predefining "chunking" of the CTS for WPT.
 
-To set up, use `npm install`.
+To set up, use `npm ci`.
 To launch, use `npm start`.

From 3a5f7893eb303e14ad55cb942b6db866de21eec8 Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Thu, 14 Sep 2023 09:03:26 +0900
Subject: [PATCH 033/166] Compat: Limit max attributes (#2953)

In compat @builtin(vertex_index) and @builtin(instance_index)
each take an attribute so account for that in this test.

It's possible we should refactor this test to not
use vertex_index, instance_instance. For example we could
make each pair of data generate the correct pixel position.

For now it seemed best to get it to pass.
The test in webgpu/compat/api/validation/encoding/render_pipeline/vertex_state.spec.ts
does a simple test that you can use maxVertexAttributes but it does
not test all the combinations like this test. It only tests that
creating a pipeline passes if you use maxVertexAttributes and
fails if you use maxVertexAttributes + the builtins above
---
 .../api/operation/vertex_state/correctness.spec.ts     | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/webgpu/api/operation/vertex_state/correctness.spec.ts b/src/webgpu/api/operation/vertex_state/correctness.spec.ts
index 56c659e80fc5..8ec536dcc511 100644
--- a/src/webgpu/api/operation/vertex_state/correctness.spec.ts
+++ b/src/webgpu/api/operation/vertex_state/correctness.spec.ts
@@ -941,13 +941,15 @@ g.test('max_buffers_and_attribs')
   .params(u => u.combine('format', kVertexFormats))
   .fn(t => {
     const { format } = t.params;
-    const attributesPerBuffer = Math.ceil(kMaxVertexAttributes / kMaxVertexBuffers);
+    // In compat mode, @builtin(vertex_index) and @builtin(instance_index) each take an attribute
+    const maxVertexAttributes = t.isCompatibility ? kMaxVertexAttributes - 2 : kMaxVertexAttributes;
+    const attributesPerBuffer = Math.ceil(maxVertexAttributes / kMaxVertexBuffers);
     let attributesEmitted = 0;
 
     const state: VertexLayoutState<{}, {}> = [];
     for (let i = 0; i < kMaxVertexBuffers; i++) {
       const attributes: GPUVertexAttribute[] = [];
-      for (let j = 0; j < attributesPerBuffer && attributesEmitted < kMaxVertexAttributes; j++) {
+      for (let j = 0; j < attributesPerBuffer && attributesEmitted < maxVertexAttributes; j++) {
         attributes.push({ format, offset: 0, shaderLocation: attributesEmitted });
         attributesEmitted++;
       }
@@ -1080,8 +1082,10 @@ g.test('overlapping_attributes')
   .fn(t => {
     const { format } = t.params;
 
+    // In compat mode, @builtin(vertex_index) and @builtin(instance_index) each take an attribute
+    const maxVertexAttributes = t.isCompatibility ? kMaxVertexAttributes - 2 : kMaxVertexAttributes;
     const attributes: GPUVertexAttribute[] = [];
-    for (let i = 0; i < kMaxVertexAttributes; i++) {
+    for (let i = 0; i < maxVertexAttributes; i++) {
       attributes.push({ format, offset: 0, shaderLocation: i });
     }
 

From ac6a70ebad24d65cc2f31bfa0a32cc384c93d2aa Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 14 Sep 2023 10:42:25 -0400
Subject: [PATCH 034/166] Split up 'scalar' tests into 'scalar' and 'vector'
 tests (#2946)

The existing code was using vectorize to generate vector subcases of
the 'scalar' fixture, which lead to a confusing situation where the
'scalar' tests were testing scalar-scalar inputs and vector-vector
inputs, but not matrix-matrix, scalar-vector, or vector-scalar.

This PR factors out the vector-vector cases into their own fixture
named 'vector', but still retains the usage of vectorize to reduce the
need to test case duplication. Beyond clarity, this also divides up
the existing tests into smaller chunks to help with load-balancing,
etc.

Fixes #2935
---
 src/webgpu/listing_meta.json                  | 112 ++++++++++--------
 .../expression/binary/af_addition.spec.ts     |  29 ++++-
 .../binary/af_multiplication.spec.ts          |  29 ++++-
 .../expression/binary/af_subtraction.spec.ts  |  29 ++++-
 .../expression/binary/f16_addition.spec.ts    |  25 +++-
 .../expression/binary/f16_division.spec.ts    |  25 +++-
 .../binary/f16_multiplication.spec.ts         |  25 +++-
 .../expression/binary/f16_subtraction.spec.ts |  25 +++-
 .../expression/binary/f32_addition.spec.ts    |  22 +++-
 .../expression/binary/f32_division.spec.ts    |  22 +++-
 .../binary/f32_multiplication.spec.ts         |  22 +++-
 .../expression/binary/f32_remainder.spec.ts   |  22 +++-
 .../expression/binary/f32_subtraction.spec.ts |  22 +++-
 13 files changed, 308 insertions(+), 101 deletions(-)

diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index f9df1b1f52af..c270ae463fbc 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -850,9 +850,10 @@
   "webgpu:idl,constants,flags:ShaderStage,values:*": { "subcaseMS": 0.034 },
   "webgpu:idl,constants,flags:TextureUsage,count:*": { "subcaseMS": 0.101 },
   "webgpu:idl,constants,flags:TextureUsage,values:*": { "subcaseMS": 0.040 },
-  "webgpu:shader,execution,expression,binary,af_addition:scalar:*": { "subcaseMS": 290.000 },
-  "webgpu:shader,execution,expression,binary,af_addition:scalar_vector:*": { "subcaseMS": 665.234 },
-  "webgpu:shader,execution,expression,binary,af_addition:vector_scalar:*": { "subcaseMS": 664.434 },
+  "webgpu:shader,execution,expression,binary,af_addition:scalar:*": { "subcaseMS": 815.300 },
+  "webgpu:shader,execution,expression,binary,af_addition:scalar_vector:*": { "subcaseMS": 1803.434 },
+  "webgpu:shader,execution,expression,binary,af_addition:vector:*": { "subcaseMS": 719.600 },
+  "webgpu:shader,execution,expression,binary,af_addition:vector_scalar:*": { "subcaseMS": 1770.734 },
   "webgpu:shader,execution,expression,binary,af_comparison:equals:*": { "subcaseMS": 23.000 },
   "webgpu:shader,execution,expression,binary,af_comparison:greater_equals:*": { "subcaseMS": 20.651 },
   "webgpu:shader,execution,expression,binary,af_comparison:greater_than:*": { "subcaseMS": 19.901 },
@@ -861,11 +862,13 @@
   "webgpu:shader,execution,expression,binary,af_comparison:not_equals:*": { "subcaseMS": 19.651 },
   "webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*": { "subcaseMS": 11169.534 },
   "webgpu:shader,execution,expression,binary,af_matrix_subtraction:matrix:*": { "subcaseMS": 14060.956 },
-  "webgpu:shader,execution,expression,binary,af_multiplication:scalar:*": { "subcaseMS": 907.726 },
+  "webgpu:shader,execution,expression,binary,af_multiplication:scalar:*": { "subcaseMS": 777.901 },
   "webgpu:shader,execution,expression,binary,af_multiplication:scalar_vector:*": { "subcaseMS": 2025.534 },
+  "webgpu:shader,execution,expression,binary,af_multiplication:vector:*": { "subcaseMS": 710.667 },
   "webgpu:shader,execution,expression,binary,af_multiplication:vector_scalar:*": { "subcaseMS": 2085.300 },
-  "webgpu:shader,execution,expression,binary,af_subtraction:scalar:*": { "subcaseMS": 960.626 },
+  "webgpu:shader,execution,expression,binary,af_subtraction:scalar:*": { "subcaseMS": 854.100 },
   "webgpu:shader,execution,expression,binary,af_subtraction:scalar_vector:*": { "subcaseMS": 2336.534 },
+  "webgpu:shader,execution,expression,binary,af_subtraction:vector:*": { "subcaseMS": 764.201 },
   "webgpu:shader,execution,expression,binary,af_subtraction:vector_scalar:*": { "subcaseMS": 2437.701 },
   "webgpu:shader,execution,expression,binary,bitwise:bitwise_and:*": { "subcaseMS": 20.982 },
   "webgpu:shader,execution,expression,binary,bitwise:bitwise_and_compound:*": { "subcaseMS": 22.513 },
@@ -885,48 +888,54 @@
   "webgpu:shader,execution,expression,binary,bool_logical:or:*": { "subcaseMS": 6.663 },
   "webgpu:shader,execution,expression,binary,bool_logical:or_compound:*": { "subcaseMS": 7.407 },
   "webgpu:shader,execution,expression,binary,bool_logical:or_short_circuit:*": { "subcaseMS": 10.050 },
-  "webgpu:shader,execution,expression,binary,f16_addition:scalar:*": { "subcaseMS": 6.807 },
-  "webgpu:shader,execution,expression,binary,f16_addition:scalar_compound:*": { "subcaseMS": 4.010 },
-  "webgpu:shader,execution,expression,binary,f16_addition:scalar_vector:*": { "subcaseMS": 2.606 },
-  "webgpu:shader,execution,expression,binary,f16_addition:vector_scalar:*": { "subcaseMS": 3.006 },
-  "webgpu:shader,execution,expression,binary,f16_addition:vector_scalar_compound:*": { "subcaseMS": 2.503 },
+  "webgpu:shader,execution,expression,binary,f16_addition:scalar:*": { "subcaseMS": 106.501 },
+  "webgpu:shader,execution,expression,binary,f16_addition:scalar_compound:*": { "subcaseMS": 5.912 },
+  "webgpu:shader,execution,expression,binary,f16_addition:scalar_vector:*": { "subcaseMS": 4.408 },
+  "webgpu:shader,execution,expression,binary,f16_addition:vector:*": { "subcaseMS": 8.204 },
+  "webgpu:shader,execution,expression,binary,f16_addition:vector_scalar:*": { "subcaseMS": 4.308 },
+  "webgpu:shader,execution,expression,binary,f16_addition:vector_scalar_compound:*": { "subcaseMS": 4.406 },
   "webgpu:shader,execution,expression,binary,f16_comparison:equals:*": { "subcaseMS": 3.907 },
   "webgpu:shader,execution,expression,binary,f16_comparison:greater_equals:*": { "subcaseMS": 3.507 },
   "webgpu:shader,execution,expression,binary,f16_comparison:greater_than:*": { "subcaseMS": 3.908 },
   "webgpu:shader,execution,expression,binary,f16_comparison:less_equals:*": { "subcaseMS": 3.108 },
   "webgpu:shader,execution,expression,binary,f16_comparison:less_than:*": { "subcaseMS": 3.508 },
   "webgpu:shader,execution,expression,binary,f16_comparison:not_equals:*": { "subcaseMS": 3.405 },
-  "webgpu:shader,execution,expression,binary,f16_division:scalar:*": { "subcaseMS": 3.105 },
-  "webgpu:shader,execution,expression,binary,f16_division:scalar_compound:*": { "subcaseMS": 4.011 },
-  "webgpu:shader,execution,expression,binary,f16_division:scalar_vector:*": { "subcaseMS": 2.406 },
-  "webgpu:shader,execution,expression,binary,f16_division:vector_scalar:*": { "subcaseMS": 3.006 },
-  "webgpu:shader,execution,expression,binary,f16_division:vector_scalar_compound:*": { "subcaseMS": 3.005 },
-  "webgpu:shader,execution,expression,binary,f16_multiplication:scalar:*": { "subcaseMS": 4.010 },
-  "webgpu:shader,execution,expression,binary,f16_multiplication:scalar_compound:*": { "subcaseMS": 3.906 },
-  "webgpu:shader,execution,expression,binary,f16_multiplication:scalar_vector:*": { "subcaseMS": 2.708 },
-  "webgpu:shader,execution,expression,binary,f16_multiplication:vector_scalar:*": { "subcaseMS": 3.306 },
-  "webgpu:shader,execution,expression,binary,f16_multiplication:vector_scalar_compound:*": { "subcaseMS": 2.501 },
-  "webgpu:shader,execution,expression,binary,f16_subtraction:scalar:*": { "subcaseMS": 3.406 },
-  "webgpu:shader,execution,expression,binary,f16_subtraction:scalar_compound:*": { "subcaseMS": 4.203 },
-  "webgpu:shader,execution,expression,binary,f16_subtraction:scalar_vector:*": { "subcaseMS": 2.602 },
-  "webgpu:shader,execution,expression,binary,f16_subtraction:vector_scalar:*": { "subcaseMS": 2.605 },
-  "webgpu:shader,execution,expression,binary,f16_subtraction:vector_scalar_compound:*": { "subcaseMS": 2.604 },
-  "webgpu:shader,execution,expression,binary,f32_addition:scalar:*": { "subcaseMS": 17.788 },
-  "webgpu:shader,execution,expression,binary,f32_addition:scalar_compound:*": { "subcaseMS": 9.919 },
-  "webgpu:shader,execution,expression,binary,f32_addition:scalar_vector:*": { "subcaseMS": 12.600 },
-  "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar:*": { "subcaseMS": 12.550 },
-  "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar_compound:*": { "subcaseMS": 12.142 },
+  "webgpu:shader,execution,expression,binary,f16_division:scalar:*": { "subcaseMS": 125.300 },
+  "webgpu:shader,execution,expression,binary,f16_division:scalar_compound:*": { "subcaseMS": 5.909 },
+  "webgpu:shader,execution,expression,binary,f16_division:scalar_vector:*": { "subcaseMS": 3.509 },
+  "webgpu:shader,execution,expression,binary,f16_division:vector:*": { "subcaseMS": 5.505 },
+  "webgpu:shader,execution,expression,binary,f16_division:vector_scalar:*": { "subcaseMS": 3.908 },
+  "webgpu:shader,execution,expression,binary,f16_division:vector_scalar_compound:*": { "subcaseMS": 4.308 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:scalar:*": { "subcaseMS": 105.202 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:scalar_compound:*": { "subcaseMS": 8.111 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:scalar_vector:*": { "subcaseMS": 3.907 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:vector:*": { "subcaseMS": 6.104 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:vector_scalar:*": { "subcaseMS": 3.908 },
+  "webgpu:shader,execution,expression,binary,f16_multiplication:vector_scalar_compound:*": { "subcaseMS": 4.205 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:scalar:*": { "subcaseMS": 101.600 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:scalar_compound:*": { "subcaseMS": 5.611 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:scalar_vector:*": { "subcaseMS": 4.308 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:vector:*": { "subcaseMS": 7.105 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:vector_scalar:*": { "subcaseMS": 4.107 },
+  "webgpu:shader,execution,expression,binary,f16_subtraction:vector_scalar_compound:*": { "subcaseMS": 4.606 },
+  "webgpu:shader,execution,expression,binary,f32_addition:scalar:*": { "subcaseMS": 352.326 },
+  "webgpu:shader,execution,expression,binary,f32_addition:scalar_compound:*": { "subcaseMS": 146.513 },
+  "webgpu:shader,execution,expression,binary,f32_addition:scalar_vector:*": { "subcaseMS": 148.117 },
+  "webgpu:shader,execution,expression,binary,f32_addition:vector:*": { "subcaseMS": 117.209 },
+  "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar:*": { "subcaseMS": 150.450 },
+  "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar_compound:*": { "subcaseMS": 152.842 },
   "webgpu:shader,execution,expression,binary,f32_comparison:equals:*": { "subcaseMS": 9.638 },
   "webgpu:shader,execution,expression,binary,f32_comparison:greater_equals:*": { "subcaseMS": 7.882 },
   "webgpu:shader,execution,expression,binary,f32_comparison:greater_than:*": { "subcaseMS": 7.388 },
   "webgpu:shader,execution,expression,binary,f32_comparison:less_equals:*": { "subcaseMS": 6.632 },
   "webgpu:shader,execution,expression,binary,f32_comparison:less_than:*": { "subcaseMS": 6.969 },
   "webgpu:shader,execution,expression,binary,f32_comparison:not_equals:*": { "subcaseMS": 6.819 },
-  "webgpu:shader,execution,expression,binary,f32_division:scalar:*": { "subcaseMS": 19.688 },
-  "webgpu:shader,execution,expression,binary,f32_division:scalar_compound:*": { "subcaseMS": 8.294 },
-  "webgpu:shader,execution,expression,binary,f32_division:scalar_vector:*": { "subcaseMS": 19.142 },
-  "webgpu:shader,execution,expression,binary,f32_division:vector_scalar:*": { "subcaseMS": 17.900 },
-  "webgpu:shader,execution,expression,binary,f32_division:vector_scalar_compound:*": { "subcaseMS": 9.859 },
+  "webgpu:shader,execution,expression,binary,f32_division:scalar:*": { "subcaseMS": 372.550 },
+  "webgpu:shader,execution,expression,binary,f32_division:scalar_compound:*": { "subcaseMS": 140.819 },
+  "webgpu:shader,execution,expression,binary,f32_division:scalar_vector:*": { "subcaseMS": 82.709 },
+  "webgpu:shader,execution,expression,binary,f32_division:vector:*": { "subcaseMS": 119.475 },
+  "webgpu:shader,execution,expression,binary,f32_division:vector_scalar:*": { "subcaseMS": 75.375 },
+  "webgpu:shader,execution,expression,binary,f32_division:vector_scalar_compound:*": { "subcaseMS": 76.017 },
   "webgpu:shader,execution,expression,binary,f32_matrix_addition:matrix:*": { "subcaseMS": 35.020 },
   "webgpu:shader,execution,expression,binary,f32_matrix_addition:matrix_compound:*": { "subcaseMS": 27.534 },
   "webgpu:shader,execution,expression,binary,f32_matrix_matrix_multiplication:matrix_matrix:*": { "subcaseMS": 134.680 },
@@ -939,21 +948,24 @@
   "webgpu:shader,execution,expression,binary,f32_matrix_vector_multiplication:matrix_vector:*": { "subcaseMS": 105.139 },
   "webgpu:shader,execution,expression,binary,f32_matrix_vector_multiplication:vector_matrix:*": { "subcaseMS": 22.501 },
   "webgpu:shader,execution,expression,binary,f32_matrix_vector_multiplication:vector_matrix_compound:*": { "subcaseMS": 16.217 },
-  "webgpu:shader,execution,expression,binary,f32_multiplication:scalar:*": { "subcaseMS": 26.382 },
-  "webgpu:shader,execution,expression,binary,f32_multiplication:scalar_compound:*": { "subcaseMS": 10.250 },
-  "webgpu:shader,execution,expression,binary,f32_multiplication:scalar_vector:*": { "subcaseMS": 35.359 },
-  "webgpu:shader,execution,expression,binary,f32_multiplication:vector_scalar:*": { "subcaseMS": 34.834 },
-  "webgpu:shader,execution,expression,binary,f32_multiplication:vector_scalar_compound:*": { "subcaseMS": 11.609 },
-  "webgpu:shader,execution,expression,binary,f32_remainder:scalar:*": { "subcaseMS": 21.982 },
-  "webgpu:shader,execution,expression,binary,f32_remainder:scalar_compound:*": { "subcaseMS": 8.844 },
-  "webgpu:shader,execution,expression,binary,f32_remainder:scalar_vector:*": { "subcaseMS": 10.650 },
-  "webgpu:shader,execution,expression,binary,f32_remainder:vector_scalar:*": { "subcaseMS": 9.525 },
-  "webgpu:shader,execution,expression,binary,f32_remainder:vector_scalar_compound:*": { "subcaseMS": 9.925 },
-  "webgpu:shader,execution,expression,binary,f32_subtraction:scalar:*": { "subcaseMS": 12.813 },
-  "webgpu:shader,execution,expression,binary,f32_subtraction:scalar_compound:*": { "subcaseMS": 9.213 },
-  "webgpu:shader,execution,expression,binary,f32_subtraction:scalar_vector:*": { "subcaseMS": 14.125 },
-  "webgpu:shader,execution,expression,binary,f32_subtraction:vector_scalar:*": { "subcaseMS": 13.292 },
-  "webgpu:shader,execution,expression,binary,f32_subtraction:vector_scalar_compound:*": { "subcaseMS": 13.150 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:scalar:*": { "subcaseMS": 360.475 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:scalar_compound:*": { "subcaseMS": 155.044 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:scalar_vector:*": { "subcaseMS": 153.642 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:vector:*": { "subcaseMS": 121.692 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:vector_scalar:*": { "subcaseMS": 156.909 },
+  "webgpu:shader,execution,expression,binary,f32_multiplication:vector_scalar_compound:*": { "subcaseMS": 157.576 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:scalar:*": { "subcaseMS": 313.175 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:scalar_compound:*": { "subcaseMS": 66.207 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:scalar_vector:*": { "subcaseMS": 64.125 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:vector:*": { "subcaseMS": 60.517 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:vector_scalar:*": { "subcaseMS": 56.025 },
+  "webgpu:shader,execution,expression,binary,f32_remainder:vector_scalar_compound:*": { "subcaseMS": 57.101 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:scalar:*": { "subcaseMS": 335.951 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:scalar_compound:*": { "subcaseMS": 149.525 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:scalar_vector:*": { "subcaseMS": 159.659 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:vector:*": { "subcaseMS": 117.142 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:vector_scalar:*": { "subcaseMS": 152.067 },
+  "webgpu:shader,execution,expression,binary,f32_subtraction:vector_scalar_compound:*": { "subcaseMS": 159.417 },
   "webgpu:shader,execution,expression,binary,i32_arithmetic:addition:*": { "subcaseMS": 23.975 },
   "webgpu:shader,execution,expression,binary,i32_arithmetic:addition_compound:*": { "subcaseMS": 9.219 },
   "webgpu:shader,execution,expression,binary,i32_arithmetic:addition_scalar_vector:*": { "subcaseMS": 33.059 },
diff --git a/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
index 777b801e131d..508df8aab33e 100644
--- a/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
@@ -85,17 +85,36 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x + y
+Expression: x + y, where x and y are scalars
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('scalar');
+    await run(
+      t,
+      abstractBinary('+'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x + y, where x and y are vectors
 Accuracy: Correctly rounded
 `
   )
   .params(u =>
-    u
-      .combine('inputSource', onlyConstInputSource)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
+    u.combine('inputSource', onlyConstInputSource).combine('vectorize', [2, 3, 4] as const)
   )
   .fn(async t => {
-    const cases = await d.get('scalar');
+    const cases = await d.get('scalar'); // Using vectorize to generate vector cases based on scalar cases
     await run(
       t,
       abstractBinary('+'),
diff --git a/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
index 80a2aa23bdcd..2f1231bf02b2 100644
--- a/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
@@ -85,17 +85,36 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x * y
+Expression: x * y, where x and y are scalars
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('scalar');
+    await run(
+      t,
+      abstractBinary('*'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x and y are vectors
 Accuracy: Correctly rounded
 `
   )
   .params(u =>
-    u
-      .combine('inputSource', onlyConstInputSource)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
+    u.combine('inputSource', onlyConstInputSource).combine('vectorize', [2, 3, 4] as const)
   )
   .fn(async t => {
-    const cases = await d.get('scalar');
+    const cases = await d.get('scalar'); // Using vectorize to generate vector cases based on scalar cases
     await run(
       t,
       abstractBinary('*'),
diff --git a/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
index 4faa21de33fd..5c4528209381 100644
--- a/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
@@ -85,17 +85,36 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x - y
+Expression: x - y, where x and y are scalars
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('scalar');
+    await run(
+      t,
+      abstractBinary('-'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x - y, where x and y are vectors
 Accuracy: Correctly rounded
 `
   )
   .params(u =>
-    u
-      .combine('inputSource', onlyConstInputSource)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
+    u.combine('inputSource', onlyConstInputSource).combine('vectorize', [2, 3, 4] as const)
   )
   .fn(async t => {
-    const cases = await d.get('scalar');
+    const cases = await d.get('scalar'); // Using vectorize to generate vector cases based on scalar cases
     await run(
       t,
       abstractBinary('-'),
diff --git a/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts
index e9b6b55c145f..59360bff9e04 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts
@@ -149,13 +149,11 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x + y
+Expression: x + y, where x and y are scalars
 Accuracy: Correctly rounded
 `
   )
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
+  .params(u => u.combine('inputSource', allInputSources))
   .beforeAllSubcases(t => {
     t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
   })
@@ -166,6 +164,25 @@ Accuracy: Correctly rounded
     await run(t, binary('+'), [TypeF16, TypeF16], TypeF16, t.params, cases);
   });
 
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x + y, where x and y are vectors
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const' // Using vectorize to generate vector cases based on scalar cases
+    );
+    await run(t, binary('+'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
+
 g.test('scalar_compound')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
diff --git a/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts
index 713448338d99..3e54ff683314 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts
@@ -141,13 +141,11 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x / y
+Expression: x / y, where x and y are scalars
 Accuracy: 2.5 ULP for |y| in the range [2^-126, 2^126]
 `
   )
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
+  .params(u => u.combine('inputSource', allInputSources))
   .beforeAllSubcases(t => {
     t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
   })
@@ -158,6 +156,25 @@ Accuracy: 2.5 ULP for |y| in the range [2^-126, 2^126]
     await run(t, binary('/'), [TypeF16, TypeF16], TypeF16, t.params, cases);
   });
 
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x / y, where x and y are vectors
+Accuracy: 2.5 ULP for |y| in the range [2^-126, 2^126]
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const' // Using vectorize to generate vector cases based on scalar cases
+    );
+    await run(t, binary('/'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
+
 g.test('scalar_compound')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
diff --git a/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts
index 3844b7f07443..bff045a88758 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts
@@ -141,13 +141,11 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x * y
+Expression: x * y, where x and y are scalars
 Accuracy: Correctly rounded
 `
   )
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
+  .params(u => u.combine('inputSource', allInputSources))
   .beforeAllSubcases(t => {
     t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
   })
@@ -158,6 +156,25 @@ Accuracy: Correctly rounded
     await run(t, binary('*'), [TypeF16, TypeF16], TypeF16, t.params, cases);
   });
 
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x and y are vectors
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const' // Using vectorize to generate vector cases based on scalar cases
+    );
+    await run(t, binary('*'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
+
 g.test('scalar_compound')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
diff --git a/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts
index e9381b3656f7..c1755502ba09 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts
@@ -141,13 +141,11 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x - y
+Expression: x - y, where x and y are scalars
 Accuracy: Correctly rounded
 `
   )
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
+  .params(u => u.combine('inputSource', allInputSources))
   .beforeAllSubcases(t => {
     t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
   })
@@ -158,6 +156,25 @@ Accuracy: Correctly rounded
     await run(t, binary('-'), [TypeF16, TypeF16], TypeF16, t.params, cases);
   });
 
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x - y, where x and y are vectors
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const' // Using vectorize to generate vector cases based on scalar cases
+    );
+    await run(t, binary('-'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
+
 g.test('scalar_compound')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
diff --git a/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
index d3c9bcfb02c3..4ad38d1727c6 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
@@ -141,13 +141,11 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x + y
+Expression: x + y, where x and y are scalars
 Accuracy: Correctly rounded
 `
   )
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
+  .params(u => u.combine('inputSource', allInputSources))
   .fn(async t => {
     const cases = await d.get(
       t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const'
@@ -155,6 +153,22 @@ Accuracy: Correctly rounded
     await run(t, binary('+'), [TypeF32, TypeF32], TypeF32, t.params, cases);
   });
 
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x + y, where x and y are vectors
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const' // Using vectorize to generate vector cases based on scalar cases
+    );
+    await run(t, binary('+'), [TypeF32, TypeF32], TypeF32, t.params, cases);
+  });
+
 g.test('scalar_compound')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
diff --git a/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts
index 205acd7fa996..e9fa078ec2f8 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts
@@ -141,13 +141,11 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x / y
+Expression: x / y, where x and y are scalars
 Accuracy: 2.5 ULP for |y| in the range [2^-126, 2^126]
 `
   )
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
+  .params(u => u.combine('inputSource', allInputSources))
   .fn(async t => {
     const cases = await d.get(
       t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const'
@@ -155,6 +153,22 @@ Accuracy: 2.5 ULP for |y| in the range [2^-126, 2^126]
     await run(t, binary('/'), [TypeF32, TypeF32], TypeF32, t.params, cases);
   });
 
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x / y, where x and y are vectors
+Accuracy: 2.5 ULP for |y| in the range [2^-126, 2^126]
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const' // Using vectorize to generate vector cases based on scalar cases
+    );
+    await run(t, binary('/'), [TypeF32, TypeF32], TypeF32, t.params, cases);
+  });
+
 g.test('scalar_compound')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
diff --git a/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts
index 95bee77b75bd..f2f644a7b225 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts
@@ -141,13 +141,11 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x * y
+Expression: x * y, where x and y are scalars
 Accuracy: Correctly rounded
 `
   )
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
+  .params(u => u.combine('inputSource', allInputSources))
   .fn(async t => {
     const cases = await d.get(
       t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const'
@@ -155,6 +153,22 @@ Accuracy: Correctly rounded
     await run(t, binary('*'), [TypeF32, TypeF32], TypeF32, t.params, cases);
   });
 
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x and y are vectors
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const' // Using vectorize to generate vector cases based on scalar cases
+    );
+    await run(t, binary('*'), [TypeF32, TypeF32], TypeF32, t.params, cases);
+  });
+
 g.test('scalar_compound')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
diff --git a/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts
index c64d5cbb6c8b..d948047bbdf0 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts
@@ -141,13 +141,11 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x % y
+Expression: x % y, where x and y are scalars
 Accuracy: Derived from x - y * trunc(x/y)
 `
   )
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
+  .params(u => u.combine('inputSource', allInputSources))
   .fn(async t => {
     const cases = await d.get(
       t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const'
@@ -155,6 +153,22 @@ Accuracy: Derived from x - y * trunc(x/y)
     await run(t, binary('%'), [TypeF32, TypeF32], TypeF32, t.params, cases);
   });
 
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x % y, where x and y are vectors
+Accuracy: Derived from x - y * trunc(x/y)
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const' // Using vectorize to generate vector cases based on scalar cases
+    );
+    await run(t, binary('%'), [TypeF32, TypeF32], TypeF32, t.params, cases);
+  });
+
 g.test('scalar_compound')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
diff --git a/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts
index f2bd7f6a5ad6..2eb137a1555a 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts
@@ -141,13 +141,11 @@ g.test('scalar')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(
     `
-Expression: x - y
+Expression: x - y, where x and y are scalars
 Accuracy: Correctly rounded
 `
   )
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
+  .params(u => u.combine('inputSource', allInputSources))
   .fn(async t => {
     const cases = await d.get(
       t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const'
@@ -155,6 +153,22 @@ Accuracy: Correctly rounded
     await run(t, binary('-'), [TypeF32, TypeF32], TypeF32, t.params, cases);
   });
 
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x - y, where x and y are vectors
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const' // Using vectorize to generate vector cases based on scalar cases
+    );
+    await run(t, binary('-'), [TypeF32, TypeF32], TypeF32, t.params, cases);
+  });
+
 g.test('scalar_compound')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
   .desc(

From 4673f2f6bcb5939c07683acbfef7e8c5e2d882dd Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 14 Sep 2023 10:51:14 -0400
Subject: [PATCH 035/166] wgsl: Add AbstractFloat `trunc` execution tests
 (#2948)

Fixes #2525
---
 src/unittests/floating_point.spec.ts          | 75 +++++++++++--------
 src/webgpu/listing_meta.json                  |  6 +-
 .../expression/call/builtin/trunc.spec.ts     | 24 ++++--
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 64 insertions(+), 43 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 825078d680db..bea923452454 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3538,7 +3538,7 @@ g.test('sqrtInterval')
     const got = trait.sqrtInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.sqrtInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `FP.${t.params.trait}.sqrtInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -3608,43 +3608,52 @@ g.test('tanhInterval_f32')
     );
   });
 
-g.test('truncInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      { input: 0, expected: 0 },
-      { input: 0.1, expected: 0 },
-      { input: 0.9, expected: 0 },
-      { input: 1.0, expected: 1 },
-      { input: 1.1, expected: 1 },
-      { input: 1.9, expected: 1 },
-      { input: -0.1, expected: 0 },
-      { input: -0.9, expected: 0 },
-      { input: -1.0, expected: -1 },
-      { input: -1.1, expected: -1 },
-      { input: -1.9, expected: -1 },
+g.test('truncInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'abstract'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          // Normals
+          { input: 0, expected: 0 },
+          { input: 0.1, expected: 0 },
+          { input: 0.9, expected: 0 },
+          { input: 1.0, expected: 1 },
+          { input: 1.1, expected: 1 },
+          { input: 1.9, expected: 1 },
+          { input: -0.1, expected: 0 },
+          { input: -0.9, expected: 0 },
+          { input: -1.0, expected: -1 },
+          { input: -1.1, expected: -1 },
+          { input: -1.9, expected: -1 },
 
-      // Edge cases
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.positive.max, expected: kValue.f32.positive.max },
-      { input: kValue.f32.positive.min, expected: 0 },
-      { input: kValue.f32.negative.min, expected: kValue.f32.negative.min },
-      { input: kValue.f32.negative.max, expected: 0 },
-
-      // 32-bit subnormals
-      { input: kValue.f32.subnormal.positive.max, expected: 0 },
-      { input: kValue.f32.subnormal.positive.min, expected: 0 },
-      { input: kValue.f32.subnormal.negative.min, expected: 0 },
-      { input: kValue.f32.subnormal.negative.max, expected: 0 },
-    ]
+          // Subnormals
+          { input: constants.positive.subnormal.max, expected: 0 },
+          { input: constants.positive.subnormal.min, expected: 0 },
+          { input: constants.negative.subnormal.min, expected: 0 },
+          { input: constants.negative.subnormal.max, expected: 0 },
+
+          // Edge cases
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: constants.positive.max },
+          { input: constants.positive.min, expected: 0 },
+          { input: constants.negative.min, expected: constants.negative.min },
+          { input: constants.negative.max, expected: 0 },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.truncInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.truncInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.truncInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `FP.${t.params.trait}.truncInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index c270ae463fbc..ada0809a0a7f 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1402,9 +1402,9 @@
   "webgpu:shader,execution,expression,call,builtin,transpose:abstract_float:*": { "subcaseMS": 35.014 },
   "webgpu:shader,execution,expression,call,builtin,transpose:f16:*": { "subcaseMS": 33.311 },
   "webgpu:shader,execution,expression,call,builtin,transpose:f32:*": { "subcaseMS": 8.184 },
-  "webgpu:shader,execution,expression,call,builtin,trunc:abstract_float:*": { "subcaseMS": 16.007 },
-  "webgpu:shader,execution,expression,call,builtin,trunc:f16:*": { "subcaseMS": 16.705 },
-  "webgpu:shader,execution,expression,call,builtin,trunc:f32:*": { "subcaseMS": 9.376 },
+  "webgpu:shader,execution,expression,call,builtin,trunc:abstract_float:*": { "subcaseMS": 455.726 },
+  "webgpu:shader,execution,expression,call,builtin,trunc:f16:*": { "subcaseMS": 81.305 },
+  "webgpu:shader,execution,expression,call,builtin,trunc:f32:*": { "subcaseMS": 48.544 },
   "webgpu:shader,execution,expression,call,builtin,unpack2x16float:unpack:*": { "subcaseMS": 11.651 },
   "webgpu:shader,execution,expression,call,builtin,unpack2x16snorm:unpack:*": { "subcaseMS": 9.275 },
   "webgpu:shader,execution,expression,call,builtin,unpack2x16unorm:unpack:*": { "subcaseMS": 8.701 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/trunc.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/trunc.spec.ts
index 8299b2dd2261..10c32ec252bf 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/trunc.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/trunc.spec.ts
@@ -10,13 +10,13 @@ Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeAbstractFloat, TypeF32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -24,15 +24,27 @@ export const d = makeCaseCache('trunc', {
   f32: () => {
     return FP.f32.generateScalarToIntervalCases(fullF32Range(), 'unfiltered', FP.f32.truncInterval);
   },
+  abstract: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      fullF64Range(),
+      'unfiltered',
+      FP.abstract.truncInterval
+    );
+  },
 });
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(t, abstractBuiltin('trunc'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases);
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index a9689494f00f..10cfb7a9e879 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4909,7 +4909,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly transposeInterval = this.unimplementedMatrixToMatrix.bind(this);
-  public readonly truncInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly truncInterval = this.truncIntervalImpl.bind(this);
 }
 
 // Pre-defined values that get used multiple times in _constants' initializers. Cannot use FPTraits members, since this

From 732f9b5a3f9de75b6938afc0922dd852a8b85732 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 14 Sep 2023 12:09:52 -0400
Subject: [PATCH 036/166] wgsl: Add f16 `trunc` execution tests (#2949)

Fixes #2524
---
 src/unittests/floating_point.spec.ts                |  2 +-
 src/webgpu/listing_meta.json                        |  2 +-
 .../execution/expression/call/builtin/trunc.spec.ts | 13 +++++++++++--
 src/webgpu/util/floating_point.ts                   |  2 +-
 4 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index bea923452454..f7abba944dde 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3611,7 +3611,7 @@ g.test('tanhInterval_f32')
 g.test('truncInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'abstract'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarToIntervalCase>(p => {
         const trait = FP[p.trait];
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index ada0809a0a7f..761d661a9b2c 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1403,7 +1403,7 @@
   "webgpu:shader,execution,expression,call,builtin,transpose:f16:*": { "subcaseMS": 33.311 },
   "webgpu:shader,execution,expression,call,builtin,transpose:f32:*": { "subcaseMS": 8.184 },
   "webgpu:shader,execution,expression,call,builtin,trunc:abstract_float:*": { "subcaseMS": 455.726 },
-  "webgpu:shader,execution,expression,call,builtin,trunc:f16:*": { "subcaseMS": 81.305 },
+  "webgpu:shader,execution,expression,call,builtin,trunc:f16:*": { "subcaseMS": 120.204 },
   "webgpu:shader,execution,expression,call,builtin,trunc:f32:*": { "subcaseMS": 48.544 },
   "webgpu:shader,execution,expression,call,builtin,unpack2x16float:unpack:*": { "subcaseMS": 11.651 },
   "webgpu:shader,execution,expression,call,builtin,unpack2x16snorm:unpack:*": { "subcaseMS": 9.275 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/trunc.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/trunc.spec.ts
index 10c32ec252bf..63cd8470f556 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/trunc.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/trunc.spec.ts
@@ -10,7 +10,7 @@ Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeAbstractFloat, TypeF32 } from '../../../../../util/conversion.js';
+import { TypeAbstractFloat, TypeF16, TypeF32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
 import { fullF32Range, fullF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
@@ -24,6 +24,9 @@ export const d = makeCaseCache('trunc', {
   f32: () => {
     return FP.f32.generateScalarToIntervalCases(fullF32Range(), 'unfiltered', FP.f32.truncInterval);
   },
+  f16: () => {
+    return FP.f16.generateScalarToIntervalCases(fullF32Range(), 'unfiltered', FP.f16.truncInterval);
+  },
   abstract: () => {
     return FP.abstract.generateScalarToIntervalCases(
       fullF64Range(),
@@ -63,4 +66,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('trunc'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 10cfb7a9e879..1ff3637aeb78 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5194,7 +5194,7 @@ class F16Traits extends FPTraits {
   public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly transposeInterval = this.unimplementedMatrixToMatrix.bind(this);
-  public readonly truncInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly truncInterval = this.truncIntervalImpl.bind(this);
 
   /** quantizeToF16 has no f16 overload. */
   private quantizeToF16IntervalNotAvailable(n: number): FPInterval {

From abe8df95e140fda299b0585a139faa9609774639 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 14 Sep 2023 12:24:12 -0400
Subject: [PATCH 037/166] wgsl: Add f16 `transpose` execution tests (#2951)

Fixes #2520
---
 src/unittests/floating_point.spec.ts          | 274 +++++++++---------
 src/webgpu/listing_meta.json                  |   4 +-
 .../expression/call/builtin/transpose.spec.ts | 151 +++++++++-
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 293 insertions(+), 138 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index f7abba944dde..915088b7454a 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5739,142 +5739,152 @@ interface MatrixToMatrixCase {
   expected: (number | IntervalBounds)[][];
 }
 
-g.test('transposeInterval_f32')
-  .paramsSubcasesOnly<MatrixToMatrixCase>([
-    {
-      input: [
-        [1, 2],
-        [3, 4],
-      ],
-      expected: [
-        [1, 3],
-        [2, 4],
-      ],
-    },
-    {
-      input: [
-        [1, 2],
-        [3, 4],
-        [5, 6],
-      ],
-      expected: [
-        [1, 3, 5],
-        [2, 4, 6],
-      ],
-    },
-    {
-      input: [
-        [1, 2],
-        [3, 4],
-        [5, 6],
-        [7, 8],
-      ],
-      expected: [
-        [1, 3, 5, 7],
-        [2, 4, 6, 8],
-      ],
-    },
-    {
-      input: [
-        [1, 2, 3],
-        [4, 5, 6],
-      ],
-      expected: [
-        [1, 4],
-        [2, 5],
-        [3, 6],
-      ],
-    },
-    {
-      input: [
-        [1, 2, 3],
-        [4, 5, 6],
-        [7, 8, 9],
-      ],
-      expected: [
-        [1, 4, 7],
-        [2, 5, 8],
-        [3, 6, 9],
-      ],
-    },
-    {
-      input: [
-        [1, 2, 3],
-        [4, 5, 6],
-        [7, 8, 9],
-        [10, 11, 12],
-      ],
-      expected: [
-        [1, 4, 7, 10],
-        [2, 5, 8, 11],
-        [3, 6, 9, 12],
-      ],
-    },
-    {
-      input: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      expected: [
-        [1, 5],
-        [2, 6],
-        [3, 7],
-        [4, 8],
-      ],
-    },
-    {
-      input: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-        [9, 10, 11, 12],
-      ],
-      expected: [
-        [1, 5, 9],
-        [2, 6, 10],
-        [3, 7, 11],
-        [4, 8, 12],
-      ],
-    },
-    {
-      input: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-        [9, 10, 11, 12],
-        [13, 14, 15, 16],
-      ],
-      expected: [
-        [1, 5, 9, 13],
-        [2, 6, 10, 14],
-        [3, 7, 11, 15],
-        [4, 8, 12, 16],
-      ],
-    },
-    {
-      input: [
-        [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.min],
-        [kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max],
-      ],
-      expected: [
-        [
-          [0, kValue.f32.subnormal.positive.max],
-          [kValue.f32.subnormal.negative.min, 0],
-        ],
-        [
-          [0, kValue.f32.subnormal.positive.min],
-          [kValue.f32.subnormal.negative.max, 0],
-        ],
-      ],
-    },
-  ])
+g.test('transposeInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<MatrixToMatrixCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        return [
+          {
+            input: [
+              [1, 2],
+              [3, 4],
+            ],
+            expected: [
+              [1, 3],
+              [2, 4],
+            ],
+          },
+          {
+            input: [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+            ],
+            expected: [
+              [1, 3, 5],
+              [2, 4, 6],
+            ],
+          },
+          {
+            input: [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+              [7, 8],
+            ],
+            expected: [
+              [1, 3, 5, 7],
+              [2, 4, 6, 8],
+            ],
+          },
+          {
+            input: [
+              [1, 2, 3],
+              [4, 5, 6],
+            ],
+            expected: [
+              [1, 4],
+              [2, 5],
+              [3, 6],
+            ],
+          },
+          {
+            input: [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+            ],
+            expected: [
+              [1, 4, 7],
+              [2, 5, 8],
+              [3, 6, 9],
+            ],
+          },
+          {
+            input: [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+              [10, 11, 12],
+            ],
+            expected: [
+              [1, 4, 7, 10],
+              [2, 5, 8, 11],
+              [3, 6, 9, 12],
+            ],
+          },
+          {
+            input: [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+            ],
+            expected: [
+              [1, 5],
+              [2, 6],
+              [3, 7],
+              [4, 8],
+            ],
+          },
+          {
+            input: [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+            ],
+            expected: [
+              [1, 5, 9],
+              [2, 6, 10],
+              [3, 7, 11],
+              [4, 8, 12],
+            ],
+          },
+          {
+            input: [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+              [13, 14, 15, 16],
+            ],
+            expected: [
+              [1, 5, 9, 13],
+              [2, 6, 10, 14],
+              [3, 7, 11, 15],
+              [4, 8, 12, 16],
+            ],
+          },
+          {
+            input: [
+              [constants.positive.subnormal.max, constants.positive.subnormal.min],
+              [constants.negative.subnormal.min, constants.negative.subnormal.max],
+            ],
+            expected: [
+              [
+                [0, constants.positive.subnormal.max],
+                [constants.negative.subnormal.min, 0],
+              ],
+              [
+                [0, constants.positive.subnormal.min],
+                [constants.negative.subnormal.max, 0],
+              ],
+            ],
+          },
+        ];
+      })
+  )
   .fn(t => {
     const input = t.params.input;
-    const expected = FP.f32.toMatrix(t.params.expected);
-    const got = FP.f32.transposeInterval(input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toMatrix(t.params.expected);
+    const got = trait.transposeInterval(input);
     t.expect(
       objectEquals(expected, got),
-      `f32.transposeInterval([${JSON.stringify(input)}]) returned '[${JSON.stringify(
-        got
-      )}]'. Expected '[${JSON.stringify(expected)}]'`
+      `FP.${t.params.trait}.transposeInterval([${JSON.stringify(
+        input
+      )}]) returned '[${JSON.stringify(got)}]'. Expected '[${JSON.stringify(expected)}]'`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 761d661a9b2c..40046ab889b1 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1399,9 +1399,9 @@
   "webgpu:shader,execution,expression,call,builtin,textureStore:store_2d_coords:*": { "subcaseMS": 28.809 },
   "webgpu:shader,execution,expression,call,builtin,textureStore:store_3d_coords:*": { "subcaseMS": 37.206 },
   "webgpu:shader,execution,expression,call,builtin,textureStore:store_array_2d_coords:*": { "subcaseMS": 98.804 },
-  "webgpu:shader,execution,expression,call,builtin,transpose:abstract_float:*": { "subcaseMS": 35.014 },
+  "webgpu:shader,execution,expression,call,builtin,transpose:abstract_float:*": { "subcaseMS": 315.915 },
   "webgpu:shader,execution,expression,call,builtin,transpose:f16:*": { "subcaseMS": 33.311 },
-  "webgpu:shader,execution,expression,call,builtin,transpose:f32:*": { "subcaseMS": 8.184 },
+  "webgpu:shader,execution,expression,call,builtin,transpose:f32:*": { "subcaseMS": 75.887 },
   "webgpu:shader,execution,expression,call,builtin,trunc:abstract_float:*": { "subcaseMS": 455.726 },
   "webgpu:shader,execution,expression,call,builtin,trunc:f16:*": { "subcaseMS": 120.204 },
   "webgpu:shader,execution,expression,call,builtin,trunc:f32:*": { "subcaseMS": 48.544 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts
index a7f4f0be3c82..c2b4894d8b00 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts
@@ -8,9 +8,9 @@ Returns the transpose of e.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeMat } from '../../../../../util/conversion.js';
+import { TypeF16, TypeF32, TypeMat } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseMatrixF32Range } from '../../../../../util/math.js';
+import { sparseMatrixF16Range, sparseMatrixF32Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -145,6 +145,132 @@ export const d = makeCaseCache('transpose', {
       FP.f32.transposeInterval
     );
   },
+  f16_mat2x2_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(2, 2),
+      'finite',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat2x2_non_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(2, 2),
+      'unfiltered',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat2x3_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(2, 3),
+      'finite',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat2x3_non_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(2, 3),
+      'unfiltered',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat2x4_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(2, 4),
+      'finite',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat2x4_non_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(2, 4),
+      'unfiltered',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat3x2_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(3, 2),
+      'finite',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat3x2_non_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(3, 2),
+      'unfiltered',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat3x3_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(3, 3),
+      'finite',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat3x3_non_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(3, 3),
+      'unfiltered',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat3x4_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(3, 4),
+      'finite',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat3x4_non_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(3, 4),
+      'unfiltered',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat4x2_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(4, 2),
+      'finite',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat4x2_non_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(4, 2),
+      'unfiltered',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat4x3_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(4, 3),
+      'finite',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat4x3_non_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(4, 3),
+      'unfiltered',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat4x4_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(4, 4),
+      'finite',
+      FP.f16.transposeInterval
+    );
+  },
+  f16_mat4x4_non_const: () => {
+    return FP.f16.generateMatrixToMatrixCases(
+      sparseMatrixF16Range(4, 4),
+      'unfiltered',
+      FP.f16.transposeInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -194,4 +320,23 @@ g.test('f16')
       .combine('cols', [2, 3, 4] as const)
       .combine('rows', [2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `f16_mat${cols}x${rows}_const`
+        : `f16_mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      builtin('transpose'),
+      [TypeMat(cols, rows, TypeF16)],
+      TypeMat(rows, cols, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 1ff3637aeb78..6616f2ccd717 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5193,7 +5193,7 @@ class F16Traits extends FPTraits {
   public readonly subtractionMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(this);
   public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly transposeInterval = this.unimplementedMatrixToMatrix.bind(this);
+  public readonly transposeInterval = this.transposeIntervalImpl.bind(this);
   public readonly truncInterval = this.truncIntervalImpl.bind(this);
 
   /** quantizeToF16 has no f16 overload. */

From edbf5a0818bd4b279a4d282586e6f9492a03adbe Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 14 Sep 2023 12:42:56 -0400
Subject: [PATCH 038/166] wgsl: Add AbstractFloat `transpose` execution tests
 (#2952)

Fixes #2521
---
 src/unittests/floating_point.spec.ts          |  2 +-
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/transpose.spec.ts | 91 +++++++++++++++++--
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 88 insertions(+), 9 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 915088b7454a..7c16b60b7991 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5742,7 +5742,7 @@ interface MatrixToMatrixCase {
 g.test('transposeInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<MatrixToMatrixCase>(p => {
         const trait = FP[p.trait];
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 40046ab889b1..672e1fd974f0 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1399,7 +1399,7 @@
   "webgpu:shader,execution,expression,call,builtin,textureStore:store_2d_coords:*": { "subcaseMS": 28.809 },
   "webgpu:shader,execution,expression,call,builtin,textureStore:store_3d_coords:*": { "subcaseMS": 37.206 },
   "webgpu:shader,execution,expression,call,builtin,textureStore:store_array_2d_coords:*": { "subcaseMS": 98.804 },
-  "webgpu:shader,execution,expression,call,builtin,transpose:abstract_float:*": { "subcaseMS": 315.915 },
+  "webgpu:shader,execution,expression,call,builtin,transpose:abstract_float:*": { "subcaseMS": 755.012 },
   "webgpu:shader,execution,expression,call,builtin,transpose:f16:*": { "subcaseMS": 33.311 },
   "webgpu:shader,execution,expression,call,builtin,transpose:f32:*": { "subcaseMS": 75.887 },
   "webgpu:shader,execution,expression,call,builtin,trunc:abstract_float:*": { "subcaseMS": 455.726 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts
index c2b4894d8b00..a37e0987797a 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts
@@ -8,17 +8,84 @@ Returns the transpose of e.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF16, TypeF32, TypeMat } from '../../../../../util/conversion.js';
+import { TypeAbstractFloat, TypeF16, TypeF32, TypeMat } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseMatrixF16Range, sparseMatrixF32Range } from '../../../../../util/math.js';
+import {
+  sparseMatrixF16Range,
+  sparseMatrixF32Range,
+  sparseMatrixF64Range,
+} from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
 export const d = makeCaseCache('transpose', {
+  abstract_mat2x2: () => {
+    return FP.abstract.generateMatrixToMatrixCases(
+      sparseMatrixF64Range(2, 2),
+      'finite',
+      FP.abstract.transposeInterval
+    );
+  },
+  abstract_mat2x3: () => {
+    return FP.abstract.generateMatrixToMatrixCases(
+      sparseMatrixF64Range(2, 3),
+      'finite',
+      FP.abstract.transposeInterval
+    );
+  },
+  abstract_mat2x4: () => {
+    return FP.abstract.generateMatrixToMatrixCases(
+      sparseMatrixF64Range(2, 4),
+      'finite',
+      FP.abstract.transposeInterval
+    );
+  },
+  abstract_mat3x2: () => {
+    return FP.abstract.generateMatrixToMatrixCases(
+      sparseMatrixF64Range(3, 2),
+      'finite',
+      FP.abstract.transposeInterval
+    );
+  },
+  abstract_mat3x3: () => {
+    return FP.abstract.generateMatrixToMatrixCases(
+      sparseMatrixF64Range(3, 3),
+      'finite',
+      FP.abstract.transposeInterval
+    );
+  },
+  abstract_mat3x4: () => {
+    return FP.abstract.generateMatrixToMatrixCases(
+      sparseMatrixF64Range(3, 4),
+      'finite',
+      FP.abstract.transposeInterval
+    );
+  },
+  abstract_mat4x2: () => {
+    return FP.abstract.generateMatrixToMatrixCases(
+      sparseMatrixF64Range(4, 2),
+      'finite',
+      FP.abstract.transposeInterval
+    );
+  },
+  abstract_mat4x3: () => {
+    return FP.abstract.generateMatrixToMatrixCases(
+      sparseMatrixF64Range(4, 3),
+      'finite',
+      FP.abstract.transposeInterval
+    );
+  },
+  abstract_mat4x4: () => {
+    return FP.abstract.generateMatrixToMatrixCases(
+      sparseMatrixF64Range(4, 4),
+      'finite',
+      FP.abstract.transposeInterval
+    );
+  },
   f32_mat2x2_const: () => {
     return FP.f32.generateMatrixToMatrixCases(
       sparseMatrixF32Range(2, 2),
@@ -278,11 +345,23 @@ g.test('abstract_float')
   .desc(`abstract float tests`)
   .params(u =>
     u
-      .combine('inputSource', allInputSources)
+      .combine('inputSource', onlyConstInputSource)
       .combine('cols', [2, 3, 4] as const)
       .combine('rows', [2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(`abstract_mat${cols}x${rows}`);
+    await run(
+      t,
+      abstractBuiltin('transpose'),
+      [TypeMat(cols, rows, TypeAbstractFloat)],
+      TypeMat(rows, cols, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#matrix-builtin-functions')
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 6616f2ccd717..914ec0157e11 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4908,7 +4908,7 @@ class FPAbstractTraits extends FPTraits {
   );
   public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly transposeInterval = this.unimplementedMatrixToMatrix.bind(this);
+  public readonly transposeInterval = this.transposeIntervalImpl.bind(this);
   public readonly truncInterval = this.truncIntervalImpl.bind(this);
 }
 

From b178e3598a3c743c0b1adf8de812f4b8d9e6c0bd Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Fri, 15 Sep 2023 02:20:11 +0900
Subject: [PATCH 039/166] Add a copy button (#2958)

Cllicking it puts the query in the clipboard
---
 src/common/runtime/standalone.ts |  8 ++++++++
 standalone/index.html            | 15 +++++++++++----
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/src/common/runtime/standalone.ts b/src/common/runtime/standalone.ts
index 87689ebac733..360760a8f50e 100644
--- a/src/common/runtime/standalone.ts
+++ b/src/common/runtime/standalone.ts
@@ -441,6 +441,14 @@ function makeTreeNodeHeaderHTML(
     .attr('alt', kOpenTestLinkAltText)
     .attr('title', kOpenTestLinkAltText)
     .appendTo(header);
+  $('<button>')
+    .addClass('copybtn')
+    .attr('alt', 'copy query')
+    .attr('title', 'copy query')
+    .on('click', () => {
+      void navigator.clipboard.writeText(n.query.toString());
+    })
+    .appendTo(header);
   if ('testCreationStack' in n && n.testCreationStack) {
     $('<button>')
       .addClass('testcaselogbtn')
diff --git a/standalone/index.html b/standalone/index.html
index 301e29946088..3c7d41e80bd2 100644
--- a/standalone/index.html
+++ b/standalone/index.html
@@ -184,7 +184,8 @@
       .leafrun,
       .nodelink,
       .collapsebtn,
-      .testcaselogbtn {
+      .testcaselogbtn,
+      .copybtn {
         display: inline-flex;
         flex-shrink: 0;
         flex-grow: 0;
@@ -202,7 +203,8 @@
       .leafrun::before,
       .nodelink::before,
       .collapsebtn::before,
-      .testcaselogbtn::before {
+      .testcaselogbtn::before,
+      .copybtn::before {
         content: "";
         width: 100%;
         height: 100%;
@@ -215,7 +217,8 @@
         .leafrun,
         .nodelink,
         .collapsebtn,
-        .testcaselogbtn {
+        .testcaselogbtn,
+        .copybtn {
           flex-basis: 24px;
           border-radius: 4px;
           width: 24px;
@@ -227,7 +230,8 @@
         .leafrun,
         .nodelink,
         .collapsebtn,
-        .testcaselogbtn {
+        .testcaselogbtn,
+        .copybtn {
           flex-basis: 36px;
           border-radius: 6px;
           width: 36px;
@@ -243,6 +247,9 @@
       .nodelink::before {
         background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAMAQMAAABsu86kAAAABlBMVEUAAAAAAAClZ7nPAAAAAXRSTlMAQObYZgAAACRJREFUCNdjYGBg+P+BoUGAYesFhj4BhvsFDPYNDHwMCMTAAACqJwbp3VgbrAAAAABJRU5ErkJggg==);
       }
+      .copybtn::before {
+        background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAMAQMAAABsu86kAAAABlBMVEUAAAAAAAClZ7nPAAAAAXRSTlMAQObYZgAAACVJREFUCNdjYGBgqGdgcGRgcGBg8H/A4KEAQhkKDBxgxP8AKA8AVNUEx41Lj8MAAAAASUVORK5CYII=);
+      }
       .nodetitle {
         display: inline;
         flex: 10 0 4em;

From bc76dacf88096b30834775a08cc226e2ce0af207 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 14 Sep 2023 13:20:55 -0400
Subject: [PATCH 040/166] wgsl: Add f16 remainder (`%`) execution tests (#2950)

Fixes #2586
---
 src/unittests/floating_point.spec.ts          | 103 ++++---
 src/webgpu/listing_meta.json                  |   6 +
 .../expression/binary/f16_remainder.spec.ts   | 278 ++++++++++++++++++
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 347 insertions(+), 42 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 7c16b60b7991..e1285b289ab5 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -4434,53 +4434,74 @@ g.test('powInterval_f32')
     );
   });
 
-g.test('remainderInterval_f32')
-  .paramsSubcasesOnly<ScalarPairToIntervalCase>(
-    // prettier-ignore
-    [
-      // 32-bit normals
-      { input: [0, 1], expected: [0, 0] },
-      { input: [0, -1], expected: [0, 0] },
-      { input: [1, 1], expected: [0, 1] },
-      { input: [1, -1], expected: [0, 1] },
-      { input: [-1, 1], expected: [-1, 0] },
-      { input: [-1, -1], expected: [-1, 0] },
-      { input: [4, 2], expected: [0, 2] },
-      { input: [-4, 2], expected: [-2, 0] },
-      { input: [4, -2], expected: [0, 2] },
-      { input: [-4, -2], expected: [-2, 0] },
-      { input: [2, 4], expected: [2, 2] },
-      { input: [-2, 4], expected: [-2, -2] },
-      { input: [2, -4], expected: [2, 2] },
-      { input: [-2, -4], expected: [-2, -2] },
+// prettier-ignore
+const kRemainderCases = {
+  f32: [
+    { input: [1, 0.1], expected: [reinterpretU32AsF32(0xb4000000), reinterpretU32AsF32(0x3dccccd8)] }, // ~[0, 0.1]
+    { input: [-1, 0.1], expected: [reinterpretU32AsF32(0xbdccccd8), reinterpretU32AsF32(0x34000000)] }, // ~[-0.1, 0]
+    { input: [1, -0.1], expected: [reinterpretU32AsF32(0xb4000000), reinterpretU32AsF32(0x3dccccd8)] }, // ~[0, 0.1]
+    { input: [-1, -0.1], expected: [reinterpretU32AsF32(0xbdccccd8), reinterpretU32AsF32(0x34000000)] }, // ~[-0.1, 0]
+  ] as ScalarPairToIntervalCase[],
+  f16: [
+    { input: [1, 0.1], expected: [reinterpretU16AsF16(0x9400), reinterpretU16AsF16(0x2e70)] }, // ~[0, 0.1]
+    { input: [-1, 0.1], expected: [reinterpretU16AsF16(0xae70), reinterpretU16AsF16(0x1400)] }, // ~[-0.1, 0]
+    { input: [1, -0.1], expected: [reinterpretU16AsF16(0x9400), reinterpretU16AsF16(0x2e70)] }, // ~[0, 0.1]
+    { input: [-1, -0.1], expected: [reinterpretU16AsF16(0xae70), reinterpretU16AsF16(0x1400)] }, // ~[-0.1, 0]
+  ] as ScalarPairToIntervalCase[],
+} as const;
 
-      // 64-bit normals
-      { input: [0, 0.1], expected: [0, 0] },
-      { input: [0, -0.1], expected: [0, 0] },
-      { input: [1, 0.1], expected: [reinterpretU32AsF32(0xb4000000), reinterpretU32AsF32(0x3dccccd8)] }, // ~[0, 0.1]
-      { input: [-1, 0.1], expected: [reinterpretU32AsF32(0xbdccccd8), reinterpretU32AsF32(0x34000000)] }, // ~[-0.1, 0]
-      { input: [1, -0.1], expected: [reinterpretU32AsF32(0xb4000000), reinterpretU32AsF32(0x3dccccd8)] }, // ~[0, 0.1]
-      { input: [-1, -0.1], expected: [reinterpretU32AsF32(0xbdccccd8), reinterpretU32AsF32(0x34000000)] }, // ~[-0.1, 0]
-
-      // Denominator out of range
-      { input: [1, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [1, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.positive, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [1, kValue.f32.positive.max], expected: kUnboundedBounds },
-      { input: [1, kValue.f32.negative.min], expected: kUnboundedBounds },
-      { input: [1, 0], expected: kUnboundedBounds },
-      { input: [1, kValue.f32.subnormal.positive.max], expected: kUnboundedBounds },
-    ]
+g.test('remainderInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarPairToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kRemainderCases[p.trait],
+          // Normals
+          { input: [0, 1], expected: 0 },
+          { input: [0, -1], expected: 0 },
+          { input: [1, 1], expected: [0, 1] },
+          { input: [1, -1], expected: [0, 1] },
+          { input: [-1, 1], expected: [-1, 0] },
+          { input: [-1, -1], expected: [-1, 0] },
+          { input: [4, 2], expected: [0, 2] },
+          { input: [-4, 2], expected: [-2, 0] },
+          { input: [4, -2], expected: [0, 2] },
+          { input: [-4, -2], expected: [-2, 0] },
+          { input: [2, 4], expected: [2, 2] },
+          { input: [-2, 4], expected: -2 },
+          { input: [2, -4], expected: 2 },
+          { input: [-2, -4], expected: [-2, -2] },
+          { input: [0, 0.1], expected: 0 },
+          { input: [0, -0.1], expected: 0 },
+          { input: [8.5, 2], expected: 0.5 },
+          { input: [1.125, 1], expected: 0.125 },
+
+          // Denominator out of range
+          { input: [1, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [1, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [constants.positive.infinity, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [1, constants.positive.max], expected: kUnboundedBounds },
+          { input: [1, constants.negative.min], expected: kUnboundedBounds },
+          { input: [1, 0], expected: kUnboundedBounds },
+          { input: [1, constants.positive.subnormal.max], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
+    const trait = FP[t.params.trait];
     const [x, y] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.remainderInterval(x, y);
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.remainderInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `f32.remainderInterval(${x}, ${y}) returned ${got}. Expected ${expected}`
+      `FP.${t.params.trait}.remainderInterval(${x}, ${y}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 672e1fd974f0..253ffb5e81bb 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -924,6 +924,12 @@
   "webgpu:shader,execution,expression,binary,f32_addition:vector:*": { "subcaseMS": 117.209 },
   "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar:*": { "subcaseMS": 150.450 },
   "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar_compound:*": { "subcaseMS": 152.842 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:scalar:*": { "subcaseMS": 101.202 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:scalar_compound:*": { "subcaseMS": 6.409 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:scalar_vector:*": { "subcaseMS": 3.910 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:vector:*": { "subcaseMS": 4.410 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:vector_scalar:*": { "subcaseMS": 4.409 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:vector_scalar_compound:*": { "subcaseMS": 4.510 },
   "webgpu:shader,execution,expression,binary,f32_comparison:equals:*": { "subcaseMS": 9.638 },
   "webgpu:shader,execution,expression,binary,f32_comparison:greater_equals:*": { "subcaseMS": 7.882 },
   "webgpu:shader,execution,expression,binary,f32_comparison:greater_than:*": { "subcaseMS": 7.388 },
diff --git a/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts
new file mode 100644
index 000000000000..29a0703b8f1e
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts
@@ -0,0 +1,278 @@
+export const description = `
+Execution Tests for non-matrix f16 remainder expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeF16, TypeVec } from '../../../../util/conversion.js';
+import { FP, FPVector } from '../../../../util/floating_point.js';
+import { sparseF16Range, sparseVectorF16Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { allInputSources, run } from '../expression.js';
+
+import { binary, compoundBinary } from './binary.js';
+
+const remainderVectorScalarInterval = (v: number[], s: number): FPVector => {
+  return FP.f16.toVector(v.map(e => FP.f16.remainderInterval(e, s)));
+};
+
+const remainderScalarVectorInterval = (s: number, v: number[]): FPVector => {
+  return FP.f16.toVector(v.map(e => FP.f16.remainderInterval(s, e)));
+};
+
+export const g = makeTestGroup(GPUTest);
+
+export const d = makeCaseCache('binary/f16_remainder', {
+  scalar_const: () => {
+    return FP.f16.generateScalarPairToIntervalCases(
+      sparseF16Range(),
+      sparseF16Range(),
+      'finite',
+      FP.f16.remainderInterval
+    );
+  },
+  scalar_non_const: () => {
+    return FP.f16.generateScalarPairToIntervalCases(
+      sparseF16Range(),
+      sparseF16Range(),
+      'unfiltered',
+      FP.f16.remainderInterval
+    );
+  },
+  vec2_scalar_const: () => {
+    return FP.f16.generateVectorScalarToVectorCases(
+      sparseVectorF16Range(2),
+      sparseF16Range(),
+      'finite',
+      remainderVectorScalarInterval
+    );
+  },
+  vec2_scalar_non_const: () => {
+    return FP.f16.generateVectorScalarToVectorCases(
+      sparseVectorF16Range(2),
+      sparseF16Range(),
+      'unfiltered',
+      remainderVectorScalarInterval
+    );
+  },
+  vec3_scalar_const: () => {
+    return FP.f16.generateVectorScalarToVectorCases(
+      sparseVectorF16Range(3),
+      sparseF16Range(),
+      'finite',
+      remainderVectorScalarInterval
+    );
+  },
+  vec3_scalar_non_const: () => {
+    return FP.f16.generateVectorScalarToVectorCases(
+      sparseVectorF16Range(3),
+      sparseF16Range(),
+      'unfiltered',
+      remainderVectorScalarInterval
+    );
+  },
+  vec4_scalar_const: () => {
+    return FP.f16.generateVectorScalarToVectorCases(
+      sparseVectorF16Range(4),
+      sparseF16Range(),
+      'finite',
+      remainderVectorScalarInterval
+    );
+  },
+  vec4_scalar_non_const: () => {
+    return FP.f16.generateVectorScalarToVectorCases(
+      sparseVectorF16Range(4),
+      sparseF16Range(),
+      'unfiltered',
+      remainderVectorScalarInterval
+    );
+  },
+  scalar_vec2_const: () => {
+    return FP.f16.generateScalarVectorToVectorCases(
+      sparseF16Range(),
+      sparseVectorF16Range(2),
+      'finite',
+      remainderScalarVectorInterval
+    );
+  },
+  scalar_vec2_non_const: () => {
+    return FP.f16.generateScalarVectorToVectorCases(
+      sparseF16Range(),
+      sparseVectorF16Range(2),
+      'unfiltered',
+      remainderScalarVectorInterval
+    );
+  },
+  scalar_vec3_const: () => {
+    return FP.f16.generateScalarVectorToVectorCases(
+      sparseF16Range(),
+      sparseVectorF16Range(3),
+      'finite',
+      remainderScalarVectorInterval
+    );
+  },
+  scalar_vec3_non_const: () => {
+    return FP.f16.generateScalarVectorToVectorCases(
+      sparseF16Range(),
+      sparseVectorF16Range(3),
+      'unfiltered',
+      remainderScalarVectorInterval
+    );
+  },
+  scalar_vec4_const: () => {
+    return FP.f16.generateScalarVectorToVectorCases(
+      sparseF16Range(),
+      sparseVectorF16Range(4),
+      'finite',
+      remainderScalarVectorInterval
+    );
+  },
+  scalar_vec4_non_const: () => {
+    return FP.f16.generateScalarVectorToVectorCases(
+      sparseF16Range(),
+      sparseVectorF16Range(4),
+      'unfiltered',
+      remainderScalarVectorInterval
+    );
+  },
+});
+
+g.test('scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x % y, where x and y are scalars
+Accuracy: Derived from x - y * trunc(x/y)
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const'
+    );
+    await run(t, binary('%'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
+
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x % y, where x and y are vectors
+Accuracy: Derived from x - y * trunc(x/y)
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const'
+    );
+    await run(t, binary('%'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
+
+g.test('scalar_compound')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x %= y
+Accuracy: Derived from x - y * trunc(x/y)
+`
+  )
+  .params(u =>
+    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'scalar_const' : 'scalar_non_const'
+    );
+    await run(t, compoundBinary('%='), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
+
+g.test('vector_scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x % y, where x is a vector and y is a scalar
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('dim', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? `vec${dim}_scalar_const` : `vec${dim}_scalar_non_const`
+    );
+    await run(
+      t,
+      binary('%'),
+      [TypeVec(dim, TypeF16), TypeF16],
+      TypeVec(dim, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector_scalar_compound')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x %= y, where x is a vector and y is a scalar
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('dim', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? `vec${dim}_scalar_const` : `vec${dim}_scalar_non_const`
+    );
+    await run(
+      t,
+      compoundBinary('%='),
+      [TypeVec(dim, TypeF16), TypeF16],
+      TypeVec(dim, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('scalar_vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x % y, where x is a scalar and y is a vector
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('dim', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? `scalar_vec${dim}_const` : `scalar_vec${dim}_non_const`
+    );
+    await run(
+      t,
+      binary('%'),
+      [TypeF16, TypeVec(dim, TypeF16)],
+      TypeVec(dim, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 914ec0157e11..0e52ff7d292f 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5180,7 +5180,7 @@ class F16Traits extends FPTraits {
   public readonly radiansInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(this);
   public readonly refractInterval = this.unimplementedRefract.bind(this);
-  public readonly remainderInterval = this.unimplementedScalarPairToInterval.bind(this);
+  public readonly remainderInterval = this.remainderIntervalImpl.bind(this);
   public readonly roundInterval = this.roundIntervalImpl.bind(this);
   public readonly saturateInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly signInterval = this.signIntervalImpl.bind(this);

From 301143fba20becd1754d862e1a9199cfdde8663e Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 14 Sep 2023 14:15:18 -0400
Subject: [PATCH 041/166] wgsl: Add f16 `radians` execution tests (#2959)

Fixes #2577
---
 src/unittests/floating_point.spec.ts          | 54 +++++++++++--------
 src/webgpu/listing_meta.json                  | 16 +++---
 .../expression/call/builtin/radians.spec.ts   | 19 +++++--
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 56 insertions(+), 35 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index e1285b289ab5..8c37b7c2dc85 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3212,33 +3212,41 @@ g.test('quantizeToF16Interval_f32')
     );
   });
 
-g.test('radiansInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: -180, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.whole), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.whole)] },
-      { input: -135, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.three_quarters), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.three_quarters)] },
-      { input: -90, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.half), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.half)] },
-      { input: -60, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.third), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.third)] },
-      { input: -45, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.quarter), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.quarter)] },
-      { input: -30, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.sixth), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.sixth)] },
-      { input: 0, expected: 0 },
-      { input: 30, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.sixth), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.sixth)] },
-      { input: 45, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.quarter), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.quarter)] },
-      { input: 60, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.third), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.third)] },
-      { input: 90, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.half), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.half)] },
-      { input: 135, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.three_quarters), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.three_quarters)] },
-      { input: 180, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.whole), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.whole)] },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+g.test('radiansInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = p.trait;
+        const constants = FP[trait].constants();
+        // prettier-ignore
+        return [
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+          { input: -180, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.whole), kPlusOneULPFunctions[trait](constants.negative.pi.whole)] },
+          { input: -135, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.three_quarters), kPlusOneULPFunctions[trait](constants.negative.pi.three_quarters)] },
+          { input: -90, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.half), kPlusOneULPFunctions[trait](constants.negative.pi.half)] },
+          { input: -60, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.third), kPlusOneULPFunctions[trait](constants.negative.pi.third)] },
+          { input: -45, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.quarter), kPlusOneULPFunctions[trait](constants.negative.pi.quarter)] },
+          { input: -30, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.sixth), kPlusOneULPFunctions[trait](constants.negative.pi.sixth)] },
+          { input: 0, expected: 0 },
+          { input: 30, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.sixth), kPlusOneULPFunctions[trait](constants.positive.pi.sixth)] },
+          { input: 45, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.quarter), kPlusOneULPFunctions[trait](constants.positive.pi.quarter)] },
+          { input: 60, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.third), kPlusOneULPFunctions[trait](constants.positive.pi.third)] },
+          { input: 90, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.half), kPlusOneULPFunctions[trait](constants.positive.pi.half)] },
+          { input: 135, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.three_quarters), kPlusOneULPFunctions[trait](constants.positive.pi.three_quarters)] },
+          { input: 180, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.whole), kPlusOneULPFunctions[trait](constants.positive.pi.whole)] },
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.radiansInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.radiansInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.radiansInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.radiansInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 253ffb5e81bb..a7d683bdfbff 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -912,6 +912,12 @@
   "webgpu:shader,execution,expression,binary,f16_multiplication:vector:*": { "subcaseMS": 6.104 },
   "webgpu:shader,execution,expression,binary,f16_multiplication:vector_scalar:*": { "subcaseMS": 3.908 },
   "webgpu:shader,execution,expression,binary,f16_multiplication:vector_scalar_compound:*": { "subcaseMS": 4.205 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:scalar:*": { "subcaseMS": 101.202 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:scalar_compound:*": { "subcaseMS": 6.409 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:scalar_vector:*": { "subcaseMS": 3.910 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:vector:*": { "subcaseMS": 4.410 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:vector_scalar:*": { "subcaseMS": 4.409 },
+  "webgpu:shader,execution,expression,binary,f16_remainder:vector_scalar_compound:*": { "subcaseMS": 4.510 },
   "webgpu:shader,execution,expression,binary,f16_subtraction:scalar:*": { "subcaseMS": 101.600 },
   "webgpu:shader,execution,expression,binary,f16_subtraction:scalar_compound:*": { "subcaseMS": 5.611 },
   "webgpu:shader,execution,expression,binary,f16_subtraction:scalar_vector:*": { "subcaseMS": 4.308 },
@@ -924,12 +930,6 @@
   "webgpu:shader,execution,expression,binary,f32_addition:vector:*": { "subcaseMS": 117.209 },
   "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar:*": { "subcaseMS": 150.450 },
   "webgpu:shader,execution,expression,binary,f32_addition:vector_scalar_compound:*": { "subcaseMS": 152.842 },
-  "webgpu:shader,execution,expression,binary,f16_remainder:scalar:*": { "subcaseMS": 101.202 },
-  "webgpu:shader,execution,expression,binary,f16_remainder:scalar_compound:*": { "subcaseMS": 6.409 },
-  "webgpu:shader,execution,expression,binary,f16_remainder:scalar_vector:*": { "subcaseMS": 3.910 },
-  "webgpu:shader,execution,expression,binary,f16_remainder:vector:*": { "subcaseMS": 4.410 },
-  "webgpu:shader,execution,expression,binary,f16_remainder:vector_scalar:*": { "subcaseMS": 4.409 },
-  "webgpu:shader,execution,expression,binary,f16_remainder:vector_scalar_compound:*": { "subcaseMS": 4.510 },
   "webgpu:shader,execution,expression,binary,f32_comparison:equals:*": { "subcaseMS": 9.638 },
   "webgpu:shader,execution,expression,binary,f32_comparison:greater_equals:*": { "subcaseMS": 7.882 },
   "webgpu:shader,execution,expression,binary,f32_comparison:greater_than:*": { "subcaseMS": 7.388 },
@@ -1280,9 +1280,9 @@
   "webgpu:shader,execution,expression,call,builtin,pow:f16:*": { "subcaseMS": 18.407 },
   "webgpu:shader,execution,expression,call,builtin,pow:f32:*": { "subcaseMS": 151.269 },
   "webgpu:shader,execution,expression,call,builtin,quantizeToF16:f32:*": { "subcaseMS": 11.063 },
-  "webgpu:shader,execution,expression,call,builtin,radians:abstract_float:*": { "subcaseMS": 20.005 },
+  "webgpu:shader,execution,expression,call,builtin,radians:abstract_float:*": { "subcaseMS": 175.108 },
   "webgpu:shader,execution,expression,call,builtin,radians:f16:*": { "subcaseMS": 18.707 },
-  "webgpu:shader,execution,expression,call,builtin,radians:f32:*": { "subcaseMS": 11.988 },
+  "webgpu:shader,execution,expression,call,builtin,radians:f32:*": { "subcaseMS": 74.432 },
   "webgpu:shader,execution,expression,call,builtin,reflect:abstract_float:*": { "subcaseMS": 20.405 },
   "webgpu:shader,execution,expression,call,builtin,reflect:f16:*": { "subcaseMS": 15.806 },
   "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec2:*": { "subcaseMS": 116.425 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/radians.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/radians.spec.ts
index db388dc56e8f..a0d47fc4e834 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/radians.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/radians.spec.ts
@@ -10,9 +10,9 @@ Component-wise when T is a vector
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF16, TypeF32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF16Range, fullF32Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -28,6 +28,13 @@ export const d = makeCaseCache('radians', {
       FP.f32.radiansInterval
     );
   },
+  f16: () => {
+    return FP.f16.generateScalarToIntervalCases(
+      fullF16Range(),
+      'unfiltered',
+      FP.f16.radiansInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -55,4 +62,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('radians'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 0e52ff7d292f..925c9b5abb4a 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5177,7 +5177,7 @@ class F16Traits extends FPTraits {
   public readonly normalizeInterval = this.unimplementedVectorToVector.bind(this);
   public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this);
   public readonly quantizeToF16Interval = this.quantizeToF16IntervalNotAvailable.bind(this);
-  public readonly radiansInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly radiansInterval = this.radiansIntervalImpl.bind(this);
   public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(this);
   public readonly refractInterval = this.unimplementedRefract.bind(this);
   public readonly remainderInterval = this.remainderIntervalImpl.bind(this);

From 98aefef300fafc8f7292654870a293cfbc37ef29 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 14 Sep 2023 14:33:52 -0400
Subject: [PATCH 042/166] wgsl: Add AbstractFloat `radians` execution tests
 (#2960)

Fixes #2576
---
 src/unittests/floating_point.spec.ts          | 61 +++++++++++++++----
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/radians.spec.ts   | 29 +++++++--
 src/webgpu/util/constants.ts                  |  8 +--
 src/webgpu/util/floating_point.ts             |  2 +-
 5 files changed, 78 insertions(+), 24 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 8c37b7c2dc85..014725cee103 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3212,10 +3212,56 @@ g.test('quantizeToF16Interval_f32')
     );
   });
 
+// prettier-ignore
+const kRadiansIntervalCases = {
+  f32: [
+    { input: -180, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.whole), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.whole)] },
+    { input: -135, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.three_quarters), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.three_quarters)] },
+    { input: -90, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.half), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.half)] },
+    { input: -60, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.third), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.third)] },
+    { input: -45, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.quarter), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.quarter)] },
+    { input: -30, expected: [kMinusOneULPFunctions['f32'](kValue.f32.negative.pi.sixth), kPlusOneULPFunctions['f32'](kValue.f32.negative.pi.sixth)] },
+    { input: 30, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.sixth), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.sixth)] },
+    { input: 45, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.quarter), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.quarter)] },
+    { input: 60, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.third), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.third)] },
+    { input: 90, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.half), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.half)] },
+    { input: 135, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.three_quarters), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.three_quarters)] },
+    { input: 180, expected: [kMinusOneULPFunctions['f32'](kValue.f32.positive.pi.whole), kPlusOneULPFunctions['f32'](kValue.f32.positive.pi.whole)] },
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: -180, expected: [kMinusOneULPFunctions['f16'](kValue.f16.negative.pi.whole), kPlusOneULPFunctions['f16'](kValue.f16.negative.pi.whole)] },
+    { input: -135, expected: [kMinusOneULPFunctions['f16'](kValue.f16.negative.pi.three_quarters), kPlusOneULPFunctions['f16'](kValue.f16.negative.pi.three_quarters)] },
+    { input: -90, expected: [kMinusOneULPFunctions['f16'](kValue.f16.negative.pi.half), kPlusOneULPFunctions['f16'](kValue.f16.negative.pi.half)] },
+    { input: -60, expected: [kMinusOneULPFunctions['f16'](kValue.f16.negative.pi.third), kPlusOneULPFunctions['f16'](kValue.f16.negative.pi.third)] },
+    { input: -45, expected: [kMinusOneULPFunctions['f16'](kValue.f16.negative.pi.quarter), kPlusOneULPFunctions['f16'](kValue.f16.negative.pi.quarter)] },
+    { input: -30, expected: [kMinusOneULPFunctions['f16'](kValue.f16.negative.pi.sixth), kPlusOneULPFunctions['f16'](kValue.f16.negative.pi.sixth)] },
+    { input: 30, expected: [kMinusOneULPFunctions['f16'](kValue.f16.positive.pi.sixth), kPlusOneULPFunctions['f16'](kValue.f16.positive.pi.sixth)] },
+    { input: 45, expected: [kMinusOneULPFunctions['f16'](kValue.f16.positive.pi.quarter), kPlusOneULPFunctions['f16'](kValue.f16.positive.pi.quarter)] },
+    { input: 60, expected: [kMinusOneULPFunctions['f16'](kValue.f16.positive.pi.third), kPlusOneULPFunctions['f16'](kValue.f16.positive.pi.third)] },
+    { input: 90, expected: [kMinusOneULPFunctions['f16'](kValue.f16.positive.pi.half), kPlusOneULPFunctions['f16'](kValue.f16.positive.pi.half)] },
+    { input: 135, expected: [kMinusOneULPFunctions['f16'](kValue.f16.positive.pi.three_quarters), kPlusOneULPFunctions['f16'](kValue.f16.positive.pi.three_quarters)] },
+    { input: 180, expected: [kMinusOneULPFunctions['f16'](kValue.f16.positive.pi.whole), kPlusOneULPFunctions['f16'](kValue.f16.positive.pi.whole)] },
+  ] as ScalarToIntervalCase[],
+  abstract: [
+    { input: -180, expected: kValue.f64.negative.pi.whole },
+    { input: -135, expected: kValue.f64.negative.pi.three_quarters },
+    { input: -90, expected: kValue.f64.negative.pi.half },
+    { input: -60, expected: kValue.f64.negative.pi.third },
+    { input: -45, expected: kValue.f64.negative.pi.quarter },
+    { input: -30, expected: kValue.f64.negative.pi.sixth },
+    { input: 30, expected: kValue.f64.positive.pi.sixth },
+    { input: 45, expected: kValue.f64.positive.pi.quarter },
+    { input: 60, expected: kValue.f64.positive.pi.third },
+    { input: 90, expected: kValue.f64.positive.pi.half },
+    { input: 135, expected: kValue.f64.positive.pi.three_quarters },
+    { input: 180, expected: kValue.f64.positive.pi.whole },
+  ] as ScalarToIntervalCase[],
+} as const;
+
 g.test('radiansInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarToIntervalCase>(p => {
         const trait = p.trait;
@@ -3223,20 +3269,9 @@ g.test('radiansInterval')
         // prettier-ignore
         return [
           { input: constants.positive.infinity, expected: kUnboundedBounds },
-          { input: -180, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.whole), kPlusOneULPFunctions[trait](constants.negative.pi.whole)] },
-          { input: -135, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.three_quarters), kPlusOneULPFunctions[trait](constants.negative.pi.three_quarters)] },
-          { input: -90, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.half), kPlusOneULPFunctions[trait](constants.negative.pi.half)] },
-          { input: -60, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.third), kPlusOneULPFunctions[trait](constants.negative.pi.third)] },
-          { input: -45, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.quarter), kPlusOneULPFunctions[trait](constants.negative.pi.quarter)] },
-          { input: -30, expected: [kMinusOneULPFunctions[trait](constants.negative.pi.sixth), kPlusOneULPFunctions[trait](constants.negative.pi.sixth)] },
           { input: 0, expected: 0 },
-          { input: 30, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.sixth), kPlusOneULPFunctions[trait](constants.positive.pi.sixth)] },
-          { input: 45, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.quarter), kPlusOneULPFunctions[trait](constants.positive.pi.quarter)] },
-          { input: 60, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.third), kPlusOneULPFunctions[trait](constants.positive.pi.third)] },
-          { input: 90, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.half), kPlusOneULPFunctions[trait](constants.positive.pi.half)] },
-          { input: 135, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.three_quarters), kPlusOneULPFunctions[trait](constants.positive.pi.three_quarters)] },
-          { input: 180, expected: [kMinusOneULPFunctions[trait](constants.positive.pi.whole), kPlusOneULPFunctions[trait](constants.positive.pi.whole)] },
           { input: constants.negative.infinity, expected: kUnboundedBounds },
+          ...kRadiansIntervalCases[trait]
         ];
       })
   )
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index a7d683bdfbff..6c2e59995b10 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1280,7 +1280,7 @@
   "webgpu:shader,execution,expression,call,builtin,pow:f16:*": { "subcaseMS": 18.407 },
   "webgpu:shader,execution,expression,call,builtin,pow:f32:*": { "subcaseMS": 151.269 },
   "webgpu:shader,execution,expression,call,builtin,quantizeToF16:f32:*": { "subcaseMS": 11.063 },
-  "webgpu:shader,execution,expression,call,builtin,radians:abstract_float:*": { "subcaseMS": 175.108 },
+  "webgpu:shader,execution,expression,call,builtin,radians:abstract_float:*": { "subcaseMS": 492.827 },
   "webgpu:shader,execution,expression,call,builtin,radians:f16:*": { "subcaseMS": 18.707 },
   "webgpu:shader,execution,expression,call,builtin,radians:f32:*": { "subcaseMS": 74.432 },
   "webgpu:shader,execution,expression,call,builtin,reflect:abstract_float:*": { "subcaseMS": 20.405 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/radians.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/radians.spec.ts
index a0d47fc4e834..63ae45b656d2 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/radians.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/radians.spec.ts
@@ -10,13 +10,13 @@ Component-wise when T is a vector
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF16, TypeF32 } from '../../../../../util/conversion.js';
+import { TypeAbstractFloat, TypeF16, TypeF32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
 import { fullF16Range, fullF32Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -35,15 +35,34 @@ export const d = makeCaseCache('radians', {
       FP.f16.radiansInterval
     );
   },
+  abstract: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      fullF16Range(),
+      'unfiltered',
+      FP.abstract.radiansInterval
+    );
+  },
 });
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(
+      t,
+      abstractBuiltin('radians'),
+      [TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/util/constants.ts b/src/webgpu/util/constants.ts
index c9a16885fd51..94d6eb949edf 100644
--- a/src/webgpu/util/constants.ts
+++ b/src/webgpu/util/constants.ts
@@ -33,9 +33,9 @@ export const kBit = {
         whole: BigInt(0x4009_21fb_5444_2d18n),
         three_quarters: BigInt(0x4002_d97c_7f33_21d2n),
         half: BigInt(0x3ff9_21fb_5444_2d18n),
-        third: BigInt(0x3ff0_c152_382d_7366n),
+        third: BigInt(0x3ff0_c152_382d_7365n),
         quarter: BigInt(0x3fe9_21fb_5444_2d18n),
-        sixth: BigInt(0x3fe0_c152_382d_7366n),
+        sixth: BigInt(0x3fe0_c152_382d_7365n),
       },
       e: BigInt(0x4005_bf0a_8b14_5769n),
     },
@@ -49,9 +49,9 @@ export const kBit = {
         whole: BigInt(0xc009_21fb_5444_2d18n),
         three_quarters: BigInt(0xc002_d97c_7f33_21d2n),
         half: BigInt(0xbff9_21fb_5444_2d18n),
-        third: BigInt(0xbff0_c152_382d_7366n),
+        third: BigInt(0xbff0_c152_382d_7365n),
         quarter: BigInt(0xbfe9_21fb_5444_2d18n),
-        sixth: BigInt(0xbfe0_c152_382d_7366n),
+        sixth: BigInt(0xbfe0_c152_382d_7365n),
       },
     },
     subnormal: {
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 925c9b5abb4a..91ebb91275b4 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4890,7 +4890,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly normalizeInterval = this.unimplementedVectorToVector.bind(this);
   public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this);
   public readonly quantizeToF16Interval = this.unimplementedScalarToInterval.bind(this);
-  public readonly radiansInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly radiansInterval = this.radiansIntervalImpl.bind(this);
   public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(this);
   public readonly refractInterval = this.unimplementedRefract.bind(this);
   public readonly remainderInterval = this.unimplementedScalarPairToInterval.bind(this);

From afb4f6fc66f1ab614035110e039bb377f33b78c5 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Fri, 15 Sep 2023 02:37:51 +0800
Subject: [PATCH 043/166] wgsl: f16 execution test for binary matrix expression
 and built-in dot (#2955)

This PR add execution tests for f16 binary matrix expression, including
matrix addition/subtraction and matrix-scalar/vector/matrix
multiplication, and also the execution test for 16 built-in dot.

Issue: #1248, #1626, #2513
---
 src/unittests/floating_point.spec.ts          | 2462 +++++++++--------
 src/webgpu/listing_meta.json                  |   16 +-
 .../binary/f16_matrix_addition.spec.ts        |  101 +
 .../f16_matrix_matrix_multiplication.spec.ts  |  114 +
 .../f16_matrix_scalar_multiplication.spec.ts  |  161 ++
 .../binary/f16_matrix_subtraction.spec.ts     |  101 +
 .../f16_matrix_vector_multiplication.spec.ts  |  156 ++
 .../expression/call/builtin/dot.spec.ts       |  138 +-
 src/webgpu/util/floating_point.ts             |   18 +-
 9 files changed, 2024 insertions(+), 1243 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/binary/f16_matrix_addition.spec.ts
 create mode 100644 src/webgpu/shader/execution/expression/binary/f16_matrix_matrix_multiplication.spec.ts
 create mode 100644 src/webgpu/shader/execution/expression/binary/f16_matrix_scalar_multiplication.spec.ts
 create mode 100644 src/webgpu/shader/execution/expression/binary/f16_matrix_subtraction.spec.ts
 create mode 100644 src/webgpu/shader/execution/expression/binary/f16_matrix_vector_multiplication.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 014725cee103..98e73ed4bdcd 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5481,56 +5481,96 @@ g.test('distanceIntervalVector_f32')
     );
   });
 
-g.test('dotInterval_f32')
-  .paramsSubcasesOnly<VectorPairToIntervalCase>(
-    // prettier-ignore
-    [
-      // vec2
-      { input: [[1.0, 0.0], [1.0, 0.0]], expected: 1.0 },
-      { input: [[0.0, 1.0], [0.0, 1.0]], expected: 1.0 },
-      { input: [[1.0, 1.0], [1.0, 1.0]], expected: 2.0 },
-      { input: [[-1.0, -1.0], [-1.0, -1.0]], expected: 2.0 },
-      { input: [[-1.0, 1.0], [1.0, -1.0]], expected: -2.0 },
-      { input: [[0.1, 0.0], [1.0, 0.0]], expected: [reinterpretU64AsF64(0x3fb9_9999_8000_0000n), reinterpretU64AsF64(0x3fb9_9999_a000_0000n)]},  // ~0.1
-
-      // vec3
-      { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: 1.0 },
-      { input: [[0.0, 1.0, 0.0], [0.0, 1.0, 0.0]], expected: 1.0 },
-      { input: [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]], expected: 1.0 },
-      { input: [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], expected: 3.0 },
-      { input: [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]], expected: 3.0 },
-      { input: [[1.0, -1.0, -1.0], [-1.0, 1.0, -1.0]], expected: -1.0 },
-      { input: [[0.1, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fb9_9999_8000_0000n), reinterpretU64AsF64(0x3fb9_9999_a000_0000n)]},  // ~0.1
+// prettier-ignore
+const kDotIntervalCases = {
+  f32: [
+    // vec2
+    { input: [[0.1, 0.0], [1.0, 0.0]], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)]},  // ~0.1
+    // vec3
+    { input: [[0.1, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)]},  // ~0.1
+    // vec4
+    { input: [[0.1, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)]},  // ~0.1
+    // Inputs with large values but cancel out to finite result. In these cases, 2.0*2.0 = 4.0 and
+    // 3.0*3.0 = 9.0 is much smaller than kValue.f32.positive.max, as a result
+    // kValue.f32.positive.max + 9.0 = kValue.f32.positive.max in f32 and even f64. So, if the
+    // positive and negative large number cancel each other first, the result would be
+    // 2.0*2.0+3.0*3.0 = 13. Otherwise, the resule would be 0.0 or 4.0 or 9.0.
+    // https://github.com/gpuweb/cts/issues/2155
+    { input: [[kValue.f32.positive.max, 1.0, 2.0, 3.0], [-1.0, kValue.f32.positive.max, -2.0, -3.0]], expected: [-13, 0] },
+    { input: [[kValue.f32.positive.max, 1.0, 2.0, 3.0], [1.0, kValue.f32.negative.min, 2.0, 3.0]], expected: [0, 13] },
+  ] as VectorPairToIntervalCase[],
+  f16: [
+    // vec2
+    { input: [[0.1, 0.0], [1.0, 0.0]], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)]},  // ~0.1
+    // vec3
+    { input: [[0.1, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)]},  // ~0.1
+    // vec4
+    { input: [[0.1, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)]},  // ~0.1
+    // Inputs with large values but cancel out to finite result. In these cases, 2.0*2.0 = 4.0 and
+    // 3.0*3.0 = 9.0 is not small enough comparing to kValue.f16.positive.max = 65504, as a result
+    // kValue.f16.positive.max + 9.0 = 65513 is exactly representable in f32 and f64. So, if the
+    // positive and negative large number don't cancel each other first, the computation will
+    // overflow f16 and result in unbounded bounds.
+    // https://github.com/gpuweb/cts/issues/2155
+    { input: [[kValue.f16.positive.max, 1.0, 2.0, 3.0], [-1.0, kValue.f16.positive.max, -2.0, -3.0]], expected: kUnboundedBounds },
+    { input: [[kValue.f16.positive.max, 1.0, 2.0, 3.0], [1.0, kValue.f16.negative.min, 2.0, 3.0]], expected: kUnboundedBounds },
+  ] as VectorPairToIntervalCase[],
+} as const;
 
-      // vec4
-      { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: 1.0 },
-      { input: [[0.0, 1.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], expected: 1.0 },
-      { input: [[0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 1.0, 0.0]], expected: 1.0 },
-      { input: [[0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.0]], expected: 1.0 },
-      { input: [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], expected: 4.0 },
-      { input: [[-1.0, -1.0, -1.0, -1.0], [-1.0, -1.0, -1.0, -1.0]], expected: 4.0 },
-      { input: [[-1.0, 1.0, -1.0, 1.0], [1.0, -1.0, 1.0, -1.0]], expected: -4.0 },
-      { input: [[0.1, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fb9_9999_8000_0000n), reinterpretU64AsF64(0x3fb9_9999_a000_0000n)]},  // ~0.1
-
-      // Test that going out of bounds in the intermediate calculations is caught correctly.
-      { input: [[kValue.f32.positive.nearest_max, kValue.f32.positive.max, kValue.f32.negative.min], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
-      { input: [[kValue.f32.positive.nearest_max, kValue.f32.negative.min, kValue.f32.positive.max], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
-      { input: [[kValue.f32.positive.max, kValue.f32.positive.nearest_max, kValue.f32.negative.min], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
-      { input: [[kValue.f32.negative.min, kValue.f32.positive.nearest_max, kValue.f32.positive.max], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
-      { input: [[kValue.f32.positive.max, kValue.f32.negative.min, kValue.f32.positive.nearest_max], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
-      { input: [[kValue.f32.negative.min, kValue.f32.positive.max, kValue.f32.positive.nearest_max], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
-
-      // https://github.com/gpuweb/cts/issues/2155
-      { input: [[kValue.f32.positive.max, 1.0, 2.0, 3.0], [-1.0, kValue.f32.positive.max, -2.0, -3.0]], expected: [-13, 0] },
-    ]
+g.test('dotInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<VectorPairToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          // vec2
+          { input: [[1.0, 0.0], [1.0, 0.0]], expected: 1.0 },
+          { input: [[0.0, 1.0], [0.0, 1.0]], expected: 1.0 },
+          { input: [[1.0, 1.0], [1.0, 1.0]], expected: 2.0 },
+          { input: [[-1.0, -1.0], [-1.0, -1.0]], expected: 2.0 },
+          { input: [[-1.0, 1.0], [1.0, -1.0]], expected: -2.0 },
+
+          // vec3
+          { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: 1.0 },
+          { input: [[0.0, 1.0, 0.0], [0.0, 1.0, 0.0]], expected: 1.0 },
+          { input: [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]], expected: 1.0 },
+          { input: [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], expected: 3.0 },
+          { input: [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]], expected: 3.0 },
+          { input: [[1.0, -1.0, -1.0], [-1.0, 1.0, -1.0]], expected: -1.0 },
+
+          // vec4
+          { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: 1.0 },
+          { input: [[0.0, 1.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], expected: 1.0 },
+          { input: [[0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 1.0, 0.0]], expected: 1.0 },
+          { input: [[0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.0]], expected: 1.0 },
+          { input: [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], expected: 4.0 },
+          { input: [[-1.0, -1.0, -1.0, -1.0], [-1.0, -1.0, -1.0, -1.0]], expected: 4.0 },
+          { input: [[-1.0, 1.0, -1.0, 1.0], [1.0, -1.0, 1.0, -1.0]], expected: -4.0 },
+
+          ...kDotIntervalCases[p.trait],
+
+          // Test that going out of bounds in the intermediate calculations is caught correctly.
+          { input: [[constants.positive.nearest_max, constants.positive.max, constants.negative.min], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
+          { input: [[constants.positive.nearest_max, constants.negative.min, constants.positive.max], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
+          { input: [[constants.positive.max, constants.positive.nearest_max, constants.negative.min], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
+          { input: [[constants.negative.min, constants.positive.nearest_max, constants.positive.max], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
+          { input: [[constants.positive.max, constants.negative.min, constants.positive.nearest_max], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
+          { input: [[constants.negative.min, constants.positive.max, constants.positive.nearest_max], [1.0, 1.0, 1.0]], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
     const [x, y] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.dotInterval(x, y);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.dotInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `f32.dotInterval([${x}], [${y}]) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.dotInterval([${x}], [${y}]) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -5960,188 +6000,186 @@ interface MatrixPairToMatrixCase {
 g.test('additionMatrixMatrixInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'abstract'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
-      .expandWithParams<MatrixPairToMatrixCase>(_ => {
+      .combineWithParams<MatrixPairToMatrixCase>([
         // Only testing that different shapes of matrices are handled correctly
         // here, to reduce test duplication.
         // additionMatrixMatrixInterval uses AdditionIntervalOp for calculating intervals,
         // so the testing for additionInterval covers the actual interval
         // calculations.
-        return [
-          {
-            input: [
-              [
-                [1, 2],
-                [3, 4],
-              ],
-              [
-                [10, 20],
-                [30, 40],
-              ],
-            ],
-            expected: [
-              [11, 22],
-              [33, 44],
-            ],
-          },
-          {
-            input: [
-              [
-                [1, 2],
-                [3, 4],
-                [5, 6],
-              ],
-              [
-                [10, 20],
-                [30, 40],
-                [50, 60],
-              ],
-            ],
-            expected: [
-              [11, 22],
-              [33, 44],
-              [55, 66],
-            ],
-          },
-          {
-            input: [
-              [
-                [1, 2],
-                [3, 4],
-                [5, 6],
-                [7, 8],
-              ],
-              [
-                [10, 20],
-                [30, 40],
-                [50, 60],
-                [70, 80],
-              ],
-            ],
-            expected: [
-              [11, 22],
-              [33, 44],
-              [55, 66],
-              [77, 88],
-            ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3],
-                [4, 5, 6],
-              ],
-              [
-                [10, 20, 30],
-                [40, 50, 60],
-              ],
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
             ],
-            expected: [
-              [11, 22, 33],
-              [44, 55, 66],
+            [
+              [10, 20],
+              [30, 40],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3],
-                [4, 5, 6],
-                [7, 8, 9],
-              ],
-              [
-                [10, 20, 30],
-                [40, 50, 60],
-                [70, 80, 90],
-              ],
+          ],
+          expected: [
+            [11, 22],
+            [33, 44],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
             ],
-            expected: [
-              [11, 22, 33],
-              [44, 55, 66],
-              [77, 88, 99],
+            [
+              [10, 20],
+              [30, 40],
+              [50, 60],
+            ],
+          ],
+          expected: [
+            [11, 22],
+            [33, 44],
+            [55, 66],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+              [7, 8],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3],
-                [4, 5, 6],
-                [7, 8, 9],
-                [10, 11, 12],
-              ],
-              [
-                [10, 20, 30],
-                [40, 50, 60],
-                [70, 80, 90],
-                [1000, 1100, 1200],
-              ],
+            [
+              [10, 20],
+              [30, 40],
+              [50, 60],
+              [70, 80],
+            ],
+          ],
+          expected: [
+            [11, 22],
+            [33, 44],
+            [55, 66],
+            [77, 88],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
             ],
-            expected: [
-              [11, 22, 33],
-              [44, 55, 66],
-              [77, 88, 99],
-              [1010, 1111, 1212],
+            [
+              [10, 20, 30],
+              [40, 50, 60],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3, 4],
-                [5, 6, 7, 8],
-              ],
-              [
-                [10, 20, 30, 40],
-                [50, 60, 70, 80],
-              ],
+          ],
+          expected: [
+            [11, 22, 33],
+            [44, 55, 66],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
             ],
-            expected: [
-              [11, 22, 33, 44],
-              [55, 66, 77, 88],
+            [
+              [10, 20, 30],
+              [40, 50, 60],
+              [70, 80, 90],
+            ],
+          ],
+          expected: [
+            [11, 22, 33],
+            [44, 55, 66],
+            [77, 88, 99],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+              [10, 11, 12],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3, 4],
-                [5, 6, 7, 8],
-                [9, 10, 11, 12],
-              ],
-              [
-                [10, 20, 30, 40],
-                [50, 60, 70, 80],
-                [90, 1000, 1100, 1200],
-              ],
+            [
+              [10, 20, 30],
+              [40, 50, 60],
+              [70, 80, 90],
+              [1000, 1100, 1200],
+            ],
+          ],
+          expected: [
+            [11, 22, 33],
+            [44, 55, 66],
+            [77, 88, 99],
+            [1010, 1111, 1212],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
             ],
-            expected: [
-              [11, 22, 33, 44],
-              [55, 66, 77, 88],
-              [99, 1010, 1111, 1212],
+            [
+              [10, 20, 30, 40],
+              [50, 60, 70, 80],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3, 4],
-                [5, 6, 7, 8],
-                [9, 10, 11, 12],
-                [13, 14, 15, 16],
-              ],
-              [
-                [10, 20, 30, 40],
-                [50, 60, 70, 80],
-                [90, 1000, 1100, 1200],
-                [1300, 1400, 1500, 1600],
-              ],
+          ],
+          expected: [
+            [11, 22, 33, 44],
+            [55, 66, 77, 88],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
             ],
-            expected: [
-              [11, 22, 33, 44],
-              [55, 66, 77, 88],
-              [99, 1010, 1111, 1212],
-              [1313, 1414, 1515, 1616],
+            [
+              [10, 20, 30, 40],
+              [50, 60, 70, 80],
+              [90, 1000, 1100, 1200],
+            ],
+          ],
+          expected: [
+            [11, 22, 33, 44],
+            [55, 66, 77, 88],
+            [99, 1010, 1111, 1212],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+              [13, 14, 15, 16],
             ],
-          },
-        ];
-      })
+            [
+              [10, 20, 30, 40],
+              [50, 60, 70, 80],
+              [90, 1000, 1100, 1200],
+              [1300, 1400, 1500, 1600],
+            ],
+          ],
+          expected: [
+            [11, 22, 33, 44],
+            [55, 66, 77, 88],
+            [99, 1010, 1111, 1212],
+            [1313, 1414, 1515, 1616],
+          ],
+        },
+      ])
   )
   .fn(t => {
     const [x, y] = t.params.input;
@@ -6159,188 +6197,186 @@ g.test('additionMatrixMatrixInterval')
 g.test('subtractionMatrixMatrixInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'abstract'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
-      .expandWithParams<MatrixPairToMatrixCase>(_ => {
+      .combineWithParams<MatrixPairToMatrixCase>([
         // Only testing that different shapes of matrices are handled correctly
         // here, to reduce test duplication.
         // subtractionMatrixMatrixInterval uses AdditionIntervalOp for calculating intervals,
         // so the testing for subtractionInterval covers the actual interval
         // calculations.
-        return [
-          {
-            input: [
-              [
-                [1, 2],
-                [3, 4],
-              ],
-              [
-                [-10, -20],
-                [-30, -40],
-              ],
-            ],
-            expected: [
-              [11, 22],
-              [33, 44],
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2],
-                [3, 4],
-                [5, 6],
-              ],
-              [
-                [-10, -20],
-                [-30, -40],
-                [-50, -60],
-              ],
+            [
+              [-10, -20],
+              [-30, -40],
             ],
-            expected: [
-              [11, 22],
-              [33, 44],
-              [55, 66],
+          ],
+          expected: [
+            [11, 22],
+            [33, 44],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2],
-                [3, 4],
-                [5, 6],
-                [7, 8],
-              ],
-              [
-                [-10, -20],
-                [-30, -40],
-                [-50, -60],
-                [-70, -80],
-              ],
+            [
+              [-10, -20],
+              [-30, -40],
+              [-50, -60],
+            ],
+          ],
+          expected: [
+            [11, 22],
+            [33, 44],
+            [55, 66],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+              [7, 8],
             ],
-            expected: [
-              [11, 22],
-              [33, 44],
-              [55, 66],
-              [77, 88],
+            [
+              [-10, -20],
+              [-30, -40],
+              [-50, -60],
+              [-70, -80],
+            ],
+          ],
+          expected: [
+            [11, 22],
+            [33, 44],
+            [55, 66],
+            [77, 88],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3],
-                [4, 5, 6],
-              ],
-              [
-                [-10, -20, -30],
-                [-40, -50, -60],
-              ],
+            [
+              [-10, -20, -30],
+              [-40, -50, -60],
             ],
-            expected: [
-              [11, 22, 33],
-              [44, 55, 66],
-            ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3],
-                [4, 5, 6],
-                [7, 8, 9],
-              ],
-              [
-                [-10, -20, -30],
-                [-40, -50, -60],
-                [-70, -80, -90],
-              ],
-            ],
-            expected: [
-              [11, 22, 33],
-              [44, 55, 66],
-              [77, 88, 99],
-            ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3],
-                [4, 5, 6],
-                [7, 8, 9],
-                [10, 11, 12],
-              ],
-              [
-                [-10, -20, -30],
-                [-40, -50, -60],
-                [-70, -80, -90],
-                [-1000, -1100, -1200],
-              ],
-            ],
-            expected: [
-              [11, 22, 33],
-              [44, 55, 66],
-              [77, 88, 99],
-              [1010, 1111, 1212],
-            ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3, 4],
-                [5, 6, 7, 8],
-              ],
-              [
-                [-10, -20, -30, -40],
-                [-50, -60, -70, -80],
-              ],
+          ],
+          expected: [
+            [11, 22, 33],
+            [44, 55, 66],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
             ],
-            expected: [
-              [11, 22, 33, 44],
-              [55, 66, 77, 88],
+            [
+              [-10, -20, -30],
+              [-40, -50, -60],
+              [-70, -80, -90],
+            ],
+          ],
+          expected: [
+            [11, 22, 33],
+            [44, 55, 66],
+            [77, 88, 99],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+              [10, 11, 12],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3, 4],
-                [5, 6, 7, 8],
-                [9, 10, 11, 12],
-              ],
-              [
-                [-10, -20, -30, -40],
-                [-50, -60, -70, -80],
-                [-90, -1000, -1100, -1200],
-              ],
+            [
+              [-10, -20, -30],
+              [-40, -50, -60],
+              [-70, -80, -90],
+              [-1000, -1100, -1200],
+            ],
+          ],
+          expected: [
+            [11, 22, 33],
+            [44, 55, 66],
+            [77, 88, 99],
+            [1010, 1111, 1212],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
             ],
-            expected: [
-              [11, 22, 33, 44],
-              [55, 66, 77, 88],
-              [99, 1010, 1111, 1212],
+            [
+              [-10, -20, -30, -40],
+              [-50, -60, -70, -80],
             ],
-          },
-          {
-            input: [
-              [
-                [1, 2, 3, 4],
-                [5, 6, 7, 8],
-                [9, 10, 11, 12],
-                [13, 14, 15, 16],
-              ],
-              [
-                [-10, -20, -30, -40],
-                [-50, -60, -70, -80],
-                [-90, -1000, -1100, -1200],
-                [-1300, -1400, -1500, -1600],
-              ],
+          ],
+          expected: [
+            [11, 22, 33, 44],
+            [55, 66, 77, 88],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
             ],
-            expected: [
-              [11, 22, 33, 44],
-              [55, 66, 77, 88],
-              [99, 1010, 1111, 1212],
-              [1313, 1414, 1515, 1616],
+            [
+              [-10, -20, -30, -40],
+              [-50, -60, -70, -80],
+              [-90, -1000, -1100, -1200],
+            ],
+          ],
+          expected: [
+            [11, 22, 33, 44],
+            [55, 66, 77, 88],
+            [99, 1010, 1111, 1212],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+              [13, 14, 15, 16],
             ],
-          },
-        ];
-      })
+            [
+              [-10, -20, -30, -40],
+              [-50, -60, -70, -80],
+              [-90, -1000, -1100, -1200],
+              [-1300, -1400, -1500, -1600],
+            ],
+          ],
+          expected: [
+            [11, 22, 33, 44],
+            [55, 66, 77, 88],
+            [99, 1010, 1111, 1212],
+            [1313, 1414, 1515, 1616],
+          ],
+        },
+      ])
   )
   .fn(t => {
     const [x, y] = t.params.input;
@@ -6355,500 +6391,546 @@ g.test('subtractionMatrixMatrixInterval')
     );
   });
 
-g.test('multiplicationMatrixMatrixInterval_f32')
-  .paramsSubcasesOnly<MatrixPairToMatrixCase>([
-    // Only testing that different shapes of matrices are handled correctly
-    // here, to reduce test duplication.
-    // multiplicationMatrixMatrixInterval uses and transposeInterval &
-    // dotInterval for calculating intervals, so the testing for those functions
-    // will cover the actual interval calculations.
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-        ],
-        [
-          [11, 22],
-          [33, 44],
-        ],
-      ],
-      expected: [
-        [77, 110],
-        [165, 242],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-        ],
-        [
-          [11, 22],
-          [33, 44],
-          [55, 66],
-        ],
-      ],
-      expected: [
-        [77, 110],
-        [165, 242],
-        [253, 374],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-        ],
-        [
-          [11, 22],
-          [33, 44],
-          [55, 66],
-          [77, 88],
-        ],
-      ],
-      expected: [
-        [77, 110],
-        [165, 242],
-        [253, 374],
-        [341, 506],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-        ],
-        [
-          [11, 22],
-          [33, 44],
-        ],
-      ],
-      expected: [
-        [99, 132, 165],
-        [209, 286, 363],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-        ],
-        [
-          [11, 22],
-          [33, 44],
-          [55, 66],
-        ],
-      ],
-      expected: [
-        [99, 132, 165],
-        [209, 286, 363],
-        [319, 440, 561],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-        ],
-        [
-          [11, 22],
-          [33, 44],
-          [55, 66],
-          [77, 88],
-        ],
-      ],
-      expected: [
-        [99, 132, 165],
-        [209, 286, 363],
-        [319, 440, 561],
-        [429, 594, 759],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-        ],
-        [
-          [11, 22],
-          [33, 44],
-        ],
-      ],
-      expected: [
-        [121, 154, 187, 220],
-        [253, 330, 407, 484],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-        ],
-        [
-          [11, 22],
-          [33, 44],
-          [55, 66],
-          [77, 88],
-        ],
-      ],
-      expected: [
-        [121, 154, 187, 220],
-        [253, 330, 407, 484],
-        [385, 506, 627, 748],
-        [517, 682, 847, 1012],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-          [5, 6],
-        ],
-        [
-          [11, 22, 33],
-          [44, 55, 66],
-        ],
-      ],
-      expected: [
-        [242, 308],
-        [539, 704],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-          [5, 6],
-        ],
-        [
-          [11, 22, 33],
-          [44, 55, 66],
-          [77, 88, 99],
-        ],
-      ],
-      expected: [
-        [242, 308],
-        [539, 704],
-        [836, 1100],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-          [5, 6],
-        ],
-        [
-          [11, 22, 33],
-          [44, 55, 66],
-          [77, 88, 99],
-          [1010, 1111, 1212],
-        ],
-      ],
-      expected: [
-        [242, 308],
-        [539, 704],
-        [836, 1100],
-        [10403, 13736],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-        ],
-        [
-          [11, 22, 33],
-          [44, 55, 66],
-        ],
-      ],
-      expected: [
-        [330, 396, 462],
-        [726, 891, 1056],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-        ],
-        [
-          [11, 22, 33],
-          [44, 55, 66],
-          [77, 88, 99],
-        ],
-      ],
-      expected: [
-        [330, 396, 462],
-        [726, 891, 1056],
-        [1122, 1386, 1650],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-        ],
-        [
-          [11, 22, 33],
-          [44, 55, 66],
-          [77, 88, 99],
-          [1010, 1111, 1212],
-        ],
-      ],
-      expected: [
-        [330, 396, 462],
-        [726, 891, 1056],
-        [1122, 1386, 1650],
-        [13938, 17271, 20604],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-          [9, 11, 11, 12],
-        ],
-        [
-          [11, 22, 33],
-          [44, 55, 66],
-        ],
-      ],
-      expected: [
-        [418, 517, 550, 616],
-        [913, 1144, 1243, 1408],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-          [9, 11, 11, 12],
-        ],
-        [
-          [11, 22, 33],
-          [44, 55, 66],
-          [77, 88, 99],
-        ],
-      ],
-      expected: [
-        [418, 517, 550, 616],
-        [913, 1144, 1243, 1408],
-        [1408, 1771, 1936, 2200],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-          [9, 11, 11, 12],
-        ],
-        [
-          [11, 22, 33],
-          [44, 55, 66],
-          [77, 88, 99],
-          [1010, 1111, 1212],
-        ],
-      ],
-      expected: [
-        [418, 517, 550, 616],
-        [913, 1144, 1243, 1408],
-        [1408, 1771, 1936, 2200],
-        [17473, 22018, 24139, 27472],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-          [5, 6],
-          [7, 8],
-        ],
-        [
-          [11, 22, 33, 44],
-          [55, 66, 77, 88],
-        ],
-      ],
-      expected: [
-        [550, 660],
-        [1254, 1540],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-          [5, 6],
-          [7, 8],
-        ],
-        [
-          [11, 22, 33, 44],
-          [55, 66, 77, 88],
-          [99, 1010, 1111, 1212],
-        ],
-      ],
-      expected: [
-        [550, 660],
-        [1254, 1540],
-        [17168, 20600],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2],
-          [3, 4],
-          [5, 6],
-          [7, 8],
-        ],
-        [
-          [11, 22, 33, 44],
-          [55, 66, 77, 88],
-          [99, 1010, 1111, 1212],
-          [1313, 1414, 1515, 1616],
-        ],
-      ],
-      expected: [
-        [550, 660],
-        [1254, 1540],
-        [17168, 20600],
-        [24442, 30300],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-          [11, 11, 12],
-        ],
-        [
-          [11, 22, 33, 44],
-          [55, 66, 77, 88],
-        ],
-      ],
-      expected: [
-        [814, 880, 990],
-        [1826, 2024, 2310],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-          [11, 11, 12],
-        ],
-        [
-          [11, 22, 33, 44],
-          [55, 66, 77, 88],
-          [99, 1010, 1111, 1212],
-        ],
-      ],
-      expected: [
-        [814, 880, 990],
-        [1826, 2024, 2310],
-        [25248, 27468, 30900],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-          [11, 11, 12],
-        ],
-        [
-          [11, 22, 33, 44],
-          [55, 66, 77, 88],
-          [99, 1010, 1111, 1212],
-          [1313, 1414, 1515, 1616],
-        ],
-      ],
-      expected: [
-        [814, 880, 990],
-        [1826, 2024, 2310],
-        [25248, 27468, 30900],
-        [35350, 39592, 45450],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-          [9, 11, 11, 12],
-          [13, 14, 15, 16],
-        ],
-        [
-          [11, 22, 33, 44],
-          [55, 66, 77, 88],
-          [99, 1010, 1111, 1212],
-        ],
-      ],
-      expected: [
-        [990, 1133, 1210, 1320],
-        [2222, 2585, 2794, 3080],
-        [30904, 35447, 37768, 41200],
-      ],
-    },
-    {
-      input: [
-        [
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-          [9, 11, 11, 12],
-          [13, 14, 15, 16],
-        ],
-        [
-          [11, 22, 33, 44],
-          [55, 66, 77, 88],
-          [99, 1010, 1111, 1212],
-          [1313, 1414, 1515, 1616],
-        ],
-      ],
-      expected: [
-        [990, 1133, 1210, 1320],
-        [2222, 2585, 2794, 3080],
-        [30904, 35447, 37768, 41200],
-        [43026, 50399, 54742, 60600],
-      ],
-    },
-  ])
+g.test('multiplicationMatrixMatrixInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .combineWithParams<MatrixPairToMatrixCase>([
+        // Only testing that different shapes of matrices are handled correctly
+        // here, to reduce test duplication.
+        // multiplicationMatrixMatrixInterval uses and transposeInterval &
+        // dotInterval for calculating intervals, so the testing for those functions
+        // will cover the actual interval calculations.
+        // Keep all expected result integer no larger than 2047 to ensure that all result is exactly
+        // represeantable in both f32 and f16.
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+            ],
+            [
+              [11, 22],
+              [33, 44],
+            ],
+          ],
+          expected: [
+            [77, 110],
+            [165, 242],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+            ],
+            [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+            ],
+          ],
+          expected: [
+            [77, 110],
+            [165, 242],
+            [253, 374],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+            ],
+            [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+              [77, 88],
+            ],
+          ],
+          expected: [
+            [77, 110],
+            [165, 242],
+            [253, 374],
+            [341, 506],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+            ],
+            [
+              [11, 22],
+              [33, 44],
+            ],
+          ],
+          expected: [
+            [99, 132, 165],
+            [209, 286, 363],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+            ],
+            [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+            ],
+          ],
+          expected: [
+            [99, 132, 165],
+            [209, 286, 363],
+            [319, 440, 561],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+            ],
+            [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+              [77, 88],
+            ],
+          ],
+          expected: [
+            [99, 132, 165],
+            [209, 286, 363],
+            [319, 440, 561],
+            [429, 594, 759],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+            ],
+            [
+              [11, 22],
+              [33, 44],
+            ],
+          ],
+          expected: [
+            [121, 154, 187, 220],
+            [253, 330, 407, 484],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+            ],
+            [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+            ],
+          ],
+          expected: [
+            [121, 154, 187, 220],
+            [253, 330, 407, 484],
+            [385, 506, 627, 748],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+            ],
+            [
+              [11, 22],
+              [33, 44],
+              [55, 66],
+              [77, 88],
+            ],
+          ],
+          expected: [
+            [121, 154, 187, 220],
+            [253, 330, 407, 484],
+            [385, 506, 627, 748],
+            [517, 682, 847, 1012],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+            ],
+            [
+              [11, 22, 33],
+              [44, 55, 66],
+            ],
+          ],
+          expected: [
+            [242, 308],
+            [539, 704],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+            ],
+            [
+              [11, 22, 33],
+              [44, 55, 66],
+              [77, 88, 99],
+            ],
+          ],
+          expected: [
+            [242, 308],
+            [539, 704],
+            [836, 1100],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+            ],
+            [
+              [11, 22, 33],
+              [44, 55, 66],
+              [77, 88, 99],
+              [10, 11, 12],
+            ],
+          ],
+          expected: [
+            [242, 308],
+            [539, 704],
+            [836, 1100],
+            [103, 136],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+            ],
+            [
+              [11, 22, 33],
+              [44, 55, 66],
+            ],
+          ],
+          expected: [
+            [330, 396, 462],
+            [726, 891, 1056],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+            ],
+            [
+              [11, 22, 33],
+              [44, 55, 66],
+              [77, 88, 99],
+            ],
+          ],
+          expected: [
+            [330, 396, 462],
+            [726, 891, 1056],
+            [1122, 1386, 1650],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+            ],
+            [
+              [11, 22, 33],
+              [44, 55, 66],
+              [77, 88, 99],
+              [10, 11, 12],
+            ],
+          ],
+          expected: [
+            [330, 396, 462],
+            [726, 891, 1056],
+            [1122, 1386, 1650],
+            [138, 171, 204],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+            ],
+            [
+              [11, 12, 13],
+              [21, 22, 23],
+            ],
+          ],
+          expected: [
+            [188, 224, 260, 296],
+            [338, 404, 470, 536],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+            ],
+            [
+              [11, 12, 13],
+              [21, 22, 23],
+              [31, 32, 33],
+            ],
+          ],
+          expected: [
+            [188, 224, 260, 296],
+            [338, 404, 470, 536],
+            [488, 584, 680, 776],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+            ],
+            [
+              [11, 12, 13],
+              [21, 22, 23],
+              [31, 32, 33],
+              [41, 42, 43],
+            ],
+          ],
+          expected: [
+            [188, 224, 260, 296],
+            [338, 404, 470, 536],
+            [488, 584, 680, 776],
+            [638, 764, 890, 1016],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+              [7, 8],
+            ],
+            [
+              [11, 22, 33, 44],
+              [55, 66, 77, 88],
+            ],
+          ],
+          expected: [
+            [550, 660],
+            [1254, 1540],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+              [7, 8],
+            ],
+            [
+              [11, 12, 13, 14],
+              [21, 22, 23, 24],
+              [31, 32, 33, 34],
+            ],
+          ],
+          expected: [
+            [210, 260],
+            [370, 460],
+            [530, 660],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+              [7, 8],
+            ],
+            [
+              [11, 12, 13, 14],
+              [21, 22, 23, 24],
+              [31, 32, 33, 34],
+              [41, 42, 43, 44],
+            ],
+          ],
+          expected: [
+            [210, 260],
+            [370, 460],
+            [530, 660],
+            [690, 860],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+              [10, 11, 12],
+            ],
+            [
+              [11, 12, 13, 14],
+              [21, 22, 23, 24],
+            ],
+          ],
+          expected: [
+            [290, 340, 390],
+            [510, 600, 690],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+              [10, 11, 12],
+            ],
+            [
+              [11, 12, 13, 14],
+              [21, 22, 23, 24],
+              [31, 32, 33, 34],
+            ],
+          ],
+          expected: [
+            [290, 340, 390],
+            [510, 600, 690],
+            [730, 860, 990],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+              [10, 11, 12],
+            ],
+            [
+              [11, 12, 13, 14],
+              [21, 22, 23, 24],
+              [31, 32, 33, 34],
+              [41, 42, 43, 44],
+            ],
+          ],
+          expected: [
+            [290, 340, 390],
+            [510, 600, 690],
+            [730, 860, 990],
+            [950, 1120, 1290],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+              [13, 14, 15, 16],
+            ],
+            [
+              [11, 12, 13, 14],
+              [21, 22, 23, 24],
+            ],
+          ],
+          expected: [
+            [370, 420, 470, 520],
+            [650, 740, 830, 920],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+              [13, 14, 15, 16],
+            ],
+            [
+              [11, 12, 13, 14],
+              [21, 22, 23, 24],
+              [31, 32, 33, 34],
+            ],
+          ],
+          expected: [
+            [370, 420, 470, 520],
+            [650, 740, 830, 920],
+            [930, 1060, 1190, 1320],
+          ],
+        },
+        {
+          input: [
+            [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+              [13, 14, 15, 16],
+            ],
+            [
+              [11, 12, 13, 14],
+              [21, 22, 23, 24],
+              [31, 32, 33, 34],
+              [41, 42, 43, 44],
+            ],
+          ],
+          expected: [
+            [370, 420, 470, 520],
+            [650, 740, 830, 920],
+            [930, 1060, 1190, 1320],
+            [1210, 1380, 1550, 1720],
+          ],
+        },
+      ])
+  )
   .fn(t => {
     const [x, y] = t.params.input;
-    const expected = FP.f32.toMatrix(t.params.expected);
-    const got = FP.f32.multiplicationMatrixMatrixInterval(x, y);
+    const trait = FP[t.params.trait];
+    const expected = trait.toMatrix(t.params.expected);
+    const got = trait.multiplicationMatrixMatrixInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `f32.multiplicationMatrixMatrixInterval([${JSON.stringify(x)}], [${JSON.stringify(
-        y
-      )}]) returned '[${JSON.stringify(got)}]'. Expected '[${JSON.stringify(expected)}]'`
+      `${t.params.trait}.multiplicationMatrixMatrixInterval([${JSON.stringify(
+        x
+      )}], [${JSON.stringify(y)}]) returned '[${JSON.stringify(got)}]'. Expected '[${JSON.stringify(
+        expected
+      )}]'`
     );
   });
 
@@ -6858,139 +6940,145 @@ interface MatrixScalarToMatrixCase {
   expected: (number | IntervalBounds)[][];
 }
 
-g.test('multiplicationMatrixScalarInterval_f32')
-  .paramsSubcasesOnly<MatrixScalarToMatrixCase>([
-    // Only testing that different shapes of matrices are handled correctly
-    // here, to reduce test duplication.
-    // multiplicationMatrixScalarInterval uses MultiplicationIntervalOp for calculating intervals,
-    // so the testing for multiplcationInterval covers the actual interval
-    // calculations.
-    {
-      matrix: [
-        [1, 2],
-        [3, 4],
-      ],
-      scalar: 10,
-      expected: [
-        [10, 20],
-        [30, 40],
-      ],
-    },
-    {
-      matrix: [
-        [1, 2],
-        [3, 4],
-        [5, 6],
-      ],
-      scalar: 10,
-      expected: [
-        [10, 20],
-        [30, 40],
-        [50, 60],
-      ],
-    },
-    {
-      matrix: [
-        [1, 2],
-        [3, 4],
-        [5, 6],
-        [7, 8],
-      ],
-      scalar: 10,
-      expected: [
-        [10, 20],
-        [30, 40],
-        [50, 60],
-        [70, 80],
-      ],
-    },
-    {
-      matrix: [
-        [1, 2, 3],
-        [4, 5, 6],
-      ],
-      scalar: 10,
-      expected: [
-        [10, 20, 30],
-        [40, 50, 60],
-      ],
-    },
-    {
-      matrix: [
-        [1, 2, 3],
-        [4, 5, 6],
-        [7, 8, 9],
-      ],
-      scalar: 10,
-      expected: [
-        [10, 20, 30],
-        [40, 50, 60],
-        [70, 80, 90],
-      ],
-    },
-    {
-      matrix: [
-        [1, 2, 3],
-        [4, 5, 6],
-        [7, 8, 9],
-        [10, 11, 12],
-      ],
-      scalar: 10,
-      expected: [
-        [10, 20, 30],
-        [40, 50, 60],
-        [70, 80, 90],
-        [100, 110, 120],
-      ],
-    },
-    {
-      matrix: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      scalar: 10,
-      expected: [
-        [10, 20, 30, 40],
-        [50, 60, 70, 80],
-      ],
-    },
-    {
-      matrix: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-        [9, 10, 11, 12],
-      ],
-      scalar: 10,
-      expected: [
-        [10, 20, 30, 40],
-        [50, 60, 70, 80],
-        [90, 100, 110, 120],
-      ],
-    },
-    {
-      matrix: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-        [9, 10, 11, 12],
-        [13, 14, 15, 16],
-      ],
-      scalar: 10,
-      expected: [
-        [10, 20, 30, 40],
-        [50, 60, 70, 80],
-        [90, 100, 110, 120],
-        [130, 140, 150, 160],
-      ],
-    },
-  ])
+g.test('multiplicationMatrixScalarInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .combineWithParams<MatrixScalarToMatrixCase>([
+        // Only testing that different shapes of matrices are handled correctly
+        // here, to reduce test duplication.
+        // multiplicationMatrixScalarInterval uses MultiplicationIntervalOp for calculating intervals,
+        // so the testing for multiplcationInterval covers the actual interval
+        // calculations.
+        {
+          matrix: [
+            [1, 2],
+            [3, 4],
+          ],
+          scalar: 10,
+          expected: [
+            [10, 20],
+            [30, 40],
+          ],
+        },
+        {
+          matrix: [
+            [1, 2],
+            [3, 4],
+            [5, 6],
+          ],
+          scalar: 10,
+          expected: [
+            [10, 20],
+            [30, 40],
+            [50, 60],
+          ],
+        },
+        {
+          matrix: [
+            [1, 2],
+            [3, 4],
+            [5, 6],
+            [7, 8],
+          ],
+          scalar: 10,
+          expected: [
+            [10, 20],
+            [30, 40],
+            [50, 60],
+            [70, 80],
+          ],
+        },
+        {
+          matrix: [
+            [1, 2, 3],
+            [4, 5, 6],
+          ],
+          scalar: 10,
+          expected: [
+            [10, 20, 30],
+            [40, 50, 60],
+          ],
+        },
+        {
+          matrix: [
+            [1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9],
+          ],
+          scalar: 10,
+          expected: [
+            [10, 20, 30],
+            [40, 50, 60],
+            [70, 80, 90],
+          ],
+        },
+        {
+          matrix: [
+            [1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9],
+            [10, 11, 12],
+          ],
+          scalar: 10,
+          expected: [
+            [10, 20, 30],
+            [40, 50, 60],
+            [70, 80, 90],
+            [100, 110, 120],
+          ],
+        },
+        {
+          matrix: [
+            [1, 2, 3, 4],
+            [5, 6, 7, 8],
+          ],
+          scalar: 10,
+          expected: [
+            [10, 20, 30, 40],
+            [50, 60, 70, 80],
+          ],
+        },
+        {
+          matrix: [
+            [1, 2, 3, 4],
+            [5, 6, 7, 8],
+            [9, 10, 11, 12],
+          ],
+          scalar: 10,
+          expected: [
+            [10, 20, 30, 40],
+            [50, 60, 70, 80],
+            [90, 100, 110, 120],
+          ],
+        },
+        {
+          matrix: [
+            [1, 2, 3, 4],
+            [5, 6, 7, 8],
+            [9, 10, 11, 12],
+            [13, 14, 15, 16],
+          ],
+          scalar: 10,
+          expected: [
+            [10, 20, 30, 40],
+            [50, 60, 70, 80],
+            [90, 100, 110, 120],
+            [130, 140, 150, 160],
+          ],
+        },
+      ])
+  )
   .fn(t => {
     const matrix = t.params.matrix;
     const scalar = t.params.scalar;
-    const expected = FP.f32.toMatrix(t.params.expected);
-    const got = FP.f32.multiplicationMatrixScalarInterval(matrix, scalar);
+    const trait = FP[t.params.trait];
+    const expected = trait.toMatrix(t.params.expected);
+    const got = trait.multiplicationMatrixScalarInterval(matrix, scalar);
     t.expect(
       objectEquals(expected, got),
-      `f32.multiplicationMatrixScalarInterval([${JSON.stringify(
+      `${t.params.trait}.multiplicationMatrixScalarInterval([${JSON.stringify(
         matrix
       )}], ${scalar}) returned '[${JSON.stringify(got)}]'. Expected '[${JSON.stringify(expected)}]'`
     );
@@ -7005,106 +7093,114 @@ interface MatrixVectorToVectorCase {
   expected: (number | IntervalBounds)[];
 }
 
-g.test('multiplicationMatrixVectorInterval_f32')
-  .paramsSubcasesOnly<MatrixVectorToVectorCase>([
-    // Only testing that different shapes of matrices are handled correctly
-    // here, to reduce test duplication.
-    // multiplicationMatrixVectorInterval uses DotIntervalOp &
-    // TransposeIntervalOp for calculating intervals, so the testing for
-    // dotInterval & transposeInterval covers the actual interval
-    // calculations.
-    {
-      matrix: [
-        [1, 2],
-        [3, 4],
-      ],
-      vector: [11, 22],
-      expected: [77, 110],
-    },
-    {
-      matrix: [
-        [1, 2, 3],
-        [4, 5, 6],
-      ],
-      vector: [11, 22],
-      expected: [99, 132, 165],
-    },
-    {
-      matrix: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-      ],
-      vector: [11, 22],
-      expected: [121, 154, 187, 220],
-    },
-    {
-      matrix: [
-        [1, 2],
-        [3, 4],
-        [5, 6],
-      ],
-      vector: [11, 22, 33],
-      expected: [242, 308],
-    },
-    {
-      matrix: [
-        [1, 2, 3],
-        [4, 5, 6],
-        [7, 8, 9],
-      ],
-      vector: [11, 22, 33],
-      expected: [330, 396, 462],
-    },
-    {
-      matrix: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-        [9, 10, 11, 12],
-      ],
-      vector: [11, 22, 33],
-      expected: [418, 484, 550, 616],
-    },
-    {
-      matrix: [
-        [1, 2],
-        [3, 4],
-        [5, 6],
-        [7, 8],
-      ],
-      vector: [11, 22, 33, 44],
-      expected: [550, 660],
-    },
-    {
-      matrix: [
-        [1, 2, 3],
-        [4, 5, 6],
-        [7, 8, 9],
-        [10, 11, 12],
-      ],
-      vector: [11, 22, 33, 44],
-      expected: [770, 880, 990],
-    },
-    {
-      matrix: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-        [9, 10, 11, 12],
-        [13, 14, 15, 16],
-      ],
-      vector: [11, 22, 33, 44],
-      expected: [990, 1100, 1210, 1320],
-    },
-  ])
+g.test('multiplicationMatrixVectorInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .combineWithParams<MatrixVectorToVectorCase>([
+        // Only testing that different shapes of matrices are handled correctly
+        // here, to reduce test duplication.
+        // multiplicationMatrixVectorInterval uses DotIntervalOp &
+        // TransposeIntervalOp for calculating intervals, so the testing for
+        // dotInterval & transposeInterval covers the actual interval
+        // calculations.
+        {
+          matrix: [
+            [1, 2],
+            [3, 4],
+          ],
+          vector: [11, 22],
+          expected: [77, 110],
+        },
+        {
+          matrix: [
+            [1, 2, 3],
+            [4, 5, 6],
+          ],
+          vector: [11, 22],
+          expected: [99, 132, 165],
+        },
+        {
+          matrix: [
+            [1, 2, 3, 4],
+            [5, 6, 7, 8],
+          ],
+          vector: [11, 22],
+          expected: [121, 154, 187, 220],
+        },
+        {
+          matrix: [
+            [1, 2],
+            [3, 4],
+            [5, 6],
+          ],
+          vector: [11, 22, 33],
+          expected: [242, 308],
+        },
+        {
+          matrix: [
+            [1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9],
+          ],
+          vector: [11, 22, 33],
+          expected: [330, 396, 462],
+        },
+        {
+          matrix: [
+            [1, 2, 3, 4],
+            [5, 6, 7, 8],
+            [9, 10, 11, 12],
+          ],
+          vector: [11, 22, 33],
+          expected: [418, 484, 550, 616],
+        },
+        {
+          matrix: [
+            [1, 2],
+            [3, 4],
+            [5, 6],
+            [7, 8],
+          ],
+          vector: [11, 22, 33, 44],
+          expected: [550, 660],
+        },
+        {
+          matrix: [
+            [1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9],
+            [10, 11, 12],
+          ],
+          vector: [11, 22, 33, 44],
+          expected: [770, 880, 990],
+        },
+        {
+          matrix: [
+            [1, 2, 3, 4],
+            [5, 6, 7, 8],
+            [9, 10, 11, 12],
+            [13, 14, 15, 16],
+          ],
+          vector: [11, 22, 33, 44],
+          expected: [990, 1100, 1210, 1320],
+        },
+      ])
+  )
   .fn(t => {
     const matrix = t.params.matrix;
     const vector = t.params.vector;
-    const expected = FP.f32.toVector(t.params.expected);
-    const got = FP.f32.multiplicationMatrixVectorInterval(matrix, vector);
+    const trait = FP[t.params.trait];
+    const expected = trait.toVector(t.params.expected);
+    const got = trait.multiplicationMatrixVectorInterval(matrix, vector);
     t.expect(
       objectEquals(expected, got),
-      `f32multiplicationMatrixVectorInterval([${JSON.stringify(matrix)}], [${JSON.stringify(
-        vector
-      )}]) returned '[${JSON.stringify(got)}]'. Expected '[${JSON.stringify(expected)}]'`
+      `${t.params.trait}.multiplicationMatrixVectorInterval([${JSON.stringify(
+        matrix
+      )}], [${JSON.stringify(vector)}]) returned '[${JSON.stringify(
+        got
+      )}]'. Expected '[${JSON.stringify(expected)}]'`
     );
   });
 
@@ -7115,104 +7211,114 @@ interface VectorMatrixToVectorCase {
 }
 
 g.test('multiplicationVectorMatrixInterval_f32')
-  .paramsSubcasesOnly<VectorMatrixToVectorCase>([
-    // Only testing that different shapes of matrices are handled correctly
-    // here, to reduce test duplication.
-    // multiplicationVectorMatrixInterval uses DotIntervalOp for calculating
-    // intervals, so the testing for dotInterval covers the actual interval
-    // calculations.
-    {
-      vector: [1, 2],
-      matrix: [
-        [11, 22],
-        [33, 44],
-      ],
-      expected: [55, 121],
-    },
-    {
-      vector: [1, 2],
-      matrix: [
-        [11, 22],
-        [33, 44],
-        [55, 66],
-      ],
-      expected: [55, 121, 187],
-    },
-    {
-      vector: [1, 2],
-      matrix: [
-        [11, 22],
-        [33, 44],
-        [55, 66],
-        [77, 88],
-      ],
-      expected: [55, 121, 187, 253],
-    },
-    {
-      vector: [1, 2, 3],
-      matrix: [
-        [11, 22, 33],
-        [44, 55, 66],
-      ],
-      expected: [154, 352],
-    },
-    {
-      vector: [1, 2, 3],
-      matrix: [
-        [11, 22, 33],
-        [44, 55, 66],
-        [77, 88, 99],
-      ],
-      expected: [154, 352, 550],
-    },
-    {
-      vector: [1, 2, 3],
-      matrix: [
-        [11, 22, 33],
-        [44, 55, 66],
-        [77, 88, 99],
-        [1010, 1111, 1212],
-      ],
-      expected: [154, 352, 550, 6868],
-    },
-    {
-      vector: [1, 2, 3, 4],
-      matrix: [
-        [11, 22, 33, 44],
-        [55, 66, 77, 88],
-      ],
-      expected: [330, 770],
-    },
-    {
-      vector: [1, 2, 3, 4],
-      matrix: [
-        [11, 22, 33, 44],
-        [55, 66, 77, 88],
-        [99, 1010, 1111, 1212],
-      ],
-      expected: [330, 770, 10300],
-    },
-    {
-      vector: [1, 2, 3, 4],
-      matrix: [
-        [11, 22, 33, 44],
-        [55, 66, 77, 88],
-        [99, 1010, 1111, 1212],
-        [1313, 1414, 1515, 1616],
-      ],
-      expected: [330, 770, 10300, 15150],
-    },
-  ])
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .combineWithParams<VectorMatrixToVectorCase>([
+        // Only testing that different shapes of matrices are handled correctly
+        // here, to reduce test duplication.
+        // multiplicationVectorMatrixInterval uses DotIntervalOp for calculating
+        // intervals, so the testing for dotInterval covers the actual interval
+        // calculations.
+        // Keep all expected result integer no larger than 2047 to ensure that all result is exactly
+        // represeantable in both f32 and f16.
+        {
+          vector: [1, 2],
+          matrix: [
+            [11, 22],
+            [33, 44],
+          ],
+          expected: [55, 121],
+        },
+        {
+          vector: [1, 2],
+          matrix: [
+            [11, 22],
+            [33, 44],
+            [55, 66],
+          ],
+          expected: [55, 121, 187],
+        },
+        {
+          vector: [1, 2],
+          matrix: [
+            [11, 22],
+            [33, 44],
+            [55, 66],
+            [77, 88],
+          ],
+          expected: [55, 121, 187, 253],
+        },
+        {
+          vector: [1, 2, 3],
+          matrix: [
+            [11, 12, 13],
+            [21, 22, 23],
+          ],
+          expected: [74, 134],
+        },
+        {
+          vector: [1, 2, 3],
+          matrix: [
+            [11, 12, 13],
+            [21, 22, 23],
+            [31, 32, 33],
+          ],
+          expected: [74, 134, 194],
+        },
+        {
+          vector: [1, 2, 3],
+          matrix: [
+            [11, 12, 13],
+            [21, 22, 23],
+            [31, 32, 33],
+            [41, 42, 43],
+          ],
+          expected: [74, 134, 194, 254],
+        },
+        {
+          vector: [1, 2, 3, 4],
+          matrix: [
+            [11, 12, 13, 14],
+            [21, 22, 23, 24],
+          ],
+          expected: [130, 230],
+        },
+        {
+          vector: [1, 2, 3, 4],
+          matrix: [
+            [11, 12, 13, 14],
+            [21, 22, 23, 24],
+            [31, 32, 33, 34],
+          ],
+          expected: [130, 230, 330],
+        },
+        {
+          vector: [1, 2, 3, 4],
+          matrix: [
+            [11, 12, 13, 14],
+            [21, 22, 23, 24],
+            [31, 32, 33, 34],
+            [41, 42, 43, 44],
+          ],
+          expected: [130, 230, 330, 430],
+        },
+      ])
+  )
   .fn(t => {
     const vector = t.params.vector;
     const matrix = t.params.matrix;
-    const expected = FP.f32.toVector(t.params.expected);
-    const got = FP.f32.multiplicationVectorMatrixInterval(vector, matrix);
+    const trait = FP[t.params.trait];
+    const expected = trait.toVector(t.params.expected);
+    const got = trait.multiplicationVectorMatrixInterval(vector, matrix);
     t.expect(
       objectEquals(expected, got),
-      `f32.multiplicationVectorMatrixInterval([${JSON.stringify(vector)}], [${JSON.stringify(
-        matrix
-      )}]) returned '[${JSON.stringify(got)}]'. Expected '[${JSON.stringify(expected)}]'`
+      `${t.params.trait}.multiplicationVectorMatrixInterval([${JSON.stringify(
+        vector
+      )}], [${JSON.stringify(matrix)}]) returned '[${JSON.stringify(
+        got
+      )}]'. Expected '[${JSON.stringify(expected)}]'`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 6c2e59995b10..cb9dcbc72b5c 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -906,6 +906,18 @@
   "webgpu:shader,execution,expression,binary,f16_division:vector:*": { "subcaseMS": 5.505 },
   "webgpu:shader,execution,expression,binary,f16_division:vector_scalar:*": { "subcaseMS": 3.908 },
   "webgpu:shader,execution,expression,binary,f16_division:vector_scalar_compound:*": { "subcaseMS": 4.308 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_addition:matrix:*": { "subcaseMS": 775.164 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_addition:matrix_compound:*": { "subcaseMS": 1251.350 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_matrix_multiplication:matrix_matrix:*": { "subcaseMS": 2049.029 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_matrix_multiplication:matrix_matrix_compound:*": { "subcaseMS": 916.581 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_scalar_multiplication:matrix_scalar:*": { "subcaseMS": 760.517 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_scalar_multiplication:matrix_scalar_compound:*": { "subcaseMS": 663.923 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_scalar_multiplication:scalar_matrix:*": { "subcaseMS": 644.509 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_subtraction:matrix:*": { "subcaseMS": 725.975 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_subtraction:matrix_compound:*": { "subcaseMS": 1106.414 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_vector_multiplication:matrix_vector:*": { "subcaseMS": 1173.548 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_vector_multiplication:vector_matrix:*": { "subcaseMS": 85.495 },
+  "webgpu:shader,execution,expression,binary,f16_matrix_vector_multiplication:vector_matrix_compound:*": { "subcaseMS": 833.634 },
   "webgpu:shader,execution,expression,binary,f16_multiplication:scalar:*": { "subcaseMS": 105.202 },
   "webgpu:shader,execution,expression,binary,f16_multiplication:scalar_compound:*": { "subcaseMS": 8.111 },
   "webgpu:shader,execution,expression,binary,f16_multiplication:scalar_vector:*": { "subcaseMS": 3.907 },
@@ -1156,7 +1168,9 @@
   "webgpu:shader,execution,expression,call,builtin,distance:f32_vec4:*": { "subcaseMS": 12.700 },
   "webgpu:shader,execution,expression,call,builtin,dot:abstract_float:*": { "subcaseMS": 8.902 },
   "webgpu:shader,execution,expression,call,builtin,dot:abstract_int:*": { "subcaseMS": 2.902 },
-  "webgpu:shader,execution,expression,call,builtin,dot:f16:*": { "subcaseMS": 3.102 },
+  "webgpu:shader,execution,expression,call,builtin,dot:f16_vec2:*": { "subcaseMS": 981.225 },
+  "webgpu:shader,execution,expression,call,builtin,dot:f16_vec3:*": { "subcaseMS": 50.350 },
+  "webgpu:shader,execution,expression,call,builtin,dot:f16_vec4:*": { "subcaseMS": 52.250 },
   "webgpu:shader,execution,expression,call,builtin,dot:f32_vec2:*": { "subcaseMS": 210.350 },
   "webgpu:shader,execution,expression,call,builtin,dot:f32_vec3:*": { "subcaseMS": 11.176 },
   "webgpu:shader,execution,expression,call,builtin,dot:f32_vec4:*": { "subcaseMS": 11.876 },
diff --git a/src/webgpu/shader/execution/expression/binary/f16_matrix_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_matrix_addition.spec.ts
new file mode 100644
index 000000000000..fe64f41503fd
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/f16_matrix_addition.spec.ts
@@ -0,0 +1,101 @@
+export const description = `
+Execution Tests for matrix f16 addition expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeF16, TypeMat } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { sparseMatrixF16Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { allInputSources, run } from '../expression.js';
+
+import { binary, compoundBinary } from './binary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+// Cases: matCxR_[non_]const
+const mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f16.generateMatrixPairToMatrixCases(
+            sparseMatrixF16Range(cols, rows),
+            sparseMatrixF16Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f16.additionMatrixMatrixInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/f16_matrix_addition', mat_cases);
+
+g.test('matrix')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x + y, where x and y are matrices
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? `mat${cols}x${rows}_const` : `mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      binary('+'),
+      [TypeMat(cols, rows, TypeF16), TypeMat(cols, rows, TypeF16)],
+      TypeMat(cols, rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('matrix_compound')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x =+ y, where x and y are matrices
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? `mat${cols}x${rows}_const` : `mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      compoundBinary('+='),
+      [TypeMat(cols, rows, TypeF16), TypeMat(cols, rows, TypeF16)],
+      TypeMat(cols, rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/binary/f16_matrix_matrix_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_matrix_matrix_multiplication.spec.ts
new file mode 100644
index 000000000000..0c8b3e8c51c4
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/f16_matrix_matrix_multiplication.spec.ts
@@ -0,0 +1,114 @@
+export const description = `
+Execution Tests for matrix-matrix f16 multiplication expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeF16, TypeMat } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { sparseMatrixF16Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { allInputSources, run } from '../expression.js';
+
+import { binary, compoundBinary } from './binary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+// Cases: matKxR_matCxK_[non_]const
+const mat_mat_cases = ([2, 3, 4] as const)
+  .flatMap(k =>
+    ([2, 3, 4] as const).flatMap(cols =>
+      ([2, 3, 4] as const).flatMap(rows =>
+        ([true, false] as const).map(nonConst => ({
+          [`mat${k}x${rows}_mat${cols}x${k}_${nonConst ? 'non_const' : 'const'}`]: () => {
+            return FP.f16.generateMatrixPairToMatrixCases(
+              sparseMatrixF16Range(k, rows),
+              sparseMatrixF16Range(cols, k),
+              nonConst ? 'unfiltered' : 'finite',
+              FP.f16.multiplicationMatrixMatrixInterval
+            );
+          },
+        }))
+      )
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/f16_matrix_matrix_multiplication', mat_mat_cases);
+
+g.test('matrix_matrix')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x is a matrix and y is a matrix
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('common_dim', [2, 3, 4] as const)
+      .combine('x_rows', [2, 3, 4] as const)
+      .combine('y_cols', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const x_cols = t.params.common_dim;
+    const x_rows = t.params.x_rows;
+    const y_cols = t.params.y_cols;
+    const y_rows = t.params.common_dim;
+
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `mat${x_cols}x${x_rows}_mat${y_cols}x${y_rows}_const`
+        : `mat${x_cols}x${x_rows}_mat${y_cols}x${y_rows}_non_const`
+    );
+    await run(
+      t,
+      binary('*'),
+      [TypeMat(x_cols, x_rows, TypeF16), TypeMat(y_cols, y_rows, TypeF16)],
+      TypeMat(y_cols, x_rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('matrix_matrix_compound')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x *= y, where x is a matrix and y is a matrix
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('common_dim', [2, 3, 4] as const)
+      .combine('x_rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const x_cols = t.params.common_dim;
+    const x_rows = t.params.x_rows;
+    const y_cols = x_cols;
+    const y_rows = t.params.common_dim;
+
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `mat${x_cols}x${x_rows}_mat${y_cols}x${y_rows}_const`
+        : `mat${x_cols}x${x_rows}_mat${y_cols}x${y_rows}_non_const`
+    );
+    await run(
+      t,
+      compoundBinary('*='),
+      [TypeMat(x_cols, x_rows, TypeF16), TypeMat(y_cols, y_rows, TypeF16)],
+      TypeMat(y_cols, x_rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/binary/f16_matrix_scalar_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_matrix_scalar_multiplication.spec.ts
new file mode 100644
index 000000000000..29d4700ee69e
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/f16_matrix_scalar_multiplication.spec.ts
@@ -0,0 +1,161 @@
+export const description = `
+Execution Tests for matrix-scalar and scalar-matrix f16 multiplication expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeF16, TypeMat } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { sparseF16Range, sparseMatrixF16Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { allInputSources, run } from '../expression.js';
+
+import { binary, compoundBinary } from './binary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+// Cases: matCxR_scalar_[non_]const
+const mat_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`mat${cols}x${rows}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f16.generateMatrixScalarToMatrixCases(
+            sparseMatrixF16Range(cols, rows),
+            sparseF16Range(),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f16.multiplicationMatrixScalarInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: scalar_matCxR_[non_]const
+const scalar_mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`scalar_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f16.generateScalarMatrixToMatrixCases(
+            sparseF16Range(),
+            sparseMatrixF16Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f16.multiplicationScalarMatrixInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/f16_matrix_scalar_multiplication', {
+  ...mat_scalar_cases,
+  ...scalar_mat_cases,
+});
+
+g.test('matrix_scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x is a matrix and y is a scalar
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `mat${cols}x${rows}_scalar_const`
+        : `mat${cols}x${rows}_scalar_non_const`
+    );
+    await run(
+      t,
+      binary('*'),
+      [TypeMat(cols, rows, TypeF16), TypeF16],
+      TypeMat(cols, rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('matrix_scalar_compound')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x *= y, where x is a matrix and y is a scalar
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `mat${cols}x${rows}_scalar_const`
+        : `mat${cols}x${rows}_scalar_non_const`
+    );
+    await run(
+      t,
+      compoundBinary('*='),
+      [TypeMat(cols, rows, TypeF16), TypeF16],
+      TypeMat(cols, rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('scalar_matrix')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x is a scalar and y is a matrix
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `scalar_mat${cols}x${rows}_const`
+        : `scalar_mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      binary('*'),
+      [TypeF16, TypeMat(cols, rows, TypeF16)],
+      TypeMat(cols, rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/binary/f16_matrix_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_matrix_subtraction.spec.ts
new file mode 100644
index 000000000000..5b5f6ba04e3f
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/f16_matrix_subtraction.spec.ts
@@ -0,0 +1,101 @@
+export const description = `
+Execution Tests for matrix f16 subtraction expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeF16, TypeMat } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { sparseMatrixF16Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { allInputSources, run } from '../expression.js';
+
+import { binary, compoundBinary } from './binary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+// Cases: matCxR_[non_]const
+const mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f16.generateMatrixPairToMatrixCases(
+            sparseMatrixF16Range(cols, rows),
+            sparseMatrixF16Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f16.subtractionMatrixMatrixInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/f16_matrix_subtraction', mat_cases);
+
+g.test('matrix')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x - y, where x and y are matrices
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? `mat${cols}x${rows}_const` : `mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      binary('-'),
+      [TypeMat(cols, rows, TypeF16), TypeMat(cols, rows, TypeF16)],
+      TypeMat(cols, rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('matrix_compound')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x -= y, where x and y are matrices
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? `mat${cols}x${rows}_const` : `mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      compoundBinary('-='),
+      [TypeMat(cols, rows, TypeF16), TypeMat(cols, rows, TypeF16)],
+      TypeMat(cols, rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/binary/f16_matrix_vector_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_matrix_vector_multiplication.spec.ts
new file mode 100644
index 000000000000..3e916c7fd400
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/f16_matrix_vector_multiplication.spec.ts
@@ -0,0 +1,156 @@
+export const description = `
+Execution Tests for matrix-vector and vector-matrix f16 multiplication expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeF16, TypeMat, TypeVec } from '../../../../util/conversion.js';
+import { FP } from '../../../../util/floating_point.js';
+import { sparseMatrixF16Range, sparseVectorF16Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { allInputSources, run } from '../expression.js';
+
+import { binary, compoundBinary } from './binary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+// Cases: matCxR_vecC_[non_]const
+const mat_vec_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`mat${cols}x${rows}_vec${cols}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f16.generateMatrixVectorToVectorCases(
+            sparseMatrixF16Range(cols, rows),
+            sparseVectorF16Range(cols),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f16.multiplicationMatrixVectorInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: vecR_matCxR_[non_]const
+const vec_mat_cases = ([2, 3, 4] as const)
+  .flatMap(rows =>
+    ([2, 3, 4] as const).flatMap(cols =>
+      ([true, false] as const).map(nonConst => ({
+        [`vec${rows}_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f16.generateVectorMatrixToVectorCases(
+            sparseVectorF16Range(rows),
+            sparseMatrixF16Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f16.multiplicationVectorMatrixInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/f16_matrix_vector_multiplication', {
+  ...mat_vec_cases,
+  ...vec_mat_cases,
+});
+
+g.test('matrix_vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x is a matrix and y is a vector
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `mat${cols}x${rows}_vec${cols}_const`
+        : `mat${cols}x${rows}_vec${cols}_non_const`
+    );
+    await run(
+      t,
+      binary('*'),
+      [TypeMat(cols, rows, TypeF16), TypeVec(cols, TypeF16)],
+      TypeVec(rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector_matrix')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x * y, where x is a vector and y is is a matrix
+Accuracy: Correctly rounded
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `vec${rows}_mat${cols}x${rows}_const`
+        : `vec${rows}_mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      binary('*'),
+      [TypeVec(rows, TypeF16), TypeMat(cols, rows, TypeF16)],
+      TypeVec(cols, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector_matrix_compound')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x *= y, where x is a vector and y is is a matrix
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', allInputSources).combine('dim', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.dim;
+    const rows = t.params.dim;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `vec${rows}_mat${cols}x${rows}_const`
+        : `vec${rows}_mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      compoundBinary('*='),
+      [TypeVec(rows, TypeF16), TypeMat(cols, rows, TypeF16)],
+      TypeVec(cols, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/dot.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/dot.spec.ts
index e2b4e92de32e..272654618360 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/dot.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/dot.spec.ts
@@ -8,7 +8,7 @@ Returns the dot product of e1 and e2.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
 import { sparseVectorF32Range, vectorF32Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
@@ -18,58 +18,27 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
-// vec3 and vec4 require calculating all possible permutations, so their runtime is much longer per test, so only using
-// sparse vectors for them
-export const d = makeCaseCache('dot', {
-  f32_vec2_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      vectorF32Range(2),
-      vectorF32Range(2),
-      'finite',
-      FP.f32.dotInterval
-    );
-  },
-  f32_vec2_non_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      vectorF32Range(2),
-      vectorF32Range(2),
-      'unfiltered',
-      FP.f32.dotInterval
-    );
-  },
-  f32_vec3_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      'finite',
-      FP.f32.dotInterval
-    );
-  },
-  f32_vec3_non_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      FP.f32.dotInterval
-    );
-  },
-  f32_vec4_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      'finite',
-      FP.f32.dotInterval
-    );
-  },
-  f32_vec4_non_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      FP.f32.dotInterval
-    );
-  },
-});
+// Cases: [f32|f16]_vecN_[non_]const
+const cases = (['f32', 'f16'] as const)
+  .flatMap(trait =>
+    ([2, 3, 4] as const).flatMap(N =>
+      ([true, false] as const).map(nonConst => ({
+        [`${trait}_vec${N}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          // vec3 and vec4 require calculating all possible permutations, so their runtime is much
+          // longer per test, so only using sparse vectors for them.
+          return FP[trait].generateVectorPairToIntervalCases(
+            N === 2 ? vectorF32Range(2) : sparseVectorF32Range(N),
+            N === 2 ? vectorF32Range(2) : sparseVectorF32Range(N),
+            nonConst ? 'unfiltered' : 'finite',
+            FP[trait].dotInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('dot', cases);
 
 g.test('abstract_int')
   .specURL('https://www.w3.org/TR/WGSL/#vector-builtin-functions')
@@ -149,8 +118,65 @@ g.test('f32_vec4')
     );
   });
 
-g.test('f16')
+g.test('f16_vec2')
   .specURL('https://www.w3.org/TR/WGSL/#vector-builtin-functions')
-  .desc(`f16 tests`)
+  .desc(`f16 tests using vec2s`)
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec2_const' : 'f16_vec2_non_const'
+    );
+    await run(
+      t,
+      builtin('dot'),
+      [TypeVec(2, TypeF16), TypeVec(2, TypeF16)],
+      TypeF16,
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec3')
+  .specURL('https://www.w3.org/TR/WGSL/#vector-builtin-functions')
+  .desc(`f16 tests using vec3s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec3_const' : 'f16_vec3_non_const'
+    );
+    await run(
+      t,
+      builtin('dot'),
+      [TypeVec(3, TypeF16), TypeVec(3, TypeF16)],
+      TypeF16,
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec4')
+  .specURL('https://www.w3.org/TR/WGSL/#vector-builtin-functions')
+  .desc(`f16 tests using vec4s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec4_const' : 'f16_vec4_non_const'
+    );
+    await run(
+      t,
+      builtin('dot'),
+      [TypeVec(4, TypeF16), TypeVec(4, TypeF16)],
+      TypeF16,
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 91ebb91275b4..5f5d6179cbcc 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5122,7 +5122,7 @@ class F16Traits extends FPTraits {
   public readonly acoshPrimaryInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly acoshIntervals = [this.acoshAlternativeInterval, this.acoshPrimaryInterval];
   public readonly additionInterval = this.additionIntervalImpl.bind(this);
-  public readonly additionMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(this);
+  public readonly additionMatrixMatrixInterval = this.additionMatrixMatrixIntervalImpl.bind(this);
   public readonly asinInterval = this.asinIntervalImpl.bind(this);
   public readonly asinhInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly atanInterval = this.atanIntervalImpl.bind(this);
@@ -5139,7 +5139,7 @@ class F16Traits extends FPTraits {
   public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(this);
   public readonly distanceInterval = this.unimplementedDistance.bind(this);
   public readonly divisionInterval = this.divisionIntervalImpl.bind(this);
-  public readonly dotInterval = this.unimplementedVectorPairToInterval.bind(this);
+  public readonly dotInterval = this.dotIntervalImpl.bind(this);
   public readonly expInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly exp2Interval = this.unimplementedScalarToInterval.bind(this);
   public readonly faceForwardIntervals = this.unimplementedFaceForward.bind(this);
@@ -5158,19 +5158,19 @@ class F16Traits extends FPTraits {
   public readonly mixIntervals = [this.mixImpreciseInterval, this.mixPreciseInterval];
   public readonly modfInterval = this.unimplementedModf.bind(this);
   public readonly multiplicationInterval = this.multiplicationIntervalImpl.bind(this);
-  public readonly multiplicationMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(
+  public readonly multiplicationMatrixMatrixInterval = this.multiplicationMatrixMatrixIntervalImpl.bind(
     this
   );
-  public readonly multiplicationMatrixScalarInterval = this.unimplementedMatrixScalarToMatrix.bind(
+  public readonly multiplicationMatrixScalarInterval = this.multiplicationMatrixScalarIntervalImpl.bind(
     this
   );
-  public readonly multiplicationScalarMatrixInterval = this.unimplementedScalarMatrixToMatrix.bind(
+  public readonly multiplicationScalarMatrixInterval = this.multiplicationScalarMatrixIntervalImpl.bind(
     this
   );
-  public readonly multiplicationMatrixVectorInterval = this.unimplementedMatrixVectorToVector.bind(
+  public readonly multiplicationMatrixVectorInterval = this.multiplicationMatrixVectorIntervalImpl.bind(
     this
   );
-  public readonly multiplicationVectorMatrixInterval = this.unimplementedVectorMatrixToVector.bind(
+  public readonly multiplicationVectorMatrixInterval = this.multiplicationVectorMatrixIntervalImpl.bind(
     this
   );
   public readonly negationInterval = this.negationIntervalImpl.bind(this);
@@ -5190,7 +5190,9 @@ class F16Traits extends FPTraits {
   public readonly sqrtInterval = this.sqrtIntervalImpl.bind(this);
   public readonly stepInterval = this.stepIntervalImpl.bind(this);
   public readonly subtractionInterval = this.subtractionIntervalImpl.bind(this);
-  public readonly subtractionMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(this);
+  public readonly subtractionMatrixMatrixInterval = this.subtractionMatrixMatrixIntervalImpl.bind(
+    this
+  );
   public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly transposeInterval = this.transposeIntervalImpl.bind(this);

From 617369d8231b93fb2fd81b92cc7f144f68f87005 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 14 Sep 2023 15:23:12 -0400
Subject: [PATCH 044/166] wgsl: Add f16 `degrees` execution tests (#2961)

Fixes #2565
---
 src/unittests/floating_point.spec.ts          | 79 +++++++++++++------
 src/webgpu/listing_meta.json                  |  4 +-
 .../expression/call/builtin/degrees.spec.ts   | 22 +++++-
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 76 insertions(+), 31 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 98e73ed4bdcd..22b35a0db811 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -2689,35 +2689,64 @@ g.test('coshInterval_f32')
     );
   });
 
-g.test('degreesInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.pi.whole, expected: [kMinusOneULPFunctions['f32'](-180), kPlusOneULPFunctions['f32'](-180)] },
-      { input: kValue.f32.negative.pi.three_quarters, expected: [kMinusOneULPFunctions['f32'](-135), kPlusOneULPFunctions['f32'](-135)] },
-      { input: kValue.f32.negative.pi.half, expected: [kMinusOneULPFunctions['f32'](-90), kPlusOneULPFunctions['f32'](-90)] },
-      { input: kValue.f32.negative.pi.third, expected: [kMinusOneULPFunctions['f32'](-60), kPlusOneULPFunctions['f32'](-60)] },
-      { input: kValue.f32.negative.pi.quarter, expected: [kMinusOneULPFunctions['f32'](-45), kPlusOneULPFunctions['f32'](-45)] },
-      { input: kValue.f32.negative.pi.sixth, expected: [kMinusOneULPFunctions['f32'](-30), kPlusOneULPFunctions['f32'](-30)] },
-      { input: 0, expected: 0 },
-      { input: kValue.f32.positive.pi.sixth, expected: [kMinusOneULPFunctions['f32'](30), kPlusOneULPFunctions['f32'](30)] },
-      { input: kValue.f32.positive.pi.quarter, expected: [kMinusOneULPFunctions['f32'](45), kPlusOneULPFunctions['f32'](45)] },
-      { input: kValue.f32.positive.pi.third, expected: [kMinusOneULPFunctions['f32'](60), kPlusOneULPFunctions['f32'](60)] },
-      { input: kValue.f32.positive.pi.half, expected: [kMinusOneULPFunctions['f32'](90), kPlusOneULPFunctions['f32'](90)] },
-      { input: kValue.f32.positive.pi.three_quarters, expected: [kMinusOneULPFunctions['f32'](135), kPlusOneULPFunctions['f32'](135)] },
-      { input: kValue.f32.positive.pi.whole, expected: [kMinusOneULPFunctions['f32'](180), kPlusOneULPFunctions['f32'](180)] },
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+// prettier-ignore
+const kDegreesIntervalCases = {
+  f32: [
+    { input: kValue.f32.negative.pi.whole, expected: [kMinusOneULPFunctions['f32'](-180), kPlusOneULPFunctions['f32'](-180)] },
+    { input: kValue.f32.negative.pi.three_quarters, expected: [kMinusOneULPFunctions['f32'](-135), kPlusOneULPFunctions['f32'](-135)] },
+    { input: kValue.f32.negative.pi.half, expected: [kMinusOneULPFunctions['f32'](-90), kPlusOneULPFunctions['f32'](-90)] },
+    { input: kValue.f32.negative.pi.third, expected: [kMinusOneULPFunctions['f32'](-60), kPlusOneULPFunctions['f32'](-60)] },
+    { input: kValue.f32.negative.pi.quarter, expected: [kMinusOneULPFunctions['f32'](-45), kPlusOneULPFunctions['f32'](-45)] },
+    { input: kValue.f32.negative.pi.sixth, expected: [kMinusOneULPFunctions['f32'](-30), kPlusOneULPFunctions['f32'](-30)] },
+    { input: kValue.f32.positive.pi.sixth, expected: [kMinusOneULPFunctions['f32'](30), kPlusOneULPFunctions['f32'](30)] },
+    { input: kValue.f32.positive.pi.quarter, expected: [kMinusOneULPFunctions['f32'](45), kPlusOneULPFunctions['f32'](45)] },
+    { input: kValue.f32.positive.pi.third, expected: [kMinusOneULPFunctions['f32'](60), kPlusOneULPFunctions['f32'](60)] },
+    { input: kValue.f32.positive.pi.half, expected: [kMinusOneULPFunctions['f32'](90), kPlusOneULPFunctions['f32'](90)] },
+    { input: kValue.f32.positive.pi.three_quarters, expected: [kMinusOneULPFunctions['f32'](135), kPlusOneULPFunctions['f32'](135)] },
+    { input: kValue.f32.positive.pi.whole, expected: [kMinusOneULPFunctions['f32'](180), kPlusOneULPFunctions['f32'](180)] },
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: kValue.f16.negative.pi.whole, expected: [-180, kPlusOneULPFunctions['f16'](-180)] },
+    { input: kValue.f16.negative.pi.three_quarters, expected: [-135, kPlusOneULPFunctions['f16'](-135)] },
+    { input: kValue.f16.negative.pi.half, expected: [-90, kPlusOneULPFunctions['f16'](-90)] },
+    { input: kValue.f16.negative.pi.third, expected: [-60, kPlusNULPFunctions['f16'](-60, 2)] },
+    { input: kValue.f16.negative.pi.quarter, expected: [-45, kPlusOneULPFunctions['f16'](-45)] },
+    { input: kValue.f16.negative.pi.sixth, expected: [-30, kPlusNULPFunctions['f16'](-30, 2)] },
+    { input: kValue.f16.positive.pi.sixth, expected: [kMinusNULPFunctions['f16'](30, 2), 30] },
+    { input: kValue.f16.positive.pi.quarter, expected: [kMinusOneULPFunctions['f16'](45), 45] },
+    { input: kValue.f16.positive.pi.third, expected: [kMinusNULPFunctions['f16'](60, 2), 60] },
+    { input: kValue.f16.positive.pi.half, expected: [kMinusOneULPFunctions['f16'](90), 90] },
+    { input: kValue.f16.positive.pi.three_quarters, expected: [kMinusOneULPFunctions['f16'](135), 135] },
+    { input: kValue.f16.positive.pi.whole, expected: [kMinusOneULPFunctions['f16'](180), 180] },
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('degreesInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = p.trait;
+        const constants = FP[trait].constants();
+        // prettier-ignore
+        return [
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: 0, expected: 0 },
+          { input: constants.positive.max, expected: kUnboundedBounds },
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          ...kDegreesIntervalCases[trait]
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.degreesInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.degreesInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.degreesInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.degreesInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index cb9dcbc72b5c..ef4c8cd4e399 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1154,9 +1154,9 @@
   "webgpu:shader,execution,expression,call,builtin,cross:abstract_float:*": { "subcaseMS": 3.002 },
   "webgpu:shader,execution,expression,call,builtin,cross:f16:*": { "subcaseMS": 16.101 },
   "webgpu:shader,execution,expression,call,builtin,cross:f32:*": { "subcaseMS": 664.926 },
-  "webgpu:shader,execution,expression,call,builtin,degrees:abstract_float:*": { "subcaseMS": 43.808 },
+  "webgpu:shader,execution,expression,call,builtin,degrees:abstract_float:*": { "subcaseMS": 176.407 },
   "webgpu:shader,execution,expression,call,builtin,degrees:f16:*": { "subcaseMS": 29.308 },
-  "webgpu:shader,execution,expression,call,builtin,degrees:f32:*": { "subcaseMS": 23.894 },
+  "webgpu:shader,execution,expression,call,builtin,degrees:f32:*": { "subcaseMS": 79.525 },
   "webgpu:shader,execution,expression,call,builtin,determinant:abstract_float:*": { "subcaseMS": 15.306 },
   "webgpu:shader,execution,expression,call,builtin,determinant:f16:*": { "subcaseMS": 22.806 },
   "webgpu:shader,execution,expression,call,builtin,determinant:f32:*": { "subcaseMS": 10.742 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/degrees.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/degrees.spec.ts
index 750cbdf34337..b0b122480386 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/degrees.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/degrees.spec.ts
@@ -9,9 +9,9 @@ Converts radians to degrees, approximating e1 × 180 ÷ π. Component-wise when
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF16, TypeF32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF16Range, fullF32Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -30,6 +30,16 @@ export const d = makeCaseCache('degrees', {
       FP.f32.degreesInterval
     );
   },
+  f16_const: () => {
+    return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'finite', FP.f16.degreesInterval);
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarToIntervalCases(
+      fullF16Range(),
+      'unfiltered',
+      FP.f16.degreesInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -57,4 +67,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('degrees'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 5f5d6179cbcc..f7cf40af9854 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5135,7 +5135,7 @@ class F16Traits extends FPTraits {
   public readonly cosInterval = this.cosIntervalImpl.bind(this);
   public readonly coshInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly crossInterval = this.unimplementedVectorPairToVector.bind(this);
-  public readonly degreesInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly degreesInterval = this.degreesIntervalImpl.bind(this);
   public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(this);
   public readonly distanceInterval = this.unimplementedDistance.bind(this);
   public readonly divisionInterval = this.divisionIntervalImpl.bind(this);

From b4dfdd2b9efe43dcb60535393358cb7cedee9636 Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Fri, 15 Sep 2023 05:42:59 +0900
Subject: [PATCH 045/166] Compat: Limit draw test attributes in compat (#2954)

In compat mode, @builtin(vertex_index) and @builtin(instance_index)
each take an attribute so adjust this test to account for that.

I don't know if this test should be refactored to make sure
16 attributes are tested (So without using the builtins).
My feeling is this is probably fine?

The test in
webgpu/compat/api/validation/encoding/render_pipeline/vertex_state.spec.ts
does a simple test that you can create a pipeline with maxVertexAttributes
but it does not actually draw with that pipeline.
---
 .../api/operation/rendering/draw.spec.ts      | 33 +++++++++++++++----
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/src/webgpu/api/operation/rendering/draw.spec.ts b/src/webgpu/api/operation/rendering/draw.spec.ts
index cd0c425b12b1..671cba3e646f 100644
--- a/src/webgpu/api/operation/rendering/draw.spec.ts
+++ b/src/webgpu/api/operation/rendering/draw.spec.ts
@@ -430,9 +430,10 @@ g.test('vertex_attributes,basic')
     const vertexCount = 4;
     const instanceCount = 4;
 
-    const attributesPerVertexBuffer =
-      t.params.vertex_attribute_count / t.params.vertex_buffer_count;
-    assert(Math.round(attributesPerVertexBuffer) === attributesPerVertexBuffer);
+    // In compat mode, @builtin(vertex_index) and @builtin(instance_index) each take an attribute.
+    const maxAttributes = t.device.limits.maxVertexAttributes - (t.isCompatibility ? 2 : 0);
+    const numAttributes = Math.min(maxAttributes, t.params.vertex_attribute_count);
+    const maxAttributesPerVertexBuffer = Math.ceil(numAttributes / t.params.vertex_buffer_count);
 
     let shaderLocation = 0;
     let attributeValue = 0;
@@ -477,7 +478,12 @@ g.test('vertex_attributes,basic')
       }
 
       const attributes: GPUVertexAttribute[] = [];
-      for (let a = 0; a < attributesPerVertexBuffer; ++a) {
+      const numAttributesForBuffer = Math.min(
+        maxAttributesPerVertexBuffer,
+        maxAttributes - b * maxAttributesPerVertexBuffer
+      );
+
+      for (let a = 0; a < numAttributesForBuffer; ++a) {
         const attribute: GPUVertexAttribute = {
           format: t.params.vertex_format,
           shaderLocation,
@@ -490,7 +496,7 @@ g.test('vertex_attributes,basic')
       }
 
       for (let v = 0; v < vertexOrInstanceCount; ++v) {
-        for (let a = 0; a < attributesPerVertexBuffer; ++a) {
+        for (let a = 0; a < numAttributesForBuffer; ++a) {
           vertexBufferValues.push(attributeValue);
           attributeValue += 1.234; // Values will get rounded later if we make a Uint32Array.
         }
@@ -570,7 +576,7 @@ g.test('vertex_attributes,basic')
     let accumulateVariableDeclarationsInFragmentShader = '';
     let accumulateVariableAssignmentsInFragmentShader = '';
     // The remaining 3 vertex attributes
-    if (t.params.vertex_attribute_count === 16) {
+    if (numAttributes === 16) {
       accumulateVariableDeclarationsInVertexShader = `
         @location(13) @interpolate(flat) outAttrib13 : vec4<${wgslFormat}>,
       `;
@@ -587,6 +593,21 @@ g.test('vertex_attributes,basic')
       outBuffer.primitives[input.primitiveId].attrib14 = input.attrib13.z;
       outBuffer.primitives[input.primitiveId].attrib15 = input.attrib13.w;
       `;
+    } else if (numAttributes === 14) {
+      accumulateVariableDeclarationsInVertexShader = `
+        @location(13) @interpolate(flat) outAttrib13 : vec4<${wgslFormat}>,
+      `;
+      accumulateVariableAssignmentsInVertexShader = `
+      output.outAttrib13 =
+          vec4<${wgslFormat}>(input.attrib12, input.attrib13, 0, 0);
+      `;
+      accumulateVariableDeclarationsInFragmentShader = `
+      @location(13) @interpolate(flat) attrib13 : vec4<${wgslFormat}>,
+      `;
+      accumulateVariableAssignmentsInFragmentShader = `
+      outBuffer.primitives[input.primitiveId].attrib12 = input.attrib13.x;
+      outBuffer.primitives[input.primitiveId].attrib13 = input.attrib13.y;
+      `;
     }
 
     const pipeline = t.device.createRenderPipeline({

From d70a32b9ec75de9da37dd4eafdef1394906c83c7 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Sat, 16 Sep 2023 00:04:28 -0400
Subject: [PATCH 046/166] wgsl: Add AbstractFloat `degree` execution tests
 (#2962)

Fixes #2564
---
 src/unittests/floating_point.spec.ts          | 16 +++++++++-
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/degrees.spec.ts   | 31 +++++++++++++++----
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 42 insertions(+), 9 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 22b35a0db811..ca097a17ad31 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -2719,12 +2719,26 @@ const kDegreesIntervalCases = {
     { input: kValue.f16.positive.pi.three_quarters, expected: [kMinusOneULPFunctions['f16'](135), 135] },
     { input: kValue.f16.positive.pi.whole, expected: [kMinusOneULPFunctions['f16'](180), 180] },
   ] as ScalarToIntervalCase[],
+  abstract: [
+    { input: kValue.f64.negative.pi.whole, expected: -180 },
+    { input: kValue.f64.negative.pi.three_quarters, expected: -135 },
+    { input: kValue.f64.negative.pi.half, expected: -90 },
+    { input: kValue.f64.negative.pi.third, expected: kPlusOneULPFunctions['abstract'](-60) },
+    { input: kValue.f64.negative.pi.quarter, expected: -45 },
+    { input: kValue.f64.negative.pi.sixth, expected: kPlusOneULPFunctions['abstract'](-30) },
+    { input: kValue.f64.positive.pi.sixth, expected: kMinusOneULPFunctions['abstract'](30) },
+    { input: kValue.f64.positive.pi.quarter, expected: 45 },
+    { input: kValue.f64.positive.pi.third, expected: kMinusOneULPFunctions['abstract'](60) },
+    { input: kValue.f64.positive.pi.half, expected: 90 },
+    { input: kValue.f64.positive.pi.three_quarters, expected: 135 },
+    { input: kValue.f64.positive.pi.whole, expected: 180 },
+  ] as ScalarToIntervalCase[],
 } as const;
 
 g.test('degreesInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarToIntervalCase>(p => {
         const trait = p.trait;
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index ef4c8cd4e399..17b43a06a40d 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1154,7 +1154,7 @@
   "webgpu:shader,execution,expression,call,builtin,cross:abstract_float:*": { "subcaseMS": 3.002 },
   "webgpu:shader,execution,expression,call,builtin,cross:f16:*": { "subcaseMS": 16.101 },
   "webgpu:shader,execution,expression,call,builtin,cross:f32:*": { "subcaseMS": 664.926 },
-  "webgpu:shader,execution,expression,call,builtin,degrees:abstract_float:*": { "subcaseMS": 176.407 },
+  "webgpu:shader,execution,expression,call,builtin,degrees:abstract_float:*": { "subcaseMS": 533.052 },
   "webgpu:shader,execution,expression,call,builtin,degrees:f16:*": { "subcaseMS": 29.308 },
   "webgpu:shader,execution,expression,call,builtin,degrees:f32:*": { "subcaseMS": 79.525 },
   "webgpu:shader,execution,expression,call,builtin,determinant:abstract_float:*": { "subcaseMS": 15.306 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/degrees.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/degrees.spec.ts
index b0b122480386..f82153ffcaca 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/degrees.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/degrees.spec.ts
@@ -9,13 +9,13 @@ Converts radians to degrees, approximating e1 × 180 ÷ π. Component-wise when
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF16, TypeF32 } from '../../../../../util/conversion.js';
+import { TypeAbstractFloat, TypeF16, TypeF32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF16Range, fullF32Range } from '../../../../../util/math.js';
+import { fullF16Range, fullF32Range, fullF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -40,15 +40,34 @@ export const d = makeCaseCache('degrees', {
       FP.f16.degreesInterval
     );
   },
+  abstract: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      fullF64Range(),
+      'finite',
+      FP.abstract.degreesInterval
+    );
+  },
 });
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(
+      t,
+      abstractBuiltin('degrees'),
+      [TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index f7cf40af9854..17b28b068664 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4848,7 +4848,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly cosInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly coshInterval = this.unimplementedScalarToInterval.bind(this);
   public readonly crossInterval = this.unimplementedVectorPairToVector.bind(this);
-  public readonly degreesInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly degreesInterval = this.degreesIntervalImpl.bind(this);
   public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(this);
   public readonly distanceInterval = this.unimplementedDistance.bind(this);
   public readonly divisionInterval = this.unimplementedScalarPairToInterval.bind(this);

From be1210e145e89e7a2943947d983f9592495e0f52 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 19 Sep 2023 13:51:56 +0800
Subject: [PATCH 047/166] wgsl: f16 execution test for built-in exp and exp2
 (#2963)

This PR add execution tests for f16 built-in exp and exp2.

Issue: #1248, #2543, #2544
---
 src/unittests/floating_point.spec.ts          | 125 ++++++++++++++----
 src/webgpu/listing_meta.json                  |   6 +-
 .../expression/call/builtin/exp.spec.ts       |  32 ++++-
 .../expression/call/builtin/exp2.spec.ts      |  32 ++++-
 src/webgpu/util/floating_point.ts             |  12 +-
 5 files changed, 162 insertions(+), 45 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index ca097a17ad31..ecd4d99b3cb1 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -2764,55 +2764,124 @@ g.test('degreesInterval')
     );
   });
 
-g.test('expInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: 0, expected: 1 },
-      { input: 1, expected: [kValue.f32.positive.e, kPlusOneULPFunctions['f32'](kValue.f32.positive.e)] },
-      { input: 89, expected: kUnboundedBounds },
-    ]
+// prettier-ignore
+const kExpIntervalCases = {
+  f32: [
+    { input: 1, expected: [kValue.f32.positive.e, kPlusOneULPFunctions['f32'](kValue.f32.positive.e)] },
+    // exp(88) = 1.6516362549940018555283297962649e+38 = 0x7ef882b6/7.
+    { input: 88, expected: [reinterpretU32AsF32(0x7ef882b6), reinterpretU32AsF32(0x7ef882b7)] },
+    // exp(89) overflow f32.
+    { input: 89, expected: kUnboundedBounds },
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: 1, expected: [kValue.f16.positive.e, kPlusOneULPFunctions['f16'](kValue.f16.positive.e)] },
+    // exp(11) = 59874.141715197818455326485792258 = 0x7b4f/0x7b50.
+    { input: 11, expected: [reinterpretU16AsF16(0x7b4f), reinterpretU16AsF16(0x7b50)] },
+    // exp(12) = 162754.79141900392080800520489849 overflow f16.
+    { input: 12, expected: kUnboundedBounds },
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('expInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = p.trait;
+        const constants = FP[trait].constants();
+        // prettier-ignore
+        return [
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: 0, expected: 1 },
+          ...kExpIntervalCases[trait],
+        ];
+      })
   )
   .fn(t => {
+    const trait = FP[t.params.trait];
     const error = (x: number): number => {
-      const n = 3 + 2 * Math.abs(t.params.input);
-      return n * oneULPF32(x);
+      let ulp_error;
+      switch (t.params.trait) {
+        case 'f32': {
+          ulp_error = 3 + 2 * Math.abs(t.params.input);
+          break;
+        }
+        case 'f16': {
+          ulp_error = 1 + 2 * Math.abs(t.params.input);
+          break;
+        }
+      }
+      return ulp_error * trait.oneULP(x);
     };
 
     t.params.expected = applyError(t.params.expected, error);
-    const expected = FP.f32.toInterval(t.params.expected);
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.expInterval(t.params.input);
 
-    const got = FP.f32.expInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.expInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.expInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
-g.test('exp2Interval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: 0, expected: 1 },
-      { input: 1, expected: 2 },
-      { input: 128, expected: kUnboundedBounds },
-    ]
+// prettier-ignore
+const kExp2IntervalCases = {
+  f32: [
+    // exp2(127) = 1.7014118346046923173168730371588e+38 = 0x7f000000, 3 + 2 * 127 = 258 ulps.
+    { input: 127, expected: reinterpretU32AsF32(0x7f000000) },
+    // exp2(128) overflow f32.
+    { input: 128, expected: kUnboundedBounds },
+  ] as ScalarToIntervalCase[],
+  f16: [
+    // exp2(15) = 32768 = 0x7800, 1 + 2 * 15 = 31 ulps
+    { input: 15, expected: reinterpretU16AsF16(0x7800) },
+    // exp2(16) = 65536 overflow f16.
+    { input: 16, expected: kUnboundedBounds },
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('exp2Interval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = p.trait;
+        const constants = FP[trait].constants();
+        // prettier-ignore
+        return [
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: 0, expected: 1 },
+          { input: 1, expected: 2 },
+          ...kExp2IntervalCases[trait],
+        ];
+      })
   )
   .fn(t => {
+    const trait = FP[t.params.trait];
     const error = (x: number): number => {
-      const n = 3 + 2 * Math.abs(t.params.input);
-      return n * oneULPF32(x);
+      let ulp_error;
+      switch (t.params.trait) {
+        case 'f32': {
+          ulp_error = 3 + 2 * Math.abs(t.params.input);
+          break;
+        }
+        case 'f16': {
+          ulp_error = 1 + 2 * Math.abs(t.params.input);
+          break;
+        }
+      }
+      return ulp_error * trait.oneULP(x);
     };
 
     t.params.expected = applyError(t.params.expected, error);
-    const expected = FP.f32.toInterval(t.params.expected);
+    const expected = trait.toInterval(t.params.expected);
 
-    const got = FP.f32.exp2Interval(t.params.input);
+    const got = trait.exp2Interval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.exp2Interval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.exp2Interval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 17b43a06a40d..a68b5206970d 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -905,7 +905,7 @@
   "webgpu:shader,execution,expression,binary,f16_division:scalar_vector:*": { "subcaseMS": 3.509 },
   "webgpu:shader,execution,expression,binary,f16_division:vector:*": { "subcaseMS": 5.505 },
   "webgpu:shader,execution,expression,binary,f16_division:vector_scalar:*": { "subcaseMS": 3.908 },
-  "webgpu:shader,execution,expression,binary,f16_division:vector_scalar_compound:*": { "subcaseMS": 4.308 },
+  "webgpu:shader,execution,expression,binary,f16_division:vector_scalar_compound:*": { "subcaseMS": 97.109 },
   "webgpu:shader,execution,expression,binary,f16_matrix_addition:matrix:*": { "subcaseMS": 775.164 },
   "webgpu:shader,execution,expression,binary,f16_matrix_addition:matrix_compound:*": { "subcaseMS": 1251.350 },
   "webgpu:shader,execution,expression,binary,f16_matrix_matrix_multiplication:matrix_matrix:*": { "subcaseMS": 2049.029 },
@@ -1183,10 +1183,10 @@
   "webgpu:shader,execution,expression,call,builtin,dpdyCoarse:f32:*": { "subcaseMS": 17.909 },
   "webgpu:shader,execution,expression,call,builtin,dpdyFine:f32:*": { "subcaseMS": 16.806 },
   "webgpu:shader,execution,expression,call,builtin,exp2:abstract_float:*": { "subcaseMS": 22.705 },
-  "webgpu:shader,execution,expression,call,builtin,exp2:f16:*": { "subcaseMS": 23.908 },
+  "webgpu:shader,execution,expression,call,builtin,exp2:f16:*": { "subcaseMS": 79.501 },
   "webgpu:shader,execution,expression,call,builtin,exp2:f32:*": { "subcaseMS": 12.169 },
   "webgpu:shader,execution,expression,call,builtin,exp:abstract_float:*": { "subcaseMS": 17.210 },
-  "webgpu:shader,execution,expression,call,builtin,exp:f16:*": { "subcaseMS": 17.605 },
+  "webgpu:shader,execution,expression,call,builtin,exp:f16:*": { "subcaseMS": 135.363 },
   "webgpu:shader,execution,expression,call,builtin,exp:f32:*": { "subcaseMS": 12.557 },
   "webgpu:shader,execution,expression,call,builtin,extractBits:i32:*": { "subcaseMS": 8.125 },
   "webgpu:shader,execution,expression,call,builtin,extractBits:u32:*": { "subcaseMS": 7.838 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/exp.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/exp.spec.ts
index 36e1d191f2c5..8b1ced3cab80 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/exp.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/exp.spec.ts
@@ -10,7 +10,7 @@ Returns the natural exponentiation of e1 (e.g. e^e1). Component-wise when T is a
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { kValue } from '../../../../../util/constants.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
 import { biasedRange, linearRange } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
@@ -22,7 +22,7 @@ export const g = makeTestGroup(GPUTest);
 
 // floor(ln(max f32 value)) = 88, so exp(88) will be within range of a f32, but exp(89) will not
 // floor(ln(max f64 value)) = 709, so exp(709) can be handled by the testing framework, but exp(710) will misbehave
-const inputs = [
+const f32_inputs = [
   0, // Returns 1 by definition
   -89, // Returns subnormal value
   kValue.f32.negative.min, // Closest to returning 0 as possible
@@ -31,12 +31,28 @@ const inputs = [
   ...linearRange(89, 709, 10), // Overflows f32, but not f64
 ];
 
+// floor(ln(max f16 value)) = 11, so exp(11) will be within range of a f16, but exp(12) will not
+const f16_inputs = [
+  0, // Returns 1 by definition
+  -12, // Returns subnormal value
+  kValue.f16.negative.min, // Closest to returning 0 as possible
+  ...biasedRange(kValue.f16.negative.max, -11, 100),
+  ...biasedRange(kValue.f16.positive.min, 11, 100),
+  ...linearRange(12, 709, 10), // Overflows f16, but not f64
+];
+
 export const d = makeCaseCache('exp', {
   f32_const: () => {
-    return FP.f32.generateScalarToIntervalCases(inputs, 'finite', FP.f32.expInterval);
+    return FP.f32.generateScalarToIntervalCases(f32_inputs, 'finite', FP.f32.expInterval);
   },
   f32_non_const: () => {
-    return FP.f32.generateScalarToIntervalCases(inputs, 'unfiltered', FP.f32.expInterval);
+    return FP.f32.generateScalarToIntervalCases(f32_inputs, 'unfiltered', FP.f32.expInterval);
+  },
+  f16_const: () => {
+    return FP.f16.generateScalarToIntervalCases(f16_inputs, 'finite', FP.f16.expInterval);
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarToIntervalCases(f16_inputs, 'unfiltered', FP.f16.expInterval);
   },
 });
 
@@ -65,4 +81,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('exp'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/exp2.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/exp2.spec.ts
index f4577d569d78..67e123cb3012 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/exp2.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/exp2.spec.ts
@@ -10,7 +10,7 @@ Returns 2 raised to the power e (e.g. 2^e). Component-wise when T is a vector.
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { kValue } from '../../../../../util/constants.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
 import { biasedRange, linearRange } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
@@ -22,7 +22,7 @@ export const g = makeTestGroup(GPUTest);
 
 // floor(log2(max f32 value)) = 127, so exp2(127) will be within range of a f32, but exp2(128) will not
 // floor(ln(max f64 value)) = 1023, so exp2(1023) can be handled by the testing framework, but exp2(1024) will misbehave
-const inputs = [
+const f32_inputs = [
   0, // Returns 1 by definition
   -128, // Returns subnormal value
   kValue.f32.negative.min, // Closest to returning 0 as possible
@@ -31,12 +31,28 @@ const inputs = [
   ...linearRange(128, 1023, 10), // Overflows f32, but not f64
 ];
 
+// floor(log2(max f16 value)) = 15, so exp2(15) will be within range of a f16, but exp2(15) will not
+const f16_inputs = [
+  0, // Returns 1 by definition
+  -16, // Returns subnormal value
+  kValue.f16.negative.min, // Closest to returning 0 as possible
+  ...biasedRange(kValue.f16.negative.max, -15, 100),
+  ...biasedRange(kValue.f16.positive.min, 15, 100),
+  ...linearRange(16, 1023, 10), // Overflows f16, but not f64
+];
+
 export const d = makeCaseCache('exp2', {
   f32_const: () => {
-    return FP.f32.generateScalarToIntervalCases(inputs, 'finite', FP.f32.exp2Interval);
+    return FP.f32.generateScalarToIntervalCases(f32_inputs, 'finite', FP.f32.exp2Interval);
   },
   f32_non_const: () => {
-    return FP.f32.generateScalarToIntervalCases(inputs, 'unfiltered', FP.f32.exp2Interval);
+    return FP.f32.generateScalarToIntervalCases(f32_inputs, 'unfiltered', FP.f32.exp2Interval);
+  },
+  f16_const: () => {
+    return FP.f16.generateScalarToIntervalCases(f16_inputs, 'finite', FP.f16.exp2Interval);
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarToIntervalCases(f16_inputs, 'unfiltered', FP.f16.exp2Interval);
   },
 });
 
@@ -65,4 +81,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('exp2'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 17b28b068664..5d8bf4452fe4 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -3219,7 +3219,9 @@ export abstract class FPTraits {
 
   private readonly ExpIntervalOp: ScalarToIntervalOp = {
     impl: (n: number): FPInterval => {
-      return this.ulpInterval(Math.exp(n), 3 + 2 * Math.abs(n));
+      assert(this.kind === 'f32' || this.kind === 'f16');
+      const ulp_error = this.kind === 'f32' ? 3 + 2 * Math.abs(n) : 1 + 2 * Math.abs(n);
+      return this.ulpInterval(Math.exp(n), ulp_error);
     },
   };
 
@@ -3232,7 +3234,9 @@ export abstract class FPTraits {
 
   private readonly Exp2IntervalOp: ScalarToIntervalOp = {
     impl: (n: number): FPInterval => {
-      return this.ulpInterval(Math.pow(2, n), 3 + 2 * Math.abs(n));
+      assert(this.kind === 'f32' || this.kind === 'f16');
+      const ulp_error = this.kind === 'f32' ? 3 + 2 * Math.abs(n) : 1 + 2 * Math.abs(n);
+      return this.ulpInterval(Math.pow(2, n), ulp_error);
     },
   };
 
@@ -5140,8 +5144,8 @@ class F16Traits extends FPTraits {
   public readonly distanceInterval = this.unimplementedDistance.bind(this);
   public readonly divisionInterval = this.divisionIntervalImpl.bind(this);
   public readonly dotInterval = this.dotIntervalImpl.bind(this);
-  public readonly expInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly exp2Interval = this.unimplementedScalarToInterval.bind(this);
+  public readonly expInterval = this.expIntervalImpl.bind(this);
+  public readonly exp2Interval = this.exp2IntervalImpl.bind(this);
   public readonly faceForwardIntervals = this.unimplementedFaceForward.bind(this);
   public readonly floorInterval = this.floorIntervalImpl.bind(this);
   public readonly fmaInterval = this.unimplementedScalarTripleToInterval.bind(this);

From cff8019fdd22c52e711ae90ed0659cf4ac0a8509 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 19 Sep 2023 12:10:14 -0400
Subject: [PATCH 048/166] wgsl: Add f16 `saturate` tests (#2964)

Issue #1635
---
 src/unittests/floating_point.spec.ts          | 88 +++++++++++++------
 src/webgpu/listing_meta.json                  |  4 +-
 .../expression/call/builtin/saturate.spec.ts  | 25 +++++-
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 83 insertions(+), 36 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index ecd4d99b3cb1..0795bef193b1 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3463,41 +3463,71 @@ g.test('roundInterval')
     );
   });
 
-g.test('saturateInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // Normals
-      { input: 0, expected: 0 },
-      { input: 1, expected: 1.0 },
-      { input: -0.1, expected: 0 },
-      { input: -1, expected: 0 },
-      { input: -10, expected: 0 },
-      { input: 0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] },  // ~0.1
-      { input: 10, expected: 1.0 },
-      { input: 11.1, expected: 1.0 },
-      { input: kValue.f32.positive.max, expected: 1.0 },
-      { input: kValue.f32.positive.min, expected: kValue.f32.positive.min },
-      { input: kValue.f32.negative.max, expected: 0.0 },
-      { input: kValue.f32.negative.min, expected: 0.0 },
+// Need to explicitly coerce expected value to IntervalBounds, because TS
+// doesn't correctly infer the type later.
+const kSaturateIntervalCases = {
+  f32: [
+    {
+      input: 0.1,
+      expected: [
+        kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)),
+        reinterpretU32AsF32(0x3dcccccd),
+      ],
+    }, // ~0.1
+  ] as ScalarToIntervalCase[],
+  f16: [
+    {
+      input: 0.1,
+      expected: [
+        reinterpretU16AsF16(0x2e66),
+        kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66)),
+      ],
+    }, // ~0.1
+  ] as ScalarToIntervalCase[],
+} as const;
 
-      // Subnormals
-      { input: kValue.f32.subnormal.positive.max, expected: [0.0, kValue.f32.subnormal.positive.max] },
-      { input: kValue.f32.subnormal.positive.min, expected: [0.0, kValue.f32.subnormal.positive.min] },
-      { input: kValue.f32.subnormal.negative.min, expected: [kValue.f32.subnormal.negative.min, 0.0] },
-      { input: kValue.f32.subnormal.negative.max, expected: [kValue.f32.subnormal.negative.max, 0.0] },
+g.test('saturateInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const constants = FP[p.trait].constants();
+        // prettier-ignore
+        return [
+          // Normals
+          { input: 0, expected: 0 },
+          { input: 1, expected: 1.0 },
+          { input: -0.1, expected: 0 },
+          { input: -1, expected: 0 },
+          { input: -10, expected: 0 },
+          { input: 10, expected: 1.0 },
+          { input: 11.1, expected: 1.0 },
+          { input: constants.positive.max, expected: 1.0 },
+          { input: constants.positive.min, expected: constants.positive.min },
+          { input: constants.negative.max, expected: 0.0 },
+          { input: constants.negative.min, expected: 0.0 },
 
-      // Infinities
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-    ]
+          // Subnormals
+          { input: constants.positive.subnormal.max, expected: [0.0, constants.positive.subnormal.max] },
+          { input: constants.positive.subnormal.min, expected: [0.0, constants.positive.subnormal.min] },
+          { input: constants.negative.subnormal.min, expected: [constants.negative.subnormal.min, 0.0] },
+          { input: constants.negative.subnormal.max, expected: [constants.negative.subnormal.max, 0.0] },
+
+          // Infinities
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          ...kSaturateIntervalCases[p.trait],
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.saturateInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.saturateInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.saturationInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.saturationInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index a68b5206970d..72a57b57cb36 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1312,9 +1312,9 @@
   "webgpu:shader,execution,expression,call,builtin,round:abstract_float:*": { "subcaseMS": 19.408 },
   "webgpu:shader,execution,expression,call,builtin,round:f16:*": { "subcaseMS": 30.509 },
   "webgpu:shader,execution,expression,call,builtin,round:f32:*": { "subcaseMS": 12.407 },
-  "webgpu:shader,execution,expression,call,builtin,saturate:abstract_float:*": { "subcaseMS": 24.607 },
+  "webgpu:shader,execution,expression,call,builtin,saturate:abstract_float:*": { "subcaseMS": 227.607 },
   "webgpu:shader,execution,expression,call,builtin,saturate:f16:*": { "subcaseMS": 23.407 },
-  "webgpu:shader,execution,expression,call,builtin,saturate:f32:*": { "subcaseMS": 12.444 },
+  "webgpu:shader,execution,expression,call,builtin,saturate:f32:*": { "subcaseMS": 116.275 },
   "webgpu:shader,execution,expression,call,builtin,select:scalar:*": { "subcaseMS": 6.882 },
   "webgpu:shader,execution,expression,call,builtin,select:vector:*": { "subcaseMS": 7.096 },
   "webgpu:shader,execution,expression,call,builtin,sign:abstract_float:*": { "subcaseMS": 31.708 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/saturate.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/saturate.spec.ts
index 3edd4d8cc73b..ad160b64f3cf 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/saturate.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/saturate.spec.ts
@@ -9,9 +9,9 @@ Returns clamp(e, 0.0, 1.0). Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF16, TypeF32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, linearRange } from '../../../../../util/math.js';
+import { fullF16Range, fullF32Range, linearRange } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -24,13 +24,24 @@ export const d = makeCaseCache('saturate', {
     return FP.f32.generateScalarToIntervalCases(
       [
         // Non-clamped values
-        ...linearRange(0.0, 1.0, 100),
+        ...linearRange(0.0, 1.0, 20),
         ...fullF32Range(),
       ],
       'unfiltered',
       FP.f32.saturateInterval
     );
   },
+  f16: () => {
+    return FP.f16.generateScalarToIntervalCases(
+      [
+        // Non-clamped values
+        ...linearRange(0.0, 1.0, 20),
+        ...fullF16Range(),
+      ],
+      'unfiltered',
+      FP.f16.saturateInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -58,4 +69,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('saturate'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 5d8bf4452fe4..47290cfd8f11 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5186,7 +5186,7 @@ class F16Traits extends FPTraits {
   public readonly refractInterval = this.unimplementedRefract.bind(this);
   public readonly remainderInterval = this.remainderIntervalImpl.bind(this);
   public readonly roundInterval = this.roundIntervalImpl.bind(this);
-  public readonly saturateInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly saturateInterval = this.saturateIntervalImpl.bind(this);
   public readonly signInterval = this.signIntervalImpl.bind(this);
   public readonly sinInterval = this.sinIntervalImpl.bind(this);
   public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this);

From 808711e03c3bac8a9a2d062dbb17806e0b396fe5 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 20 Sep 2023 13:29:33 +0800
Subject: [PATCH 049/166] wgsl: F16 unary conversion expression execution tests
 (#2965)

This PR add execution tests for f16 unary conversion expression,
and also add f16-to-f32 tests.

Issue: #2302
---
 src/webgpu/listing_meta.json                  |  10 +-
 .../expression/unary/f16_conversion.spec.ts   | 301 ++++++++++++++++++
 .../expression/unary/f32_conversion.spec.ts   | 216 +++++--------
 3 files changed, 397 insertions(+), 130 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/unary/f16_conversion.spec.ts

diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 72a57b57cb36..c762d7d5e283 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1443,9 +1443,17 @@
   "webgpu:shader,execution,expression,unary,bool_conversion:u32:*": { "subcaseMS": 7.401 },
   "webgpu:shader,execution,expression,unary,bool_logical:negation:*": { "subcaseMS": 6.413 },
   "webgpu:shader,execution,expression,unary,f16_arithmetic:negation:*": { "subcaseMS": 117.604 },
+  "webgpu:shader,execution,expression,unary,f16_conversion:bool:*": { "subcaseMS": 34.694 },
+  "webgpu:shader,execution,expression,unary,f16_conversion:f16:*": { "subcaseMS": 36.013 },
+  "webgpu:shader,execution,expression,unary,f16_conversion:f16_mat:*": { "subcaseMS": 47.109 },
+  "webgpu:shader,execution,expression,unary,f16_conversion:f32:*": { "subcaseMS": 30.900 },
+  "webgpu:shader,execution,expression,unary,f16_conversion:f32_mat:*": { "subcaseMS": 37.820 },
+  "webgpu:shader,execution,expression,unary,f16_conversion:i32:*": { "subcaseMS": 24.557 },
+  "webgpu:shader,execution,expression,unary,f16_conversion:u32:*": { "subcaseMS": 84.500 },
   "webgpu:shader,execution,expression,unary,f32_arithmetic:negation:*": { "subcaseMS": 16.400 },
   "webgpu:shader,execution,expression,unary,f32_conversion:bool:*": { "subcaseMS": 7.182 },
-  "webgpu:shader,execution,expression,unary,f32_conversion:f16:*": { "subcaseMS": 15.908 },
+  "webgpu:shader,execution,expression,unary,f32_conversion:f16:*": { "subcaseMS": 107.463 },
+  "webgpu:shader,execution,expression,unary,f32_conversion:f16_mat:*": { "subcaseMS": 60.170 },
   "webgpu:shader,execution,expression,unary,f32_conversion:f32:*": { "subcaseMS": 7.538 },
   "webgpu:shader,execution,expression,unary,f32_conversion:f32_mat:*": { "subcaseMS": 7.759 },
   "webgpu:shader,execution,expression,unary,f32_conversion:i32:*": { "subcaseMS": 7.701 },
diff --git a/src/webgpu/shader/execution/expression/unary/f16_conversion.spec.ts b/src/webgpu/shader/execution/expression/unary/f16_conversion.spec.ts
new file mode 100644
index 000000000000..9eb84f0270fc
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/unary/f16_conversion.spec.ts
@@ -0,0 +1,301 @@
+export const description = `
+Execution Tests for the f32 conversion operations
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import {
+  bool,
+  f16,
+  i32,
+  TypeBool,
+  TypeF32,
+  TypeF16,
+  TypeI32,
+  TypeMat,
+  TypeU32,
+  u32,
+} from '../../../../util/conversion.js';
+import { FP, FPInterval } from '../../../../util/floating_point.js';
+import {
+  fullF32Range,
+  fullF16Range,
+  fullI32Range,
+  fullU32Range,
+  sparseMatrixF32Range,
+  sparseMatrixF16Range,
+} from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { allInputSources, run, ShaderBuilder } from '../expression.js';
+
+import { unary } from './unary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+const f16FiniteRangeInterval = new FPInterval(
+  'f32',
+  FP.f16.constants().negative.min,
+  FP.f16.constants().positive.max
+);
+
+// Cases: f32_matCxR_[non_]const
+// Note that f32 values may be not exactly representable in f16 and/or out of range.
+const f32_mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`f32_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f32.generateMatrixToMatrixCases(
+            sparseMatrixF32Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f16.correctlyRoundedMatrix
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_matCxR_[non_]const
+const f16_mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`f16_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          // Input matrix is of f16 types, use f16.generateMatrixToMatrixCases.
+          return FP.f16.generateMatrixToMatrixCases(
+            sparseMatrixF16Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f16.correctlyRoundedMatrix
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('unary/f16_conversion', {
+  bool: () => {
+    return [
+      { input: bool(true), expected: f16(1.0) },
+      { input: bool(false), expected: f16(0.0) },
+    ];
+  },
+  u32_non_const: () => {
+    return [...fullU32Range(), 65504].map(u => {
+      return { input: u32(u), expected: FP.f16.correctlyRoundedInterval(u) };
+    });
+  },
+  u32_const: () => {
+    return [...fullU32Range(), 65504]
+      .filter(v => f16FiniteRangeInterval.contains(v))
+      .map(u => {
+        return { input: u32(u), expected: FP.f16.correctlyRoundedInterval(u) };
+      });
+  },
+  i32_non_const: () => {
+    return [...fullI32Range(), 65504, -65504].map(i => {
+      return { input: i32(i), expected: FP.f16.correctlyRoundedInterval(i) };
+    });
+  },
+  i32_const: () => {
+    return [...fullI32Range(), 65504, -65504]
+      .filter(v => f16FiniteRangeInterval.contains(v))
+      .map(i => {
+        return { input: i32(i), expected: FP.f16.correctlyRoundedInterval(i) };
+      });
+  },
+  // Note that f32 values may be not exactly representable in f16 and/or out of range.
+  f32_non_const: () => {
+    return FP.f32.generateScalarToIntervalCases(
+      [...fullF32Range(), 65535.996, -65535.996],
+      'unfiltered',
+      FP.f16.correctlyRoundedInterval
+    );
+  },
+  f32_const: () => {
+    return FP.f32.generateScalarToIntervalCases(
+      [...fullF32Range(), 65535.996, -65535.996],
+      'finite',
+      FP.f16.correctlyRoundedInterval
+    );
+  },
+  // All f16 values are exactly representable in f16.
+  f16: () => {
+    return fullF16Range().map(f => {
+      return { input: f16(f), expected: FP.f16.correctlyRoundedInterval(f) };
+    });
+  },
+  ...f32_mat_cases,
+  ...f16_mat_cases,
+});
+
+/** Generate a ShaderBuilder based on how the test case is to be vectorized */
+function vectorizeToExpression(vectorize: undefined | 2 | 3 | 4): ShaderBuilder {
+  return vectorize === undefined ? unary('f16') : unary(`vec${vectorize}<f16>`);
+}
+
+/** Generate a ShaderBuilder for a matrix of the provided dimensions */
+function matrixExperession(cols: number, rows: number): ShaderBuilder {
+  return unary(`mat${cols}x${rows}<f16>`);
+}
+
+g.test('bool')
+  .specURL('https://www.w3.org/TR/WGSL/#value-constructor-builtin-function')
+  .desc(
+    `
+f16(e), where e is a bool
+
+The result is 1.0 if e is true and 0.0 otherwise
+`
+  )
+  .params(u =>
+    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('bool');
+    await run(t, vectorizeToExpression(t.params.vectorize), [TypeBool], TypeF16, t.params, cases);
+  });
+
+g.test('u32')
+  .specURL('https://www.w3.org/TR/WGSL/#bool-builtin')
+  .desc(
+    `
+f16(e), where e is a u32
+
+Converted to f16, +/-Inf if out of range
+`
+  )
+  .params(u =>
+    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'u32_const' : 'u32_non_const');
+    await run(t, vectorizeToExpression(t.params.vectorize), [TypeU32], TypeF16, t.params, cases);
+  });
+
+g.test('i32')
+  .specURL('https://www.w3.org/TR/WGSL/#value-constructor-builtin-function')
+  .desc(
+    `
+f16(e), where e is a i32
+
+Converted to f16, +/-Inf if out of range
+`
+  )
+  .params(u =>
+    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'i32_const' : 'i32_non_const');
+    await run(t, vectorizeToExpression(t.params.vectorize), [TypeI32], TypeF16, t.params, cases);
+  });
+
+g.test('f32')
+  .specURL('https://www.w3.org/TR/WGSL/#value-constructor-builtin-function')
+  .desc(
+    `
+f16(e), where e is a f32
+
+Correctly rounded to f16
+`
+  )
+  .params(u =>
+    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f32_const' : 'f32_non_const');
+    await run(t, vectorizeToExpression(t.params.vectorize), [TypeF32], TypeF16, t.params, cases);
+  });
+
+g.test('f32_mat')
+  .specURL('https://www.w3.org/TR/WGSL/#matrix-builtin-functions')
+  .desc(`f32 matrix to f16 matrix tests`)
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `f32_mat${cols}x${rows}_const`
+        : `f32_mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      matrixExperession(cols, rows),
+      [TypeMat(cols, rows, TypeF32)],
+      TypeMat(cols, rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16')
+  .specURL('https://www.w3.org/TR/WGSL/#value-constructor-builtin-function')
+  .desc(
+    `
+  f16(e), where e is a f16
+
+  Identical.
+  `
+  )
+  .params(u =>
+    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, vectorizeToExpression(t.params.vectorize), [TypeF16], TypeF16, t.params, cases);
+  });
+
+g.test('f16_mat')
+  .specURL('https://www.w3.org/TR/WGSL/#matrix-builtin-functions')
+  .desc(`f16 matrix to f16 matrix tests, expected identical`)
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `f16_mat${cols}x${rows}_const`
+        : `f16_mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      matrixExperession(cols, rows),
+      [TypeMat(cols, rows, TypeF16)],
+      TypeMat(cols, rows, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/unary/f32_conversion.spec.ts b/src/webgpu/shader/execution/expression/unary/f32_conversion.spec.ts
index e192ae5a8692..223b13c2d554 100644
--- a/src/webgpu/shader/execution/expression/unary/f32_conversion.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/f32_conversion.spec.ts
@@ -7,9 +7,11 @@ import { GPUTest } from '../../../../gpu_test.js';
 import {
   bool,
   f32,
+  f16,
   i32,
   TypeBool,
   TypeF32,
+  TypeF16,
   TypeI32,
   TypeMat,
   TypeU32,
@@ -18,9 +20,11 @@ import {
 import { FP } from '../../../../util/floating_point.js';
 import {
   fullF32Range,
+  fullF16Range,
   fullI32Range,
   fullU32Range,
   sparseMatrixF32Range,
+  sparseMatrixF16Range,
 } from '../../../../util/math.js';
 import { makeCaseCache } from '../case_cache.js';
 import { allInputSources, run, ShaderBuilder } from '../expression.js';
@@ -29,6 +33,42 @@ import { unary } from './unary.js';
 
 export const g = makeTestGroup(GPUTest);
 
+// Cases: f32_matCxR_[non_]const
+const f32_mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`f32_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f32.generateMatrixToMatrixCases(
+            sparseMatrixF32Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f32.correctlyRoundedMatrix
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_matCxR_[non_]const
+// Note that all f16 values are exactly representable in f32.
+const f16_mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`f16_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          // Input matrix is of f16 types, use f16.generateMatrixToMatrixCases.
+          return FP.f16.generateMatrixToMatrixCases(
+            sparseMatrixF16Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f32.correctlyRoundedMatrix
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('unary/f32_conversion', {
   bool: () => {
     return [
@@ -51,132 +91,14 @@ export const d = makeCaseCache('unary/f32_conversion', {
       return { input: f32(f), expected: FP.f32.correctlyRoundedInterval(f) };
     });
   },
-  f32_mat2x2_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat2x2_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat2x3_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      'finite',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat2x3_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      'unfiltered',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat2x4_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      'finite',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat2x4_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      'unfiltered',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat3x2_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      'finite',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat3x2_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      'unfiltered',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat3x3_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      'finite',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat3x3_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      'unfiltered',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat3x4_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      'finite',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat3x4_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      'unfiltered',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat4x2_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      'finite',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat4x2_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      'unfiltered',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat4x3_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      'finite',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat4x3_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      'unfiltered',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat4x4_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      'finite',
-      FP.f32.correctlyRoundedMatrix
-    );
-  },
-  f32_mat4x4_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      'unfiltered',
-      FP.f32.correctlyRoundedMatrix
-    );
+  // All f16 values are exactly representable in f32.
+  f16: () => {
+    return fullF16Range().map(f => {
+      return { input: f16(f), expected: FP.f32.correctlyRoundedInterval(f) };
+    });
   },
+  ...f32_mat_cases,
+  ...f16_mat_cases,
 });
 
 /** Generate a ShaderBuilder based on how the test case is to be vectorized */
@@ -288,12 +210,48 @@ g.test('f16')
   .specURL('https://www.w3.org/TR/WGSL/#value-constructor-builtin-function')
   .desc(
     `
-i32(e), where e is a f16
+  f32(e), where e is a f16
 
-e is converted to u32, rounding towards zero
-`
+  Expect the same value, since all f16 values is exactly representable in f32.
+  `
   )
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, vectorizeToExpression(t.params.vectorize), [TypeF16], TypeF32, t.params, cases);
+  });
+
+g.test('f16_mat')
+  .specURL('https://www.w3.org/TR/WGSL/#matrix-builtin-functions')
+  .desc(`f16 matrix to f32 matrix tests`)
+  .params(u =>
+    u
+      .combine('inputSource', allInputSources)
+      .combine('cols', [2, 3, 4] as const)
+      .combine('rows', [2, 3, 4] as const)
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cols = t.params.cols;
+    const rows = t.params.rows;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `f16_mat${cols}x${rows}_const`
+        : `f16_mat${cols}x${rows}_non_const`
+    );
+    await run(
+      t,
+      matrixExperession(cols, rows),
+      [TypeMat(cols, rows, TypeF16)],
+      TypeMat(cols, rows, TypeF32),
+      t.params,
+      cases
+    );
+  });

From 3c422eb518e5c97eefde8a2b41b1f07c3480890c Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 20 Sep 2023 09:50:26 -0400
Subject: [PATCH 050/166] wgsl: Add interval names to unimplemented bindings
 (#2967)

Fixes #2966
---
 src/webgpu/util/floating_point.ts | 295 ++++++++++++++++++++----------
 1 file changed, 196 insertions(+), 99 deletions(-)

diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 47290cfd8f11..d740d51d5884 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -854,124 +854,138 @@ export abstract class FPTraits {
   }
 
   /** Stub for scalar to interval generator */
-  protected unimplementedScalarToInterval(_x: number | FPInterval): FPInterval {
-    unreachable(`Not yet implemented for ${this.kind}`);
+  protected unimplementedScalarToInterval(name: string, _x: number | FPInterval): FPInterval {
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for scalar pair to interval generator */
   protected unimplementedScalarPairToInterval(
+    name: string,
     _x: number | FPInterval,
     _y: number | FPInterval
   ): FPInterval {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is yet implemented for '${this.kind}'`);
   }
 
   /** Stub for scalar triple to interval generator */
   protected unimplementedScalarTripleToInterval(
+    name: string,
     _x: number | FPInterval,
     _y: number | FPInterval,
     _z: number | FPInterval
   ): FPInterval {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for scalar to vector generator */
-  protected unimplementedScalarToVector(_x: number | FPInterval): FPVector {
-    unreachable(`Not yet implemented for ${this.kind}`);
+  protected unimplementedScalarToVector(name: string, _x: number | FPInterval): FPVector {
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for vector to interval generator */
-  protected unimplementedVectorToInterval(_x: (number | FPInterval)[]): FPInterval {
-    unreachable(`Not yet implemented for ${this.kind}`);
+  protected unimplementedVectorToInterval(name: string, _x: (number | FPInterval)[]): FPInterval {
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for vector pair to interval generator */
   protected unimplementedVectorPairToInterval(
+    name: string,
     _x: (number | FPInterval)[],
     _y: (number | FPInterval)[]
   ): FPInterval {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for vector to vector generator */
-  protected unimplementedVectorToVector(_x: (number | FPInterval)[]): FPVector {
-    unreachable(`Not yet implemented for ${this.kind}`);
+  protected unimplementedVectorToVector(name: string, _x: (number | FPInterval)[]): FPVector {
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for vector pair to vector generator */
   protected unimplementedVectorPairToVector(
+    name: string,
     _x: (number | FPInterval)[],
     _y: (number | FPInterval)[]
   ): FPVector {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for vector-scalar to vector generator */
   protected unimplementedVectorScalarToVector(
+    name: string,
     _x: (number | FPInterval)[],
     _y: number | FPInterval
   ): FPVector {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for scalar-vector to vector generator */
   protected unimplementedScalarVectorToVector(
+    name: string,
     _x: number | FPInterval,
     _y: (number | FPInterval)[]
   ): FPVector {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for matrix to interval generator */
-  protected unimplementedMatrixToInterval(_x: Array2D<number>): FPInterval {
-    unreachable(`Not yet implemented for ${this.kind}`);
+  protected unimplementedMatrixToInterval(name: string, _x: Array2D<number>): FPInterval {
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
-  /** Stub for matrix to matix generator */
-  protected unimplementedMatrixToMatrix(_x: Array2D<number>): FPMatrix {
-    unreachable(`Not yet implemented for ${this.kind}`);
+  /** Stub for matrix to matirx generator */
+  protected unimplementedMatrixToMatrix(name: string, _x: Array2D<number>): FPMatrix {
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for matrix pair to matrix generator */
-  protected unimplementedMatrixPairToMatrix(_x: Array2D<number>, _y: Array2D<number>): FPMatrix {
-    unreachable(`Not yet implemented for ${this.kind}`);
+  protected unimplementedMatrixPairToMatrix(
+    name: string,
+    _x: Array2D<number>,
+    _y: Array2D<number>
+  ): FPMatrix {
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for matrix-scalar to matrix generator  */
   protected unimplementedMatrixScalarToMatrix(
+    name: string,
     _x: Array2D<number>,
     _y: number | FPInterval
   ): FPMatrix {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for scalar-matrix to matrix generator  */
   protected unimplementedScalarMatrixToMatrix(
+    name: string,
     _x: number | FPInterval,
     _y: Array2D<number>
   ): FPMatrix {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for matrix-vector to vector generator  */
   protected unimplementedMatrixVectorToVector(
+    name: string,
     _x: Array2D<number>,
     _y: (number | FPInterval)[]
   ): FPVector {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for vector-matrix to vector generator  */
   protected unimplementedVectorMatrixToVector(
+    name: string,
     _x: (number | FPInterval)[],
     _y: Array2D<number>
   ): FPVector {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for distance generator */
   protected unimplementedDistance(_x: number | number[], _y: number | number[]): FPInterval {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'distance' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for faceForward */
@@ -980,22 +994,22 @@ export abstract class FPTraits {
     _y: number[],
     _z: number[]
   ): (FPVector | undefined)[] {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'faceForward' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for length generator */
   protected unimplementedLength(_x: number | FPInterval | number[] | FPVector): FPInterval {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'length' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for modf generator */
   protected unimplementedModf(_x: number): { fract: FPInterval; whole: FPInterval } {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'modf' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for refract generator */
   protected unimplementedRefract(_i: number[], _s: number[], _r: number): FPVector {
-    unreachable(`Not yet implemented for ${this.kind}`);
+    unreachable(`'refract' is not yet implemented for '${this.kind}'`);
   }
 
   /** Version of absoluteErrorInterval that always returns the unboundedInterval */
@@ -4834,84 +4848,140 @@ class FPAbstractTraits extends FPTraits {
 
   // Framework - API - Overrides
   public readonly absInterval = this.absIntervalImpl.bind(this);
-  public readonly acosInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly acoshAlternativeInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly acoshPrimaryInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly acosInterval = this.unimplementedScalarToInterval.bind(this, 'acosInterval');
+  public readonly acoshAlternativeInterval = this.unimplementedScalarToInterval.bind(
+    this,
+    'acoshAlternativeInterval'
+  );
+  public readonly acoshPrimaryInterval = this.unimplementedScalarToInterval.bind(
+    this,
+    'acoshPrimaryInterval'
+  );
   public readonly acoshIntervals = [this.acoshAlternativeInterval, this.acoshPrimaryInterval];
   public readonly additionInterval = this.additionIntervalImpl.bind(this);
   public readonly additionMatrixMatrixInterval = this.additionMatrixMatrixIntervalImpl.bind(this);
-  public readonly asinInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly asinhInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly atanInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly atan2Interval = this.unimplementedScalarPairToInterval.bind(this);
-  public readonly atanhInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly ceilInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly clampMedianInterval = this.unimplementedScalarTripleToInterval.bind(this);
-  public readonly clampMinMaxInterval = this.unimplementedScalarTripleToInterval.bind(this);
+  public readonly asinInterval = this.unimplementedScalarToInterval.bind(this, 'asinInterval');
+  public readonly asinhInterval = this.unimplementedScalarToInterval.bind(this, 'asinhInterval');
+  public readonly atanInterval = this.unimplementedScalarToInterval.bind(this, 'atanInterval');
+  public readonly atan2Interval = this.unimplementedScalarPairToInterval.bind(
+    this,
+    'atan2Interval'
+  );
+  public readonly atanhInterval = this.unimplementedScalarToInterval.bind(this, 'atanhInterval');
+  public readonly ceilInterval = this.unimplementedScalarToInterval.bind(this, 'ceilInterval');
+  public readonly clampMedianInterval = this.unimplementedScalarTripleToInterval.bind(
+    this,
+    'clampMedianInterval'
+  );
+  public readonly clampMinMaxInterval = this.unimplementedScalarTripleToInterval.bind(
+    this,
+    'clampMinMaxInterval'
+  );
   public readonly clampIntervals = [this.clampMedianInterval, this.clampMinMaxInterval];
-  public readonly cosInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly coshInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly crossInterval = this.unimplementedVectorPairToVector.bind(this);
+  public readonly cosInterval = this.unimplementedScalarToInterval.bind(this, 'cosInterval');
+  public readonly coshInterval = this.unimplementedScalarToInterval.bind(this, 'coshInterval');
+  public readonly crossInterval = this.unimplementedVectorPairToVector.bind(this, 'crossInterval');
   public readonly degreesInterval = this.degreesIntervalImpl.bind(this);
-  public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(this);
+  public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(
+    this,
+    'determinantInterval'
+  );
   public readonly distanceInterval = this.unimplementedDistance.bind(this);
-  public readonly divisionInterval = this.unimplementedScalarPairToInterval.bind(this);
-  public readonly dotInterval = this.unimplementedVectorPairToInterval.bind(this);
-  public readonly expInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly exp2Interval = this.unimplementedScalarToInterval.bind(this);
+  public readonly divisionInterval = this.unimplementedScalarPairToInterval.bind(
+    this,
+    'divisionInterval'
+  );
+  public readonly dotInterval = this.unimplementedVectorPairToInterval.bind(this, 'dotInterval');
+  public readonly expInterval = this.unimplementedScalarToInterval.bind(this, 'expInterval');
+  public readonly exp2Interval = this.unimplementedScalarToInterval.bind(this, 'exp2Interval');
   public readonly faceForwardIntervals = this.unimplementedFaceForward.bind(this);
-  public readonly floorInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly fmaInterval = this.unimplementedScalarTripleToInterval.bind(this);
-  public readonly fractInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly inverseSqrtInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly ldexpInterval = this.unimplementedScalarPairToInterval.bind(this);
+  public readonly floorInterval = this.unimplementedScalarToInterval.bind(this, 'floorInterval');
+  public readonly fmaInterval = this.unimplementedScalarTripleToInterval.bind(this, 'fmaInterval');
+  public readonly fractInterval = this.unimplementedScalarToInterval.bind(this, 'fractInterval');
+  public readonly inverseSqrtInterval = this.unimplementedScalarToInterval.bind(
+    this,
+    'inverseSqrtInterval'
+  );
+  public readonly ldexpInterval = this.unimplementedScalarPairToInterval.bind(
+    this,
+    'ldexpInterval'
+  );
   public readonly lengthInterval = this.unimplementedLength.bind(this);
-  public readonly logInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly log2Interval = this.unimplementedScalarToInterval.bind(this);
-  public readonly maxInterval = this.unimplementedScalarPairToInterval.bind(this);
-  public readonly minInterval = this.unimplementedScalarPairToInterval.bind(this);
-  public readonly mixImpreciseInterval = this.unimplementedScalarTripleToInterval.bind(this);
-  public readonly mixPreciseInterval = this.unimplementedScalarTripleToInterval.bind(this);
+  public readonly logInterval = this.unimplementedScalarToInterval.bind(this, 'logInterval');
+  public readonly log2Interval = this.unimplementedScalarToInterval.bind(this, 'log2Interval');
+  public readonly maxInterval = this.unimplementedScalarPairToInterval.bind(this, 'maxInterval');
+  public readonly minInterval = this.unimplementedScalarPairToInterval.bind(this, 'minInterval');
+  public readonly mixImpreciseInterval = this.unimplementedScalarTripleToInterval.bind(
+    this,
+    'mixImpreciseInterval'
+  );
+  public readonly mixPreciseInterval = this.unimplementedScalarTripleToInterval.bind(
+    this,
+    'mixPreciseInterval'
+  );
   public readonly mixIntervals = [this.mixImpreciseInterval, this.mixPreciseInterval];
   public readonly modfInterval = this.unimplementedModf.bind(this);
   public readonly multiplicationInterval = this.multiplicationIntervalImpl.bind(this);
   public readonly multiplicationMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(
-    this
+    this,
+    'multiplicationMatrixMatrixInterval'
   );
   public readonly multiplicationMatrixScalarInterval = this.unimplementedMatrixScalarToMatrix.bind(
-    this
+    this,
+    'multiplicationMatrixScalarInterval'
   );
   public readonly multiplicationScalarMatrixInterval = this.unimplementedScalarMatrixToMatrix.bind(
-    this
+    this,
+    'multiplicationScalarMatrixInterval'
   );
   public readonly multiplicationMatrixVectorInterval = this.unimplementedMatrixVectorToVector.bind(
-    this
+    this,
+    'multiplicationMatrixVectorInterval'
   );
   public readonly multiplicationVectorMatrixInterval = this.unimplementedVectorMatrixToVector.bind(
-    this
+    this,
+    'multiplicationVectorMatrixInterval'
   );
   public readonly negationInterval = this.negationIntervalImpl.bind(this);
-  public readonly normalizeInterval = this.unimplementedVectorToVector.bind(this);
-  public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this);
-  public readonly quantizeToF16Interval = this.unimplementedScalarToInterval.bind(this);
+  public readonly normalizeInterval = this.unimplementedVectorToVector.bind(
+    this,
+    'normalizeInterval'
+  );
+  public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this, 'powInterval');
+  public readonly quantizeToF16Interval = this.unimplementedScalarToInterval.bind(
+    this,
+    'quantizeToF16Interval'
+  );
   public readonly radiansInterval = this.radiansIntervalImpl.bind(this);
-  public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(this);
+  public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(
+    this,
+    'reflectInterval'
+  );
   public readonly refractInterval = this.unimplementedRefract.bind(this);
-  public readonly remainderInterval = this.unimplementedScalarPairToInterval.bind(this);
-  public readonly roundInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly saturateInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly signInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly sinInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly smoothStepInterval = this.unimplementedScalarTripleToInterval.bind(this);
-  public readonly sqrtInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly stepInterval = this.unimplementedScalarPairToInterval.bind(this);
+  public readonly remainderInterval = this.unimplementedScalarPairToInterval.bind(
+    this,
+    'remainderInterval'
+  );
+  public readonly roundInterval = this.unimplementedScalarToInterval.bind(this, 'roundInterval');
+  public readonly saturateInterval = this.unimplementedScalarToInterval.bind(
+    this,
+    'saturateInterval'
+  );
+  public readonly signInterval = this.unimplementedScalarToInterval.bind(this, 'signInterval');
+  public readonly sinInterval = this.unimplementedScalarToInterval.bind(this, 'sinInterval');
+  public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this, 'sinhInterval');
+  public readonly smoothStepInterval = this.unimplementedScalarTripleToInterval.bind(
+    this,
+    'smoothStepInterval'
+  );
+  public readonly sqrtInterval = this.unimplementedScalarToInterval.bind(this, 'sqrtInterval');
+  public readonly stepInterval = this.unimplementedScalarPairToInterval.bind(this, 'stepInterval');
   public readonly subtractionInterval = this.subtractionIntervalImpl.bind(this);
   public readonly subtractionMatrixMatrixInterval = this.subtractionMatrixMatrixIntervalImpl.bind(
     this
   );
-  public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly tanInterval = this.unimplementedScalarToInterval.bind(this, 'tanInterval');
+  public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this, 'tanhInterval');
   public readonly transposeInterval = this.transposeIntervalImpl.bind(this);
   public readonly truncInterval = this.truncIntervalImpl.bind(this);
 }
@@ -5122,25 +5192,34 @@ class F16Traits extends FPTraits {
   // Framework - API - Overrides
   public readonly absInterval = this.absIntervalImpl.bind(this);
   public readonly acosInterval = this.acosIntervalImpl.bind(this);
-  public readonly acoshAlternativeInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly acoshPrimaryInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly acoshAlternativeInterval = this.unimplementedScalarToInterval.bind(
+    this,
+    'acoshAlternativeInterval'
+  );
+  public readonly acoshPrimaryInterval = this.unimplementedScalarToInterval.bind(
+    this,
+    'acoshPrimaryInterval'
+  );
   public readonly acoshIntervals = [this.acoshAlternativeInterval, this.acoshPrimaryInterval];
   public readonly additionInterval = this.additionIntervalImpl.bind(this);
   public readonly additionMatrixMatrixInterval = this.additionMatrixMatrixIntervalImpl.bind(this);
   public readonly asinInterval = this.asinIntervalImpl.bind(this);
-  public readonly asinhInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly asinhInterval = this.unimplementedScalarToInterval.bind(this, 'asinhInterval');
   public readonly atanInterval = this.atanIntervalImpl.bind(this);
   public readonly atan2Interval = this.atan2IntervalImpl.bind(this);
-  public readonly atanhInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly atanhInterval = this.unimplementedScalarToInterval.bind(this, 'atanhInterval');
   public readonly ceilInterval = this.ceilIntervalImpl.bind(this);
   public readonly clampMedianInterval = this.clampMedianIntervalImpl.bind(this);
   public readonly clampMinMaxInterval = this.clampMinMaxIntervalImpl.bind(this);
   public readonly clampIntervals = [this.clampMedianInterval, this.clampMinMaxInterval];
   public readonly cosInterval = this.cosIntervalImpl.bind(this);
-  public readonly coshInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly crossInterval = this.unimplementedVectorPairToVector.bind(this);
+  public readonly coshInterval = this.unimplementedScalarToInterval.bind(this, 'coshInterval');
+  public readonly crossInterval = this.unimplementedVectorPairToVector.bind(this, 'crossInterval');
   public readonly degreesInterval = this.degreesIntervalImpl.bind(this);
-  public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(this);
+  public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(
+    this,
+    'determinantInterval'
+  );
   public readonly distanceInterval = this.unimplementedDistance.bind(this);
   public readonly divisionInterval = this.divisionIntervalImpl.bind(this);
   public readonly dotInterval = this.dotIntervalImpl.bind(this);
@@ -5148,17 +5227,26 @@ class F16Traits extends FPTraits {
   public readonly exp2Interval = this.exp2IntervalImpl.bind(this);
   public readonly faceForwardIntervals = this.unimplementedFaceForward.bind(this);
   public readonly floorInterval = this.floorIntervalImpl.bind(this);
-  public readonly fmaInterval = this.unimplementedScalarTripleToInterval.bind(this);
-  public readonly fractInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly fmaInterval = this.unimplementedScalarTripleToInterval.bind(this, 'fmaInterval');
+  public readonly fractInterval = this.unimplementedScalarToInterval.bind(this, 'fractInterval');
   public readonly inverseSqrtInterval = this.inverseSqrtIntervalImpl.bind(this);
-  public readonly ldexpInterval = this.unimplementedScalarPairToInterval.bind(this);
+  public readonly ldexpInterval = this.unimplementedScalarPairToInterval.bind(
+    this,
+    'ldexpInterval'
+  );
   public readonly lengthInterval = this.unimplementedLength.bind(this);
   public readonly logInterval = this.logIntervalImpl.bind(this);
   public readonly log2Interval = this.log2IntervalImpl.bind(this);
   public readonly maxInterval = this.maxIntervalImpl.bind(this);
   public readonly minInterval = this.minIntervalImpl.bind(this);
-  public readonly mixImpreciseInterval = this.unimplementedScalarTripleToInterval.bind(this);
-  public readonly mixPreciseInterval = this.unimplementedScalarTripleToInterval.bind(this);
+  public readonly mixImpreciseInterval = this.unimplementedScalarTripleToInterval.bind(
+    this,
+    'mixImpreciseInterval'
+  );
+  public readonly mixPreciseInterval = this.unimplementedScalarTripleToInterval.bind(
+    this,
+    'mixPreciseInterval'
+  );
   public readonly mixIntervals = [this.mixImpreciseInterval, this.mixPreciseInterval];
   public readonly modfInterval = this.unimplementedModf.bind(this);
   public readonly multiplicationInterval = this.multiplicationIntervalImpl.bind(this);
@@ -5178,27 +5266,36 @@ class F16Traits extends FPTraits {
     this
   );
   public readonly negationInterval = this.negationIntervalImpl.bind(this);
-  public readonly normalizeInterval = this.unimplementedVectorToVector.bind(this);
-  public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this);
+  public readonly normalizeInterval = this.unimplementedVectorToVector.bind(
+    this,
+    'normalizeInterval'
+  );
+  public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this, 'powInterval');
   public readonly quantizeToF16Interval = this.quantizeToF16IntervalNotAvailable.bind(this);
   public readonly radiansInterval = this.radiansIntervalImpl.bind(this);
-  public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(this);
+  public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(
+    this,
+    'reflectInterval'
+  );
   public readonly refractInterval = this.unimplementedRefract.bind(this);
   public readonly remainderInterval = this.remainderIntervalImpl.bind(this);
   public readonly roundInterval = this.roundIntervalImpl.bind(this);
   public readonly saturateInterval = this.saturateIntervalImpl.bind(this);
   public readonly signInterval = this.signIntervalImpl.bind(this);
   public readonly sinInterval = this.sinIntervalImpl.bind(this);
-  public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly smoothStepInterval = this.unimplementedScalarTripleToInterval.bind(this);
+  public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this, 'sinhInterval');
+  public readonly smoothStepInterval = this.unimplementedScalarTripleToInterval.bind(
+    this,
+    'smoothStepInterval'
+  );
   public readonly sqrtInterval = this.sqrtIntervalImpl.bind(this);
   public readonly stepInterval = this.stepIntervalImpl.bind(this);
   public readonly subtractionInterval = this.subtractionIntervalImpl.bind(this);
   public readonly subtractionMatrixMatrixInterval = this.subtractionMatrixMatrixIntervalImpl.bind(
     this
   );
-  public readonly tanInterval = this.unimplementedScalarToInterval.bind(this);
-  public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this);
+  public readonly tanInterval = this.unimplementedScalarToInterval.bind(this, 'tanInterval');
+  public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this, 'tanhInterval');
   public readonly transposeInterval = this.transposeIntervalImpl.bind(this);
   public readonly truncInterval = this.truncIntervalImpl.bind(this);
 

From 86e342fa8a2fac68f7bc7a70144da904e527f02d Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 20 Sep 2023 10:30:41 -0400
Subject: [PATCH 051/166] wgsl: Add AbstractFloat `max` execution tests (#2971)

Fixes #2968
---
 src/unittests/floating_point.spec.ts          | 10 ++++-
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/max.spec.ts       | 40 ++++++++++++++++---
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 0795bef193b1..15edda774025 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -4310,12 +4310,20 @@ const kMaxInterval64BitsCases = {
     { input: [-0.1, 0.1], expected: [reinterpretU16AsF16(0x2e66), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66))] },  // ~0.1
     { input: [-0.1, -0.1], expected: [reinterpretU16AsF16(0xae67), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xae67))] },  // ~-0.1
   ] as ScalarPairToIntervalCase[],
+  abstract: [
+    { input: [0.1, 0], expected: 0.1 },
+    { input: [0, 0.1], expected: 0.1 },
+    { input: [0.1, 0.1], expected: 0.1 },
+    { input: [0.1, -0.1], expected: 0.1 },
+    { input: [-0.1, 0.1], expected: 0.1 },
+    { input: [-0.1, -0.1], expected: -0.1 },
+  ] as ScalarPairToIntervalCase[],
 } as const;
 
 g.test('maxInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarPairToIntervalCase>(p => {
         const trait = FP[p.trait];
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index c762d7d5e283..9d08c08d1fb4 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1246,7 +1246,7 @@
   "webgpu:shader,execution,expression,call,builtin,log:abstract_float:*": { "subcaseMS": 17.911 },
   "webgpu:shader,execution,expression,call,builtin,log:f16:*": { "subcaseMS": 8.603 },
   "webgpu:shader,execution,expression,call,builtin,log:f32:*": { "subcaseMS": 26.725 },
-  "webgpu:shader,execution,expression,call,builtin,max:abstract_float:*": { "subcaseMS": 25.508 },
+  "webgpu:shader,execution,expression,call,builtin,max:abstract_float:*": { "subcaseMS": 2810.001 },
   "webgpu:shader,execution,expression,call,builtin,max:abstract_int:*": { "subcaseMS": 33.508 },
   "webgpu:shader,execution,expression,call,builtin,max:f16:*": { "subcaseMS": 37.404 },
   "webgpu:shader,execution,expression,call,builtin,max:f32:*": { "subcaseMS": 300.619 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/max.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/max.spec.ts
index eae99ee598ad..6654b4951ce7 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/max.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/max.spec.ts
@@ -18,13 +18,21 @@ Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { i32, TypeF32, TypeF16, TypeI32, TypeU32, u32 } from '../../../../../util/conversion.js';
+import {
+  i32,
+  TypeF32,
+  TypeF16,
+  TypeI32,
+  TypeU32,
+  u32,
+  TypeAbstractFloat,
+} from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range, sparseF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, Case, run } from '../../expression.js';
+import { allInputSources, Case, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 /** Generate set of max test cases from list of interesting values */
 function generateTestCases(
@@ -59,6 +67,14 @@ export const d = makeCaseCache('max', {
       FP.f16.maxInterval
     );
   },
+  abstract: () => {
+    return FP.abstract.generateScalarPairToIntervalCases(
+      sparseF64Range(),
+      sparseF64Range(),
+      'unfiltered',
+      FP.abstract.maxInterval
+    );
+  },
 });
 
 g.test('abstract_int')
@@ -107,9 +123,21 @@ g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(
+      t,
+      abstractBuiltin('max'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index d740d51d5884..6c919bcba387 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4909,7 +4909,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly lengthInterval = this.unimplementedLength.bind(this);
   public readonly logInterval = this.unimplementedScalarToInterval.bind(this, 'logInterval');
   public readonly log2Interval = this.unimplementedScalarToInterval.bind(this, 'log2Interval');
-  public readonly maxInterval = this.unimplementedScalarPairToInterval.bind(this, 'maxInterval');
+  public readonly maxInterval = this.maxIntervalImpl.bind(this);
   public readonly minInterval = this.unimplementedScalarPairToInterval.bind(this, 'minInterval');
   public readonly mixImpreciseInterval = this.unimplementedScalarTripleToInterval.bind(
     this,

From efed3d8878fcaa5c72c25f51b73b7e5a83d21ce0 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 20 Sep 2023 11:51:14 -0400
Subject: [PATCH 052/166] wgsl: Add AbstractFloat `min` execution tests (#2972)

Fixes #2969
---
 src/unittests/floating_point.spec.ts          | 10 ++++-
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/min.spec.ts       | 40 ++++++++++++++++---
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 15edda774025..0f3d0fddbf09 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -4401,12 +4401,20 @@ const kMinInterval64BitsCases = {
     { input: [-0.1, 0.1], expected: [reinterpretU16AsF16(0xae67), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xae67))] },  // ~-0.1
     { input: [-0.1, -0.1], expected: [reinterpretU16AsF16(0xae67), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xae67))] },  // ~-0.1
   ] as ScalarPairToIntervalCase[],
+  abstract: [
+    { input: [-0.1, 0], expected: -0.1 },
+    { input: [0, -0.1], expected: -0.1 },
+    { input: [0.1, 0.1], expected: 0.1 },
+    { input: [0.1, -0.1], expected: -0.1 },
+    { input: [-0.1, 0.1], expected: -0.1 },
+    { input: [-0.1, -0.1], expected: -0.1 },
+  ] as ScalarPairToIntervalCase[],
 } as const;
 
 g.test('minInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarPairToIntervalCase>(p => {
         const trait = FP[p.trait];
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 9d08c08d1fb4..e3ad7551f3c6 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1252,7 +1252,7 @@
   "webgpu:shader,execution,expression,call,builtin,max:f32:*": { "subcaseMS": 300.619 },
   "webgpu:shader,execution,expression,call,builtin,max:i32:*": { "subcaseMS": 7.350 },
   "webgpu:shader,execution,expression,call,builtin,max:u32:*": { "subcaseMS": 6.700 },
-  "webgpu:shader,execution,expression,call,builtin,min:abstract_float:*": { "subcaseMS": 30.405 },
+  "webgpu:shader,execution,expression,call,builtin,min:abstract_float:*": { "subcaseMS": 3054.101 },
   "webgpu:shader,execution,expression,call,builtin,min:abstract_int:*": { "subcaseMS": 19.806 },
   "webgpu:shader,execution,expression,call,builtin,min:f16:*": { "subcaseMS": 8.006 },
   "webgpu:shader,execution,expression,call,builtin,min:f32:*": { "subcaseMS": 298.463 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/min.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/min.spec.ts
index 69d8af3efc05..6c05319546dc 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/min.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/min.spec.ts
@@ -17,13 +17,21 @@ Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { i32, TypeF32, TypeF16, TypeI32, TypeU32, u32 } from '../../../../../util/conversion.js';
+import {
+  i32,
+  TypeF32,
+  TypeF16,
+  TypeI32,
+  TypeU32,
+  u32,
+  TypeAbstractFloat,
+} from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range, sparseF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, Case, run } from '../../expression.js';
+import { allInputSources, Case, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -44,6 +52,14 @@ export const d = makeCaseCache('min', {
       FP.f16.minInterval
     );
   },
+  abstract: () => {
+    return FP.abstract.generateScalarPairToIntervalCases(
+      sparseF64Range(),
+      sparseF64Range(),
+      'unfiltered',
+      FP.abstract.minInterval
+    );
+  },
 });
 
 /** Generate set of min test cases from list of interesting values */
@@ -106,9 +122,21 @@ g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(
+      t,
+      abstractBuiltin('min'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 6c919bcba387..50acda38e3e4 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4910,7 +4910,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly logInterval = this.unimplementedScalarToInterval.bind(this, 'logInterval');
   public readonly log2Interval = this.unimplementedScalarToInterval.bind(this, 'log2Interval');
   public readonly maxInterval = this.maxIntervalImpl.bind(this);
-  public readonly minInterval = this.unimplementedScalarPairToInterval.bind(this, 'minInterval');
+  public readonly minInterval = this.minIntervalImpl.bind(this);
   public readonly mixImpreciseInterval = this.unimplementedScalarTripleToInterval.bind(
     this,
     'mixImpreciseInterval'

From 52981ae8a5a2ed4f69f6f3972049e19a315d0ddd Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 20 Sep 2023 12:17:09 -0400
Subject: [PATCH 053/166] wgsl: Add AbstractFloat `clamp` execution tests
 (#2973)

Fixes #2970
---
 src/unittests/floating_point.spec.ts          |  4 +--
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/clamp.spec.ts     | 36 +++++++++++++++----
 src/webgpu/util/floating_point.ts             | 10 ++----
 4 files changed, 34 insertions(+), 18 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 0f3d0fddbf09..58cf3fed75bc 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -4906,7 +4906,7 @@ interface ScalarTripleToIntervalCase {
 g.test('clampMedianInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarTripleToIntervalCase>(p => {
         const trait = FP[p.trait];
@@ -4964,7 +4964,7 @@ g.test('clampMedianInterval')
 g.test('clampMinMaxInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarTripleToIntervalCase>(p => {
         const trait = FP[p.trait];
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index e3ad7551f3c6..1542aa9e7a57 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1133,7 +1133,7 @@
   "webgpu:shader,execution,expression,call,builtin,ceil:abstract_float:*": { "subcaseMS": 23.611 },
   "webgpu:shader,execution,expression,call,builtin,ceil:f16:*": { "subcaseMS": 29.209 },
   "webgpu:shader,execution,expression,call,builtin,ceil:f32:*": { "subcaseMS": 11.132 },
-  "webgpu:shader,execution,expression,call,builtin,clamp:abstract_float:*": { "subcaseMS": 28.706 },
+  "webgpu:shader,execution,expression,call,builtin,clamp:abstract_float:*": { "subcaseMS": 11800.350 },
   "webgpu:shader,execution,expression,call,builtin,clamp:abstract_int:*": { "subcaseMS": 18.104 },
   "webgpu:shader,execution,expression,call,builtin,clamp:f16:*": { "subcaseMS": 32.809 },
   "webgpu:shader,execution,expression,call,builtin,clamp:f32:*": { "subcaseMS": 159.926 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts
index a7fb74d56e89..47aa4604498f 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts
@@ -16,13 +16,20 @@ Component-wise when T is a vector.
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { kValue } from '../../../../../util/constants.js';
-import { ScalarType, TypeF32, TypeF16, TypeI32, TypeU32 } from '../../../../../util/conversion.js';
+import {
+  ScalarType,
+  TypeF32,
+  TypeF16,
+  TypeI32,
+  TypeU32,
+  TypeAbstractFloat,
+} from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseF32Range, sparseF16Range } from '../../../../../util/math.js';
+import { sparseF32Range, sparseF16Range, sparseF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, Case, run } from '../../expression.js';
+import { allInputSources, Case, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -66,6 +73,9 @@ export const d = makeCaseCache('clamp', {
   f16_non_const: () => {
     return generateFloatTestCases(sparseF16Range(), 'f16', 'non-const');
   },
+  abstract: () => {
+    return generateFloatTestCases(sparseF64Range(), 'abstract', 'const');
+  },
 });
 
 /** @returns a set of clamp test cases from an ascending list of integer values */
@@ -88,7 +98,7 @@ function generateIntegerTestCases(
 
 function generateFloatTestCases(
   test_values: Array<number>,
-  trait: 'f32' | 'f16',
+  trait: 'f32' | 'f16' | 'abstract',
   stage: 'const' | 'non-const'
 ): Array<Case> {
   return test_values.flatMap(low =>
@@ -143,9 +153,21 @@ g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(
+      t,
+      abstractBuiltin('clamp'),
+      [TypeAbstractFloat, TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 50acda38e3e4..5692fb4098de 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4869,14 +4869,8 @@ class FPAbstractTraits extends FPTraits {
   );
   public readonly atanhInterval = this.unimplementedScalarToInterval.bind(this, 'atanhInterval');
   public readonly ceilInterval = this.unimplementedScalarToInterval.bind(this, 'ceilInterval');
-  public readonly clampMedianInterval = this.unimplementedScalarTripleToInterval.bind(
-    this,
-    'clampMedianInterval'
-  );
-  public readonly clampMinMaxInterval = this.unimplementedScalarTripleToInterval.bind(
-    this,
-    'clampMinMaxInterval'
-  );
+  public readonly clampMedianInterval = this.clampMedianIntervalImpl.bind(this);
+  public readonly clampMinMaxInterval = this.clampMinMaxIntervalImpl.bind(this);
   public readonly clampIntervals = [this.clampMedianInterval, this.clampMinMaxInterval];
   public readonly cosInterval = this.unimplementedScalarToInterval.bind(this, 'cosInterval');
   public readonly coshInterval = this.unimplementedScalarToInterval.bind(this, 'coshInterval');

From 782e79f7e992a75d0da62fbc26660cd32bc659e3 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 20 Sep 2023 15:00:07 -0400
Subject: [PATCH 054/166] wgsl: Add AbstractFloat `saturate` execution tests
 (#2974)

Fixes #1635
---
 src/unittests/floating_point.spec.ts          |  8 ++++-
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/saturate.spec.ts  | 36 +++++++++++++++----
 src/webgpu/util/floating_point.ts             |  5 +--
 4 files changed, 38 insertions(+), 13 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 58cf3fed75bc..8e2089fd0ab7 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3484,12 +3484,18 @@ const kSaturateIntervalCases = {
       ],
     }, // ~0.1
   ] as ScalarToIntervalCase[],
+  abstract: [
+    {
+      input: 0.1,
+      expected: 0.1,
+    }, // ~0.1
+  ] as ScalarToIntervalCase[],
 } as const;
 
 g.test('saturateInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarToIntervalCase>(p => {
         const constants = FP[p.trait].constants();
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 1542aa9e7a57..658f238a344f 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1312,7 +1312,7 @@
   "webgpu:shader,execution,expression,call,builtin,round:abstract_float:*": { "subcaseMS": 19.408 },
   "webgpu:shader,execution,expression,call,builtin,round:f16:*": { "subcaseMS": 30.509 },
   "webgpu:shader,execution,expression,call,builtin,round:f32:*": { "subcaseMS": 12.407 },
-  "webgpu:shader,execution,expression,call,builtin,saturate:abstract_float:*": { "subcaseMS": 227.607 },
+  "webgpu:shader,execution,expression,call,builtin,saturate:abstract_float:*": { "subcaseMS": 527.425 },
   "webgpu:shader,execution,expression,call,builtin,saturate:f16:*": { "subcaseMS": 23.407 },
   "webgpu:shader,execution,expression,call,builtin,saturate:f32:*": { "subcaseMS": 116.275 },
   "webgpu:shader,execution,expression,call,builtin,select:scalar:*": { "subcaseMS": 6.882 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/saturate.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/saturate.spec.ts
index ad160b64f3cf..2f165029219c 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/saturate.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/saturate.spec.ts
@@ -9,13 +9,13 @@ Returns clamp(e, 0.0, 1.0). Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF16, TypeF32 } from '../../../../../util/conversion.js';
+import { TypeAbstractFloat, TypeF16, TypeF32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF16Range, fullF32Range, linearRange } from '../../../../../util/math.js';
+import { fullF16Range, fullF32Range, fullF64Range, linearRange } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -42,16 +42,38 @@ export const d = makeCaseCache('saturate', {
       FP.f16.saturateInterval
     );
   },
+  abstract: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      [
+        // Non-clamped values
+        ...linearRange(0.0, 1.0, 20),
+        ...fullF64Range(),
+      ],
+      'unfiltered',
+      FP.abstract.saturateInterval
+    );
+  },
 });
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
-
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(
+      t,
+      abstractBuiltin('saturate'),
+      [TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`f32 tests`)
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 5692fb4098de..05d350785296 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4957,10 +4957,7 @@ class FPAbstractTraits extends FPTraits {
     'remainderInterval'
   );
   public readonly roundInterval = this.unimplementedScalarToInterval.bind(this, 'roundInterval');
-  public readonly saturateInterval = this.unimplementedScalarToInterval.bind(
-    this,
-    'saturateInterval'
-  );
+  public readonly saturateInterval = this.saturateIntervalImpl.bind(this);
   public readonly signInterval = this.unimplementedScalarToInterval.bind(this, 'signInterval');
   public readonly sinInterval = this.unimplementedScalarToInterval.bind(this, 'sinInterval');
   public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this, 'sinhInterval');

From a3cd7551b7a4475646e21335296a315866720ba4 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 20 Sep 2023 15:53:10 -0400
Subject: [PATCH 055/166] wgsl: Add f16 `cross` execution tests (#2975)

Fixes #2540
---
 src/unittests/floating_point.spec.ts          | 107 ++++++++++++------
 src/webgpu/listing_meta.json                  |   2 +-
 .../expression/call/builtin/cross.spec.ts     |  35 +++++-
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 107 insertions(+), 39 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 8e2089fd0ab7..2837eaf31937 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5784,45 +5784,84 @@ interface VectorPairToVectorCase {
   expected: (number | IntervalBounds)[];
 }
 
-g.test('crossInterval_f32')
-  .paramsSubcasesOnly<VectorPairToVectorCase>(
-    // prettier-ignore
-    [
-      // parallel vectors, AXB == 0
-      { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [0.0, 0.0, 0.0] },
-      { input: [[0.0, 1.0, 0.0], [0.0, 1.0, 0.0]], expected: [0.0, 0.0, 0.0] },
-      { input: [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]], expected: [0.0, 0.0, 0.0] },
-      { input: [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], expected: [0.0, 0.0, 0.0] },
-      { input: [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]], expected: [0.0, 0.0, 0.0] },
-      { input: [[0.1, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [0.0, 0.0, 0.0] },
-      { input: [[kValue.f32.subnormal.positive.max, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [0.0, 0.0, 0.0] },
-
-      // non-parallel vectors, AXB != 0
-      // f32 normals
-      { input: [[1.0, -1.0, -1.0], [-1.0, 1.0, -1.0]], expected: [2.0, 2.0, 0.0] },
-      { input: [[1.0, 2, 3], [1.0, 5.0, 7.0]], expected: [-1, -4, 3] },
-
-      // f64 normals
-      { input: [[0.1, -0.1, -0.1], [-0.1, 0.1, -0.1]],
-        expected: [[reinterpretU32AsF32(0x3ca3d708), reinterpretU32AsF32(0x3ca3d70b)],  // ~0.02
-          [reinterpretU32AsF32(0x3ca3d708), reinterpretU32AsF32(0x3ca3d70b)],  // ~0.02
-          [reinterpretU32AsF32(0xb1400000), reinterpretU32AsF32(0x31400000)]] },  // ~0
-
-      // f32 subnormals
-      { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max, kValue.f32.subnormal.negative.min],
-          [kValue.f32.subnormal.negative.min, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.negative.max]],
-        expected: [[0.0, reinterpretU32AsF32(0x00000002)],  // ~0
-          [0.0, reinterpretU32AsF32(0x00000002)],  // ~0
-          [reinterpretU32AsF32(0x80000001), reinterpretU32AsF32(0x00000001)]] },  // ~0
-    ]
+// prettier-ignore
+const kCrossIntervalCases = {
+  f32: [
+    { input: [
+        [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max, kValue.f32.subnormal.negative.min],
+        [kValue.f32.subnormal.negative.min, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.negative.max]
+      ],
+      expected: [
+        [0.0, reinterpretU32AsF32(0x00000002)], // ~0
+        [0.0, reinterpretU32AsF32(0x00000002)], // ~0
+        [reinterpretU32AsF32(0x80000001), reinterpretU32AsF32(0x00000001)] // ~0
+      ]},
+    { input: [
+        [0.1, -0.1, -0.1],
+        [-0.1, 0.1, -0.1]
+      ],
+      expected: [
+        [reinterpretU32AsF32(0x3ca3d708), reinterpretU32AsF32(0x3ca3d70b)], // ~0.02
+        [reinterpretU32AsF32(0x3ca3d708), reinterpretU32AsF32(0x3ca3d70b)], // ~0.02
+        [reinterpretU32AsF32(0xb1400000), reinterpretU32AsF32(0x31400000)], // ~0
+      ]},
+  ] as VectorPairToVectorCase[],
+  f16: [
+    { input: [
+        [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.max, kValue.f16.subnormal.negative.min],
+        [kValue.f16.subnormal.negative.min, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.negative.max]
+      ],
+      expected: [
+        [0.0, reinterpretU16AsF16(0x0002)], // ~0
+        [0.0, reinterpretU16AsF16(0x0002)], // ~0
+        [reinterpretU16AsF16(0x8001), reinterpretU16AsF16(0x0001)] // ~0
+      ]},
+    { input: [
+        [0.1, -0.1, -0.1],
+        [-0.1, 0.1, -0.1]
+      ],
+      expected: [
+        [reinterpretU16AsF16(0x251e), reinterpretU16AsF16(0x2520)], // ~0.02
+        [reinterpretU16AsF16(0x251e), reinterpretU16AsF16(0x2520)], // ~0.02
+        [reinterpretU16AsF16(0x8100), reinterpretU16AsF16(0x0100)] // ~0
+      ]},
+  ] as VectorPairToVectorCase[],
+} as const;
+
+g.test('crossInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<VectorPairToVectorCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          // parallel vectors, AXB == 0
+          { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [0.0, 0.0, 0.0] },
+          { input: [[0.0, 1.0, 0.0], [0.0, 1.0, 0.0]], expected: [0.0, 0.0, 0.0] },
+          { input: [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]], expected: [0.0, 0.0, 0.0] },
+          { input: [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], expected: [0.0, 0.0, 0.0] },
+          { input: [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]], expected: [0.0, 0.0, 0.0] },
+          { input: [[0.1, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [0.0, 0.0, 0.0] },
+          { input: [[constants.positive.subnormal.max, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [0.0, 0.0, 0.0] },
+
+          // non-parallel vectors, AXB != 0
+          { input: [[1.0, -1.0, -1.0], [-1.0, 1.0, -1.0]], expected: [2.0, 2.0, 0.0] },
+          { input: [[1.0, 2, 3], [1.0, 5.0, 7.0]], expected: [-1, -4, 3] },
+          ...kCrossIntervalCases[p.trait],
+        ];
+      })
   )
   .fn(t => {
     const [x, y] = t.params.input;
-    const expected = FP.f32.toVector(t.params.expected);
-    const got = FP.f32.crossInterval(x, y);
+    const trait = FP[t.params.trait];
+    const expected = trait.toVector(t.params.expected);
+    const got = trait.crossInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `f32.crossInterval([${x}], [${y}]) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.crossInterval([${x}], [${y}]) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 658f238a344f..af61441966ba 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1152,7 +1152,7 @@
   "webgpu:shader,execution,expression,call,builtin,countTrailingZeros:i32:*": { "subcaseMS": 7.844 },
   "webgpu:shader,execution,expression,call,builtin,countTrailingZeros:u32:*": { "subcaseMS": 7.851 },
   "webgpu:shader,execution,expression,call,builtin,cross:abstract_float:*": { "subcaseMS": 3.002 },
-  "webgpu:shader,execution,expression,call,builtin,cross:f16:*": { "subcaseMS": 16.101 },
+  "webgpu:shader,execution,expression,call,builtin,cross:f16:*": { "subcaseMS": 115.503 },
   "webgpu:shader,execution,expression,call,builtin,cross:f32:*": { "subcaseMS": 664.926 },
   "webgpu:shader,execution,expression,call,builtin,degrees:abstract_float:*": { "subcaseMS": 533.052 },
   "webgpu:shader,execution,expression,call,builtin,degrees:f16:*": { "subcaseMS": 29.308 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/cross.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/cross.spec.ts
index 627e0c9d20d5..ba949e773b07 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/cross.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/cross.spec.ts
@@ -8,9 +8,9 @@ Returns the cross product of e1 and e2.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { TypeF16, TypeF32, TypeVec } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { vectorF32Range } from '../../../../../util/math.js';
+import { vectorF16Range, vectorF32Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -35,6 +35,22 @@ export const d = makeCaseCache('cross', {
       FP.f32.crossInterval
     );
   },
+  f16_const: () => {
+    return FP.f16.generateVectorPairToVectorCases(
+      vectorF16Range(3),
+      vectorF16Range(3),
+      'finite',
+      FP.f16.crossInterval
+    );
+  },
+  f16_non_const: () => {
+    return FP.f16.generateVectorPairToVectorCases(
+      vectorF16Range(3),
+      vectorF16Range(3),
+      'unfiltered',
+      FP.f16.crossInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -63,4 +79,17 @@ g.test('f16')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`f16 tests`)
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(
+      t,
+      builtin('cross'),
+      [TypeVec(3, TypeF16), TypeVec(3, TypeF16)],
+      TypeVec(3, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 05d350785296..97ac2dd00404 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5205,7 +5205,7 @@ class F16Traits extends FPTraits {
   public readonly clampIntervals = [this.clampMedianInterval, this.clampMinMaxInterval];
   public readonly cosInterval = this.cosIntervalImpl.bind(this);
   public readonly coshInterval = this.unimplementedScalarToInterval.bind(this, 'coshInterval');
-  public readonly crossInterval = this.unimplementedVectorPairToVector.bind(this, 'crossInterval');
+  public readonly crossInterval = this.crossIntervalImpl.bind(this);
   public readonly degreesInterval = this.degreesIntervalImpl.bind(this);
   public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(
     this,

From 718a9edf11fc361b5e7a2ba7fd418bceae79c02e Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 20 Sep 2023 17:00:30 -0400
Subject: [PATCH 056/166] wgsl: Add AbstractFloat `cross` execution tests
 (#2976)

Fixes #2541
---
 src/unittests/floating_point.spec.ts          | 36 +++++++++++++++----
 .../expression/call/builtin/cross.spec.ts     | 30 ++++++++++++----
 src/webgpu/util/floating_point.ts             |  2 +-
 3 files changed, 54 insertions(+), 14 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 2837eaf31937..1988b79e1da5 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5794,8 +5794,9 @@ const kCrossIntervalCases = {
       expected: [
         [0.0, reinterpretU32AsF32(0x00000002)], // ~0
         [0.0, reinterpretU32AsF32(0x00000002)], // ~0
-        [reinterpretU32AsF32(0x80000001), reinterpretU32AsF32(0x00000001)] // ~0
-      ]},
+        [kValue.f32.subnormal.negative.max, kValue.f32.subnormal.positive.min] // ~0
+      ]
+    },
     { input: [
         [0.1, -0.1, -0.1],
         [-0.1, 0.1, -0.1]
@@ -5804,7 +5805,8 @@ const kCrossIntervalCases = {
         [reinterpretU32AsF32(0x3ca3d708), reinterpretU32AsF32(0x3ca3d70b)], // ~0.02
         [reinterpretU32AsF32(0x3ca3d708), reinterpretU32AsF32(0x3ca3d70b)], // ~0.02
         [reinterpretU32AsF32(0xb1400000), reinterpretU32AsF32(0x31400000)], // ~0
-      ]},
+      ]
+    },
   ] as VectorPairToVectorCase[],
   f16: [
     { input: [
@@ -5814,8 +5816,9 @@ const kCrossIntervalCases = {
       expected: [
         [0.0, reinterpretU16AsF16(0x0002)], // ~0
         [0.0, reinterpretU16AsF16(0x0002)], // ~0
-        [reinterpretU16AsF16(0x8001), reinterpretU16AsF16(0x0001)] // ~0
-      ]},
+        [kValue.f16.subnormal.negative.max, kValue.f16.subnormal.positive.min] // ~0
+      ]
+    },
     { input: [
         [0.1, -0.1, -0.1],
         [-0.1, 0.1, -0.1]
@@ -5824,14 +5827,33 @@ const kCrossIntervalCases = {
         [reinterpretU16AsF16(0x251e), reinterpretU16AsF16(0x2520)], // ~0.02
         [reinterpretU16AsF16(0x251e), reinterpretU16AsF16(0x2520)], // ~0.02
         [reinterpretU16AsF16(0x8100), reinterpretU16AsF16(0x0100)] // ~0
-      ]},
+      ]
+    },
+  ] as VectorPairToVectorCase[],
+  abstract: [
+    { input: [
+        [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.negative.max, kValue.f64.subnormal.negative.min],
+        [kValue.f64.subnormal.negative.min, kValue.f64.subnormal.positive.min, kValue.f64.subnormal.negative.max]
+      ],
+      expected: [0.0, 0.0, 0.0]
+    },
+    { input: [
+        [0.1, -0.1, -0.1],
+        [-0.1, 0.1, -0.1]
+      ],
+      expected: [
+        reinterpretU64AsF64(0x3f94_7ae1_47ae_147cn), // ~0.02
+        reinterpretU64AsF64(0x3f94_7ae1_47ae_147cn), // ~0.02
+        0.0
+      ]
+    },
   ] as VectorPairToVectorCase[],
 } as const;
 
 g.test('crossInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<VectorPairToVectorCase>(p => {
         const trait = FP[p.trait];
diff --git a/src/webgpu/shader/execution/expression/call/builtin/cross.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/cross.spec.ts
index ba949e773b07..2b0b3e58ced1 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/cross.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/cross.spec.ts
@@ -8,13 +8,13 @@ Returns the cross product of e1 and e2.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF16, TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { TypeAbstractFloat, TypeF16, TypeF32, TypeVec } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { vectorF16Range, vectorF32Range } from '../../../../../util/math.js';
+import { sparseVectorF64Range, vectorF16Range, vectorF32Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -51,13 +51,31 @@ export const d = makeCaseCache('cross', {
       FP.f16.crossInterval
     );
   },
+  abstract: () => {
+    return FP.abstract.generateVectorPairToVectorCases(
+      sparseVectorF64Range(3),
+      sparseVectorF64Range(3),
+      'finite',
+      FP.abstract.crossInterval
+    );
+  },
 });
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
-  .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(
+      t,
+      abstractBuiltin('cross'),
+      [TypeVec(3, TypeAbstractFloat), TypeVec(3, TypeAbstractFloat)],
+      TypeVec(3, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 97ac2dd00404..b44b671f9432 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4874,7 +4874,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly clampIntervals = [this.clampMedianInterval, this.clampMinMaxInterval];
   public readonly cosInterval = this.unimplementedScalarToInterval.bind(this, 'cosInterval');
   public readonly coshInterval = this.unimplementedScalarToInterval.bind(this, 'coshInterval');
-  public readonly crossInterval = this.unimplementedVectorPairToVector.bind(this, 'crossInterval');
+  public readonly crossInterval = this.crossIntervalImpl.bind(this);
   public readonly degreesInterval = this.degreesIntervalImpl.bind(this);
   public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(
     this,

From b6cd07c974342af8fa23adc1b9a22c9e1451a28d Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Thu, 21 Sep 2023 10:35:05 +0800
Subject: [PATCH 057/166] wgsl: f16 to bool/i32/u32 conversion expression
 execution tests (#2977)

This PR add execution tests for f16 to bool/i32/u32 conversion expression.

Issue: #2302
---
 src/webgpu/listing_meta.json                  |  8 ++--
 .../expression/unary/bool_conversion.spec.ts  | 24 +++++++++-
 .../expression/unary/i32_conversion.spec.ts   | 44 +++++++++++++++++--
 .../expression/unary/u32_conversion.spec.ts   | 44 +++++++++++++++++--
 4 files changed, 107 insertions(+), 13 deletions(-)

diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index af61441966ba..26f74b786d6d 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1437,8 +1437,8 @@
   "webgpu:shader,execution,expression,unary,af_assignment:f16:*": { "subcaseMS": 1.000 },
   "webgpu:shader,execution,expression,unary,af_assignment:f32:*": { "subcaseMS": 42.000 },
   "webgpu:shader,execution,expression,unary,bool_conversion:bool:*": { "subcaseMS": 8.357 },
-  "webgpu:shader,execution,expression,unary,bool_conversion:f16:*": { "subcaseMS": 28.710 },
-  "webgpu:shader,execution,expression,unary,bool_conversion:f32:*": { "subcaseMS": 8.513 },
+  "webgpu:shader,execution,expression,unary,bool_conversion:f16:*": { "subcaseMS": 44.794 },
+  "webgpu:shader,execution,expression,unary,bool_conversion:f32:*": { "subcaseMS": 41.276 },
   "webgpu:shader,execution,expression,unary,bool_conversion:i32:*": { "subcaseMS": 8.219 },
   "webgpu:shader,execution,expression,unary,bool_conversion:u32:*": { "subcaseMS": 7.401 },
   "webgpu:shader,execution,expression,unary,bool_logical:negation:*": { "subcaseMS": 6.413 },
@@ -1461,14 +1461,14 @@
   "webgpu:shader,execution,expression,unary,i32_arithmetic:negation:*": { "subcaseMS": 7.244 },
   "webgpu:shader,execution,expression,unary,i32_complement:i32_complement:*": { "subcaseMS": 9.075 },
   "webgpu:shader,execution,expression,unary,i32_conversion:bool:*": { "subcaseMS": 6.457 },
-  "webgpu:shader,execution,expression,unary,i32_conversion:f16:*": { "subcaseMS": 21.310 },
+  "webgpu:shader,execution,expression,unary,i32_conversion:f16:*": { "subcaseMS": 44.363 },
   "webgpu:shader,execution,expression,unary,i32_conversion:f32:*": { "subcaseMS": 8.275 },
   "webgpu:shader,execution,expression,unary,i32_conversion:i32:*": { "subcaseMS": 7.707 },
   "webgpu:shader,execution,expression,unary,i32_conversion:u32:*": { "subcaseMS": 6.969 },
   "webgpu:shader,execution,expression,unary,u32_complement:u32_complement:*": { "subcaseMS": 7.632 },
   "webgpu:shader,execution,expression,unary,u32_conversion:abstract_int:*": { "subcaseMS": 20.406 },
   "webgpu:shader,execution,expression,unary,u32_conversion:bool:*": { "subcaseMS": 7.713 },
-  "webgpu:shader,execution,expression,unary,u32_conversion:f16:*": { "subcaseMS": 14.705 },
+  "webgpu:shader,execution,expression,unary,u32_conversion:f16:*": { "subcaseMS": 34.251 },
   "webgpu:shader,execution,expression,unary,u32_conversion:f32:*": { "subcaseMS": 7.913 },
   "webgpu:shader,execution,expression,unary,u32_conversion:i32:*": { "subcaseMS": 8.319 },
   "webgpu:shader,execution,expression,unary,u32_conversion:u32:*": { "subcaseMS": 7.057 },
diff --git a/src/webgpu/shader/execution/expression/unary/bool_conversion.spec.ts b/src/webgpu/shader/execution/expression/unary/bool_conversion.spec.ts
index 4911a6baae9e..8fcfed339fb6 100644
--- a/src/webgpu/shader/execution/expression/unary/bool_conversion.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/bool_conversion.spec.ts
@@ -8,19 +8,23 @@ import { anyOf } from '../../../../util/compare.js';
 import {
   bool,
   f32,
+  f16,
   i32,
   Scalar,
   TypeBool,
   TypeF32,
+  TypeF16,
   TypeI32,
   TypeU32,
   u32,
 } from '../../../../util/conversion.js';
 import {
   fullF32Range,
+  fullF16Range,
   fullI32Range,
   fullU32Range,
   isSubnormalNumberF32,
+  isSubnormalNumberF16,
 } from '../../../../util/math.js';
 import { makeCaseCache } from '../case_cache.js';
 import { allInputSources, run, ShaderBuilder } from '../expression.js';
@@ -58,6 +62,18 @@ export const d = makeCaseCache('unary/bool_conversion', {
       return { input: f32(f), expected: anyOf(...expected) };
     });
   },
+  f16: () => {
+    return fullF16Range().map(f => {
+      const expected: Scalar[] = [];
+      if (f !== 0) {
+        expected.push(bool(true));
+      }
+      if (isSubnormalNumberF16(f)) {
+        expected.push(bool(false));
+      }
+      return { input: f16(f), expected: anyOf(...expected) };
+    });
+  },
 });
 
 /** Generate expression builder based on how the test case is to be vectorized */
@@ -149,4 +165,10 @@ The result is false if e is 0.0 or -0.0, and true otherwise.
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, vectorizeToExpression(t.params.vectorize), [TypeF16], TypeBool, t.params, cases);
+  });
diff --git a/src/webgpu/shader/execution/expression/unary/i32_conversion.spec.ts b/src/webgpu/shader/execution/expression/unary/i32_conversion.spec.ts
index 97393e552e32..4d326f87f776 100644
--- a/src/webgpu/shader/execution/expression/unary/i32_conversion.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/i32_conversion.spec.ts
@@ -8,15 +8,24 @@ import { kValue } from '../../../../util/constants.js';
 import {
   bool,
   f32,
+  f16,
   i32,
   reinterpretU32AsI32,
   TypeBool,
   TypeF32,
+  TypeF16,
   TypeI32,
   TypeU32,
   u32,
 } from '../../../../util/conversion.js';
-import { fullF32Range, fullI32Range, fullU32Range, quantizeToF32 } from '../../../../util/math.js';
+import {
+  fullF32Range,
+  fullF16Range,
+  fullI32Range,
+  fullU32Range,
+  quantizeToF32,
+  quantizeToF16,
+} from '../../../../util/math.js';
 import { makeCaseCache } from '../case_cache.js';
 import { allInputSources, run, ShaderBuilder } from '../expression.js';
 
@@ -56,8 +65,8 @@ export const d = makeCaseCache('unary/i32_conversion', {
         return { input: f32(f), expected: i32(kValue.i32.positive.max) };
       }
 
-      // All integers <= 2^24 are precisely representable as f32, so just need
-      // to round towards 0 for the nearest integer to 0 from f.
+      // All f32 no larger than 2^24 has a precise interger part and a fractional part, just need
+      // to trunc towards 0 for the result integer.
       if (Math.abs(f) <= 2 ** 24) {
         return { input: f32(f), expected: i32(Math.trunc(f)) };
       }
@@ -70,6 +79,27 @@ export const d = makeCaseCache('unary/i32_conversion', {
       return { input: f32(f), expected: i32(quantizeToF32(f)) };
     });
   },
+  f16: () => {
+    // Note that finite f16 values are always in range of i32.
+    return fullF16Range().map(f => {
+      // Handles zeros and subnormals
+      if (Math.abs(f) < 1.0) {
+        return { input: f16(f), expected: i32(0) };
+      }
+
+      // All f16 no larger than <= 2^12 has a precise interger part and a fractional part, just need
+      // to trunc towards 0 for the result integer.
+      if (Math.abs(f) <= 2 ** 12) {
+        return { input: f16(f), expected: i32(Math.trunc(f)) };
+      }
+
+      // All f16s larger than 2 ** 12 are integers, so in theory one could use them directly, expect
+      // that number is actually f64 internally, so they need to be quantized to f16 first.
+      // Cannot just use trunc here, since that might produce a i32 value that is precise in f64,
+      // but not in f16.
+      return { input: f16(f), expected: i32(quantizeToF16(f)) };
+    });
+  },
 });
 
 /** Generate a ShaderBuilder based on how the test case is to be vectorized */
@@ -157,4 +187,10 @@ e is converted to u32, rounding towards zero
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, vectorizeToExpression(t.params.vectorize), [TypeF16], TypeI32, t.params, cases);
+  });
diff --git a/src/webgpu/shader/execution/expression/unary/u32_conversion.spec.ts b/src/webgpu/shader/execution/expression/unary/u32_conversion.spec.ts
index 328ad08e7909..255662c6e402 100644
--- a/src/webgpu/shader/execution/expression/unary/u32_conversion.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/u32_conversion.spec.ts
@@ -8,15 +8,24 @@ import { kValue } from '../../../../util/constants.js';
 import {
   bool,
   f32,
+  f16,
   i32,
   reinterpretI32AsU32,
   TypeBool,
   TypeF32,
+  TypeF16,
   TypeI32,
   TypeU32,
   u32,
 } from '../../../../util/conversion.js';
-import { fullF32Range, fullI32Range, fullU32Range, quantizeToF32 } from '../../../../util/math.js';
+import {
+  fullF32Range,
+  fullF16Range,
+  fullI32Range,
+  fullU32Range,
+  quantizeToF32,
+  quantizeToF16,
+} from '../../../../util/math.js';
 import { makeCaseCache } from '../case_cache.js';
 import { allInputSources, run, ShaderBuilder } from '../expression.js';
 
@@ -52,8 +61,8 @@ export const d = makeCaseCache('unary/u32_conversion', {
         return { input: f32(f), expected: u32(kValue.u32.max) };
       }
 
-      // All integers <= 2^24 are precisely representable as f32, so just need
-      // to round towards 0 for the nearest integer to 0 from f.
+      // All f32 no larger than 2^24 has a precise interger part and a fractional part, just need
+      // to trunc towards 0 for the result integer.
       if (f <= 2 ** 24) {
         return { input: f32(f), expected: u32(Math.floor(f)) };
       }
@@ -66,6 +75,27 @@ export const d = makeCaseCache('unary/u32_conversion', {
       return { input: f32(f), expected: u32(quantizeToF32(f)) };
     });
   },
+  f16: () => {
+    // Note that all positive finite f16 values are in range of u32.
+    return fullF16Range().map(f => {
+      // Handles zeros, subnormals, and negatives
+      if (f < 1.0) {
+        return { input: f16(f), expected: u32(0) };
+      }
+
+      // All f16 no larger than <= 2^12 has a precise interger part and a fractional part, just need
+      // to trunc towards 0 for the result integer.
+      if (f <= 2 ** 12) {
+        return { input: f16(f), expected: u32(Math.trunc(f)) };
+      }
+
+      // All f16s larger than 2 ** 12 are integers, so in theory one could use them directly, expect
+      // that number is actually f64 internally, so they need to be quantized to f16 first.
+      // Cannot just use trunc here, since that might produce a u32 value that is precise in f64,
+      // but not in f16.
+      return { input: f16(f), expected: u32(quantizeToF16(f)) };
+    });
+  },
 });
 
 /** Generate a ShaderBuilder based on how the test case is to be vectorized */
@@ -153,7 +183,13 @@ e is converted to u32, rounding towards zero
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, vectorizeToExpression(t.params.vectorize), [TypeF16], TypeU32, t.params, cases);
+  });
 
 g.test('abstract_int')
   .specURL('https://www.w3.org/TR/WGSL/#value-constructor-builtin-function')

From b1a998fade8e8689acf1e700baf8a7245a0d58c1 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Thu, 21 Sep 2023 14:21:23 +0800
Subject: [PATCH 058/166] wgsl: F16 execution tests for built-in length and
 distance (#2979)

This PR add execution tests for f16 built-in length and distance.

Issue: #1248, #2555, #2557
---
 src/unittests/floating_point.spec.ts          | 376 ++++++++++--------
 src/webgpu/listing_meta.json                  |  10 +-
 .../expression/call/builtin/distance.spec.ts  | 172 +++++---
 .../expression/call/builtin/length.spec.ts    | 126 ++++--
 src/webgpu/util/floating_point.ts             |   4 +-
 5 files changed, 434 insertions(+), 254 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 1988b79e1da5..c769a144bcf3 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3050,44 +3050,73 @@ g.test('inverseSqrtInterval')
     );
   });
 
-g.test('lengthIntervalScalar_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-      //
-      // length(0) = kUnboundedBounds, because length uses sqrt, which is defined as 1/inversesqrt
-      {input: 0, expected: kUnboundedBounds },
-      {input: 1.0, expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: -1.0, expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: 0.1, expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-      {input: -0.1, expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-      {input: 10.0, expected: [reinterpretU64AsF64(0x4023_ffff_7000_0000n), reinterpretU64AsF64(0x4024_0000_b000_0000n)] },  // ~10
-      {input: -10.0, expected: [reinterpretU64AsF64(0x4023_ffff_7000_0000n), reinterpretU64AsF64(0x4024_0000_b000_0000n)] },  // ~10
-
-      // Subnormal Cases
-      { input: kValue.f32.subnormal.negative.min, expected: kUnboundedBounds },
-      { input: kValue.f32.subnormal.negative.max, expected: kUnboundedBounds },
-      { input: kValue.f32.subnormal.positive.min, expected: kUnboundedBounds },
-      { input: kValue.f32.subnormal.positive.max, expected: kUnboundedBounds },
+// Expectation interval of 1/inverseSqrt(sum(x[i]^2)) on some special values array x for certain
+// float traits, used as expectation for `length` and `distance`.
+// These cases are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kRootSumSquareExpectionInterval = {
+  f32: {
+    '[0.1]': [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)],  // ~0.1
+    '[1.0]' : [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)],  // ~1.0
+    '[10]' : [reinterpretU64AsF64(0x4023_ffff_7000_0000n), reinterpretU64AsF64(0x4024_0000_b000_0000n)],  // ~10
+    '[1.0, 1.0]' : [reinterpretU64AsF64(0x3ff6_a09d_b000_0000n), reinterpretU64AsF64(0x3ff6_a09f_1000_0000n)],  // ~√2
+    '[1.0, 1.0, 1.0]' : [reinterpretU64AsF64(0x3ffb_b67a_1000_0000n), reinterpretU64AsF64(0x3ffb_b67b_b000_0000n)],  // ~√3
+    '[1.0, 1.0, 1.0, 1.0]' : [reinterpretU64AsF64(0x3fff_ffff_7000_0000n), reinterpretU64AsF64(0x4000_0000_9000_0000n)],  // ~2
+  } as {[s: string]: IntervalBounds},
+  f16: {
+    '[0.1]': [reinterpretU64AsF64(0x3fb9_7e00_0000_0000n), reinterpretU64AsF64(0x3fb9_b600_0000_0000n)],  // ~0.1
+    '[1.0]' : [reinterpretU64AsF64(0x3fef_ee00_0000_0000n), reinterpretU64AsF64(0x3ff0_1200_0000_0000n)],  // ~1.0
+    '[10]' : [reinterpretU64AsF64(0x4023_ea00_0000_0000n), reinterpretU64AsF64(0x4024_1200_0000_0000n)],  // ~10
+    '[1.0, 1.0]' : [reinterpretU64AsF64(0x3ff6_8a00_0000_0000n), reinterpretU64AsF64(0x3ff6_b600_0000_0000n)],  // ~√2
+    '[1.0, 1.0, 1.0]' : [reinterpretU64AsF64(0x3ffb_9a00_0000_0000n), reinterpretU64AsF64(0x3ffb_d200_0000_0000n)],  // ~√3
+    '[1.0, 1.0, 1.0, 1.0]' : [reinterpretU64AsF64(0x3fff_ee00_0000_0000n), reinterpretU64AsF64(0x4000_1200_0000_0000n)],  // ~2
+  } as {[s: string]: IntervalBounds},
+} as const;
 
-      // Edge cases
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.max, expected: kUnboundedBounds },
-      { input: kValue.f32.positive.min, expected: kUnboundedBounds },
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-    ]
+g.test('lengthIntervalScalar')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          {input: 1.0, expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: -1.0, expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: 0.1, expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+          {input: -0.1, expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+          {input: 10.0, expected: kRootSumSquareExpectionInterval[p.trait]['[10]'] },  // ~10
+          {input: -10.0, expected: kRootSumSquareExpectionInterval[p.trait]['[10]'] },  // ~10
+
+          // length(0) = kUnboundedBounds, because length uses sqrt, which is defined as 1/inversesqrt
+          {input: 0, expected: kUnboundedBounds },
+
+          // Subnormal Cases
+          { input: constants.negative.subnormal.min, expected: kUnboundedBounds },
+          { input: constants.negative.subnormal.max, expected: kUnboundedBounds },
+          { input: constants.positive.subnormal.min, expected: kUnboundedBounds },
+          { input: constants.positive.subnormal.max, expected: kUnboundedBounds },
+
+          // Edge cases
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: constants.negative.max, expected: kUnboundedBounds },
+          { input: constants.positive.min, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.lengthInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.lengthInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.lengthInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.lengthInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -4096,53 +4125,58 @@ g.test('atan2Interval')
     );
   });
 
-g.test('distanceIntervalScalar_f32')
-  .paramsSubcasesOnly<ScalarPairToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable  form due to the inherited nature
-      // of the errors.
-      //
-      // distance(x, y), where x - y = 0 has an acceptance interval of kUnboundedBounds,
-      // because distance(x, y) = length(x - y), and length(0) = kUnboundedBounds
-      { input: [0, 0], expected: kUnboundedBounds },
-      { input: [1.0, 0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [0.0, 1.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [1.0, 1.0], expected: kUnboundedBounds },
-      { input: [-0.0, -1.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [0.0, -1.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [-1.0, -1.0], expected: kUnboundedBounds },
-      { input: [0.1, 0], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-      { input: [0, 0.1], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-      { input: [-0.1, 0], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-      { input: [0, -0.1], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-      { input: [10.0, 0], expected: [reinterpretU64AsF64(0x4023_ffff_7000_0000n), reinterpretU64AsF64(0x4024_0000_b000_0000n)] },  // ~10
-      { input: [0, 10.0], expected: [reinterpretU64AsF64(0x4023_ffff_7000_0000n), reinterpretU64AsF64(0x4024_0000_b000_0000n)] },  // ~10
-      { input: [-10.0, 0], expected: [reinterpretU64AsF64(0x4023_ffff_7000_0000n), reinterpretU64AsF64(0x4024_0000_b000_0000n)] },  // ~10
-      { input: [0, -10.0], expected: [reinterpretU64AsF64(0x4023_ffff_7000_0000n), reinterpretU64AsF64(0x4024_0000_b000_0000n)] },  // ~10
-
-      // Subnormal Cases
-      { input: [kValue.f32.subnormal.negative.min, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.subnormal.negative.max, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.subnormal.positive.min, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.subnormal.positive.max, 0], expected: kUnboundedBounds },
+g.test('distanceIntervalScalar')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarPairToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          { input: [1.0, 0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [0.0, 1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [-0.0, -1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [0.0, -1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [0.1, 0], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+          { input: [0, 0.1], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+          { input: [-0.1, 0], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+          { input: [0, -0.1], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+          { input: [10.0, 0], expected: kRootSumSquareExpectionInterval[p.trait]['[10]'] },  // ~10
+          { input: [0, 10.0], expected: kRootSumSquareExpectionInterval[p.trait]['[10]'] },  // ~10
+          { input: [-10.0, 0], expected: kRootSumSquareExpectionInterval[p.trait]['[10]'] },  // ~10
+          { input: [0, -10.0], expected: kRootSumSquareExpectionInterval[p.trait]['[10]'] },  // ~10
+
+          // distance(x, y), where x - y = 0 has an acceptance interval of kUnboundedBounds,
+          // because distance(x, y) = length(x - y), and length(0) = kUnboundedBounds
+          { input: [0, 0], expected: kUnboundedBounds },
+          { input: [1.0, 1.0], expected: kUnboundedBounds },
+          { input: [-1.0, -1.0], expected: kUnboundedBounds },
 
-      // Edge cases
-      { input: [kValue.f32.infinity.positive, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.negative.min, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.negative.max, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.positive.min, 0], expected: kUnboundedBounds },
-      { input: [kValue.f32.positive.max, 0], expected: kUnboundedBounds },
-    ]
+          // Subnormal Cases
+          { input: [constants.negative.subnormal.min, 0], expected: kUnboundedBounds },
+          { input: [constants.negative.subnormal.max, 0], expected: kUnboundedBounds },
+          { input: [constants.positive.subnormal.min, 0], expected: kUnboundedBounds },
+          { input: [constants.positive.subnormal.max, 0], expected: kUnboundedBounds },
+
+          // Edge cases
+          { input: [constants.positive.infinity, 0], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, 0], expected: kUnboundedBounds },
+          { input: [constants.negative.min, 0], expected: kUnboundedBounds },
+          { input: [constants.negative.max, 0], expected: kUnboundedBounds },
+          { input: [constants.positive.min, 0], expected: kUnboundedBounds },
+          { input: [constants.positive.max, 0], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.distanceInterval(...t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.distanceInterval(...t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.distanceInterval(${t.params.input[0]}, ${t.params.input[1]}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.distanceInterval(${t.params.input[0]}, ${t.params.input[1]}) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -5528,53 +5562,57 @@ interface VectorToIntervalCase {
   expected: number | IntervalBounds;
 }
 
-g.test('lengthIntervalVector_f32')
-  .paramsSubcasesOnly<VectorToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-
-      // vec2
-      {input: [1.0, 0.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: [0.0, 1.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: [1.0, 1.0], expected: [reinterpretU64AsF64(0x3ff6_a09d_b000_0000n), reinterpretU64AsF64(0x3ff6_a09f_1000_0000n)] },  // ~√2
-      {input: [-1.0, -1.0], expected: [reinterpretU64AsF64(0x3ff6_a09d_b000_0000n), reinterpretU64AsF64(0x3ff6_a09f_1000_0000n)] },  // ~√2
-      {input: [-1.0, 1.0], expected: [reinterpretU64AsF64(0x3ff6_a09d_b000_0000n), reinterpretU64AsF64(0x3ff6_a09f_1000_0000n)] },  // ~√2
-      {input: [0.1, 0.0], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-
-      // vec3
-      {input: [1.0, 0.0, 0.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: [0.0, 1.0, 0.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: [0.0, 0.0, 1.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: [1.0, 1.0, 1.0], expected: [reinterpretU64AsF64(0x3ffb_b67a_1000_0000n), reinterpretU64AsF64(0x3ffb_b67b_b000_0000n)] },  // ~√3
-      {input: [-1.0, -1.0, -1.0], expected: [reinterpretU64AsF64(0x3ffb_b67a_1000_0000n), reinterpretU64AsF64(0x3ffb_b67b_b000_0000n)] },  // ~√3
-      {input: [1.0, -1.0, -1.0], expected: [reinterpretU64AsF64(0x3ffb_b67a_1000_0000n), reinterpretU64AsF64(0x3ffb_b67b_b000_0000n)] },  // ~√3
-      {input: [0.1, 0.0, 0.0], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
+g.test('lengthIntervalVector')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<VectorToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          // vec2
+          {input: [1.0, 0.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: [0.0, 1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: [1.0, 1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0]'] },  // ~√2
+          {input: [-1.0, -1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0]'] },  // ~√2
+          {input: [-1.0, 1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0]'] },  // ~√2
+          {input: [0.1, 0.0], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
 
-      // vec4
-      {input: [1.0, 0.0, 0.0, 0.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: [0.0, 1.0, 0.0, 0.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: [0.0, 0.0, 1.0, 0.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: [0.0, 0.0, 0.0, 1.0], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      {input: [1.0, 1.0, 1.0, 1.0], expected: [reinterpretU64AsF64(0x3fff_ffff_7000_0000n), reinterpretU64AsF64(0x4000_0000_9000_0000n)] },  // ~2
-      {input: [-1.0, -1.0, -1.0, -1.0], expected: [reinterpretU64AsF64(0x3fff_ffff_7000_0000n), reinterpretU64AsF64(0x4000_0000_9000_0000n)] },  // ~2
-      {input: [-1.0, 1.0, -1.0, 1.0], expected: [reinterpretU64AsF64(0x3fff_ffff_7000_0000n), reinterpretU64AsF64(0x4000_0000_9000_0000n)] },  // ~2
-      {input: [0.1, 0.0, 0.0, 0.0], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
+          // vec3
+          {input: [1.0, 0.0, 0.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: [0.0, 1.0, 0.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: [0.0, 0.0, 1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: [1.0, 1.0, 1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0]'] },  // ~√3
+          {input: [-1.0, -1.0, -1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0]'] },  // ~√3
+          {input: [1.0, -1.0, -1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0]'] },  // ~√3
+          {input: [0.1, 0.0, 0.0], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
 
-      // Test that dot going OOB bounds in the intermediate calculations propagates
-      { input: [kValue.f32.positive.nearest_max, kValue.f32.positive.max, kValue.f32.negative.min], expected: kUnboundedBounds },
-      { input: [kValue.f32.positive.max, kValue.f32.positive.nearest_max, kValue.f32.negative.min], expected: kUnboundedBounds },
-      { input: [kValue.f32.negative.min, kValue.f32.positive.max, kValue.f32.positive.nearest_max], expected: kUnboundedBounds },
-    ]
+          // vec4
+          {input: [1.0, 0.0, 0.0, 0.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: [0.0, 1.0, 0.0, 0.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: [0.0, 0.0, 1.0, 0.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: [0.0, 0.0, 0.0, 1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          {input: [1.0, 1.0, 1.0, 1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0, 1.0]'] },  // ~2
+          {input: [-1.0, -1.0, -1.0, -1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0, 1.0]'] },  // ~2
+          {input: [-1.0, 1.0, -1.0, 1.0], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0, 1.0]'] },  // ~2
+          {input: [0.1, 0.0, 0.0, 0.0], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+
+          // Test that dot going OOB bounds in the intermediate calculations propagates
+          { input: [constants.positive.nearest_max, constants.positive.max, constants.negative.min], expected: kUnboundedBounds },
+          { input: [constants.positive.max, constants.positive.nearest_max, constants.negative.min], expected: kUnboundedBounds },
+          { input: [constants.negative.min, constants.positive.max, constants.positive.nearest_max], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.lengthInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.lengthInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.lengthInterval([${t.params.input}]) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.lengthInterval([${t.params.input}]) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -5583,65 +5621,67 @@ interface VectorPairToIntervalCase {
   expected: number | IntervalBounds;
 }
 
-g.test('distanceIntervalVector_f32')
-  .paramsSubcasesOnly<VectorPairToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-      //
-      // distance(x, y), where x - y = 0 has an acceptance interval of kUnboundedBounds,
-      // because distance(x, y) = length(x - y), and length(0) = kUnboundedBounds
+g.test('distanceIntervalVector')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<VectorPairToIntervalCase>(p => {
+        // prettier-ignore
+        return [
+          // distance(x, y), where x - y = 0 has an acceptance interval of kUnboundedBounds,
+          // because distance(x, y) = length(x - y), and length(0) = kUnboundedBounds.
 
-      // vec2
-      { input: [[1.0, 0.0], [1.0, 0.0]], expected: kUnboundedBounds },
-      { input: [[1.0, 0.0], [0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0], [1.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[-1.0, 0.0], [0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0], [-1.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 1.0], [-1.0, 0.0]], expected: [reinterpretU64AsF64(0x3ff6_a09d_b000_0000n), reinterpretU64AsF64(0x3ff6_a09f_1000_0000n)] },  // ~√2
-      { input: [[0.1, 0.0], [0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
+          // vec2
+          { input: [[1.0, 0.0], [1.0, 0.0]], expected: kUnboundedBounds },
+          { input: [[1.0, 0.0], [0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0], [1.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[-1.0, 0.0], [0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0], [-1.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 1.0], [-1.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0]'] },  // ~√2
+          { input: [[0.1, 0.0], [0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
 
-      // vec3
-      { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: kUnboundedBounds },
-      { input: [[1.0, 0.0, 0.0], [0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 1.0, 0.0], [0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 1.0], [0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 0.0], [0.0, 0.0, 1.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3ffb_b67a_1000_0000n), reinterpretU64AsF64(0x3ffb_b67b_b000_0000n)] },  // ~√3
-      { input: [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]], expected: [reinterpretU64AsF64(0x3ffb_b67a_1000_0000n), reinterpretU64AsF64(0x3ffb_b67b_b000_0000n)] },  // ~√3
-      { input: [[-1.0, -1.0, -1.0], [0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3ffb_b67a_1000_0000n), reinterpretU64AsF64(0x3ffb_b67b_b000_0000n)] },  // ~√3
-      { input: [[0.0, 0.0, 0.0], [-1.0, -1.0, -1.0]], expected: [reinterpretU64AsF64(0x3ffb_b67a_1000_0000n), reinterpretU64AsF64(0x3ffb_b67b_b000_0000n)] },  // ~√3
-      { input: [[0.1, 0.0, 0.0], [0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-      { input: [[0.0, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
+          // vec3
+          { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: kUnboundedBounds },
+          { input: [[1.0, 0.0, 0.0], [0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 1.0, 0.0], [0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 1.0], [0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 0.0], [0.0, 0.0, 1.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0]'] },  // ~√3
+          { input: [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0]'] },  // ~√3
+          { input: [[-1.0, -1.0, -1.0], [0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0]'] },  // ~√3
+          { input: [[0.0, 0.0, 0.0], [-1.0, -1.0, -1.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0]'] },  // ~√3
+          { input: [[0.1, 0.0, 0.0], [0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+          { input: [[0.0, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
 
-      // vec4
-      { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: kUnboundedBounds },
-      { input: [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]], expected: [reinterpretU64AsF64(0x3fef_ffff_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_9000_0000n)] },  // ~1
-      { input: [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fff_ffff_7000_0000n), reinterpretU64AsF64(0x4000_0000_9000_0000n)] },  // ~2
-      { input: [[0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]], expected: [reinterpretU64AsF64(0x3fff_ffff_7000_0000n), reinterpretU64AsF64(0x4000_0000_9000_0000n)] },  // ~2
-      { input: [[-1.0, 1.0, -1.0, 1.0], [0.0, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fff_ffff_7000_0000n), reinterpretU64AsF64(0x4000_0000_9000_0000n)] },  // ~2
-      { input: [[0.0, 0.0, 0.0, 0.0], [1.0, -1.0, 1.0, -1.0]], expected: [reinterpretU64AsF64(0x3fff_ffff_7000_0000n), reinterpretU64AsF64(0x4000_0000_9000_0000n)] },  // ~2
-      { input: [[0.1, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-      { input: [[0.0, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: [reinterpretU64AsF64(0x3fb9_9998_9000_0000n), reinterpretU64AsF64(0x3fb9_999a_7000_0000n)] },  // ~0.1
-    ]
+          // vec4
+          { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: kUnboundedBounds },
+          { input: [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0]'] },  // ~1
+          { input: [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0, 1.0]'] },  // ~2
+          { input: [[0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0, 1.0]'] },  // ~2
+          { input: [[-1.0, 1.0, -1.0, 1.0], [0.0, 0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0, 1.0]'] },  // ~2
+          { input: [[0.0, 0.0, 0.0, 0.0], [1.0, -1.0, 1.0, -1.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[1.0, 1.0, 1.0, 1.0]'] },  // ~2
+          { input: [[0.1, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+          { input: [[0.0, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: kRootSumSquareExpectionInterval[p.trait]['[0.1]'] },  // ~0.1
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.distanceInterval(...t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.distanceInterval(...t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.distanceInterval([${t.params.input[0]}, ${t.params.input[1]}]) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.lengthInterval([${t.params.input[0]}, ${t.params.input[1]}]) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 26f74b786d6d..4486d0ba6198 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1161,7 +1161,10 @@
   "webgpu:shader,execution,expression,call,builtin,determinant:f16:*": { "subcaseMS": 22.806 },
   "webgpu:shader,execution,expression,call,builtin,determinant:f32:*": { "subcaseMS": 10.742 },
   "webgpu:shader,execution,expression,call,builtin,distance:abstract_float:*": { "subcaseMS": 14.503 },
-  "webgpu:shader,execution,expression,call,builtin,distance:f16:*": { "subcaseMS": 24.508 },
+  "webgpu:shader,execution,expression,call,builtin,distance:f16:*": { "subcaseMS": 6675.626 },
+  "webgpu:shader,execution,expression,call,builtin,distance:f16_vec2:*": { "subcaseMS": 78.300 },
+  "webgpu:shader,execution,expression,call,builtin,distance:f16_vec3:*": { "subcaseMS": 47.925 },
+  "webgpu:shader,execution,expression,call,builtin,distance:f16_vec4:*": { "subcaseMS": 57.825 },
   "webgpu:shader,execution,expression,call,builtin,distance:f32:*": { "subcaseMS": 875.325 },
   "webgpu:shader,execution,expression,call,builtin,distance:f32_vec2:*": { "subcaseMS": 9.826 },
   "webgpu:shader,execution,expression,call,builtin,distance:f32_vec3:*": { "subcaseMS": 10.901 },
@@ -1235,7 +1238,10 @@
   "webgpu:shader,execution,expression,call,builtin,ldexp:f16:*": { "subcaseMS": 36.705 },
   "webgpu:shader,execution,expression,call,builtin,ldexp:f32:*": { "subcaseMS": 66.419 },
   "webgpu:shader,execution,expression,call,builtin,length:abstract_float:*": { "subcaseMS": 31.303 },
-  "webgpu:shader,execution,expression,call,builtin,length:f16:*": { "subcaseMS": 28.405 },
+  "webgpu:shader,execution,expression,call,builtin,length:f16:*": { "subcaseMS": 490.450 },
+  "webgpu:shader,execution,expression,call,builtin,length:f16_vec2:*": { "subcaseMS": 33.551 },
+  "webgpu:shader,execution,expression,call,builtin,length:f16_vec3:*": { "subcaseMS": 79.301 },
+  "webgpu:shader,execution,expression,call,builtin,length:f16_vec4:*": { "subcaseMS": 156.826 },
   "webgpu:shader,execution,expression,call,builtin,length:f32:*": { "subcaseMS": 107.275 },
   "webgpu:shader,execution,expression,call,builtin,length:f32_vec2:*": { "subcaseMS": 9.751 },
   "webgpu:shader,execution,expression,call,builtin,length:f32_vec3:*": { "subcaseMS": 10.825 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts
index a3d41b528c73..13cddf6403ab 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts
@@ -10,9 +10,14 @@ Returns the distance between e1 and e2 (e.g. length(e1-e2)).
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, sparseVectorF32Range } from '../../../../../util/math.js';
+import {
+  fullF32Range,
+  fullF16Range,
+  sparseVectorF32Range,
+  sparseVectorF16Range,
+} from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -20,6 +25,38 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
+// Cases: f32_vecN_[non_]const
+const f32_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f32_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorPairToIntervalCases(
+          sparseVectorF32Range(n),
+          sparseVectorF32Range(n),
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f32.distanceInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_vecN_[non_]const
+const f16_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f16_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorPairToIntervalCases(
+          sparseVectorF16Range(n),
+          sparseVectorF16Range(n),
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f16.distanceInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('distance', {
   f32_const: () => {
     return FP.f32.generateScalarPairToIntervalCases(
@@ -37,54 +74,24 @@ export const d = makeCaseCache('distance', {
       FP.f32.distanceInterval
     );
   },
-  f32_vec2_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      'finite',
-      FP.f32.distanceInterval
-    );
-  },
-  f32_vec2_non_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      FP.f32.distanceInterval
-    );
-  },
-  f32_vec3_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
+  ...f32_vec_cases,
+  f16_const: () => {
+    return FP.f16.generateScalarPairToIntervalCases(
+      fullF16Range(),
+      fullF16Range(),
       'finite',
-      FP.f32.distanceInterval
+      FP.f16.distanceInterval
     );
   },
-  f32_vec3_non_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
+  f16_non_const: () => {
+    return FP.f16.generateScalarPairToIntervalCases(
+      fullF16Range(),
+      fullF16Range(),
       'unfiltered',
-      FP.f32.distanceInterval
-    );
-  },
-  f32_vec4_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      'finite',
-      FP.f32.distanceInterval
-    );
-  },
-  f32_vec4_non_const: () => {
-    return FP.f32.generateVectorPairToIntervalCases(
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      FP.f32.distanceInterval
+      FP.f16.distanceInterval
     );
   },
+  ...f16_vec_cases,
 });
 
 g.test('abstract_float')
@@ -159,9 +166,76 @@ g.test('f32_vec4')
   });
 
 g.test('f16')
-  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
   .desc(`f16 tests`)
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('distance'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
+
+g.test('f16_vec2')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec2s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec2_const' : 'f16_vec2_non_const'
+    );
+    await run(
+      t,
+      builtin('distance'),
+      [TypeVec(2, TypeF16), TypeVec(2, TypeF16)],
+      TypeF16,
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec3')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec3s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec3_const' : 'f16_vec3_non_const'
+    );
+    await run(
+      t,
+      builtin('distance'),
+      [TypeVec(3, TypeF16), TypeVec(3, TypeF16)],
+      TypeF16,
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec4')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec4s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec4_const' : 'f16_vec4_non_const'
+    );
+    await run(
+      t,
+      builtin('distance'),
+      [TypeVec(4, TypeF16), TypeVec(4, TypeF16)],
+      TypeF16,
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/length.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/length.spec.ts
index ca11ac0b0d5a..85c1f851697d 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/length.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/length.spec.ts
@@ -9,9 +9,14 @@ Returns the length of e (e.g. abs(e) if T is a scalar, or sqrt(e[0]^2 + e[1]^2 +
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, vectorF32Range } from '../../../../../util/math.js';
+import {
+  fullF32Range,
+  fullF16Range,
+  vectorF32Range,
+  vectorF16Range,
+} from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -19,6 +24,36 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
+// Cases: f32_vecN_[non_]const
+const f32_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f32_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorToIntervalCases(
+          vectorF32Range(n),
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f32.lengthInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_vecN_[non_]const
+const f16_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f16_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorToIntervalCases(
+          vectorF16Range(n),
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f16.lengthInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('length', {
   f32: () => {
     return FP.f32.generateScalarToIntervalCases(
@@ -27,36 +62,15 @@ export const d = makeCaseCache('length', {
       FP.f32.lengthInterval
     );
   },
-  f32_vec2_const: () => {
-    return FP.f32.generateVectorToIntervalCases(vectorF32Range(2), 'finite', FP.f32.lengthInterval);
-  },
-  f32_vec2_non_const: () => {
-    return FP.f32.generateVectorToIntervalCases(
-      vectorF32Range(2),
-      'unfiltered',
-      FP.f32.lengthInterval
-    );
-  },
-  f32_vec3_const: () => {
-    return FP.f32.generateVectorToIntervalCases(vectorF32Range(3), 'finite', FP.f32.lengthInterval);
-  },
-  f32_vec3_non_const: () => {
-    return FP.f32.generateVectorToIntervalCases(
-      vectorF32Range(3),
-      'unfiltered',
-      FP.f32.lengthInterval
-    );
-  },
-  f32_vec4_const: () => {
-    return FP.f32.generateVectorToIntervalCases(vectorF32Range(4), 'finite', FP.f32.lengthInterval);
-  },
-  f32_vec4_non_const: () => {
-    return FP.f32.generateVectorToIntervalCases(
-      vectorF32Range(4),
+  ...f32_vec_cases,
+  f16: () => {
+    return FP.f16.generateScalarToIntervalCases(
+      fullF16Range(),
       'unfiltered',
-      FP.f32.lengthInterval
+      FP.f16.lengthInterval
     );
   },
+  ...f16_vec_cases,
 });
 
 g.test('abstract_float')
@@ -112,7 +126,53 @@ g.test('f32_vec4')
 g.test('f16')
   .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
   .desc(`f16 tests`)
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('length'), [TypeF16], TypeF16, t.params, cases);
+  });
+
+g.test('f16_vec2')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec2s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec2_const' : 'f16_vec2_non_const'
+    );
+    await run(t, builtin('length'), [TypeVec(2, TypeF16)], TypeF16, t.params, cases);
+  });
+
+g.test('f16_vec3')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec3s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec3_const' : 'f16_vec3_non_const'
+    );
+    await run(t, builtin('length'), [TypeVec(3, TypeF16)], TypeF16, t.params, cases);
+  });
+
+g.test('f16_vec4')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec4s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec4_const' : 'f16_vec4_non_const'
+    );
+    await run(t, builtin('length'), [TypeVec(4, TypeF16)], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index b44b671f9432..d8b1845dd402 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5211,7 +5211,7 @@ class F16Traits extends FPTraits {
     this,
     'determinantInterval'
   );
-  public readonly distanceInterval = this.unimplementedDistance.bind(this);
+  public readonly distanceInterval = this.distanceIntervalImpl.bind(this);
   public readonly divisionInterval = this.divisionIntervalImpl.bind(this);
   public readonly dotInterval = this.dotIntervalImpl.bind(this);
   public readonly expInterval = this.expIntervalImpl.bind(this);
@@ -5225,7 +5225,7 @@ class F16Traits extends FPTraits {
     this,
     'ldexpInterval'
   );
-  public readonly lengthInterval = this.unimplementedLength.bind(this);
+  public readonly lengthInterval = this.lengthIntervalImpl.bind(this);
   public readonly logInterval = this.logIntervalImpl.bind(this);
   public readonly log2Interval = this.log2IntervalImpl.bind(this);
   public readonly maxInterval = this.maxIntervalImpl.bind(this);

From c2956655378dc2f27ba8e5b5f84cac1f73df3c45 Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Thu, 21 Sep 2023 11:13:30 -0700
Subject: [PATCH 059/166] Show parseQuery error (#2982)

Some errors in parsing the query string were only showing
in the JavaScript console so that for a bad query the test page
would just show nothing. This is an attempt to try to surface
those errors to the page.
---
 src/common/runtime/standalone.ts | 33 +++++++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 7 deletions(-)

diff --git a/src/common/runtime/standalone.ts b/src/common/runtime/standalone.ts
index 360760a8f50e..4ec300d30684 100644
--- a/src/common/runtime/standalone.ts
+++ b/src/common/runtime/standalone.ts
@@ -11,7 +11,7 @@ import { parseQuery } from '../internal/query/parseQuery.js';
 import { TestQueryLevel } from '../internal/query/query.js';
 import { TestTreeNode, TestSubtree, TestTreeLeaf, TestTree } from '../internal/tree.js';
 import { setDefaultRequestAdapterOptions } from '../util/navigator_gpu.js';
-import { assert, ErrorWithExtra, unreachable } from '../util/util.js';
+import { ErrorWithExtra, unreachable } from '../util/util.js';
 
 import {
   kCTSOptionsInfo,
@@ -543,6 +543,14 @@ function createSearchQuery(queries: string[], params?: string) {
   return `?${params}${params ? '&' : ''}${queries.map(q => 'q=' + q).join('&')}`;
 }
 
+/**
+ * Show an info message on the page.
+ * @param msg Message to show
+ */
+function showInfo(msg: string) {
+  $('#info')[0].textContent = msg;
+}
+
 void (async () => {
   const loader = new DefaultTestFileLoader();
 
@@ -609,26 +617,37 @@ void (async () => {
   };
   addOptionsToPage(options, kStandaloneOptionsInfos);
 
-  assert(qs.length === 1, 'currently, there must be exactly one ?q=');
-  const rootQuery = parseQuery(qs[0]);
+  if (qs.length !== 1) {
+    showInfo('currently, there must be exactly one ?q=');
+    return;
+  }
+
+  let rootQuery;
+  try {
+    rootQuery = parseQuery(qs[0]);
+  } catch (e) {
+    showInfo((e as Error).toString());
+    return;
+  }
+
   if (rootQuery.level > lastQueryLevelToExpand) {
     lastQueryLevelToExpand = rootQuery.level;
   }
   loader.addEventListener('import', ev => {
-    $('#info')[0].textContent = `loading: ${ev.data.url}`;
+    showInfo(`loading: ${ev.data.url}`);
   });
   loader.addEventListener('imported', ev => {
-    $('#info')[0].textContent = `imported: ${ev.data.url}`;
+    showInfo(`imported: ${ev.data.url}`);
   });
   loader.addEventListener('finish', () => {
-    $('#info')[0].textContent = '';
+    showInfo('');
   });
 
   let tree;
   try {
     tree = await loader.loadTree(rootQuery);
   } catch (err) {
-    $('#info')[0].textContent = (err as Error).toString();
+    showInfo((err as Error).toString());
     return;
   }
 

From 30c129e2ed4a61149eeb697d8abd6cb155b3e70f Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 25 Sep 2023 11:34:53 -0400
Subject: [PATCH 060/166] Change generate-cache to validate-cache (#2981)

For `npm test` only check that the cache validates (don't build it)
since building it is relatively expensive compared to other checks
performed.

Issue #2980
---
 Gruntfile.js                    | 10 +++++-----
 src/common/tools/.eslintrc.json |  2 ++
 src/common/tools/gen_cache.ts   | 10 +++++++++-
 3 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/Gruntfile.js b/Gruntfile.js
index a3d42a91ab31..51b4971a06bf 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -26,6 +26,10 @@ module.exports = function (grunt) {
         cmd: 'node',
         args: ['tools/validate', 'src/webgpu', 'src/stress', 'src/manual', 'src/unittests', 'src/demo'],
       },
+      'validate-cache': {
+        cmd: 'node',
+        args: ['tools/gen_cache', 'out', 'src/webgpu', '--validate'],
+      },
       'generate-wpt-cts-html': {
         cmd: 'node',
         args: ['tools/gen_wpt_cts_html', 'tools/gen_wpt_cfg_unchunked.json'],
@@ -34,10 +38,6 @@ module.exports = function (grunt) {
         cmd: 'node',
         args: ['tools/gen_wpt_cts_html', 'tools/gen_wpt_cfg_chunked2sec.json'],
       },
-      'generate-cache': {
-        cmd: 'node',
-        args: ['tools/gen_cache', 'out', 'src/webgpu'],
-      },
       unittest: {
         cmd: 'node',
         args: ['tools/run_node', 'unittests:*'],
@@ -194,11 +194,11 @@ module.exports = function (grunt) {
   registerTaskAndAddToHelp('pre', 'Run all presubmit checks: standalone+wpt+typecheck+unittest+lint', [
     'clean',
     'run:validate',
+    'run:validate-cache',
     'build-standalone',
     'run:generate-listings',
     'build-wpt',
     'run:build-out-node',
-    'run:generate-cache',
     'build-done-message',
     'ts:check',
     'run:presubmit',
diff --git a/src/common/tools/.eslintrc.json b/src/common/tools/.eslintrc.json
index aed978d4597a..9b5babff4432 100644
--- a/src/common/tools/.eslintrc.json
+++ b/src/common/tools/.eslintrc.json
@@ -1,4 +1,6 @@
 {
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": { "project": "../../../tsconfig.json" },
   "rules": {
     "no-console": "off",
     "no-process-exit": "off",
diff --git a/src/common/tools/gen_cache.ts b/src/common/tools/gen_cache.ts
index f4674d14db3a..c712f2ede48e 100644
--- a/src/common/tools/gen_cache.ts
+++ b/src/common/tools/gen_cache.ts
@@ -14,12 +14,13 @@ DataCache will load this instead of building the expensive data at CTS runtime.
 Options:
   --help          Print this message and exit.
   --list          Print the list of output files without writing them.
+  --validate      Check that cache should build (Tests for collisions).
   --verbose       Print each action taken.
 `);
   process.exit(rc);
 }
 
-let mode: 'emit' | 'list' = 'emit';
+let mode: 'emit' | 'list' | 'validate' = 'emit';
 let verbose = false;
 
 const nonFlagsArgs: string[] = [];
@@ -35,6 +36,9 @@ for (const a of process.argv) {
       case '--verbose':
         verbose = true;
         break;
+      case '--validate':
+        mode = 'validate';
+        break;
       default:
         console.log('unrecognized flag: ', a);
         usage(1);
@@ -148,6 +152,10 @@ and
             console.log(outPath);
             break;
           }
+          case 'validate': {
+            // Only check currently performed is the collision detection above
+            break;
+          }
         }
       }
     }

From 0447990a43973392ca18aec8a0422f67e5b6776e Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 25 Sep 2023 11:38:45 -0400
Subject: [PATCH 061/166] Convert specifying complex case combos to map-reduce
 generation (#2984)

This substantially reduces code size in a number of test files that
have to iterate all possible combinations of matrix sizes.

This pattern has been shown
(https://github.com/gpuweb/cts/issues/2980#issuecomment-1728701268) to
not have a significant performance hit on case generation.

A couple of situations where either there is expected changes in the
near future, i.e. adding AF or f16 tests, or there isn't a significant
win, i.e. frexp, have been omitted from this refactoring.

Fixes #2957

---------

Co-authored-by: jzm-intel <zhaoming.jiang@intel.com>
---
 .../expression/binary/af_addition.spec.ts     |  84 ++--
 .../binary/af_matrix_addition.spec.ts         |  91 +---
 .../binary/af_matrix_subtraction.spec.ts      |  91 +---
 .../binary/af_multiplication.spec.ts          |  84 ++--
 .../expression/binary/af_subtraction.spec.ts  |  84 ++--
 .../expression/binary/f16_addition.spec.ts    | 166 ++-----
 .../expression/binary/f16_division.spec.ts    | 158 ++----
 .../binary/f16_multiplication.spec.ts         | 158 ++----
 .../expression/binary/f16_remainder.spec.ts   | 158 ++----
 .../expression/binary/f16_subtraction.spec.ts | 158 ++----
 .../expression/binary/f32_addition.spec.ts    | 158 ++----
 .../expression/binary/f32_division.spec.ts    | 158 ++----
 .../binary/f32_matrix_addition.spec.ts        | 165 +------
 .../f32_matrix_matrix_multiplication.spec.ts  | 455 +-----------------
 .../f32_matrix_scalar_multiplication.spec.ts  | 326 ++-----------
 .../binary/f32_matrix_subtraction.spec.ts     | 165 +------
 .../f32_matrix_vector_multiplication.spec.ts  | 342 ++-----------
 .../binary/f32_multiplication.spec.ts         | 158 ++----
 .../expression/binary/f32_remainder.spec.ts   | 158 ++----
 .../expression/binary/f32_subtraction.spec.ts | 158 ++----
 .../call/builtin/determinant.spec.ts          |  58 +--
 .../expression/call/builtin/transpose.spec.ts | 367 ++------------
 22 files changed, 799 insertions(+), 3101 deletions(-)

diff --git a/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
index 508df8aab33e..1765ce3d95cb 100644
--- a/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
@@ -22,8 +22,8 @@ const additionScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('binary/af_addition', {
-  scalar: () => {
+const scalar_cases = {
+  ['scalar']: () => {
     return FP.abstract.generateScalarPairToIntervalCases(
       sparseF64Range(),
       sparseF64Range(),
@@ -31,54 +31,38 @@ export const d = makeCaseCache('binary/af_addition', {
       FP.abstract.additionInterval
     );
   },
-  vec2_scalar: () => {
-    return FP.abstract.generateVectorScalarToVectorCases(
-      sparseVectorF64Range(2),
-      sparseF64Range(),
-      'finite',
-      additionVectorScalarInterval
-    );
-  },
-  vec3_scalar: () => {
-    return FP.abstract.generateVectorScalarToVectorCases(
-      sparseVectorF64Range(3),
-      sparseF64Range(),
-      'finite',
-      additionVectorScalarInterval
-    );
-  },
-  vec4_scalar: () => {
-    return FP.abstract.generateVectorScalarToVectorCases(
-      sparseVectorF64Range(4),
-      sparseF64Range(),
-      'finite',
-      additionVectorScalarInterval
-    );
-  },
-  scalar_vec2: () => {
-    return FP.abstract.generateScalarVectorToVectorCases(
-      sparseF64Range(),
-      sparseVectorF64Range(2),
-      'finite',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec3: () => {
-    return FP.abstract.generateScalarVectorToVectorCases(
-      sparseF64Range(),
-      sparseVectorF64Range(3),
-      'finite',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec4: () => {
-    return FP.abstract.generateScalarVectorToVectorCases(
-      sparseF64Range(),
-      sparseVectorF64Range(4),
-      'finite',
-      additionScalarVectorInterval
-    );
-  },
+};
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`vec${dim}_scalar`]: () => {
+      return FP.abstract.generateVectorScalarToVectorCases(
+        sparseVectorF64Range(dim),
+        sparseF64Range(),
+        'finite',
+        additionVectorScalarInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`scalar_vec${dim}`]: () => {
+      return FP.abstract.generateScalarVectorToVectorCases(
+        sparseF64Range(),
+        sparseVectorF64Range(dim),
+        'finite',
+        additionScalarVectorInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/af_addition', {
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/af_matrix_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/af_matrix_addition.spec.ts
index 2897168d7225..86bddec89467 100644
--- a/src/webgpu/shader/execution/expression/binary/af_matrix_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_matrix_addition.spec.ts
@@ -14,80 +14,23 @@ import { abstractBinary } from './binary.js';
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('binary/af_matrix_addition', {
-  mat2x2: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(2, 2),
-      sparseMatrixF64Range(2, 2),
-      'finite',
-      FP.abstract.additionMatrixMatrixInterval
-    );
-  },
-  mat2x3: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(2, 3),
-      sparseMatrixF64Range(2, 3),
-      'finite',
-      FP.abstract.additionMatrixMatrixInterval
-    );
-  },
-  mat2x4: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(2, 4),
-      sparseMatrixF64Range(2, 4),
-      'finite',
-      FP.abstract.additionMatrixMatrixInterval
-    );
-  },
-  mat3x2: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(3, 2),
-      sparseMatrixF64Range(3, 2),
-      'finite',
-      FP.abstract.additionMatrixMatrixInterval
-    );
-  },
-  mat3x3: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(3, 3),
-      sparseMatrixF64Range(3, 3),
-      'finite',
-      FP.abstract.additionMatrixMatrixInterval
-    );
-  },
-  mat3x4: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(3, 4),
-      sparseMatrixF64Range(3, 4),
-      'finite',
-      FP.abstract.additionMatrixMatrixInterval
-    );
-  },
-  mat4x2: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(4, 2),
-      sparseMatrixF64Range(4, 2),
-      'finite',
-      FP.abstract.additionMatrixMatrixInterval
-    );
-  },
-  mat4x3: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(4, 3),
-      sparseMatrixF64Range(4, 3),
-      'finite',
-      FP.abstract.additionMatrixMatrixInterval
-    );
-  },
-  mat4x4: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(4, 4),
-      sparseMatrixF64Range(4, 4),
-      'finite',
-      FP.abstract.additionMatrixMatrixInterval
-    );
-  },
-});
+// Cases: matCxR
+const mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).map(rows => ({
+      [`mat${cols}x${rows}`]: () => {
+        return FP.abstract.generateMatrixPairToMatrixCases(
+          sparseMatrixF64Range(cols, rows),
+          sparseMatrixF64Range(cols, rows),
+          'finite',
+          FP.abstract.additionMatrixMatrixInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/af_matrix_addition', mat_cases);
 
 g.test('matrix')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
diff --git a/src/webgpu/shader/execution/expression/binary/af_matrix_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/af_matrix_subtraction.spec.ts
index 0837b05ff415..849c11611f80 100644
--- a/src/webgpu/shader/execution/expression/binary/af_matrix_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_matrix_subtraction.spec.ts
@@ -14,80 +14,23 @@ import { abstractBinary } from './binary.js';
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('abstractBinary/af_matrix_subtraction', {
-  mat2x2: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(2, 2),
-      sparseMatrixF64Range(2, 2),
-      'finite',
-      FP.abstract.subtractionMatrixMatrixInterval
-    );
-  },
-  mat2x3: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(2, 3),
-      sparseMatrixF64Range(2, 3),
-      'finite',
-      FP.abstract.subtractionMatrixMatrixInterval
-    );
-  },
-  mat2x4: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(2, 4),
-      sparseMatrixF64Range(2, 4),
-      'finite',
-      FP.abstract.subtractionMatrixMatrixInterval
-    );
-  },
-  mat3x2: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(3, 2),
-      sparseMatrixF64Range(3, 2),
-      'finite',
-      FP.abstract.subtractionMatrixMatrixInterval
-    );
-  },
-  mat3x3: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(3, 3),
-      sparseMatrixF64Range(3, 3),
-      'finite',
-      FP.abstract.subtractionMatrixMatrixInterval
-    );
-  },
-  mat3x4: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(3, 4),
-      sparseMatrixF64Range(3, 4),
-      'finite',
-      FP.abstract.subtractionMatrixMatrixInterval
-    );
-  },
-  mat4x2: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(4, 2),
-      sparseMatrixF64Range(4, 2),
-      'finite',
-      FP.abstract.subtractionMatrixMatrixInterval
-    );
-  },
-  mat4x3: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(4, 3),
-      sparseMatrixF64Range(4, 3),
-      'finite',
-      FP.abstract.subtractionMatrixMatrixInterval
-    );
-  },
-  mat4x4: () => {
-    return FP.abstract.generateMatrixPairToMatrixCases(
-      sparseMatrixF64Range(4, 4),
-      sparseMatrixF64Range(4, 4),
-      'finite',
-      FP.abstract.subtractionMatrixMatrixInterval
-    );
-  },
-});
+// Cases: matCxR
+const mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).map(rows => ({
+      [`mat${cols}x${rows}`]: () => {
+        return FP.abstract.generateMatrixPairToMatrixCases(
+          sparseMatrixF64Range(cols, rows),
+          sparseMatrixF64Range(cols, rows),
+          'finite',
+          FP.abstract.subtractionMatrixMatrixInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/af_matrix_subtraction', mat_cases);
 
 g.test('matrix')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
diff --git a/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
index 2f1231bf02b2..83d60aaa9a23 100644
--- a/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
@@ -22,8 +22,8 @@ const multiplicationScalarVectorInterval = (s: number, v: number[]): FPVector =>
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('abstractBinary/af_multiplication', {
-  scalar: () => {
+const scalar_cases = {
+  ['scalar']: () => {
     return FP.abstract.generateScalarPairToIntervalCases(
       sparseF64Range(),
       sparseF64Range(),
@@ -31,54 +31,38 @@ export const d = makeCaseCache('abstractBinary/af_multiplication', {
       FP.abstract.multiplicationInterval
     );
   },
-  vec2_scalar: () => {
-    return FP.abstract.generateVectorScalarToVectorCases(
-      sparseVectorF64Range(2),
-      sparseF64Range(),
-      'finite',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec3_scalar: () => {
-    return FP.abstract.generateVectorScalarToVectorCases(
-      sparseVectorF64Range(3),
-      sparseF64Range(),
-      'finite',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec4_scalar: () => {
-    return FP.abstract.generateVectorScalarToVectorCases(
-      sparseVectorF64Range(4),
-      sparseF64Range(),
-      'finite',
-      multiplicationVectorScalarInterval
-    );
-  },
-  scalar_vec2: () => {
-    return FP.abstract.generateScalarVectorToVectorCases(
-      sparseF64Range(),
-      sparseVectorF64Range(2),
-      'finite',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec3: () => {
-    return FP.abstract.generateScalarVectorToVectorCases(
-      sparseF64Range(),
-      sparseVectorF64Range(3),
-      'finite',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec4: () => {
-    return FP.abstract.generateScalarVectorToVectorCases(
-      sparseF64Range(),
-      sparseVectorF64Range(4),
-      'finite',
-      multiplicationScalarVectorInterval
-    );
-  },
+};
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`vec${dim}_scalar`]: () => {
+      return FP.abstract.generateVectorScalarToVectorCases(
+        sparseVectorF64Range(dim),
+        sparseF64Range(),
+        'finite',
+        multiplicationVectorScalarInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`scalar_vec${dim}`]: () => {
+      return FP.abstract.generateScalarVectorToVectorCases(
+        sparseF64Range(),
+        sparseVectorF64Range(dim),
+        'finite',
+        multiplicationScalarVectorInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/af_multiplication', {
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
index 5c4528209381..c2d4cd90941c 100644
--- a/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
@@ -22,8 +22,8 @@ const subtractionScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('abstractBinary/af_subtraction', {
-  scalar: () => {
+const scalar_cases = {
+  ['scalar']: () => {
     return FP.abstract.generateScalarPairToIntervalCases(
       sparseF64Range(),
       sparseF64Range(),
@@ -31,54 +31,38 @@ export const d = makeCaseCache('abstractBinary/af_subtraction', {
       FP.abstract.subtractionInterval
     );
   },
-  vec2_scalar: () => {
-    return FP.abstract.generateVectorScalarToVectorCases(
-      sparseVectorF64Range(2),
-      sparseF64Range(),
-      'finite',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec3_scalar: () => {
-    return FP.abstract.generateVectorScalarToVectorCases(
-      sparseVectorF64Range(3),
-      sparseF64Range(),
-      'finite',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec4_scalar: () => {
-    return FP.abstract.generateVectorScalarToVectorCases(
-      sparseVectorF64Range(4),
-      sparseF64Range(),
-      'finite',
-      subtractionVectorScalarInterval
-    );
-  },
-  scalar_vec2: () => {
-    return FP.abstract.generateScalarVectorToVectorCases(
-      sparseF64Range(),
-      sparseVectorF64Range(2),
-      'finite',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec3: () => {
-    return FP.abstract.generateScalarVectorToVectorCases(
-      sparseF64Range(),
-      sparseVectorF64Range(3),
-      'finite',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec4: () => {
-    return FP.abstract.generateScalarVectorToVectorCases(
-      sparseF64Range(),
-      sparseVectorF64Range(4),
-      'finite',
-      subtractionScalarVectorInterval
-    );
-  },
+};
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`vec${dim}_scalar`]: () => {
+      return FP.abstract.generateVectorScalarToVectorCases(
+        sparseVectorF64Range(dim),
+        sparseF64Range(),
+        'finite',
+        subtractionVectorScalarInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`scalar_vec${dim}`]: () => {
+      return FP.abstract.generateScalarVectorToVectorCases(
+        sparseF64Range(),
+        sparseVectorF64Range(dim),
+        'finite',
+        subtractionScalarVectorInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/af_subtraction', {
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts
index 59360bff9e04..e285277b5cf4 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts
@@ -22,127 +22,53 @@ const additionScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f16.generateScalarPairToIntervalCases(
+        sparseF16Range(),
+        sparseF16Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f16.additionInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorScalarToVectorCases(
+          sparseVectorF16Range(dim),
+          sparseF16Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          additionVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateScalarVectorToVectorCases(
+          sparseF16Range(),
+          sparseVectorF16Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          additionScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f16_addition', {
-  scalar_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'finite',
-      FP.f16.additionInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'unfiltered',
-      FP.f16.additionInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'finite',
-      additionVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'unfiltered',
-      additionVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'finite',
-      additionVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'unfiltered',
-      additionVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'finite',
-      additionVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'unfiltered',
-      additionVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'finite',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'unfiltered',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'finite',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'unfiltered',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'finite',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'unfiltered',
-      additionScalarVectorInterval
-    );
-  },
-  subtraction_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'finite',
-      FP.f16.subtractionInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts
index 3e54ff683314..346c38499df2 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts
@@ -22,119 +22,53 @@ const divisionScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f16.generateScalarPairToIntervalCases(
+        sparseF16Range(),
+        sparseF16Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f16.divisionInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorScalarToVectorCases(
+          sparseVectorF16Range(dim),
+          sparseF16Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          divisionVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateScalarVectorToVectorCases(
+          sparseF16Range(),
+          sparseVectorF16Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          divisionScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f16_division', {
-  scalar_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'finite',
-      FP.f16.divisionInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'unfiltered',
-      FP.f16.divisionInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'finite',
-      divisionVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'unfiltered',
-      divisionVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'finite',
-      divisionVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'unfiltered',
-      divisionVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'finite',
-      divisionVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'unfiltered',
-      divisionVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'finite',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'unfiltered',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'finite',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'unfiltered',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'finite',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'unfiltered',
-      divisionScalarVectorInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts
index bff045a88758..a2985ec0303f 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts
@@ -22,119 +22,53 @@ const multiplicationScalarVectorInterval = (s: number, v: number[]): FPVector =>
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f16.generateScalarPairToIntervalCases(
+        sparseF16Range(),
+        sparseF16Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f16.multiplicationInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorScalarToVectorCases(
+          sparseVectorF16Range(dim),
+          sparseF16Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          multiplicationVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateScalarVectorToVectorCases(
+          sparseF16Range(),
+          sparseVectorF16Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          multiplicationScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f16_multiplication', {
-  scalar_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'finite',
-      FP.f16.multiplicationInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'unfiltered',
-      FP.f16.multiplicationInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'finite',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'unfiltered',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'finite',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'unfiltered',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'finite',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'unfiltered',
-      multiplicationVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'finite',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'unfiltered',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'finite',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'unfiltered',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'finite',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'unfiltered',
-      multiplicationScalarVectorInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts
index 29a0703b8f1e..5a9de5d84e1c 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts
@@ -22,119 +22,53 @@ const remainderScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f16.generateScalarPairToIntervalCases(
+        sparseF16Range(),
+        sparseF16Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f16.remainderInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorScalarToVectorCases(
+          sparseVectorF16Range(dim),
+          sparseF16Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          remainderVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateScalarVectorToVectorCases(
+          sparseF16Range(),
+          sparseVectorF16Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          remainderScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f16_remainder', {
-  scalar_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'finite',
-      FP.f16.remainderInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'unfiltered',
-      FP.f16.remainderInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'finite',
-      remainderVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'unfiltered',
-      remainderVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'finite',
-      remainderVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'unfiltered',
-      remainderVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'finite',
-      remainderVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'unfiltered',
-      remainderVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'finite',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'unfiltered',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'finite',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'unfiltered',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'finite',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'unfiltered',
-      remainderScalarVectorInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts
index c1755502ba09..81c0d94845c6 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts
@@ -22,119 +22,53 @@ const subtractionScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f16.generateScalarPairToIntervalCases(
+        sparseF16Range(),
+        sparseF16Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f16.subtractionInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorScalarToVectorCases(
+          sparseVectorF16Range(dim),
+          sparseF16Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          subtractionVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateScalarVectorToVectorCases(
+          sparseF16Range(),
+          sparseVectorF16Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          subtractionScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f16_subtraction', {
-  scalar_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'finite',
-      FP.f16.subtractionInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f16.generateScalarPairToIntervalCases(
-      sparseF16Range(),
-      sparseF16Range(),
-      'unfiltered',
-      FP.f16.subtractionInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'finite',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(2),
-      sparseF16Range(),
-      'unfiltered',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'finite',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(3),
-      sparseF16Range(),
-      'unfiltered',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'finite',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f16.generateVectorScalarToVectorCases(
-      sparseVectorF16Range(4),
-      sparseF16Range(),
-      'unfiltered',
-      subtractionVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'finite',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(2),
-      'unfiltered',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'finite',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(3),
-      'unfiltered',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'finite',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f16.generateScalarVectorToVectorCases(
-      sparseF16Range(),
-      sparseVectorF16Range(4),
-      'unfiltered',
-      subtractionScalarVectorInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
index 4ad38d1727c6..53051b29e364 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
@@ -22,119 +22,53 @@ const additionScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f32.generateScalarPairToIntervalCases(
+        sparseF32Range(),
+        sparseF32Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f32.additionInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorScalarToVectorCases(
+          sparseVectorF32Range(dim),
+          sparseF32Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          additionVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateScalarVectorToVectorCases(
+          sparseF32Range(),
+          sparseVectorF32Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          additionScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f32_addition', {
-  scalar_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'finite',
-      FP.f32.additionInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.additionInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'finite',
-      additionVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'unfiltered',
-      additionVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'finite',
-      additionVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'unfiltered',
-      additionVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'finite',
-      additionVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'unfiltered',
-      additionVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'finite',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'finite',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'finite',
-      additionScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      additionScalarVectorInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts
index e9fa078ec2f8..f2d5b6a1c70a 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts
@@ -22,119 +22,53 @@ const divisionScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f32.generateScalarPairToIntervalCases(
+        sparseF32Range(),
+        sparseF32Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f32.divisionInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorScalarToVectorCases(
+          sparseVectorF32Range(dim),
+          sparseF32Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          divisionVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateScalarVectorToVectorCases(
+          sparseF32Range(),
+          sparseVectorF32Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          divisionScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f32_division', {
-  scalar_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'finite',
-      FP.f32.divisionInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.divisionInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'finite',
-      divisionVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'unfiltered',
-      divisionVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'finite',
-      divisionVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'unfiltered',
-      divisionVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'finite',
-      divisionVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'unfiltered',
-      divisionVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'finite',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'finite',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'finite',
-      divisionScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      divisionScalarVectorInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_matrix_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_matrix_addition.spec.ts
index cd78168a9d53..9f11c3cac19d 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_matrix_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_matrix_addition.spec.ts
@@ -14,152 +14,25 @@ import { binary, compoundBinary } from './binary.js';
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('binary/f32_matrix_addition', {
-  mat2x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat2x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat2x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(2, 3),
-      'finite',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat2x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(2, 3),
-      'unfiltered',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat2x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(2, 4),
-      'finite',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat2x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(2, 4),
-      'unfiltered',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat3x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(3, 2),
-      'finite',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat3x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(3, 2),
-      'unfiltered',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat3x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(3, 3),
-      'finite',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat3x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(3, 3),
-      'unfiltered',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat3x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(3, 4),
-      'finite',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat3x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(3, 4),
-      'unfiltered',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat4x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(4, 2),
-      'finite',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat4x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(4, 2),
-      'unfiltered',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat4x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(4, 3),
-      'finite',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat4x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(4, 3),
-      'unfiltered',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat4x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(4, 4),
-      'finite',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-  mat4x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(4, 4),
-      'unfiltered',
-      FP.f32.additionMatrixMatrixInterval
-    );
-  },
-});
+// Cases: matCxR_[non_]const
+const mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f32.generateMatrixPairToMatrixCases(
+            sparseMatrixF32Range(cols, rows),
+            sparseMatrixF32Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f32.additionMatrixMatrixInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/f32_matrix_addition', mat_cases);
 
 g.test('matrix')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_matrix_matrix_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_matrix_matrix_multiplication.spec.ts
index 76e30682ecbd..2c48eab1872c 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_matrix_matrix_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_matrix_matrix_multiplication.spec.ts
@@ -14,440 +14,27 @@ import { binary, compoundBinary } from './binary.js';
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('binary/f32_matrix_matrix_multiplication', {
-  mat2x2_mat2x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x2_mat2x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x3_mat2x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x3_mat2x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x2_mat3x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(3, 2),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x2_mat3x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(3, 2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x3_mat3x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(3, 2),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x3_mat3x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(3, 2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x4_mat2x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x4_mat2x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x2_mat4x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(4, 2),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x2_mat4x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(4, 2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x4_mat4x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(4, 2),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x4_mat4x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(4, 2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x3_mat4x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(4, 2),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x3_mat4x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(4, 2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x4_mat3x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(3, 2),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat2x4_mat3x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(3, 2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x3_mat3x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(3, 3),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x3_mat3x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(3, 3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x2_mat3x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(3, 3),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x2_mat3x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(3, 3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x3_mat2x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(2, 3),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x3_mat2x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(2, 3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x2_mat2x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(2, 3),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x2_mat2x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(2, 3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x4_mat3x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(3, 3),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x4_mat3x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(3, 3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x3_mat4x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(4, 3),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x3_mat4x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(4, 3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x4_mat4x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(4, 3),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x4_mat4x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(4, 3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x2_mat4x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(4, 3),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x2_mat4x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(4, 3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x4_mat2x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(2, 3),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat3x4_mat2x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(2, 3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x4_mat4x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(4, 4),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x4_mat4x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(4, 4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x2_mat4x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(4, 4),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x2_mat4x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(4, 4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x4_mat2x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(2, 4),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x4_mat2x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(2, 4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x2_mat2x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(2, 4),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x2_mat2x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(2, 4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x3_mat4x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(4, 4),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x3_mat4x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(4, 4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x4_mat3x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(3, 4),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x4_mat3x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(3, 4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x3_mat3x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(3, 4),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x3_mat3x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(3, 4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x2_mat3x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(3, 4),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x2_mat3x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(3, 4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x3_mat2x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(2, 4),
-      'finite',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-  mat4x3_mat2x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(2, 4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixMatrixInterval
-    );
-  },
-});
+// Cases: matKxR_matCxK_[non_]const
+const mat_mat_cases = ([2, 3, 4] as const)
+  .flatMap(k =>
+    ([2, 3, 4] as const).flatMap(cols =>
+      ([2, 3, 4] as const).flatMap(rows =>
+        ([true, false] as const).map(nonConst => ({
+          [`mat${k}x${rows}_mat${cols}x${k}_${nonConst ? 'non_const' : 'const'}`]: () => {
+            return FP.f32.generateMatrixPairToMatrixCases(
+              sparseMatrixF32Range(k, rows),
+              sparseMatrixF32Range(cols, k),
+              nonConst ? 'unfiltered' : 'finite',
+              FP.f32.multiplicationMatrixMatrixInterval
+            );
+          },
+        }))
+      )
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/f32_matrix_matrix_multiplication', mat_mat_cases);
 
 g.test('matrix_matrix')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_matrix_scalar_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_matrix_scalar_multiplication.spec.ts
index 4ce8072cc1cd..f3d36b83828a 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_matrix_scalar_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_matrix_scalar_multiplication.spec.ts
@@ -14,295 +14,45 @@ import { binary, compoundBinary } from './binary.js';
 
 export const g = makeTestGroup(GPUTest);
 
+// Cases: matCxR_scalar_[non_]const
+const mat_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`mat${cols}x${rows}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f32.generateMatrixScalarToMatrixCases(
+            sparseMatrixF32Range(cols, rows),
+            sparseF32Range(),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f32.multiplicationMatrixScalarInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: scalar_matCxR_[non_]const
+const scalar_mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`scalar_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f32.generateScalarMatrixToMatrixCases(
+            sparseF32Range(),
+            sparseMatrixF32Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f32.multiplicationScalarMatrixInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f32_matrix_scalar_multiplication', {
-  mat2x2_scalar_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat2x2_scalar_non_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat2x3_scalar_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat2x3_scalar_non_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat2x4_scalar_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat2x4_scalar_non_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat3x2_scalar_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat3x2_scalar_non_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat3x3_scalar_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat3x3_scalar_non_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat3x4_scalar_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat3x4_scalar_non_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat4x2_scalar_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat4x2_scalar_non_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat4x3_scalar_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat4x3_scalar_non_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat4x4_scalar_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  mat4x4_scalar_non_const: () => {
-    return FP.f32.generateMatrixScalarToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationMatrixScalarInterval
-    );
-  },
-  scalar_mat2x2_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat2x2_non_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat2x3_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(2, 3),
-      'finite',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat2x3_non_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(2, 3),
-      'unfiltered',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat2x4_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(2, 4),
-      'finite',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat2x4_non_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(2, 4),
-      'unfiltered',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat3x2_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(3, 2),
-      'finite',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat3x2_non_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(3, 2),
-      'unfiltered',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat3x3_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(3, 3),
-      'finite',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat3x3_non_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(3, 3),
-      'unfiltered',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat3x4_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(3, 4),
-      'finite',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat3x4_non_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(3, 4),
-      'unfiltered',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat4x2_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(4, 2),
-      'finite',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat4x2_non_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(4, 2),
-      'unfiltered',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat4x3_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(4, 3),
-      'finite',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat4x3_non_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(4, 3),
-      'unfiltered',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat4x4_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(4, 4),
-      'finite',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
-  scalar_mat4x4_non_const: () => {
-    return FP.f32.generateScalarMatrixToMatrixCases(
-      sparseF32Range(),
-      sparseMatrixF32Range(4, 4),
-      'unfiltered',
-      FP.f32.multiplicationScalarMatrixInterval
-    );
-  },
+  ...mat_scalar_cases,
+  ...scalar_mat_cases,
 });
 
 g.test('matrix_scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_matrix_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_matrix_subtraction.spec.ts
index 67bb46448741..5f101d9b270f 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_matrix_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_matrix_subtraction.spec.ts
@@ -14,152 +14,25 @@ import { binary, compoundBinary } from './binary.js';
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('binary/f32_matrix_subtraction', {
-  mat2x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat2x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat2x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(2, 3),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat2x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      sparseMatrixF32Range(2, 3),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat2x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(2, 4),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat2x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      sparseMatrixF32Range(2, 4),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat3x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(3, 2),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat3x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      sparseMatrixF32Range(3, 2),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat3x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(3, 3),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat3x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      sparseMatrixF32Range(3, 3),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat3x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(3, 4),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat3x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      sparseMatrixF32Range(3, 4),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat4x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(4, 2),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat4x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      sparseMatrixF32Range(4, 2),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat4x3_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(4, 3),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat4x3_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      sparseMatrixF32Range(4, 3),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat4x4_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(4, 4),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  mat4x4_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      sparseMatrixF32Range(4, 4),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-});
+// Cases: matCxR_[non_]const
+const mat_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f32.generateMatrixPairToMatrixCases(
+            sparseMatrixF32Range(cols, rows),
+            sparseMatrixF32Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f32.subtractionMatrixMatrixInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/f32_matrix_subtraction', mat_cases);
 
 g.test('matrix')
   .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_matrix_vector_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_matrix_vector_multiplication.spec.ts
index f0e863cd2beb..e6cdf16d9240 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_matrix_vector_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_matrix_vector_multiplication.spec.ts
@@ -14,311 +14,45 @@ import { binary, compoundBinary } from './binary.js';
 
 export const g = makeTestGroup(GPUTest);
 
+// Cases: matCxR_vecC_[non_]const
+const mat_vec_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`mat${cols}x${rows}_vec${cols}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f32.generateMatrixVectorToVectorCases(
+            sparseMatrixF32Range(cols, rows),
+            sparseVectorF32Range(cols),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f32.multiplicationMatrixVectorInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: vecR_matCxR_[non_]const
+const vec_mat_cases = ([2, 3, 4] as const)
+  .flatMap(rows =>
+    ([2, 3, 4] as const).flatMap(cols =>
+      ([true, false] as const).map(nonConst => ({
+        [`vec${rows}_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f32.generateVectorMatrixToVectorCases(
+            sparseVectorF32Range(rows),
+            sparseMatrixF32Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f32.multiplicationVectorMatrixInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f32_matrix_vector_multiplication', {
-  mat2x2_vec2_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(2, 2),
-      sparseVectorF32Range(2),
-      'finite',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat2x2_vec2_non_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(2, 2),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat2x3_vec2_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(2, 3),
-      sparseVectorF32Range(2),
-      'finite',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat2x3_vec2_non_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(2, 3),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat2x4_vec2_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(2, 4),
-      sparseVectorF32Range(2),
-      'finite',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat2x4_vec2_non_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(2, 4),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat3x2_vec3_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(3, 2),
-      sparseVectorF32Range(3),
-      'finite',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat3x2_vec3_non_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(3, 2),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat3x3_vec3_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(3, 3),
-      sparseVectorF32Range(3),
-      'finite',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat3x3_vec3_non_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(3, 3),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat3x4_vec3_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(3, 4),
-      sparseVectorF32Range(3),
-      'finite',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat3x4_vec3_non_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(3, 4),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat4x2_vec4_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(4, 2),
-      sparseVectorF32Range(4),
-      'finite',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat4x2_vec4_non_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(4, 2),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat4x3_vec4_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(4, 3),
-      sparseVectorF32Range(4),
-      'finite',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat4x3_vec4_non_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(4, 3),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat4x4_vec4_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(4, 4),
-      sparseVectorF32Range(4),
-      'finite',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  mat4x4_vec4_non_const: () => {
-    return FP.f32.generateMatrixVectorToVectorCases(
-      sparseMatrixF32Range(4, 4),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      FP.f32.multiplicationMatrixVectorInterval
-    );
-  },
-  vec2_mat2x2_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(2),
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec2_mat2x2_non_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(2),
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec2_mat3x2_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(2),
-      sparseMatrixF32Range(3, 2),
-      'finite',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec2_mat3x2_non_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(2),
-      sparseMatrixF32Range(3, 2),
-      'unfiltered',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec2_mat4x2_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(2),
-      sparseMatrixF32Range(4, 2),
-      'finite',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec2_mat4x2_non_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(2),
-      sparseMatrixF32Range(4, 2),
-      'unfiltered',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec3_mat2x3_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(3),
-      sparseMatrixF32Range(2, 3),
-      'finite',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec3_mat2x3_non_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(3),
-      sparseMatrixF32Range(2, 3),
-      'unfiltered',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec3_mat3x3_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(3),
-      sparseMatrixF32Range(3, 3),
-      'finite',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec3_mat3x3_non_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(3),
-      sparseMatrixF32Range(3, 3),
-      'unfiltered',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec3_mat4x3_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(3),
-      sparseMatrixF32Range(4, 3),
-      'finite',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec3_mat4x3_non_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(3),
-      sparseMatrixF32Range(4, 3),
-      'unfiltered',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec4_mat2x4_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(4),
-      sparseMatrixF32Range(2, 4),
-      'finite',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec4_mat2x4_non_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(4),
-      sparseMatrixF32Range(2, 4),
-      'unfiltered',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec4_mat3x4_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(4),
-      sparseMatrixF32Range(3, 4),
-      'finite',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec4_mat3x4_non_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(4),
-      sparseMatrixF32Range(3, 4),
-      'unfiltered',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec4_mat4x4_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(4),
-      sparseMatrixF32Range(4, 4),
-      'finite',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  vec4_mat4x4_non_const: () => {
-    return FP.f32.generateVectorMatrixToVectorCases(
-      sparseVectorF32Range(4),
-      sparseMatrixF32Range(4, 4),
-      'unfiltered',
-      FP.f32.multiplicationVectorMatrixInterval
-    );
-  },
-  subtraction_mat2x2_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
-  subtraction_mat2x2_non_const: () => {
-    return FP.f32.generateMatrixPairToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.subtractionMatrixMatrixInterval
-    );
-  },
+  ...mat_vec_cases,
+  ...vec_mat_cases,
 });
 
 g.test('matrix_vector')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts
index f2f644a7b225..406642fcb553 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts
@@ -22,119 +22,53 @@ const multiplicationScalarVectorInterval = (s: number, v: number[]): FPVector =>
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f32.generateScalarPairToIntervalCases(
+        sparseF32Range(),
+        sparseF32Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f32.multiplicationInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorScalarToVectorCases(
+          sparseVectorF32Range(dim),
+          sparseF32Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          multiplicationVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateScalarVectorToVectorCases(
+          sparseF32Range(),
+          sparseVectorF32Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          multiplicationScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f32_multiplication', {
-  scalar_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'finite',
-      FP.f32.multiplicationInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.multiplicationInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'finite',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'unfiltered',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'finite',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'unfiltered',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'finite',
-      multiplicationVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'unfiltered',
-      multiplicationVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'finite',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'finite',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'finite',
-      multiplicationScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      multiplicationScalarVectorInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts
index d948047bbdf0..44058939b83a 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts
@@ -22,119 +22,53 @@ const remainderScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f32.generateScalarPairToIntervalCases(
+        sparseF32Range(),
+        sparseF32Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f32.remainderInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorScalarToVectorCases(
+          sparseVectorF32Range(dim),
+          sparseF32Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          remainderVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateScalarVectorToVectorCases(
+          sparseF32Range(),
+          sparseVectorF32Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          remainderScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f32_remainder', {
-  scalar_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'finite',
-      FP.f32.remainderInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.remainderInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'finite',
-      remainderVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'unfiltered',
-      remainderVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'finite',
-      remainderVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'unfiltered',
-      remainderVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'finite',
-      remainderVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'unfiltered',
-      remainderVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'finite',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'finite',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'finite',
-      remainderScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      remainderScalarVectorInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts
index 2eb137a1555a..0fbb2e8d7107 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts
@@ -22,119 +22,53 @@ const subtractionScalarVectorInterval = (s: number, v: number[]): FPVector => {
 
 export const g = makeTestGroup(GPUTest);
 
+const scalar_cases = ([true, false] as const)
+  .map(nonConst => ({
+    [`scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+      return FP.f32.generateScalarPairToIntervalCases(
+        sparseF32Range(),
+        sparseF32Range(),
+        nonConst ? 'unfiltered' : 'finite',
+        FP.f32.subtractionInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`vec${dim}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorScalarToVectorCases(
+          sparseVectorF32Range(dim),
+          sparseF32Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          subtractionVectorScalarInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`scalar_vec${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateScalarVectorToVectorCases(
+          sparseF32Range(),
+          sparseVectorF32Range(dim),
+          nonConst ? 'unfiltered' : 'finite',
+          subtractionScalarVectorInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('binary/f32_subtraction', {
-  scalar_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'finite',
-      FP.f32.subtractionInterval
-    );
-  },
-  scalar_non_const: () => {
-    return FP.f32.generateScalarPairToIntervalCases(
-      sparseF32Range(),
-      sparseF32Range(),
-      'unfiltered',
-      FP.f32.subtractionInterval
-    );
-  },
-  vec2_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'finite',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec2_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'unfiltered',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec3_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'finite',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec3_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'unfiltered',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec4_scalar_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'finite',
-      subtractionVectorScalarInterval
-    );
-  },
-  vec4_scalar_non_const: () => {
-    return FP.f32.generateVectorScalarToVectorCases(
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'unfiltered',
-      subtractionVectorScalarInterval
-    );
-  },
-  scalar_vec2_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'finite',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec2_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec3_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'finite',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec3_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec4_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'finite',
-      subtractionScalarVectorInterval
-    );
-  },
-  scalar_vec4_non_const: () => {
-    return FP.f32.generateScalarVectorToVectorCases(
-      sparseF32Range(),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      subtractionScalarVectorInterval
-    );
-  },
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
 });
 
 g.test('scalar')
diff --git a/src/webgpu/shader/execution/expression/call/builtin/determinant.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/determinant.spec.ts
index be06606673e5..466d1dc02276 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/determinant.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/determinant.spec.ts
@@ -64,49 +64,23 @@ const kDeterminantMatrixF32Values = {
   ]),
 };
 
+// Cases: f32_matDxD_[non_]const
+const f32_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`f32_mat${dim}x${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateMatrixToScalarCases(
+          kDeterminantMatrixF32Values[dim],
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f32.determinantInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('determinant', {
-  f32_mat2x2_const: () => {
-    return FP.f32.generateMatrixToScalarCases(
-      kDeterminantMatrixF32Values[2],
-      'finite',
-      FP.f32.determinantInterval
-    );
-  },
-  f32_mat2x2_non_const: () => {
-    return FP.f32.generateMatrixToScalarCases(
-      kDeterminantMatrixF32Values[2],
-      'unfiltered',
-      FP.f32.determinantInterval
-    );
-  },
-  f32_mat3x3_const: () => {
-    return FP.f32.generateMatrixToScalarCases(
-      kDeterminantMatrixF32Values[3],
-      'finite',
-      FP.f32.determinantInterval
-    );
-  },
-  f32_mat3x3_non_const: () => {
-    return FP.f32.generateMatrixToScalarCases(
-      kDeterminantMatrixF32Values[3],
-      'unfiltered',
-      FP.f32.determinantInterval
-    );
-  },
-  f32_mat4x4_const: () => {
-    return FP.f32.generateMatrixToScalarCases(
-      kDeterminantMatrixF32Values[4],
-      'finite',
-      FP.f32.determinantInterval
-    );
-  },
-  f32_mat4x4_non_const: () => {
-    return FP.f32.generateMatrixToScalarCases(
-      kDeterminantMatrixF32Values[4],
-      'unfiltered',
-      FP.f32.determinantInterval
-    );
-  },
+  ...f32_cases,
 });
 
 g.test('abstract_float')
diff --git a/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts
index a37e0987797a..6fd4887f357c 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/transpose.spec.ts
@@ -22,322 +22,59 @@ import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
+// Cases: f32_matCxR_[non_]const
+const f32_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`f32_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f32.generateMatrixToMatrixCases(
+            sparseMatrixF32Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f32.transposeInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_matCxR_[non_]const
+const f16_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).flatMap(rows =>
+      ([true, false] as const).map(nonConst => ({
+        [`f16_mat${cols}x${rows}_${nonConst ? 'non_const' : 'const'}`]: () => {
+          return FP.f16.generateMatrixToMatrixCases(
+            sparseMatrixF16Range(cols, rows),
+            nonConst ? 'unfiltered' : 'finite',
+            FP.f16.transposeInterval
+          );
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: abstract_matCxR
+const abstract_cases = ([2, 3, 4] as const)
+  .flatMap(cols =>
+    ([2, 3, 4] as const).map(rows => ({
+      [`abstract_mat${cols}x${rows}`]: () => {
+        return FP.abstract.generateMatrixToMatrixCases(
+          sparseMatrixF64Range(cols, rows),
+          'finite',
+          FP.abstract.transposeInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('transpose', {
-  abstract_mat2x2: () => {
-    return FP.abstract.generateMatrixToMatrixCases(
-      sparseMatrixF64Range(2, 2),
-      'finite',
-      FP.abstract.transposeInterval
-    );
-  },
-  abstract_mat2x3: () => {
-    return FP.abstract.generateMatrixToMatrixCases(
-      sparseMatrixF64Range(2, 3),
-      'finite',
-      FP.abstract.transposeInterval
-    );
-  },
-  abstract_mat2x4: () => {
-    return FP.abstract.generateMatrixToMatrixCases(
-      sparseMatrixF64Range(2, 4),
-      'finite',
-      FP.abstract.transposeInterval
-    );
-  },
-  abstract_mat3x2: () => {
-    return FP.abstract.generateMatrixToMatrixCases(
-      sparseMatrixF64Range(3, 2),
-      'finite',
-      FP.abstract.transposeInterval
-    );
-  },
-  abstract_mat3x3: () => {
-    return FP.abstract.generateMatrixToMatrixCases(
-      sparseMatrixF64Range(3, 3),
-      'finite',
-      FP.abstract.transposeInterval
-    );
-  },
-  abstract_mat3x4: () => {
-    return FP.abstract.generateMatrixToMatrixCases(
-      sparseMatrixF64Range(3, 4),
-      'finite',
-      FP.abstract.transposeInterval
-    );
-  },
-  abstract_mat4x2: () => {
-    return FP.abstract.generateMatrixToMatrixCases(
-      sparseMatrixF64Range(4, 2),
-      'finite',
-      FP.abstract.transposeInterval
-    );
-  },
-  abstract_mat4x3: () => {
-    return FP.abstract.generateMatrixToMatrixCases(
-      sparseMatrixF64Range(4, 3),
-      'finite',
-      FP.abstract.transposeInterval
-    );
-  },
-  abstract_mat4x4: () => {
-    return FP.abstract.generateMatrixToMatrixCases(
-      sparseMatrixF64Range(4, 4),
-      'finite',
-      FP.abstract.transposeInterval
-    );
-  },
-  f32_mat2x2_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      'finite',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat2x2_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 2),
-      'unfiltered',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat2x3_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      'finite',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat2x3_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 3),
-      'unfiltered',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat2x4_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      'finite',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat2x4_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(2, 4),
-      'unfiltered',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat3x2_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      'finite',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat3x2_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 2),
-      'unfiltered',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat3x3_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      'finite',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat3x3_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 3),
-      'unfiltered',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat3x4_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      'finite',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat3x4_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(3, 4),
-      'unfiltered',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat4x2_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      'finite',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat4x2_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 2),
-      'unfiltered',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat4x3_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      'finite',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat4x3_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 3),
-      'unfiltered',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat4x4_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      'finite',
-      FP.f32.transposeInterval
-    );
-  },
-  f32_mat4x4_non_const: () => {
-    return FP.f32.generateMatrixToMatrixCases(
-      sparseMatrixF32Range(4, 4),
-      'unfiltered',
-      FP.f32.transposeInterval
-    );
-  },
-  f16_mat2x2_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(2, 2),
-      'finite',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat2x2_non_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(2, 2),
-      'unfiltered',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat2x3_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(2, 3),
-      'finite',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat2x3_non_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(2, 3),
-      'unfiltered',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat2x4_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(2, 4),
-      'finite',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat2x4_non_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(2, 4),
-      'unfiltered',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat3x2_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(3, 2),
-      'finite',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat3x2_non_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(3, 2),
-      'unfiltered',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat3x3_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(3, 3),
-      'finite',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat3x3_non_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(3, 3),
-      'unfiltered',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat3x4_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(3, 4),
-      'finite',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat3x4_non_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(3, 4),
-      'unfiltered',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat4x2_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(4, 2),
-      'finite',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat4x2_non_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(4, 2),
-      'unfiltered',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat4x3_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(4, 3),
-      'finite',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat4x3_non_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(4, 3),
-      'unfiltered',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat4x4_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(4, 4),
-      'finite',
-      FP.f16.transposeInterval
-    );
-  },
-  f16_mat4x4_non_const: () => {
-    return FP.f16.generateMatrixToMatrixCases(
-      sparseMatrixF16Range(4, 4),
-      'unfiltered',
-      FP.f16.transposeInterval
-    );
-  },
+  ...f32_cases,
+  ...f16_cases,
+  ...abstract_cases,
 });
 
 g.test('abstract_float')

From 5c10bd29a1361c94a0ba759a778b0dd18480f380 Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Mon, 25 Sep 2023 12:42:32 -0700
Subject: [PATCH 062/166] Compat: Refactor vertex_state tests for new limits
 (#2988)

* Compat: Refactor vertex_state tests for new limits

Compat has different limits than non-Compat and tons
of the CTS needs to be refactored from assuming the
default limits are fixed.
---
 src/common/util/data_tables.ts                |  76 ++++
 src/common/util/util.ts                       |  28 ++
 .../render_pipeline/vertex_state.spec.ts      | 327 ++++++++++++------
 src/webgpu/capability_info.ts                 | 159 ++++++---
 src/webgpu/gpu_test.ts                        |  27 +-
 5 files changed, 470 insertions(+), 147 deletions(-)

diff --git a/src/common/util/data_tables.ts b/src/common/util/data_tables.ts
index 9b8ccb115904..9309b9d2fd97 100644
--- a/src/common/util/data_tables.ts
+++ b/src/common/util/data_tables.ts
@@ -51,3 +51,79 @@ export function makeTable<
   /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
   return result as any;
 }
+
+/**
+ * Creates an info lookup object from a more nicely-formatted table.
+ *
+ * Note: Using `as const` on the arguments to this function is necessary to infer the correct type.
+ *
+ * Example:
+ *
+ * ```
+ * const t = makeTableWithDefaults(
+ *   { c: 'default' },       // columnRenames
+ *   ['a', 'default', 'd'],  // columnsKept
+ *   ['a', 'b', 'c', 'd'],   // columns
+ *   [123, 456, 789, 1011],  // defaults
+ *   {                       // table
+ *     foo: [1, 2, 3, 4],
+ *     bar: [5,  ,  , 8],
+ *     moo: [ , 9,10,  ],
+ *   }
+ * );
+ *
+ * // t = {
+ * //   foo: { a:   1, default:   3, d:    4 },
+ * //   bar: { a:   5, default: 789, d:    8 },
+ * //   moo: { a: 123, default:  10, d: 1011 },
+ * // };
+ * ```
+ *
+ * MAINTENANCE_TODO: `ZipKeysWithValues<Members, Table[k], Defaults>` is incorrect
+ * because Members no longer maps to Table[k]. It's not clear if this is even possible to fix
+ * because it requires mapping, not zipping. Maybe passing in a index mapping
+ * would fix it (which is gross) but if you have columnsKept as [0, 2, 3] then maybe it would
+ * be possible to generate the correct type? I don't think we can generate the map at compile time
+ * so we'd have to hand code it. Other ideas, don't generate kLimitsInfoCore and kLimitsInfoCompat
+ * where they are keys of infos. Instead, generate kLimitsInfoCoreDefaults, kLimitsInfoCoreMaximums,
+ * kLimitsInfoCoreClasses where each is just a `{[k: string]: type}`. Could zip those after or,
+ * maybe that suggests passing in the hard coded indices would work.
+ *
+ * @param columnRenames the name of the column in the table that will be assigned to the 'default' property of each entry.
+ * @param columnsKept the names of properties you want in the generated lookup table. This must be a subset of the columns of the tables except for the name 'default' which is looked from the previous argument.
+ * @param columns the names of the columns of the name
+ * @param defaults the default value by column for any element in a row of the table that is undefined
+ * @param table named table rows.
+ */
+export function makeTableRenameAndFilter<
+  Members extends readonly string[],
+  DataMembers extends readonly string[],
+  Defaults extends readonly unknown[],
+  Table extends { readonly [k: string]: readonly unknown[] }
+>(
+  columnRenames: { [key: string]: string },
+  columnsKept: Members,
+  columns: DataMembers,
+  defaults: Defaults,
+  table: Table
+): {
+  readonly [k in keyof Table]: ResolveType<ZipKeysWithValues<Members, Table[k], Defaults>>;
+} {
+  const result: { [k: string]: { [m: string]: unknown } } = {};
+  const keyToIndex = new Map<string, number>(
+    columnsKept.map(name => {
+      const remappedName = columnRenames[name] === undefined ? name : columnRenames[name];
+      return [name, columns.indexOf(remappedName)];
+    })
+  );
+  for (const [k, v] of Object.entries<readonly unknown[]>(table)) {
+    const item: { [m: string]: unknown } = {};
+    for (const member of columnsKept) {
+      const ndx = keyToIndex.get(member)!;
+      item[member] = v[ndx] ?? defaults[ndx];
+    }
+    result[k] = item;
+  }
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  return result as any;
+}
diff --git a/src/common/util/util.ts b/src/common/util/util.ts
index ca77841bb169..ebee7d59b85a 100644
--- a/src/common/util/util.ts
+++ b/src/common/util/util.ts
@@ -423,3 +423,31 @@ export function memcpy(
 ): void {
   subarrayAsU8(dst.dst, dst).set(subarrayAsU8(src.src, src));
 }
+
+/**
+ * Used to create a value that is specified by multiplying some runtime value
+ * by a constant and then adding a constant to it.
+ */
+export interface ValueTestVariant {
+  mult: number;
+  add: number;
+}
+
+/**
+ * Filters out SpecValues that are the same.
+ */
+export function filterUniqueValueTestVariants(valueTestVariants: ValueTestVariant[]) {
+  return new Map<string, ValueTestVariant>(
+    valueTestVariants.map(v => [`m:${v.mult},a:${v.add}`, v])
+  ).values();
+}
+
+/**
+ * Used to create a value that is specified by multiplied some runtime value
+ * by a constant and then adding a constant to it. This happens often in test
+ * with limits that can only be known at runtime and yet we need a way to
+ * add parameters to a test and those parameters must be constants.
+ */
+export function makeValueTestVariant(base: number, variant: ValueTestVariant) {
+  return base * variant.mult + variant.add;
+}
diff --git a/src/webgpu/api/validation/render_pipeline/vertex_state.spec.ts b/src/webgpu/api/validation/render_pipeline/vertex_state.spec.ts
index f8821ae4eadb..c500a9f930f5 100644
--- a/src/webgpu/api/validation/render_pipeline/vertex_state.spec.ts
+++ b/src/webgpu/api/validation/render_pipeline/vertex_state.spec.ts
@@ -4,12 +4,10 @@ This test dedicatedly tests validation of GPUVertexState of createRenderPipeline
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
 import {
-  kMaxVertexAttributes,
-  kMaxVertexBufferArrayStride,
-  kMaxVertexBuffers,
-  kVertexFormats,
-  kVertexFormatInfo,
-} from '../../../capability_info.js';
+  filterUniqueValueTestVariants,
+  makeValueTestVariant,
+} from '../../../../common/util/util.js';
+import { kVertexFormats, kVertexFormatInfo } from '../../../capability_info.js';
 import { ValidationTest } from '../validation_test.js';
 
 const VERTEX_SHADER_CODE_WITH_NO_INPUT = `
@@ -149,12 +147,17 @@ g.test('max_vertex_buffer_limit')
   )
   .paramsSubcasesOnly(u =>
     u //
-      .combine('count', [0, 1, kMaxVertexBuffers, kMaxVertexBuffers + 1])
+      .combine('countVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: 0 },
+        { mult: 1, add: 1 },
+      ])
       .combine('lastEmpty', [false, true])
   )
   .fn(t => {
-    const { count, lastEmpty } = t.params;
-
+    const { countVariant, lastEmpty } = t.params;
+    const count = t.makeLimitVariant('maxVertexBuffers', countVariant);
     const vertexBuffers = [];
     for (let i = 0; i < count; i++) {
       if (lastEmpty || i !== count - 1) {
@@ -167,7 +170,7 @@ g.test('max_vertex_buffer_limit')
       }
     }
 
-    const success = count <= kMaxVertexBuffers;
+    const success = count <= t.device.limits.maxVertexBuffers;
     t.testVertexState(success, vertexBuffers);
   });
 
@@ -179,11 +182,17 @@ g.test('max_vertex_attribute_limit')
   )
   .paramsSubcasesOnly(u =>
     u //
-      .combine('attribCount', [0, 1, kMaxVertexAttributes, kMaxVertexAttributes + 1])
+      .combine('attribCountVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: 0 },
+        { mult: 1, add: 1 },
+      ])
       .combine('attribsPerBuffer', [0, 1, 4])
   )
   .fn(t => {
-    const { attribCount, attribsPerBuffer } = t.params;
+    const { attribCountVariant, attribsPerBuffer } = t.params;
+    const attribCount = t.makeLimitVariant('maxVertexAttributes', attribCountVariant);
 
     const vertexBuffers = [];
 
@@ -191,7 +200,7 @@ g.test('max_vertex_attribute_limit')
     while (attribsAdded !== attribCount) {
       // Choose how many attributes to add for this buffer. The last buffer gets all remaining attributes.
       let targetCount = Math.min(attribCount, attribsAdded + attribsPerBuffer);
-      if (vertexBuffers.length === kMaxVertexBuffers - 1) {
+      if (vertexBuffers.length === t.device.limits.maxVertexBuffers - 1) {
         targetCount = attribCount;
       }
 
@@ -204,7 +213,7 @@ g.test('max_vertex_attribute_limit')
       vertexBuffers.push({ arrayStride: 0, attributes });
     }
 
-    const success = attribCount <= kMaxVertexAttributes;
+    const success = attribCount <= t.device.limits.maxVertexAttributes;
     t.testVertexState(success, vertexBuffers);
   });
 
@@ -216,23 +225,28 @@ g.test('max_vertex_buffer_array_stride_limit')
   )
   .paramsSubcasesOnly(u =>
     u //
-      .combine('vertexBufferIndex', [0, 1, kMaxVertexBuffers - 1])
-      .combine('arrayStride', [
-        0,
-        4,
-        256,
-        kMaxVertexBufferArrayStride - 4,
-        kMaxVertexBufferArrayStride,
-        kMaxVertexBufferArrayStride + 4,
+      .combine('vertexBufferIndexVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
+      .combine('arrayStrideVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 4 },
+        { mult: 0, add: 256 },
+        { mult: 1, add: -4 },
+        { mult: 1, add: 0 },
+        { mult: 1, add: +4 },
       ])
   )
   .fn(t => {
-    const { vertexBufferIndex, arrayStride } = t.params;
-
+    const { vertexBufferIndexVariant, arrayStrideVariant } = t.params;
+    const vertexBufferIndex = t.makeLimitVariant('maxVertexBuffers', vertexBufferIndexVariant);
+    const arrayStride = t.makeLimitVariant('maxVertexBufferArrayStride', arrayStrideVariant);
     const vertexBuffers = [];
     vertexBuffers[vertexBufferIndex] = { arrayStride, attributes: [] };
 
-    const success = arrayStride <= kMaxVertexBufferArrayStride;
+    const success = arrayStride <= t.device.limits.maxVertexBufferArrayStride;
     t.testVertexState(success, vertexBuffers);
   });
 
@@ -244,19 +258,25 @@ g.test('vertex_buffer_array_stride_limit_alignment')
   )
   .paramsSubcasesOnly(u =>
     u //
-      .combine('vertexBufferIndex', [0, 1, kMaxVertexBuffers - 1])
-      .combine('arrayStride', [
-        0,
-        1,
-        2,
-        4,
-        kMaxVertexBufferArrayStride - 4,
-        kMaxVertexBufferArrayStride - 2,
-        kMaxVertexBufferArrayStride,
+      .combine('vertexBufferIndexVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
+      .combine('arrayStrideVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 0, add: 2 },
+        { mult: 0, add: 4 },
+        { mult: 1, add: -4 },
+        { mult: 1, add: -2 },
+        { mult: 1, add: 0 },
       ])
   )
   .fn(t => {
-    const { vertexBufferIndex, arrayStride } = t.params;
+    const { vertexBufferIndexVariant, arrayStrideVariant } = t.params;
+    const vertexBufferIndex = t.makeLimitVariant('maxVertexBuffers', vertexBufferIndexVariant);
+    const arrayStride = t.makeLimitVariant('maxVertexBufferArrayStride', arrayStrideVariant);
 
     const vertexBuffers = [];
     vertexBuffers[vertexBufferIndex] = { arrayStride, attributes: [] };
@@ -274,18 +294,37 @@ g.test('vertex_attribute_shaderLocation_limit')
   )
   .paramsSubcasesOnly(u =>
     u //
-      .combine('vertexBufferIndex', [0, 1, kMaxVertexBuffers - 1])
-      .combine('extraAttributeCount', [0, 1, kMaxVertexAttributes - 1])
+      .combine('vertexBufferIndexVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
+      .combine('extraAttributeCountVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
       .combine('testAttributeAtStart', [false, true])
-      .combine('testShaderLocation', [0, 1, kMaxVertexAttributes - 1, kMaxVertexAttributes])
+      .combine('testShaderLocationVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+        { mult: 1, add: 0 },
+      ])
   )
   .fn(t => {
     const {
-      vertexBufferIndex,
-      extraAttributeCount,
-      testShaderLocation,
+      vertexBufferIndexVariant,
+      extraAttributeCountVariant,
+      testShaderLocationVariant,
       testAttributeAtStart,
     } = t.params;
+    const vertexBufferIndex = t.makeLimitVariant('maxVertexBuffers', vertexBufferIndexVariant);
+    const extraAttributeCount = t.makeLimitVariant(
+      'maxVertexAttributes',
+      extraAttributeCountVariant
+    );
+    const testShaderLocation = t.makeLimitVariant('maxVertexAttributes', testShaderLocationVariant);
 
     const attributes: GPUVertexAttribute[] = [];
     addTestAttributes(attributes, {
@@ -298,7 +337,7 @@ g.test('vertex_attribute_shaderLocation_limit')
     const vertexBuffers = [];
     vertexBuffers[vertexBufferIndex] = { arrayStride: 256, attributes };
 
-    const success = testShaderLocation < kMaxVertexAttributes;
+    const success = testShaderLocation < t.device.limits.maxVertexAttributes;
     t.testVertexState(success, vertexBuffers);
   });
 
@@ -311,24 +350,46 @@ g.test('vertex_attribute_shaderLocation_unique')
   )
   .paramsSubcasesOnly(u =>
     u //
-      .combine('vertexBufferIndexA', [0, 1, kMaxVertexBuffers - 1])
-      .combine('vertexBufferIndexB', [0, 1, kMaxVertexBuffers - 1])
+      .combine('vertexBufferIndexAVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
+      .combine('vertexBufferIndexBVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
       .combine('testAttributeAtStartA', [false, true])
       .combine('testAttributeAtStartB', [false, true])
-      .combine('shaderLocationA', [0, 1, 7, kMaxVertexAttributes - 1])
-      .combine('shaderLocationB', [0, 1, 7, kMaxVertexAttributes - 1])
+      .combine('shaderLocationAVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 0, add: 7 },
+        { mult: 1, add: -1 },
+      ])
+      .combine('shaderLocationBVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 0, add: 7 },
+        { mult: 1, add: -1 },
+      ])
       .combine('extraAttributeCount', [0, 4])
   )
   .fn(t => {
     const {
-      vertexBufferIndexA,
-      vertexBufferIndexB,
+      vertexBufferIndexAVariant,
+      vertexBufferIndexBVariant,
       testAttributeAtStartA,
       testAttributeAtStartB,
-      shaderLocationA,
-      shaderLocationB,
+      shaderLocationAVariant,
+      shaderLocationBVariant,
       extraAttributeCount,
     } = t.params;
+    const vertexBufferIndexA = t.makeLimitVariant('maxVertexBuffers', vertexBufferIndexAVariant);
+    const vertexBufferIndexB = t.makeLimitVariant('maxVertexBuffers', vertexBufferIndexBVariant);
+    const shaderLocationA = t.makeLimitVariant('maxVertexAttributes', shaderLocationAVariant);
+    const shaderLocationB = t.makeLimitVariant('maxVertexAttributes', shaderLocationBVariant);
 
     // Depending on the params, the vertexBuffer for A and B can be the same or different. To support
     // both cases without code changes we treat `vertexBufferAttributes` as a map from indices to
@@ -374,10 +435,17 @@ g.test('vertex_shader_input_location_limit')
   )
   .paramsSubcasesOnly(u =>
     u //
-      .combine('testLocation', [0, 1, kMaxVertexAttributes - 1, kMaxVertexAttributes, 2 ** 31 - 1])
+      .combine('testLocationVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+        { mult: 1, add: 0 },
+        { mult: 0, add: 2 ** 31 - 1 },
+      ])
   )
   .fn(t => {
-    const { testLocation } = t.params;
+    const { testLocationVariant } = t.params;
+    const testLocation = t.makeLimitVariant('maxVertexAttributes', testLocationVariant);
 
     const shader = t.generateTestVertexShader([
       {
@@ -399,7 +467,7 @@ g.test('vertex_shader_input_location_limit')
       },
     ];
 
-    const success = testLocation < kMaxVertexAttributes;
+    const success = testLocation < t.device.limits.maxVertexAttributes;
     t.testVertexState(success, vertexBuffers, shader);
   });
 
@@ -411,18 +479,38 @@ g.test('vertex_shader_input_location_in_vertex_state')
   )
   .paramsSubcasesOnly(u =>
     u //
-      .combine('vertexBufferIndex', [0, 1, kMaxVertexBuffers - 1])
-      .combine('extraAttributeCount', [0, 1, kMaxVertexAttributes - 1])
+      .combine('vertexBufferIndexVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
+      .combine('extraAttributeCountVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
       .combine('testAttributeAtStart', [false, true])
-      .combine('testShaderLocation', [0, 1, 4, 7, kMaxVertexAttributes - 1])
+      .combine('testShaderLocationVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 0, add: 4 },
+        { mult: 0, add: 5 },
+        { mult: 1, add: -1 },
+      ])
   )
   .fn(t => {
     const {
-      vertexBufferIndex,
-      extraAttributeCount,
+      vertexBufferIndexVariant,
+      extraAttributeCountVariant,
       testAttributeAtStart,
-      testShaderLocation,
+      testShaderLocationVariant,
     } = t.params;
+    const vertexBufferIndex = t.makeLimitVariant('maxVertexBuffers', vertexBufferIndexVariant);
+    const extraAttributeCount = t.makeLimitVariant(
+      'maxVertexAttributes',
+      extraAttributeCountVariant
+    );
+    const testShaderLocation = t.makeLimitVariant('maxVertexAttributes', testShaderLocationVariant);
     // We have a shader using `testShaderLocation`.
     const shader = t.generateTestVertexShader([
       {
@@ -512,37 +600,54 @@ g.test('vertex_attribute_offset_alignment')
   .params(u =>
     u
       .combine('format', kVertexFormats)
-      .combine('arrayStride', [256, kMaxVertexBufferArrayStride])
-      .expand('offset', p => {
+      .combine('arrayStrideVariant', [
+        { mult: 0, add: 256 },
+        { mult: 1, add: 0 },
+      ])
+      .expand('offsetVariant', p => {
         const { bytesPerComponent, componentCount } = kVertexFormatInfo[p.format];
         const formatSize = bytesPerComponent * componentCount;
-
-        return new Set([
-          0,
-          Math.floor(formatSize / 2),
-          formatSize,
-          2,
-          4,
-          p.arrayStride - formatSize,
-          p.arrayStride - formatSize - Math.floor(formatSize / 2),
-          p.arrayStride - formatSize - 4,
-          p.arrayStride - formatSize - 2,
+        return filterUniqueValueTestVariants([
+          { mult: 0, add: 0 },
+          { mult: 0, add: Math.floor(formatSize / 2) },
+          { mult: 0, add: formatSize },
+          { mult: 0, add: 2 },
+          { mult: 0, add: 4 },
+          { mult: 1, add: -formatSize },
+          { mult: 1, add: -formatSize - Math.floor(formatSize / 2) },
+          { mult: 1, add: -formatSize - 4 },
+          { mult: 1, add: -formatSize - 2 },
         ]);
       })
       .beginSubcases()
-      .combine('vertexBufferIndex', [0, 1, kMaxVertexBuffers - 1])
-      .combine('extraAttributeCount', [0, 1, kMaxVertexAttributes - 1])
+      .combine('vertexBufferIndexVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
+      .combine('extraAttributeCountVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
       .combine('testAttributeAtStart', [false, true])
   )
   .fn(t => {
     const {
       format,
-      arrayStride,
-      offset,
-      vertexBufferIndex,
-      extraAttributeCount,
+      arrayStrideVariant,
+      offsetVariant,
+      vertexBufferIndexVariant,
+      extraAttributeCountVariant,
       testAttributeAtStart,
     } = t.params;
+    const arrayStride = t.makeLimitVariant('maxVertexBufferArrayStride', arrayStrideVariant);
+    const vertexBufferIndex = t.makeLimitVariant('maxVertexBuffers', vertexBufferIndexVariant);
+    const extraAttributeCount = t.makeLimitVariant(
+      'maxVertexAttributes',
+      extraAttributeCountVariant
+    );
+    const offset = makeValueTestVariant(arrayStride, offsetVariant);
 
     const attributes: GPUVertexAttribute[] = [];
     addTestAttributes(attributes, {
@@ -575,46 +680,60 @@ g.test('vertex_attribute_contained_in_stride')
     u
       .combine('format', kVertexFormats)
       .beginSubcases()
-      .combine('arrayStride', [
-        0,
-        256,
-        kMaxVertexBufferArrayStride - 4,
-        kMaxVertexBufferArrayStride,
+      .combine('arrayStrideVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 256 },
+        { mult: 1, add: -4 },
+        { mult: 1, add: 0 },
       ])
-      .expand('offset', function* (p) {
+      .expand('offsetVariant', function* (p) {
         // Compute a bunch of test offsets to test.
         const { bytesPerComponent, componentCount } = kVertexFormatInfo[p.format];
         const formatSize = bytesPerComponent * componentCount;
-        yield 0;
-        yield 4;
-
-        // arrayStride = 0 is a special case because for the offset validation it acts the same
-        // as arrayStride = kMaxVertexBufferArrayStride. We special case here so as to avoid adding
-        // negative offsets that would cause an IDL exception to be thrown instead of a validation
-        // error.
-        const stride = p.arrayStride !== 0 ? p.arrayStride : kMaxVertexBufferArrayStride;
-        yield stride - formatSize;
-        yield stride - formatSize + 4;
+        yield { mult: 0, add: 0 };
+        yield { mult: 0, add: 4 };
+        yield { mult: 1, add: -formatSize };
+        yield { mult: 1, add: -formatSize + 4 };
 
         // Avoid adding duplicate cases when formatSize == 4 (it is already tested above)
         if (formatSize !== 4) {
-          yield formatSize;
-          yield stride;
+          yield { mult: 0, add: formatSize };
+          yield { mult: 1, add: 0 };
         }
       })
-      .combine('vertexBufferIndex', [0, 1, kMaxVertexBuffers - 1])
-      .combine('extraAttributeCount', [0, 1, kMaxVertexAttributes - 1])
+      .combine('vertexBufferIndexVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
+      .combine('extraAttributeCountVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
       .combine('testAttributeAtStart', [false, true])
   )
   .fn(t => {
     const {
       format,
-      arrayStride,
-      offset,
-      vertexBufferIndex,
-      extraAttributeCount,
+      arrayStrideVariant,
+      offsetVariant,
+      vertexBufferIndexVariant,
+      extraAttributeCountVariant,
       testAttributeAtStart,
     } = t.params;
+    const arrayStride = t.makeLimitVariant('maxVertexBufferArrayStride', arrayStrideVariant);
+    const vertexBufferIndex = t.makeLimitVariant('maxVertexBuffers', vertexBufferIndexVariant);
+    const extraAttributeCount = t.makeLimitVariant(
+      'maxVertexAttributes',
+      extraAttributeCountVariant
+    );
+    // arrayStride = 0 is a special case because for the offset validation it acts the same
+    // as arrayStride = device.limits.maxVertexBufferArrayStride. We special case here so as to avoid adding
+    // negative offsets that would cause an IDL exception to be thrown instead of a validation
+    // error.
+    const stride = arrayStride !== 0 ? arrayStride : t.device.limits.maxVertexBufferArrayStride;
+    const offset = makeValueTestVariant(stride, offsetVariant);
 
     const attributes: GPUVertexAttribute[] = [];
     addTestAttributes(attributes, {
@@ -629,7 +748,7 @@ g.test('vertex_attribute_contained_in_stride')
 
     const formatInfo = kVertexFormatInfo[format];
     const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
-    const limit = arrayStride === 0 ? kMaxVertexBufferArrayStride : arrayStride;
+    const limit = arrayStride === 0 ? t.device.limits.maxVertexBufferArrayStride : arrayStride;
 
     const success = offset + formatSize <= limit;
     t.testVertexState(success, vertexBuffers);
@@ -641,7 +760,7 @@ g.test('many_attributes_overlapping')
     // Create many attributes, each of them intersects with at least 3 others.
     const attributes = [];
     const formats = ['float32x4', 'uint32x4', 'sint32x4'] as const;
-    for (let i = 0; i < kMaxVertexAttributes; i++) {
+    for (let i = 0; i < t.device.limits.maxVertexAttributes; i++) {
       attributes.push({ format: formats[i % 3], offset: i * 4, shaderLocation: i } as const);
     }
 
diff --git a/src/webgpu/capability_info.ts b/src/webgpu/capability_info.ts
index 4da0efb1fde6..fbffa67048d5 100644
--- a/src/webgpu/capability_info.ts
+++ b/src/webgpu/capability_info.ts
@@ -3,7 +3,13 @@
 
 /* eslint-disable no-sparse-arrays */
 
-import { keysOf, makeTable, numericKeysOf, valueof } from '../common/util/data_tables.js';
+import {
+  keysOf,
+  makeTable,
+  makeTableRenameAndFilter,
+  numericKeysOf,
+  valueof,
+} from '../common/util/data_tables.js';
 import { assertTypeTrue, TypeEqual } from '../common/util/types.js';
 import { unreachable } from '../common/util/util.js';
 
@@ -347,6 +353,7 @@ assertTypeTrue<TypeEqual<BindableResource, typeof kBindableResources[number]>>()
 /** Dynamic buffer offsets require offset to be divisible by 256, by spec. */
 export const kMinDynamicBufferOffsetAlignment = 256;
 
+// MAINTENANCE_TODO: remove these as tests need to use different limits for compatibility mode
 /** Default `PerShaderStage` binding limits, by spec. */
 export const kPerStageBindingLimits: {
   readonly [k in PerStageBindingLimitClass]: {
@@ -642,50 +649,107 @@ export const kIndexFormat: readonly GPUIndexFormat[] = ['uint16', 'uint32'];
 assertTypeTrue<TypeEqual<GPUIndexFormat, typeof kIndexFormat[number]>>();
 
 /** Info for each entry of GPUSupportedLimits */
-export const kLimitInfo = /* prettier-ignore */ makeTable(
-                                               [    'class', 'default',            'maximumValue'] as const,
-                                               [  'maximum',          ,     kMaxUnsignedLongValue] as const, {
-  'maxTextureDimension1D':                     [           ,      8192,                          ],
-  'maxTextureDimension2D':                     [           ,      8192,                          ],
-  'maxTextureDimension3D':                     [           ,      2048,                          ],
-  'maxTextureArrayLayers':                     [           ,       256,                          ],
-
-  'maxBindGroups':                             [           ,         4,                          ],
-  'maxBindingsPerBindGroup':                   [           ,      1000,                          ],
-  'maxDynamicUniformBuffersPerPipelineLayout': [           ,         8,                          ],
-  'maxDynamicStorageBuffersPerPipelineLayout': [           ,         4,                          ],
-  'maxSampledTexturesPerShaderStage':          [           ,        16,                          ],
-  'maxSamplersPerShaderStage':                 [           ,        16,                          ],
-  'maxStorageBuffersPerShaderStage':           [           ,         8,                          ],
-  'maxStorageTexturesPerShaderStage':          [           ,         4,                          ],
-  'maxUniformBuffersPerShaderStage':           [           ,        12,                          ],
-
-  'maxUniformBufferBindingSize':               [           ,     65536, kMaxUnsignedLongLongValue],
-  'maxStorageBufferBindingSize':               [           , 134217728, kMaxUnsignedLongLongValue],
-  'minUniformBufferOffsetAlignment':           ['alignment',       256,                          ],
-  'minStorageBufferOffsetAlignment':           ['alignment',       256,                          ],
-
-  'maxVertexBuffers':                          [           ,         8,                          ],
-  'maxBufferSize':                             [           , 268435456, kMaxUnsignedLongLongValue],
-  'maxVertexAttributes':                       [           ,        16,                          ],
-  'maxVertexBufferArrayStride':                [           ,      2048,                          ],
-  'maxInterStageShaderComponents':             [           ,        60,                          ],
-  'maxInterStageShaderVariables':              [           ,        16,                          ],
-
-  'maxColorAttachments':                       [           ,         8,                          ],
-  'maxColorAttachmentBytesPerSample':          [           ,        32,                          ],
-
-  'maxComputeWorkgroupStorageSize':            [           ,     16384,                          ],
-  'maxComputeInvocationsPerWorkgroup':         [           ,       256,                          ],
-  'maxComputeWorkgroupSizeX':                  [           ,       256,                          ],
-  'maxComputeWorkgroupSizeY':                  [           ,       256,                          ],
-  'maxComputeWorkgroupSizeZ':                  [           ,        64,                          ],
-  'maxComputeWorkgroupsPerDimension':          [           ,     65535,                          ],
-} as const);
+const [
+  kLimitInfoKeys,
+  kLimitInfoDefaults,
+  kLimitInfoData,
+] = /* prettier-ignore */ [
+                                               [    'class',    'core', 'compatibility',            'maximumValue'] as const,
+                                               [  'maximum',          ,                ,     kMaxUnsignedLongValue] as const, {
+  'maxTextureDimension1D':                     [           ,      8192,            4096,                          ],
+  'maxTextureDimension2D':                     [           ,      8192,            4096,                          ],
+  'maxTextureDimension3D':                     [           ,      2048,            1024,                          ],
+  'maxTextureArrayLayers':                     [           ,       256,             256,                          ],
+
+  'maxBindGroups':                             [           ,         4,               4,                          ],
+  'maxBindingsPerBindGroup':                   [           ,      1000,            1000,                          ],
+  'maxDynamicUniformBuffersPerPipelineLayout': [           ,         8,               8,                          ],
+  'maxDynamicStorageBuffersPerPipelineLayout': [           ,         4,               4,                          ],
+  'maxSampledTexturesPerShaderStage':          [           ,        16,              16,                          ],
+  'maxSamplersPerShaderStage':                 [           ,        16,              16,                          ],
+  'maxStorageBuffersPerShaderStage':           [           ,         8,               4,                          ],
+  'maxStorageTexturesPerShaderStage':          [           ,         4,               4,                          ],
+  'maxUniformBuffersPerShaderStage':           [           ,        12,              12,                          ],
+
+  'maxUniformBufferBindingSize':               [           ,     65536,           16384, kMaxUnsignedLongLongValue],
+  'maxStorageBufferBindingSize':               [           , 134217728,       134217728, kMaxUnsignedLongLongValue],
+  'minUniformBufferOffsetAlignment':           ['alignment',       256,             256,                          ],
+  'minStorageBufferOffsetAlignment':           ['alignment',       256,             256,                          ],
+
+  'maxVertexBuffers':                          [           ,         8,               8,                          ],
+  'maxBufferSize':                             [           , 268435456,       268435456, kMaxUnsignedLongLongValue],
+  'maxVertexAttributes':                       [           ,        16,              16,                          ],
+  'maxVertexBufferArrayStride':                [           ,      2048,            2048,                          ],
+  'maxInterStageShaderComponents':             [           ,        60,              60,                          ],
+  'maxInterStageShaderVariables':              [           ,        16,              16,                          ],
+
+  'maxColorAttachments':                       [           ,         8,               4,                          ],
+  'maxColorAttachmentBytesPerSample':          [           ,        32,              32,                          ],
+
+  'maxComputeWorkgroupStorageSize':            [           ,     16384,           16384,                          ],
+  'maxComputeInvocationsPerWorkgroup':         [           ,       256,             128,                          ],
+  'maxComputeWorkgroupSizeX':                  [           ,       256,             128,                          ],
+  'maxComputeWorkgroupSizeY':                  [           ,       256,             128,                          ],
+  'maxComputeWorkgroupSizeZ':                  [           ,        64,              64,                          ],
+  'maxComputeWorkgroupsPerDimension':          [           ,     65535,           65535,                          ],
+} as const];
+
+/**
+ * Feature levels corresponding to core WebGPU and WebGPU
+ * in compatibility mode. They can be passed to
+ * getDefaultLimits though if you have access to an adapter
+ * it's preferred to use getDefaultLimitsForAdapter.
+ */
+export const kFeatureLevels = ['core', 'compatibility'] as const;
+export type FeatureLevel = typeof kFeatureLevels[number];
+
+const kLimitKeys = ['class', 'default', 'maximumValue'] as const;
+
+const kLimitInfoCore = makeTableRenameAndFilter(
+  { default: 'core' },
+  kLimitKeys,
+  kLimitInfoKeys,
+  kLimitInfoDefaults,
+  kLimitInfoData
+);
+
+const kLimitInfoCompatibility = makeTableRenameAndFilter(
+  { default: 'compatibility' },
+  kLimitKeys,
+  kLimitInfoKeys,
+  kLimitInfoDefaults,
+  kLimitInfoData
+);
+
+// MAINTENANCE_TODO: remove this as tests need to use different limits for compatibility mode
+export const kLimitInfo = kLimitInfoCore;
+
+const kLimitInfos = {
+  core: kLimitInfoCore,
+  compatibility: kLimitInfoCompatibility,
+} as const;
+
+export const kLimitClasses = Object.fromEntries(
+  Object.entries(kLimitInfoCore).map(([k, { class: c }]) => [k, c])
+);
+
+export function getDefaultLimits(featureLevel: FeatureLevel) {
+  return kLimitInfos[featureLevel];
+}
+
+export function getDefaultLimitsForAdapter(adapter: GPUAdapter) {
+  // MAINTENANCE_TODO: Remove casts when GPUAdapter IDL has isCompatibilityMode.
+  return getDefaultLimits(
+    ((adapter as unknown) as { isCompatibilityMode: boolean }).isCompatibilityMode
+      ? 'compatibility'
+      : 'core'
+  );
+}
 
 /** List of all entries of GPUSupportedLimits. */
-export const kLimits = keysOf(kLimitInfo);
+export const kLimits = keysOf(kLimitInfoCore);
 
+// MAINTENANCE_TODO: remove these as tests need to use different limits for compatibility mode
 // Pipeline limits
 
 /** Maximum number of color attachments to a render pass, by spec. */
@@ -696,6 +760,17 @@ export const kMaxVertexBuffers = kLimitInfo.maxVertexBuffers.default;
 export const kMaxVertexAttributes = kLimitInfo.maxVertexAttributes.default;
 /** `maxVertexBufferArrayStride` in a vertex buffer in a GPURenderPipeline, by spec. */
 export const kMaxVertexBufferArrayStride = kLimitInfo.maxVertexBufferArrayStride.default;
+/**
+ * The number of color attachments to test.
+ * The CTS needs to generate a consistent list of tests.
+ * We can't use any default limits since they different from core to compat mode
+ * So, tests should use this value and filter out any values that are out of
+ * range for the current device.
+ *
+ * The test in maxColorAttachments.spec.ts tests that kMaxColorAttachmentsToTest
+ * is large enough to cover all devices tested.
+ */
+export const kMaxColorAttachmentsToTest = 32;
 
 /** The size of indirect draw parameters in the indirectBuffer of drawIndirect */
 export const kDrawIndirectParametersSize = 4;
diff --git a/src/webgpu/gpu_test.ts b/src/webgpu/gpu_test.ts
index 68683b63fe0c..aa0189c9e5ea 100644
--- a/src/webgpu/gpu_test.ts
+++ b/src/webgpu/gpu_test.ts
@@ -11,14 +11,16 @@ import {
 import { globalTestConfig } from '../common/framework/test_config.js';
 import {
   assert,
+  makeValueTestVariant,
   memcpy,
   range,
+  ValueTestVariant,
   TypedArrayBufferView,
   TypedArrayBufferViewConstructor,
   unreachable,
 } from '../common/util/util.js';
 
-import { kQueryTypeInfo } from './capability_info.js';
+import { getDefaultLimits, kLimits, kQueryTypeInfo } from './capability_info.js';
 import {
   kTextureFormatInfo,
   kEncodableTextureFormats,
@@ -117,6 +119,10 @@ export class GPUTestSubcaseBatchState extends SubcaseBatchState {
     return globalTestConfig.compatibility;
   }
 
+  getDefaultLimits() {
+    return getDefaultLimits(this.isCompatibility ? 'compatibility' : 'core');
+  }
+
   /**
    * Some tests or cases need particular feature flags or limits to be enabled.
    * Call this function with a descriptor or feature name (or `undefined`) to select a
@@ -200,6 +206,13 @@ export class GPUTestSubcaseBatchState extends SubcaseBatchState {
     throw new SkipTestCase(msg);
   }
 
+  /** Throws an exception making the subcase as skipped if condition is true */
+  skipIf(cond: boolean, msg: string | (() => string) = '') {
+    if (cond) {
+      this.skip(typeof msg === 'function' ? msg() : msg);
+    }
+  }
+
   /**
    * Skips test if any format is not supported.
    */
@@ -263,6 +276,18 @@ export class GPUTestBase extends Fixture<GPUTestSubcaseBatchState> {
     return globalTestConfig.compatibility;
   }
 
+  getDefaultLimits() {
+    return getDefaultLimits(this.isCompatibility ? 'compatibility' : 'core');
+  }
+
+  getDefaultLimit(limit: typeof kLimits[number]) {
+    return this.getDefaultLimits()[limit].default;
+  }
+
+  makeLimitVariant(limit: typeof kLimits[number], variant: ValueTestVariant) {
+    return makeValueTestVariant(this.device.limits[limit], variant);
+  }
+
   canCallCopyTextureToBufferWithTextureFormat(format: GPUTextureFormat) {
     return !this.isCompatibility || !isCompressedTextureFormat(format);
   }

From a50d0906eedac478595363ad1342787a581f9e2e Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Mon, 25 Sep 2023 14:07:24 -0700
Subject: [PATCH 063/166] Compat: Make createBindGroup test handle different
 limits (#2994)

---
 .../api/validation/createBindGroup.spec.ts    | 109 +++++++-----------
 1 file changed, 43 insertions(+), 66 deletions(-)

diff --git a/src/webgpu/api/validation/createBindGroup.spec.ts b/src/webgpu/api/validation/createBindGroup.spec.ts
index 9c20db694b6b..269805541bb1 100644
--- a/src/webgpu/api/validation/createBindGroup.spec.ts
+++ b/src/webgpu/api/validation/createBindGroup.spec.ts
@@ -5,7 +5,7 @@ export const description = `
 `;
 
 import { makeTestGroup } from '../../../common/framework/test_group.js';
-import { assert, unreachable } from '../../../common/util/util.js';
+import { assert, makeValueTestVariant, unreachable } from '../../../common/util/util.js';
 import {
   allBindingEntries,
   bindingTypeInfo,
@@ -15,7 +15,6 @@ import {
   kBufferBindingTypes,
   kBufferUsages,
   kCompareFunctions,
-  kLimitInfo,
   kSamplerBindingTypes,
   kTextureUsages,
   kTextureViewDimensions,
@@ -882,24 +881,20 @@ g.test('buffer,resource_offset')
     u //
       .combine('type', kBufferBindingTypes)
       .beginSubcases()
-      .expand('offset', ({ type }) =>
-        type === 'uniform'
-          ? [
-              kLimitInfo.minUniformBufferOffsetAlignment.default,
-              kLimitInfo.minUniformBufferOffsetAlignment.default * 0.5,
-              kLimitInfo.minUniformBufferOffsetAlignment.default * 1.5,
-              kLimitInfo.minUniformBufferOffsetAlignment.default + 2,
-            ]
-          : [
-              kLimitInfo.minStorageBufferOffsetAlignment.default,
-              kLimitInfo.minStorageBufferOffsetAlignment.default * 0.5,
-              kLimitInfo.minStorageBufferOffsetAlignment.default * 1.5,
-              kLimitInfo.minStorageBufferOffsetAlignment.default + 2,
-            ]
-      )
+      .combine('offsetAddMult', [
+        { add: 0, mult: 0 },
+        { add: 0, mult: 0.5 },
+        { add: 0, mult: 1.5 },
+        { add: 2, mult: 0 },
+      ])
   )
   .fn(t => {
-    const { type, offset } = t.params;
+    const { type, offsetAddMult } = t.params;
+    const minAlignment =
+      t.device.limits[
+        type === 'uniform' ? 'minUniformBufferOffsetAlignment' : 'minStorageBufferOffsetAlignment'
+      ];
+    const offset = makeValueTestVariant(minAlignment, offsetAddMult);
 
     const bindGroupLayout = t.device.createBindGroupLayout({
       entries: [
@@ -911,14 +906,8 @@ g.test('buffer,resource_offset')
       ],
     });
 
-    let usage, isValid;
-    if (type === 'uniform') {
-      usage = GPUBufferUsage.UNIFORM;
-      isValid = offset % kLimitInfo.minUniformBufferOffsetAlignment.default === 0;
-    } else {
-      usage = GPUBufferUsage.STORAGE;
-      isValid = offset % kLimitInfo.minStorageBufferOffsetAlignment.default === 0;
-    }
+    const usage = type === 'uniform' ? GPUBufferUsage.UNIFORM : GPUBufferUsage.STORAGE;
+    const isValid = offset % minAlignment === 0;
 
     const buffer = t.device.createBuffer({
       size: 1024,
@@ -947,22 +936,23 @@ g.test('buffer,resource_binding_size')
       .beginSubcases()
       // Test a size of 1 (for uniform buffer) or 4 (for storage and read-only storage buffer)
       // then values just within and just above the limit.
-      .expand('bindingSize', ({ type }) =>
-        type === 'uniform'
-          ? [
-              1,
-              kLimitInfo.maxUniformBufferBindingSize.default,
-              kLimitInfo.maxUniformBufferBindingSize.default + 1,
-            ]
-          : [
-              4,
-              kLimitInfo.maxStorageBufferBindingSize.default,
-              kLimitInfo.maxStorageBufferBindingSize.default + 4,
-            ]
-      )
+      .combine('bindingSize', [
+        { base: 1, limit: 0 },
+        { base: 0, limit: 1 },
+        { base: 1, limit: 1 },
+      ])
   )
   .fn(t => {
-    const { type, bindingSize } = t.params;
+    const {
+      type,
+      bindingSize: { base, limit },
+    } = t.params;
+    const mult = type === 'uniform' ? 1 : 4;
+    const maxBindingSize =
+      t.device.limits[
+        type === 'uniform' ? 'maxUniformBufferBindingSize' : 'maxStorageBufferBindingSize'
+      ];
+    const bindingSize = base * mult + maxBindingSize * limit;
 
     const bindGroupLayout = t.device.createBindGroupLayout({
       entries: [
@@ -974,17 +964,12 @@ g.test('buffer,resource_binding_size')
       ],
     });
 
-    let usage, isValid;
-    if (type === 'uniform') {
-      usage = GPUBufferUsage.UNIFORM;
-      isValid = bindingSize <= kLimitInfo.maxUniformBufferBindingSize.default;
-    } else {
-      usage = GPUBufferUsage.STORAGE;
-      isValid = bindingSize <= kLimitInfo.maxStorageBufferBindingSize.default;
-    }
+    const usage = type === 'uniform' ? GPUBufferUsage.UNIFORM : GPUBufferUsage.STORAGE;
+    const isValid = bindingSize <= maxBindingSize;
 
+    // MAINTENANCE_TODO: Allocating the max size seems likely to fail. Refactor test.
     const buffer = t.device.createBuffer({
-      size: kLimitInfo.maxStorageBufferBindingSize.default,
+      size: maxBindingSize,
       usage,
     });
 
@@ -1007,26 +992,18 @@ g.test('buffer,effective_buffer_binding_size')
     u
       .combine('type', kBufferBindingTypes)
       .beginSubcases()
-      .expand('offset', ({ type }) =>
-        type === 'uniform'
-          ? [0, kLimitInfo.minUniformBufferOffsetAlignment.default]
-          : [0, kLimitInfo.minStorageBufferOffsetAlignment.default]
-      )
-      .expand('bufferSize', ({ type }) =>
-        type === 'uniform'
-          ? [
-              kLimitInfo.minUniformBufferOffsetAlignment.default + 8,
-              kLimitInfo.minUniformBufferOffsetAlignment.default + 10,
-            ]
-          : [
-              kLimitInfo.minStorageBufferOffsetAlignment.default + 8,
-              kLimitInfo.minStorageBufferOffsetAlignment.default + 10,
-            ]
-      )
+      .combine('offsetMult', [0, 1])
+      .combine('bufferSizeAddition', [8, 10])
       .combine('bindingSize', [undefined, 2, 4, 6])
   )
   .fn(t => {
-    const { type, offset, bufferSize, bindingSize } = t.params;
+    const { type, offsetMult, bufferSizeAddition, bindingSize } = t.params;
+    const minAlignment =
+      t.device.limits[
+        type === 'uniform' ? 'minUniformBufferOffsetAlignment' : 'minStorageBufferOffsetAlignment'
+      ];
+    const offset = minAlignment * offsetMult;
+    const bufferSize = minAlignment + bufferSizeAddition;
 
     const bindGroupLayout = t.device.createBindGroupLayout({
       entries: [

From 257cc42375923ff0fb4449d2e767accf9bd4615e Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Mon, 25 Sep 2023 14:23:52 -0700
Subject: [PATCH 064/166] Compat: Make createBindGroupLayout tests handle
 different limits (#2995)

---
 .../validation/createBindGroupLayout.spec.ts  | 24 +++++++++----------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/src/webgpu/api/validation/createBindGroupLayout.spec.ts b/src/webgpu/api/validation/createBindGroupLayout.spec.ts
index b3252e5953d1..521e560964cb 100644
--- a/src/webgpu/api/validation/createBindGroupLayout.spec.ts
+++ b/src/webgpu/api/validation/createBindGroupLayout.spec.ts
@@ -7,7 +7,6 @@ TODO: make sure tests are complete.
 import { kUnitCaseParamsBuilder } from '../../../common/framework/params_builder.js';
 import { makeTestGroup } from '../../../common/framework/test_group.js';
 import {
-  kLimitInfo,
   kShaderStages,
   kShaderStageCombinations,
   kStorageTextureAccessValues,
@@ -63,27 +62,26 @@ g.test('maximum_binding_limit')
   `
   )
   .paramsSubcasesOnly(u =>
-    u //
-      .combine('binding', [
-        1,
-        4,
-        8,
-        256,
-        kLimitInfo.maxBindingsPerBindGroup.default - 1,
-        kLimitInfo.maxBindingsPerBindGroup.default,
-      ])
+    u.combine('bindingVariant', [1, 4, 8, 256, 'default', 'default-minus-one'] as const)
   )
   .fn(t => {
-    const { binding } = t.params;
+    const { bindingVariant } = t.params;
     const entries: Array<GPUBindGroupLayoutEntry> = [];
 
+    const binding =
+      bindingVariant === 'default'
+        ? t.device.limits.maxBindingsPerBindGroup
+        : bindingVariant === 'default-minus-one'
+        ? t.device.limits.maxBindingsPerBindGroup - 1
+        : bindingVariant;
+
     entries.push({
       binding,
       visibility: GPUShaderStage.COMPUTE,
       buffer: { type: 'storage' as const },
     });
 
-    const success = binding < kLimitInfo.maxBindingsPerBindGroup.default;
+    const success = binding < t.device.limits.maxBindingsPerBindGroup;
 
     t.expectValidationError(() => {
       t.device.createBindGroupLayout({
@@ -297,7 +295,7 @@ const kMaxResourcesCases = kUnitCaseParamsBuilder
   .combine('extraVisibility', kShaderStages)
   .filter(p => (bindingTypeInfo(p.extraEntry).validStages & p.extraVisibility) !== 0);
 
-// Should never fail unless kLimitInfo.maxBindingsPerBindGroup.default is exceeded, because the validation for
+// Should never fail unless limitInfo.maxBindingsPerBindGroup.default is exceeded, because the validation for
 // resources-of-type-per-stage is in pipeline layout creation.
 g.test('max_resources_per_stage,in_bind_group_layout')
   .desc(

From db357a2439736290c38900b7ba98e2df54ea8dda Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Mon, 25 Sep 2023 15:01:05 -0700
Subject: [PATCH 065/166] Compat: make basic compute test handle different
 limits (#3001)

---
 .../api/operation/compute/basic.spec.ts       | 39 +++++++++----------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/src/webgpu/api/operation/compute/basic.spec.ts b/src/webgpu/api/operation/compute/basic.spec.ts
index b53c40ffddb7..fcfcf5731c8b 100644
--- a/src/webgpu/api/operation/compute/basic.spec.ts
+++ b/src/webgpu/api/operation/compute/basic.spec.ts
@@ -3,18 +3,11 @@ Basic command buffer compute tests.
 `;
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
-import { kLimitInfo } from '../../../capability_info.js';
 import { GPUTest } from '../../../gpu_test.js';
 import { checkElementsEqualGenerated } from '../../../util/check_contents.js';
 
 export const g = makeTestGroup(GPUTest);
 
-const kMaxComputeWorkgroupSize = [
-  kLimitInfo.maxComputeWorkgroupSizeX.default,
-  kLimitInfo.maxComputeWorkgroupSizeY.default,
-  kLimitInfo.maxComputeWorkgroupSizeZ.default,
-];
-
 g.test('memcpy').fn(t => {
   const data = new Uint32Array([0x01020304]);
 
@@ -71,27 +64,33 @@ g.test('large_dispatch')
   .params(u =>
     u
       // Reasonably-sized powers of two, and some stranger larger sizes.
-      .combine('dispatchSize', [
-        256,
-        2048,
-        315,
-        628,
-        2179,
-        kLimitInfo.maxComputeWorkgroupsPerDimension.default,
-      ])
+      .combine('dispatchSize', [256, 2048, 315, 628, 2179, 'maximum'] as const)
       // Test some reasonable workgroup sizes.
       .beginSubcases()
       // 0 == x axis; 1 == y axis; 2 == z axis.
       .combine('largeDimension', [0, 1, 2] as const)
-      .expand('workgroupSize', p => [1, 2, 8, 32, kMaxComputeWorkgroupSize[p.largeDimension]])
+      .expand('workgroupSize', p => [1, 2, 8, 32, 'maximum'] as const)
   )
   .fn(t => {
     // The output storage buffer is filled with this value.
     const val = 0x01020304;
     const badVal = 0xbaadf00d;
 
-    const wgSize = t.params.workgroupSize;
-    const bufferLength = t.params.dispatchSize * wgSize;
+    const kMaxComputeWorkgroupSize = [
+      t.device.limits.maxComputeWorkgroupSizeX,
+      t.device.limits.maxComputeWorkgroupSizeY,
+      t.device.limits.maxComputeWorkgroupSizeZ,
+    ];
+
+    const wgSize =
+      t.params.workgroupSize === 'maximum'
+        ? kMaxComputeWorkgroupSize[t.params.largeDimension]
+        : t.params.workgroupSize;
+    const dispatchSize =
+      t.params.dispatchSize === 'maximum'
+        ? t.device.limits.maxComputeWorkgroupsPerDimension
+        : t.params.dispatchSize;
+    const bufferLength = dispatchSize * wgSize;
     const bufferByteSize = Uint32Array.BYTES_PER_ELEMENT * bufferLength;
     const dst = t.device.createBuffer({
       size: bufferByteSize,
@@ -101,9 +100,9 @@ g.test('large_dispatch')
     // Only use one large dimension and workgroup size in the dispatch
     // call to keep the size of the test reasonable.
     const dims = [1, 1, 1];
-    dims[t.params.largeDimension] = t.params.dispatchSize;
+    dims[t.params.largeDimension] = dispatchSize;
     const wgSizes = [1, 1, 1];
-    wgSizes[t.params.largeDimension] = t.params.workgroupSize;
+    wgSizes[t.params.largeDimension] = wgSize;
     const pipeline = t.device.createComputePipeline({
       layout: 'auto',
       compute: {

From 28733c03a24fe1c9a6edb142f3288052e7461ade Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 14:55:00 -0700
Subject: [PATCH 066/166] Compat: make requestDevice tests handle different
 limits

---
 .../operation/adapter/requestDevice.spec.ts   | 31 ++++++++++++-------
 1 file changed, 20 insertions(+), 11 deletions(-)

diff --git a/src/webgpu/api/operation/adapter/requestDevice.spec.ts b/src/webgpu/api/operation/adapter/requestDevice.spec.ts
index 5dcd53c86e5a..7d930a5e19df 100644
--- a/src/webgpu/api/operation/adapter/requestDevice.spec.ts
+++ b/src/webgpu/api/operation/adapter/requestDevice.spec.ts
@@ -9,7 +9,12 @@ import { Fixture } from '../../../../common/framework/fixture.js';
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
 import { getGPU } from '../../../../common/util/navigator_gpu.js';
 import { assert, assertReject, raceWithRejectOnTimeout } from '../../../../common/util/util.js';
-import { kFeatureNames, kLimitInfo, kLimits } from '../../../capability_info.js';
+import {
+  getDefaultLimitsForAdapter,
+  kFeatureNames,
+  kLimits,
+  kLimitClasses,
+} from '../../../capability_info.js';
 import { clamp, isPowerOfTwo } from '../../../util/math.js';
 
 export const g = makeTestGroup(Fixture);
@@ -40,10 +45,11 @@ g.test('default')
     // Default device should have no features.
     t.expect(device.features.size === 0, 'Default device should not have any features');
     // All limits should be defaults.
+    const limitInfo = getDefaultLimitsForAdapter(adapter);
     for (const limit of kLimits) {
       t.expect(
-        device.limits[limit] === kLimitInfo[limit].default,
-        `Expected ${limit} == default: ${device.limits[limit]} != ${kLimitInfo[limit].default}`
+        device.limits[limit] === limitInfo[limit].default,
+        `Expected ${limit} == default: ${device.limits[limit]} != ${limitInfo[limit].default}`
       );
     }
 
@@ -239,10 +245,11 @@ g.test('limits,supported')
     const adapter = await gpu.requestAdapter();
     assert(adapter !== null);
 
+    const limitInfo = getDefaultLimitsForAdapter(adapter);
     let value: number = -1;
     switch (limitValue) {
       case 'default':
-        value = kLimitInfo[limit].default;
+        value = limitInfo[limit].default;
         break;
       case 'adapter':
         value = adapter.limits[limit];
@@ -271,7 +278,7 @@ g.test('limit,better_than_supported')
       .combine('limit', kLimits)
       .beginSubcases()
       .expandWithParams(p => {
-        switch (kLimitInfo[p.limit].class) {
+        switch (kLimitClasses[p.limit]) {
           case 'maximum':
             return [
               { mul: 1, add: 1 },
@@ -293,9 +300,10 @@ g.test('limit,better_than_supported')
     const adapter = await gpu.requestAdapter();
     assert(adapter !== null);
 
+    const limitInfo = getDefaultLimitsForAdapter(adapter);
     const value = adapter.limits[limit] * mul + add;
     const requiredLimits = {
-      [limit]: clamp(value, { min: 0, max: kLimitInfo[limit].maximumValue }),
+      [limit]: clamp(value, { min: 0, max: limitInfo[limit].maximumValue }),
     };
 
     t.shouldReject('OperationError', adapter.requestDevice({ requiredLimits }));
@@ -314,7 +322,7 @@ g.test('limit,worse_than_default')
       .combine('limit', kLimits)
       .beginSubcases()
       .expandWithParams(p => {
-        switch (kLimitInfo[p.limit].class) {
+        switch (kLimitClasses[p.limit]) {
           case 'maximum':
             return [
               { mul: 1, add: -1 },
@@ -336,13 +344,14 @@ g.test('limit,worse_than_default')
     const adapter = await gpu.requestAdapter();
     assert(adapter !== null);
 
-    const value = kLimitInfo[limit].default * mul + add;
+    const limitInfo = getDefaultLimitsForAdapter(adapter);
+    const value = limitInfo[limit].default * mul + add;
     const requiredLimits = {
-      [limit]: clamp(value, { min: 0, max: kLimitInfo[limit].maximumValue }),
+      [limit]: clamp(value, { min: 0, max: limitInfo[limit].maximumValue }),
     };
 
     let success;
-    switch (kLimitInfo[limit].class) {
+    switch (limitInfo[limit].class) {
       case 'alignment':
         success = isPowerOfTwo(value);
         break;
@@ -355,7 +364,7 @@ g.test('limit,worse_than_default')
       const device = await adapter.requestDevice({ requiredLimits });
       assert(device !== null);
       t.expect(
-        device.limits[limit] === kLimitInfo[limit].default,
+        device.limits[limit] === limitInfo[limit].default,
         'Devices reported limit should match the default limit'
       );
       device.destroy();

From 62382d04de920d7311621573152fdaf8049693eb Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 15:15:52 -0700
Subject: [PATCH 067/166] Compat: make maxColorAttachments test handle
 different limits

---
 .../limits/maxColorAttachments.spec.ts            | 15 +++++++++++++--
 src/webgpu/listing_meta.json                      |  1 +
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/webgpu/api/validation/capability_checks/limits/maxColorAttachments.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxColorAttachments.spec.ts
index 5d650c3b5d3a..53c3b48c6bab 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxColorAttachments.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxColorAttachments.spec.ts
@@ -1,6 +1,7 @@
 import { range } from '../../../../../common/util/util.js';
+import { kMaxColorAttachmentsToTest } from '../../../../capability_info.js';
 
-import { kMaximumLimitBaseParams, getDefaultLimit, makeLimitTestGroup } from './limit_utils.js';
+import { kMaximumLimitBaseParams, makeLimitTestGroup } from './limit_utils.js';
 
 function getPipelineDescriptor(device: GPUDevice, testValue: number): GPURenderPipelineDescriptor {
   const code = `
@@ -105,9 +106,19 @@ g.test('validate,maxColorAttachmentBytesPerSample')
   .desc(`Test ${limit} against maxColorAttachmentBytesPerSample`)
   .fn(t => {
     const { adapter, defaultLimit, adapterLimit: maximumLimit } = t;
-    const minColorAttachmentBytesPerSample = getDefaultLimit('maxColorAttachmentBytesPerSample');
+    const minColorAttachmentBytesPerSample = t.getDefaultLimit('maxColorAttachmentBytesPerSample');
     // The smallest attachment is 1 byte
     // so make sure maxColorAttachments < maxColorAttachmentBytesPerSample
     t.expect(defaultLimit <= minColorAttachmentBytesPerSample);
     t.expect(maximumLimit <= adapter.limits.maxColorAttachmentBytesPerSample);
   });
+
+g.test('validate,kMaxColorAttachmentsToTest')
+  .desc(
+    `
+    Tests that kMaxColorAttachmentsToTest is large enough to test the limits of this device
+  `
+  )
+  .fn(t => {
+    t.expect(t.adapter.limits.maxColorAttachments <= kMaxColorAttachmentsToTest);
+  });
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 4486d0ba6198..1f83b70f96f4 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -286,6 +286,7 @@
   "webgpu:api,validation,capability_checks,limits,maxColorAttachments:createRenderBundle,at_over:*": { "subcaseMS": 12.681 },
   "webgpu:api,validation,capability_checks,limits,maxColorAttachments:createRenderPipeline,at_over:*": { "subcaseMS": 10.450 },
   "webgpu:api,validation,capability_checks,limits,maxColorAttachments:validate,maxColorAttachmentBytesPerSample:*": { "subcaseMS": 1.101 },
+  "webgpu:api,validation,capability_checks,limits,maxColorAttachments:validate,kMaxColorAttachmentsToTest:*": { "subcaseMS": 1.101 },
   "webgpu:api,validation,capability_checks,limits,maxComputeInvocationsPerWorkgroup:createComputePipeline,at_over:*": { "subcaseMS": 13.735 },
   "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeX:createComputePipeline,at_over:*": { "subcaseMS": 14.465 },
   "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeY:createComputePipeline,at_over:*": { "subcaseMS": 14.131 },

From 5ab05f9d779091b43e3c8fcec71b471783a6d331 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 16:10:30 -0700
Subject: [PATCH 068/166] Compat: Refactor limits utils for compat limits

---
 .../capability_checks/limits/limit_utils.ts   | 29 +++++++------------
 1 file changed, 10 insertions(+), 19 deletions(-)

diff --git a/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts b/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
index fa1bd58620f0..c91e1637a950 100644
--- a/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
@@ -2,10 +2,8 @@ import { kUnitCaseParamsBuilder } from '../../../../../common/framework/params_b
 import { makeTestGroup } from '../../../../../common/framework/test_group.js';
 import { getGPU } from '../../../../../common/util/navigator_gpu.js';
 import { assert, range, reorder, ReorderOrder } from '../../../../../common/util/util.js';
-import { kLimitInfo } from '../../../../capability_info.js';
-import { kTextureFormatInfo } from '../../../../format_info.js';
+import { kLimitInfo, getDefaultLimitsForAdapter } from '../../../../capability_info.js';
 import { GPUTestBase } from '../../../../gpu_test.js';
-import { align } from '../../../../util/math.js';
 
 type GPUSupportedLimit = keyof GPUSupportedLimits;
 
@@ -76,19 +74,6 @@ function getWGSLBindings(
   ).join('\n        ');
 }
 
-/**
- * Given an array of GPUColorTargetState return the number of bytes per sample
- */
-export function computeBytesPerSample(targets: GPUColorTargetState[]) {
-  let bytesPerSample = 0;
-  for (const { format } of targets) {
-    const info = kTextureFormatInfo[format];
-    const alignedBytesPerSample = align(bytesPerSample, info.colorRender!.alignment);
-    bytesPerSample = alignedBytesPerSample + info.colorRender!.byteCost;
-  }
-  return bytesPerSample;
-}
-
 export function getPerStageWGSLForBindingCombinationImpl(
   bindingCombination: BindingCombination,
   order: ReorderOrder,
@@ -272,6 +257,12 @@ export const kMinimumLimitValueTests = [
 ] as const;
 export type MinimumLimitValueTest = typeof kMinimumLimitValueTests[number];
 
+export function getDefaultLimitForAdapter(adapter: GPUAdapter, limit: GPUSupportedLimit): number {
+  const limitInfo = getDefaultLimitsForAdapter(adapter);
+  return limitInfo[limit as keyof typeof limitInfo].default;
+}
+
+// MAINTENANCE_TODO: remove as soon as compat refactor is done and this is no longer used.
 export function getDefaultLimit(limit: GPUSupportedLimit): number {
   return (kLimitInfo as Record<string, { default: number }>)[limit].default;
 }
@@ -321,7 +312,7 @@ export class LimitTestsImpl extends GPUTestBase {
     const gpu = getGPU(this.rec);
     this._adapter = await gpu.requestAdapter();
     const limit = this.limit;
-    this.defaultLimit = getDefaultLimit(limit);
+    this.defaultLimit = getDefaultLimitForAdapter(this.adapter, limit);
     this.adapterLimit = this.adapter.limits[limit] as number;
     assert(!Number.isNaN(this.defaultLimit));
     assert(!Number.isNaN(this.adapterLimit));
@@ -354,7 +345,7 @@ export class LimitTestsImpl extends GPUTestBase {
   getDefaultOrAdapterLimit(limit: GPUSupportedLimit, limitMode: LimitMode) {
     switch (limitMode) {
       case 'defaultLimit':
-        return getDefaultLimit(limit);
+        return getDefaultLimitForAdapter(this.adapter, limit);
       case 'adapterLimit':
         return this.adapter.limits[limit];
     }
@@ -380,7 +371,7 @@ export class LimitTestsImpl extends GPUTestBase {
         const extraLimit = extraLimitStr as GPUSupportedLimit;
         requiredLimits[extraLimit] =
           limitMode === 'defaultLimit'
-            ? getDefaultLimit(extraLimit)
+            ? getDefaultLimitForAdapter(adapter, extraLimit)
             : (adapter.limits[extraLimit] as number);
       }
     }

From bbddf3a660e0ae39036dc71399b61674cdbe14fb Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Mon, 25 Sep 2023 16:31:26 -0700
Subject: [PATCH 069/166] Compat: make buffer create test handle different
 limits (#3005)

---
 src/webgpu/api/validation/buffer/create.spec.ts | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/src/webgpu/api/validation/buffer/create.spec.ts b/src/webgpu/api/validation/buffer/create.spec.ts
index 2766d40530f0..9631c368fe41 100644
--- a/src/webgpu/api/validation/buffer/create.spec.ts
+++ b/src/webgpu/api/validation/buffer/create.spec.ts
@@ -8,7 +8,6 @@ import {
   kAllBufferUsageBits,
   kBufferSizeAlignment,
   kBufferUsages,
-  kLimitInfo,
 } from '../../../capability_info.js';
 import { GPUConst } from '../../../constants.js';
 import { kMaxSafeMultipleOf8 } from '../../../util/math.js';
@@ -46,18 +45,11 @@ g.test('size')
 
 g.test('limit')
   .desc('Test buffer size is validated against maxBufferSize.')
-  .params(u =>
-    u
-      .beginSubcases()
-      .combine('size', [
-        kLimitInfo.maxBufferSize.default - 1,
-        kLimitInfo.maxBufferSize.default,
-        kLimitInfo.maxBufferSize.default + 1,
-      ])
-  )
+  .params(u => u.beginSubcases().combine('sizeAddition', [-1, 0, +1]))
   .fn(t => {
-    const { size } = t.params;
-    const isValid = size <= kLimitInfo.maxBufferSize.default;
+    const { sizeAddition } = t.params;
+    const size = t.makeLimitVariant('maxBufferSize', { mult: 1, add: sizeAddition });
+    const isValid = size <= t.device.limits.maxBufferSize;
     const usage = BufferUsage.COPY_SRC;
     t.expectGPUError('validation', () => t.device.createBuffer({ size, usage }), !isValid);
   });

From b62d1b8971f96db0834c8fa8a294c91d391ec5ec Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 15:06:29 -0700
Subject: [PATCH 070/166] Compat: make vertex state correctness tests handle
 different limits

---
 .../vertex_state/correctness.spec.ts          | 137 ++++++++++++------
 1 file changed, 91 insertions(+), 46 deletions(-)

diff --git a/src/webgpu/api/operation/vertex_state/correctness.spec.ts b/src/webgpu/api/operation/vertex_state/correctness.spec.ts
index 8ec536dcc511..aa06b7dca517 100644
--- a/src/webgpu/api/operation/vertex_state/correctness.spec.ts
+++ b/src/webgpu/api/operation/vertex_state/correctness.spec.ts
@@ -4,11 +4,14 @@ float tolerance.
 `;
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
-import { assert, memcpy, unreachable } from '../../../../common/util/util.js';
 import {
-  kMaxVertexAttributes,
-  kMaxVertexBufferArrayStride,
-  kMaxVertexBuffers,
+  assert,
+  filterUniqueValueTestVariants,
+  makeValueTestVariant,
+  memcpy,
+  unreachable,
+} from '../../../../common/util/util.js';
+import {
   kPerStageBindingLimits,
   kVertexFormatInfo,
   kVertexFormats,
@@ -95,7 +98,10 @@ class VertexStateTest extends GPUTest {
     // However this might not work in the future for implementations that allow even more vertex
     // attributes so there will need to be larger changes when that happens.
     const maxUniformBuffers = kPerStageBindingLimits['uniformBuf'].max;
-    assert(maxUniformBuffers + kPerStageBindingLimits['storageBuf'].max >= kMaxVertexAttributes);
+    assert(
+      maxUniformBuffers + kPerStageBindingLimits['storageBuf'].max >=
+        this.device.limits.maxVertexAttributes
+    );
 
     let vsInputs = '';
     let vsChecks = '';
@@ -600,11 +606,21 @@ g.test('vertex_format_to_shader_format_conversion')
       .combine('format', kVertexFormats)
       .combine('shaderComponentCount', [1, 2, 3, 4])
       .beginSubcases()
-      .combine('slot', [0, 1, kMaxVertexBuffers - 1])
-      .combine('shaderLocation', [0, 1, kMaxVertexAttributes - 1])
+      .combine('slotVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
+      .combine('shaderLocationVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: -1 },
+      ])
   )
   .fn(t => {
-    const { format, shaderComponentCount, slot, shaderLocation } = t.params;
+    const { format, shaderComponentCount, slotVariant, shaderLocationVariant } = t.params;
+    const slot = t.makeLimitVariant('maxVertexBuffers', slotVariant);
+    const shaderLocation = t.makeLimitVariant('maxVertexAttributes', shaderLocationVariant);
     t.runTest([
       {
         slot,
@@ -683,30 +699,40 @@ g.test('non_zero_array_stride_and_attribute_offset')
     u //
       .combine('format', kVertexFormats)
       .beginSubcases()
-      .expand('arrayStride', p => {
+      .expand('arrayStrideVariant', p => {
         const formatInfo = kVertexFormatInfo[p.format];
         const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
 
-        return [align(formatSize, 4), align(formatSize, 4) + 4, kMaxVertexBufferArrayStride];
+        return [
+          { mult: 0, add: align(formatSize, 4) },
+          { mult: 0, add: align(formatSize, 4) + 4 },
+          { mult: 1, add: 0 },
+        ];
       })
-      .expand('offset', p => {
+      .expand('offsetVariant', p => {
         const formatInfo = kVertexFormatInfo[p.format];
         const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
-        return new Set(
-          [
-            0,
-            formatSize,
-            4,
-            p.arrayStride / 2,
-            p.arrayStride - formatSize * 2,
-            p.arrayStride - formatSize - 4,
-            p.arrayStride - formatSize,
-          ].map(offset => clamp(offset, { min: 0, max: p.arrayStride - formatSize }))
-        );
+        return [
+          { mult: 0, add: 0 },
+          { mult: 0, add: formatSize },
+          { mult: 0, add: 4 },
+          { mult: 0.5, add: 0 },
+          { mult: 1, add: -formatSize * 2 },
+          { mult: 1, add: -formatSize - 4 },
+          { mult: 1, add: -formatSize },
+        ];
       })
   )
   .fn(t => {
-    const { format, arrayStride, offset } = t.params;
+    const { format, arrayStrideVariant, offsetVariant } = t.params;
+    const arrayStride = t.makeLimitVariant('maxVertexBufferArrayStride', arrayStrideVariant);
+    const formatInfo = kVertexFormatInfo[format];
+    const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+    const offset = clamp(makeValueTestVariant(arrayStride, offsetVariant), {
+      min: 0,
+      max: arrayStride - formatSize,
+    });
+
     t.runTest([
       {
         slot: 0,
@@ -764,11 +790,16 @@ g.test('vertex_buffer_used_multiple_times_overlapped')
     u //
       .combine('format', kVertexFormats)
       .beginSubcases()
-      .combine('vbCount', [2, 3, kMaxVertexBuffers])
+      .combine('vbCountVariant', [
+        { mult: 0, add: 2 },
+        { mult: 0, add: 3 },
+        { mult: 1, add: 0 },
+      ])
       .combine('additionalVBOffset', [0, 4, 120])
   )
   .fn(t => {
-    const { format, vbCount, additionalVBOffset } = t.params;
+    const { format, vbCountVariant, additionalVBOffset } = t.params;
+    const vbCount = t.makeLimitVariant('maxVertexBuffers', vbCountVariant);
     const kVertexCount = 20;
     const kInstanceCount = 1;
     const formatInfo = kVertexFormatInfo[format];
@@ -863,11 +894,16 @@ g.test('vertex_buffer_used_multiple_times_interleaved')
     u //
       .combine('format', kVertexFormats)
       .beginSubcases()
-      .combine('vbCount', [2, 3, kMaxVertexBuffers])
+      .combine('vbCountVariant', [
+        { mult: 0, add: 2 },
+        { mult: 0, add: 3 },
+        { mult: 1, add: 0 },
+      ])
       .combine('additionalVBOffset', [0, 4, 120])
   )
   .fn(t => {
-    const { format, vbCount, additionalVBOffset } = t.params;
+    const { format, vbCountVariant, additionalVBOffset } = t.params;
+    const vbCount = t.makeLimitVariant('maxVertexBuffers', vbCountVariant);
     const kVertexCount = 20;
     const kInstanceCount = 1;
     const formatInfo = kVertexFormatInfo[format];
@@ -942,12 +978,14 @@ g.test('max_buffers_and_attribs')
   .fn(t => {
     const { format } = t.params;
     // In compat mode, @builtin(vertex_index) and @builtin(instance_index) each take an attribute
-    const maxVertexAttributes = t.isCompatibility ? kMaxVertexAttributes - 2 : kMaxVertexAttributes;
-    const attributesPerBuffer = Math.ceil(maxVertexAttributes / kMaxVertexBuffers);
+    const maxVertexBuffers = t.device.limits.maxVertexBuffers;
+    const deviceMaxVertexAttributes = t.device.limits.maxVertexAttributes;
+    const maxVertexAttributes = deviceMaxVertexAttributes - (t.isCompatibility ? 2 : 0);
+    const attributesPerBuffer = Math.ceil(maxVertexAttributes / maxVertexBuffers);
     let attributesEmitted = 0;
 
     const state: VertexLayoutState<{}, {}> = [];
-    for (let i = 0; i < kMaxVertexBuffers; i++) {
+    for (let i = 0; i < maxVertexBuffers; i++) {
       const attributes: GPUVertexAttribute[] = [];
       for (let j = 0; j < attributesPerBuffer && attributesEmitted < maxVertexAttributes; j++) {
         attributes.push({ format, offset: 0, shaderLocation: attributesEmitted });
@@ -974,25 +1012,26 @@ g.test('array_stride_zero')
       .combine('format', kVertexFormats)
       .beginSubcases()
       .combine('stepMode', ['vertex', 'instance'] as const)
-      .expand('offset', p => {
+      .expand('offsetVariant', p => {
         const formatInfo = kVertexFormatInfo[p.format];
         const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
-        return new Set([
-          0,
-          4,
-          8,
-          formatSize,
-          formatSize * 2,
-          kMaxVertexBufferArrayStride / 2,
-          kMaxVertexBufferArrayStride - formatSize - 4,
-          kMaxVertexBufferArrayStride - formatSize - 8,
-          kMaxVertexBufferArrayStride - formatSize,
-          kMaxVertexBufferArrayStride - formatSize * 2,
+        return filterUniqueValueTestVariants([
+          { mult: 0, add: 0 },
+          { mult: 0, add: 4 },
+          { mult: 0, add: 8 },
+          { mult: 0, add: formatSize },
+          { mult: 0, add: formatSize * 2 },
+          { mult: 0.5, add: 0 },
+          { mult: 1, add: -formatSize - 4 },
+          { mult: 1, add: -formatSize - 8 },
+          { mult: 1, add: -formatSize },
+          { mult: 1, add: -formatSize * 2 },
         ]);
       })
   )
   .fn(t => {
-    const { format, stepMode, offset } = t.params;
+    const { format, stepMode, offsetVariant } = t.params;
+    const offset = t.makeLimitVariant('maxVertexBufferArrayStride', offsetVariant);
     const kCount = 10;
 
     // Create the stride 0 part of the test, first by faking a single vertex being drawn and
@@ -1055,7 +1094,7 @@ g.test('discontiguous_location_and_attribs')
   .fn(t => {
     t.runTest([
       {
-        slot: kMaxVertexBuffers - 1,
+        slot: t.device.limits.maxVertexBuffers - 1,
         arrayStride: 4,
         stepMode: 'vertex',
         attributes: [
@@ -1068,7 +1107,13 @@ g.test('discontiguous_location_and_attribs')
         arrayStride: 16,
         stepMode: 'instance',
         vbOffset: 1000,
-        attributes: [{ format: 'uint32x4', offset: 0, shaderLocation: kMaxVertexAttributes - 1 }],
+        attributes: [
+          {
+            format: 'uint32x4',
+            offset: 0,
+            shaderLocation: t.device.limits.maxVertexAttributes - 1,
+          },
+        ],
       },
     ]);
   });
@@ -1083,7 +1128,7 @@ g.test('overlapping_attributes')
     const { format } = t.params;
 
     // In compat mode, @builtin(vertex_index) and @builtin(instance_index) each take an attribute
-    const maxVertexAttributes = t.isCompatibility ? kMaxVertexAttributes - 2 : kMaxVertexAttributes;
+    const maxVertexAttributes = t.device.limits.maxVertexAttributes - (t.isCompatibility ? 2 : 0);
     const attributes: GPUVertexAttribute[] = [];
     for (let i = 0; i < maxVertexAttributes; i++) {
       attributes.push({ format, offset: 0, shaderLocation: i });

From 95855c1480b759dff6b6a2ee9e78ccc5503501ca Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 17:37:17 -0700
Subject: [PATCH 071/166] add skipIf to Fixture

---
 src/common/framework/fixture.ts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/common/framework/fixture.ts b/src/common/framework/fixture.ts
index 7722a4fe1b0c..381d60ba047a 100644
--- a/src/common/framework/fixture.ts
+++ b/src/common/framework/fixture.ts
@@ -166,6 +166,13 @@ export class Fixture<S extends SubcaseBatchState = SubcaseBatchState> {
     throw new SkipTestCase(msg);
   }
 
+  /** Throws an exception marking the subcase as skipped if condition is true */
+  skipIf(cond: boolean, msg: string | (() => string) = '') {
+    if (cond) {
+      this.skip(typeof msg === 'function' ? msg() : msg);
+    }
+  }
+
   /** Log a warning and increase the result status to "Warn". */
   warn(msg?: string): void {
     this.rec.warn(new Error(msg));

From 6d6e7c99a4654f1cb99bdf1a40c819fd4663ed34 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 14:34:39 -0700
Subject: [PATCH 072/166] Compat: make attachment compatibility test handle
 different limits

---
 .../attachment_compatibility.spec.ts          | 24 +++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/src/webgpu/api/validation/render_pass/attachment_compatibility.spec.ts b/src/webgpu/api/validation/render_pass/attachment_compatibility.spec.ts
index 02110561b3d7..2170224ed931 100644
--- a/src/webgpu/api/validation/render_pass/attachment_compatibility.spec.ts
+++ b/src/webgpu/api/validation/render_pass/attachment_compatibility.spec.ts
@@ -4,7 +4,7 @@ Validation for attachment compatibility between render passes, bundles, and pipe
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
 import { range } from '../../../../common/util/util.js';
-import { kTextureSampleCounts, kMaxColorAttachments } from '../../../capability_info.js';
+import { kMaxColorAttachmentsToTest, kTextureSampleCounts } from '../../../capability_info.js';
 import {
   kRegularTextureFormats,
   kSizedDepthStencilFormats,
@@ -15,7 +15,7 @@ import {
 } from '../../../format_info.js';
 import { ValidationTest } from '../validation_test.js';
 
-const kColorAttachmentCounts = range(kMaxColorAttachments, i => i + 1);
+const kColorAttachmentCounts = range(kMaxColorAttachmentsToTest, i => i + 1);
 const kColorAttachments = kColorAttachmentCounts
   .map(count => {
     // generate cases with 0..1 null attachments at different location
@@ -241,6 +241,17 @@ g.test('render_pass_and_bundle,color_sparse')
   )
   .fn(t => {
     const { passAttachments, bundleAttachments } = t.params;
+
+    const maxColorAttachments = t.device.limits.maxColorAttachments;
+    t.skipIf(
+      passAttachments.length > maxColorAttachments,
+      `num passAttachments: ${passAttachments.length} > maxColorAttachments for device: ${maxColorAttachments}`
+    );
+    t.skipIf(
+      bundleAttachments.length > maxColorAttachments,
+      `num bundleAttachments: ${bundleAttachments.length} > maxColorAttachments for device: ${maxColorAttachments}`
+    );
+
     const colorFormats = bundleAttachments.map(i => (i ? 'rgba8uint' : null));
     const bundleEncoder = t.device.createRenderBundleEncoder({
       colorFormats,
@@ -424,6 +435,15 @@ Test that each of color attachments in render passes or bundles match that of th
   )
   .fn(t => {
     const { encoderType, encoderAttachments, pipelineAttachments } = t.params;
+    const maxColorAttachments = t.device.limits.maxColorAttachments;
+    t.skipIf(
+      encoderAttachments.length > maxColorAttachments,
+      `num encoderAttachments: ${encoderAttachments.length} > maxColorAttachments for device: ${maxColorAttachments}`
+    );
+    t.skipIf(
+      pipelineAttachments.length > maxColorAttachments,
+      `num pipelineAttachments: ${pipelineAttachments.length} > maxColorAttachments for device: ${maxColorAttachments}`
+    );
 
     const colorTargets = pipelineAttachments.map(i =>
       i ? ({ format: 'rgba8uint', writeMask: 0 } as GPUColorTargetState) : null

From bc9f28287609e43dafce0d5da83c2093eae414b5 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 26 Sep 2023 10:58:30 +0800
Subject: [PATCH 073/166] util: Add negative zero in full F16/F32/F64 range
 (#2978)

This PR add negative zero in fullF16Range, fullF32Range, and fullF64Range.
---
 src/unittests/maths.spec.ts | 52 ++++++++++++++++++-------------------
 src/webgpu/util/math.ts     | 12 +++++++++
 2 files changed, 38 insertions(+), 26 deletions(-)

diff --git a/src/unittests/maths.spec.ts b/src/unittests/maths.spec.ts
index fa3899e21e9a..eae2d03d4c87 100644
--- a/src/unittests/maths.spec.ts
+++ b/src/unittests/maths.spec.ts
@@ -1535,19 +1535,19 @@ g.test('fullF32Range')
   .paramsSimple<fullF32RangeCase>(
     // prettier-ignore
     [
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
-        { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, 0.0] },
-        { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, 0.0 ] },
-        { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -1.9999998807907104, kValue.f32.negative.max, 0.0 ] },
-        { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, 0.0 ] },
-        { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, 0.0 ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f32.subnormal.positive.min ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f32.positive.min ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f32.positive.min, kValue.f32.positive.max ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f32.positive.min, 1.9999998807907104, kValue.f32.positive.max ] },
-        { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f32.negative.min, kValue.f32.subnormal.negative.min, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.positive.min ] },
-        { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max, kValue.f32.positive.min, kValue.f32.positive.max ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ -0.0, 0.0 ] },
+        { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -0.0, 0.0] },
+        { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, -0.0, 0.0 ] },
+        { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -1.9999998807907104, kValue.f32.negative.max, -0.0, 0.0 ] },
+        { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, -0.0, 0.0 ] },
+        { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, -0.0, 0.0 ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f32.subnormal.positive.min ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ -0.0, 0.0, kValue.f32.positive.min ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ -0.0, 0.0, kValue.f32.positive.min, kValue.f32.positive.max ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ -0.0, 0.0, kValue.f32.positive.min, 1.9999998807907104, kValue.f32.positive.max ] },
+        { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f32.negative.min, kValue.f32.subnormal.negative.min, -0.0, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.positive.min ] },
+        { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, -0.0, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max, kValue.f32.positive.min, kValue.f32.positive.max ] },
     ]
   )
   .fn(test => {
@@ -1576,19 +1576,19 @@ g.test('fullF16Range')
   .paramsSimple<fullF16RangeCase>(
     // prettier-ignore
     [
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
-          { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, 0.0] },
-          { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, 0.0 ] },
-          { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -1.9990234375, kValue.f16.negative.max, 0.0 ] },
-          { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, 0.0 ] },
-          { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, 0.0 ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f16.subnormal.positive.min ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f16.positive.min ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f16.positive.min, kValue.f16.positive.max ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f16.positive.min, 1.9990234375, kValue.f16.positive.max ] },
-          { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f16.negative.min, kValue.f16.subnormal.negative.min, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.positive.min ] },
-          { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max, kValue.f16.positive.min, kValue.f16.positive.max ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ -0.0, 0.0 ] },
+          { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -0.0, 0.0] },
+          { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, -0.0, 0.0 ] },
+          { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -1.9990234375, kValue.f16.negative.max, -0.0, 0.0 ] },
+          { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, -0.0, 0.0 ] },
+          { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, -0.0, 0.0 ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f16.subnormal.positive.min ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ -0.0, 0.0, kValue.f16.positive.min ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ -0.0, 0.0, kValue.f16.positive.min, kValue.f16.positive.max ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ -0.0, 0.0, kValue.f16.positive.min, 1.9990234375, kValue.f16.positive.max ] },
+          { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f16.negative.min, kValue.f16.subnormal.negative.min, -0.0, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.positive.min ] },
+          { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, -0.0, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max, kValue.f16.positive.min, kValue.f16.positive.max ] },
       ]
   )
   .fn(test => {
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 54bba7abfb71..cc25342b0da3 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -920,6 +920,9 @@ export function fullF32Range(
       kBit.f32.subnormal.negative.max,
       counts.neg_sub
     ),
+    // -0.0
+    0x80000000,
+    // +0.0
     0,
     ...linearRange(
       kBit.f32.subnormal.positive.min,
@@ -984,6 +987,9 @@ export function fullF16Range(
       kBit.f16.subnormal.negative.max,
       counts.neg_sub
     ),
+    // -0.0
+    0x8000,
+    // +0.0
     0,
     ...linearRange(
       kBit.f16.subnormal.positive.min,
@@ -1032,6 +1038,9 @@ export function fullF64Range(
       kBit.f64.subnormal.negative.max,
       counts.neg_sub
     ),
+    // -0.0
+    0x8000_0000_0000_0000n,
+    // +0.0
     0n,
     ...linearRangeBigInt(
       kBit.f64.subnormal.positive.min,
@@ -1088,6 +1097,9 @@ export function filteredF64Range(
       kBit.f64.subnormal.negative.max,
       counts.neg_sub
     ),
+    // -0.0
+    0x8000_0000_0000_0000n,
+    // +0.0
     0n,
     ...linearRangeBigInt(
       kBit.f64.subnormal.positive.min,

From 7b1b8e8b441079d0843d49d25ca3b04c40bff13a Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 26 Sep 2023 10:59:00 +0800
Subject: [PATCH 074/166] wgsl: add f16 execution test for builtin normalize
 (#2985)

This PR add execution test for f16 built-in normalize.

Issue: #1248, #2571
---
 src/unittests/floating_point.spec.ts          |  82 ++++++++----
 src/webgpu/listing_meta.json                  |   4 +-
 .../expression/call/builtin/normalize.spec.ts | 126 +++++++++++-------
 src/webgpu/util/floating_point.ts             |   5 +-
 4 files changed, 135 insertions(+), 82 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index c769a144bcf3..0cdbb754ecbe 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5783,39 +5783,69 @@ interface VectorToVectorCase {
   expected: (number | IntervalBounds)[];
 }
 
-g.test('normalizeInterval_f32')
-  .paramsSubcasesOnly<VectorToVectorCase>(
-    // prettier-ignore
-    [
-      // vec2
-      {input: [1.0, 0.0], expected: [[reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0]
-      {input: [0.0, 1.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)]] },  // [ ~0.0, ~1.0]
-      {input: [-1.0, 0.0], expected: [[reinterpretU64AsF64(0xbff0_0000_b000_0000n), reinterpretU64AsF64(0xbfef_fffe_7000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0]
-      {input: [1.0, 1.0], expected: [[reinterpretU64AsF64(0x3fe6_a09d_5000_0000n), reinterpretU64AsF64(0x3fe6_a09f_9000_0000n)], [reinterpretU64AsF64(0x3fe6_a09d_5000_0000n), reinterpretU64AsF64(0x3fe6_a09f_9000_0000n)]] },  // [ ~1/√2, ~1/√2]
+// prettier-ignore
+const kNormalizeIntervalCases = {
+  f32: [
+    // vec2
+    {input: [1.0, 0.0], expected: [[reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0]
+    {input: [0.0, 1.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)]] },  // [ ~0.0, ~1.0]
+    {input: [-1.0, 0.0], expected: [[reinterpretU64AsF64(0xbff0_0000_b000_0000n), reinterpretU64AsF64(0xbfef_fffe_7000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0]
+    {input: [1.0, 1.0], expected: [[reinterpretU64AsF64(0x3fe6_a09d_5000_0000n), reinterpretU64AsF64(0x3fe6_a09f_9000_0000n)], [reinterpretU64AsF64(0x3fe6_a09d_5000_0000n), reinterpretU64AsF64(0x3fe6_a09f_9000_0000n)]] },  // [ ~1/√2, ~1/√2]
 
-      // vec3
-      {input: [1.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0, ~0.0]
-      {input: [0.0, 1.0, 0.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~0.0, ~1.0, ~0.0]
-      {input: [0.0, 0.0, 1.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)]] },  // [ ~0.0, ~0.0, ~1.0]
-      {input: [-1.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0xbff0_0000_b000_0000n), reinterpretU64AsF64(0xbfef_fffe_7000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0, ~0.0]
-      {input: [1.0, 1.0, 1.0], expected: [[reinterpretU64AsF64(0x3fe2_79a6_5000_0000n), reinterpretU64AsF64(0x3fe2_79a8_5000_0000n)], [reinterpretU64AsF64(0x3fe2_79a6_5000_0000n), reinterpretU64AsF64(0x3fe2_79a8_5000_0000n)], [reinterpretU64AsF64(0x3fe2_79a6_5000_0000n), reinterpretU64AsF64(0x3fe2_79a8_5000_0000n)]] },  // [ ~1/√3, ~1/√3, ~1/√3]
+    // vec3
+    {input: [1.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0, ~0.0]
+    {input: [0.0, 1.0, 0.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~0.0, ~1.0, ~0.0]
+    {input: [0.0, 0.0, 1.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)]] },  // [ ~0.0, ~0.0, ~1.0]
+    {input: [-1.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0xbff0_0000_b000_0000n), reinterpretU64AsF64(0xbfef_fffe_7000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0, ~0.0]
+    {input: [1.0, 1.0, 1.0], expected: [[reinterpretU64AsF64(0x3fe2_79a6_5000_0000n), reinterpretU64AsF64(0x3fe2_79a8_5000_0000n)], [reinterpretU64AsF64(0x3fe2_79a6_5000_0000n), reinterpretU64AsF64(0x3fe2_79a8_5000_0000n)], [reinterpretU64AsF64(0x3fe2_79a6_5000_0000n), reinterpretU64AsF64(0x3fe2_79a8_5000_0000n)]] },  // [ ~1/√3, ~1/√3, ~1/√3]
 
-      // vec4
-      {input: [1.0, 0.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0, ~0.0, ~0.0]
-      {input: [0.0, 1.0, 0.0, 0.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~0.0, ~1.0, ~0.0, ~0.0]
-      {input: [0.0, 0.0, 1.0, 0.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~0.0, ~0.0, ~1.0, ~0.0]
-      {input: [0.0, 0.0, 0.0, 1.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)]] },  // [ ~0.0, ~0.0, ~0.0, ~1.0]
-      {input: [-1.0, 0.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0xbff0_0000_b000_0000n), reinterpretU64AsF64(0xbfef_fffe_7000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0, ~0.0, ~0.0]
-      {input: [1.0, 1.0, 1.0, 1.0], expected: [[reinterpretU64AsF64(0x3fdf_fffe_7000_0000n), reinterpretU64AsF64(0x3fe0_0000_b000_0000n)], [reinterpretU64AsF64(0x3fdf_fffe_7000_0000n), reinterpretU64AsF64(0x3fe0_0000_b000_0000n)], [reinterpretU64AsF64(0x3fdf_fffe_7000_0000n), reinterpretU64AsF64(0x3fe0_0000_b000_0000n)], [reinterpretU64AsF64(0x3fdf_fffe_7000_0000n), reinterpretU64AsF64(0x3fe0_0000_b000_0000n)]] },  // [ ~1/√4, ~1/√4, ~1/√4]
-    ]
+    // vec4
+    {input: [1.0, 0.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0, ~0.0, ~0.0]
+    {input: [0.0, 1.0, 0.0, 0.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~0.0, ~1.0, ~0.0, ~0.0]
+    {input: [0.0, 0.0, 1.0, 0.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~0.0, ~0.0, ~1.0, ~0.0]
+    {input: [0.0, 0.0, 0.0, 1.0], expected: [[reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU64AsF64(0x3fef_fffe_7000_0000n), reinterpretU64AsF64(0x3ff0_0000_b000_0000n)]] },  // [ ~0.0, ~0.0, ~0.0, ~1.0]
+    {input: [-1.0, 0.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0xbff0_0000_b000_0000n), reinterpretU64AsF64(0xbfef_fffe_7000_0000n)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)], [reinterpretU32AsF32(0x81200000), reinterpretU32AsF32(0x01200000)]] },  // [ ~1.0, ~0.0, ~0.0, ~0.0]
+    {input: [1.0, 1.0, 1.0, 1.0], expected: [[reinterpretU64AsF64(0x3fdf_fffe_7000_0000n), reinterpretU64AsF64(0x3fe0_0000_b000_0000n)], [reinterpretU64AsF64(0x3fdf_fffe_7000_0000n), reinterpretU64AsF64(0x3fe0_0000_b000_0000n)], [reinterpretU64AsF64(0x3fdf_fffe_7000_0000n), reinterpretU64AsF64(0x3fe0_0000_b000_0000n)], [reinterpretU64AsF64(0x3fdf_fffe_7000_0000n), reinterpretU64AsF64(0x3fe0_0000_b000_0000n)]] },  // [ ~1/√4, ~1/√4, ~1/√4]
+  ] as VectorToVectorCase[],
+  f16: [
+    // vec2
+    {input: [1.0, 0.0], expected: [[reinterpretU64AsF64(0x3fef_ce00_0000_0000n), reinterpretU64AsF64(0x3ff0_1600_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)]] },  // [ ~1.0, ~0.0]
+    {input: [0.0, 1.0], expected: [[reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0x3fef_ce00_0000_0000n), reinterpretU64AsF64(0x3ff0_1600_0000_0000n)]] },  // [ ~0.0, ~1.0]
+    {input: [-1.0, 0.0], expected: [[reinterpretU64AsF64(0xbff0_1600_0000_0000n), reinterpretU64AsF64(0xbfef_ce00_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)]] },  // [ ~1.0, ~0.0]
+    {input: [1.0, 1.0], expected: [[reinterpretU64AsF64(0x3fe6_7e00_0000_0000n), reinterpretU64AsF64(0x3fe6_c600_0000_0000n)], [reinterpretU64AsF64(0x3fe6_7e00_0000_0000n), reinterpretU64AsF64(0x3fe6_c600_0000_0000n)]] },  // [ ~1/√2, ~1/√2]
+
+    // vec3
+    {input: [1.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0x3fef_ce00_0000_0000n), reinterpretU64AsF64(0x3ff0_1600_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)]] },  // [ ~1.0, ~0.0, ~0.0]
+    {input: [0.0, 1.0, 0.0], expected: [[reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0x3fef_ce00_0000_0000n), reinterpretU64AsF64(0x3ff0_1600_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)]] },  // [ ~0.0, ~1.0, ~0.0]
+    {input: [0.0, 0.0, 1.0], expected: [[reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0x3fef_ce00_0000_0000n), reinterpretU64AsF64(0x3ff0_1600_0000_0000n)]] },  // [ ~0.0, ~0.0, ~1.0]
+    {input: [-1.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0xbff0_1600_0000_0000n), reinterpretU64AsF64(0xbfef_ce00_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)]] },  // [ ~1.0, ~0.0, ~0.0]
+    {input: [1.0, 1.0, 1.0], expected: [[reinterpretU64AsF64(0x3fe2_5a00_0000_0000n), reinterpretU64AsF64(0x3fe2_9a00_0000_0000n)], [reinterpretU64AsF64(0x3fe2_5a00_0000_0000n), reinterpretU64AsF64(0x3fe2_9a00_0000_0000n)], [reinterpretU64AsF64(0x3fe2_5a00_0000_0000n), reinterpretU64AsF64(0x3fe2_9a00_0000_0000n)]] },  // [ ~1/√3, ~1/√3, ~1/√3]
+
+    // vec4
+    {input: [1.0, 0.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0x3fef_ce00_0000_0000n), reinterpretU64AsF64(0x3ff0_1600_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)]] },  // [ ~1.0, ~0.0, ~0.0, ~0.0]
+    {input: [0.0, 1.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0x3fef_ce00_0000_0000n), reinterpretU64AsF64(0x3ff0_1600_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)]] },  // [ ~0.0, ~1.0, ~0.0, ~0.0]
+    {input: [0.0, 0.0, 1.0, 0.0], expected: [[reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0x3fef_ce00_0000_0000n), reinterpretU64AsF64(0x3ff0_1600_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)]] },  // [ ~0.0, ~0.0, ~1.0, ~0.0]
+    {input: [0.0, 0.0, 0.0, 1.0], expected: [[reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0x3fef_ce00_0000_0000n), reinterpretU64AsF64(0x3ff0_1600_0000_0000n)]] },  // [ ~0.0, ~0.0, ~0.0, ~1.0]
+    {input: [-1.0, 0.0, 0.0, 0.0], expected: [[reinterpretU64AsF64(0xbff0_1600_0000_0000n), reinterpretU64AsF64(0xbfef_ce00_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)], [reinterpretU64AsF64(0xbf24_0000_0000_0000n), reinterpretU64AsF64(0x3f24_0000_0000_0000n)]] },  // [ ~1.0, ~0.0, ~0.0, ~0.0]
+    {input: [1.0, 1.0, 1.0, 1.0], expected: [[reinterpretU64AsF64(0x3fdf_ce00_0000_0000n), reinterpretU64AsF64(0x3fe0_1600_0000_0000n)], [reinterpretU64AsF64(0x3fdf_ce00_0000_0000n), reinterpretU64AsF64(0x3fe0_1600_0000_0000n)], [reinterpretU64AsF64(0x3fdf_ce00_0000_0000n), reinterpretU64AsF64(0x3fe0_1600_0000_0000n)], [reinterpretU64AsF64(0x3fdf_ce00_0000_0000n), reinterpretU64AsF64(0x3fe0_1600_0000_0000n)]] },  // [ ~1/√4, ~1/√4, ~1/√4]
+  ] as VectorToVectorCase[],
+} as const;
+
+g.test('normalizeInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<VectorToVectorCase>(p => kNormalizeIntervalCases[p.trait])
   )
   .fn(t => {
     const x = t.params.input;
-    const expected = FP.f32.toVector(t.params.expected);
-    const got = FP.f32.normalizeInterval(x);
+    const trait = FP[t.params.trait];
+    const expected = trait.toVector(t.params.expected);
+    const got = trait.normalizeInterval(x);
     t.expect(
       objectEquals(expected, got),
-      `f32.normalizeInterval([${x}]) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.normalizeInterval([${x}]) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 1f83b70f96f4..f848e87498b7 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1288,7 +1288,9 @@
   "webgpu:shader,execution,expression,call,builtin,modf:f32_vec4_whole:*": { "subcaseMS": 13.550 },
   "webgpu:shader,execution,expression,call,builtin,modf:f32_whole:*": { "subcaseMS": 10.725 },
   "webgpu:shader,execution,expression,call,builtin,normalize:abstract_float:*": { "subcaseMS": 28.508 },
-  "webgpu:shader,execution,expression,call,builtin,normalize:f16:*": { "subcaseMS": 24.205 },
+  "webgpu:shader,execution,expression,call,builtin,normalize:f16_vec2:*": { "subcaseMS": 635.100 },
+  "webgpu:shader,execution,expression,call,builtin,normalize:f16_vec3:*": { "subcaseMS": 112.501 },
+  "webgpu:shader,execution,expression,call,builtin,normalize:f16_vec4:*": { "subcaseMS": 210.526 },
   "webgpu:shader,execution,expression,call,builtin,normalize:f32_vec2:*": { "subcaseMS": 65.975 },
   "webgpu:shader,execution,expression,call,builtin,normalize:f32_vec3:*": { "subcaseMS": 12.825 },
   "webgpu:shader,execution,expression,call,builtin,normalize:f32_vec4:*": { "subcaseMS": 14.500 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/normalize.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/normalize.spec.ts
index 5c79ce3caf90..615617b4483e 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/normalize.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/normalize.spec.ts
@@ -8,9 +8,9 @@ Returns a unit vector in the same direction as e.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { vectorF32Range } from '../../../../../util/math.js';
+import { vectorF32Range, vectorF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -18,49 +18,39 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
+// Cases: f32_vecN_[non_]const
+const f32_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f32_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorToVectorCases(
+          vectorF32Range(n),
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f32.normalizeInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_vecN_[non_]const
+const f16_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f16_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorToVectorCases(
+          vectorF16Range(n),
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f16.normalizeInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('normalize', {
-  f32_vec2_const: () => {
-    return FP.f32.generateVectorToVectorCases(
-      vectorF32Range(2),
-      'finite',
-      FP.f32.normalizeInterval
-    );
-  },
-  f32_vec2_non_const: () => {
-    return FP.f32.generateVectorToVectorCases(
-      vectorF32Range(2),
-      'unfiltered',
-      FP.f32.normalizeInterval
-    );
-  },
-  f32_vec3_const: () => {
-    return FP.f32.generateVectorToVectorCases(
-      vectorF32Range(3),
-      'finite',
-      FP.f32.normalizeInterval
-    );
-  },
-  f32_vec3_non_const: () => {
-    return FP.f32.generateVectorToVectorCases(
-      vectorF32Range(3),
-      'unfiltered',
-      FP.f32.normalizeInterval
-    );
-  },
-  f32_vec4_const: () => {
-    return FP.f32.generateVectorToVectorCases(
-      vectorF32Range(4),
-      'finite',
-      FP.f32.normalizeInterval
-    );
-  },
-  f32_vec4_non_const: () => {
-    return FP.f32.generateVectorToVectorCases(
-      vectorF32Range(4),
-      'unfiltered',
-      FP.f32.normalizeInterval
-    );
-  },
+  ...f32_vec_cases,
+  ...f16_vec_cases,
 });
 
 g.test('abstract_float')
@@ -104,10 +94,44 @@ g.test('f32_vec4')
     await run(t, builtin('normalize'), [TypeVec(4, TypeF32)], TypeVec(4, TypeF32), t.params, cases);
   });
 
-g.test('f16')
-  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
-  .desc(`f16 tests`)
-  .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
-  )
-  .unimplemented();
+g.test('f16_vec2')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec2s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec2_const' : 'f16_vec2_non_const'
+    );
+    await run(t, builtin('normalize'), [TypeVec(2, TypeF16)], TypeVec(2, TypeF16), t.params, cases);
+  });
+
+g.test('f16_vec3')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec3s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec3_const' : 'f16_vec3_non_const'
+    );
+    await run(t, builtin('normalize'), [TypeVec(3, TypeF16)], TypeVec(3, TypeF16), t.params, cases);
+  });
+
+g.test('f16_vec4')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec4s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec4_const' : 'f16_vec4_non_const'
+    );
+    await run(t, builtin('normalize'), [TypeVec(4, TypeF16)], TypeVec(4, TypeF16), t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index d8b1845dd402..1519c2db630f 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5257,10 +5257,7 @@ class F16Traits extends FPTraits {
     this
   );
   public readonly negationInterval = this.negationIntervalImpl.bind(this);
-  public readonly normalizeInterval = this.unimplementedVectorToVector.bind(
-    this,
-    'normalizeInterval'
-  );
+  public readonly normalizeInterval = this.normalizeIntervalImpl.bind(this);
   public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this, 'powInterval');
   public readonly quantizeToF16Interval = this.quantizeToF16IntervalNotAvailable.bind(this);
   public readonly radiansInterval = this.radiansIntervalImpl.bind(this);

From ca67842f4722d987750749b605ad81dc8f03566b Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 26 Sep 2023 11:01:40 +0800
Subject: [PATCH 075/166] wgsl: add f16 execution test for builtin tan (#2987)

This PR add execution test for f16 built-in tan, and also add more
testcase for f32 tan.

Issue: #1248, #2507
---
 src/unittests/floating_point.spec.ts          | 103 ++++++++++++------
 src/webgpu/listing_meta.json                  |   2 +-
 .../expression/call/builtin/tan.spec.ts       |  23 +++-
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 91 insertions(+), 39 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 0cdbb754ecbe..910e382deac6 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3762,44 +3762,79 @@ g.test('sqrtInterval')
     );
   });
 
-g.test('tanInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // All of these are hard coded, since the error intervals are difficult to
-      // express in a closed human--readable form.
-      // Some easy looking cases like f(x = -π|π) = 0 are actually quite
-      // difficult. This is because the interval is calculated from the results
-      // of sin(x)/cos(x), which becomes very messy at x = -π|π, since π is
-      // irrational, thus does not have an exact representation as a f32.
-      //
-      // Even at 0, which has a precise f32 value, there is still the problem
-      // that result of sin(0) and cos(0) will be intervals due to the inherited
-      // nature of errors, so the proper interval will be an interval calculated
-      // from dividing an interval by another interval and applying an error
-      // function to that.
-      //
-      // This complexity is why the entire interval framework was developed.
-      //
-      // The examples here have been manually traced to confirm the expectation
-      // values are correct.
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.pi.whole, expected: [reinterpretU64AsF64(0xbf40_02bc_9000_0000n), reinterpretU64AsF64(0x3f40_0144_f000_0000n)] },  // ~0.0
-      { input: kValue.f32.negative.pi.half, expected: kUnboundedBounds },
-      { input: 0, expected: [reinterpretU64AsF64(0xbf40_0200_b000_0000n), reinterpretU64AsF64(0x3f40_0200_b000_0000n)] },  // ~0.0
-      { input: kValue.f32.positive.pi.half, expected: kUnboundedBounds },
-      { input: kValue.f32.positive.pi.whole, expected: [reinterpretU64AsF64(0xbf40_0144_f000_0000n), reinterpretU64AsF64(0x3f40_02bc_9000_0000n)] },  // ~0.0
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+// All of these are hard coded, since the error intervals are difficult to express in a closed
+// human--readable form.
+// Some easy looking cases like f(x = -π|π) = 0 are actually quite difficult. This is because the
+// interval is calculated from the results of sin(x)/cos(x), which becomes very messy at x = -π|π,
+// since π is irrational, thus does not have an exact representation as a float.
+//
+// Even at 0, which has a precise f32/f16 value, there is still the problem that result of sin(0)
+// and cos(0) will be intervals due to the inherited nature of errors, so the proper interval will
+// be an interval calculated from dividing an interval by another interval and applying an error
+// function to that.
+//
+// This complexity is why the entire interval framework was developed.
+//
+// The examples here have been manually traced to confirm the expectation values are correct.
+// prettier-ignore
+const kTanIntervalCases = {
+  f32: [
+    { input: kValue.f32.negative.pi.whole, expected: [reinterpretU64AsF64(0xbf40_02bc_9000_0000n), reinterpretU64AsF64(0x3f40_0144_f000_0000n)] },  // ~0.0
+    { input: kValue.f32.negative.pi.three_quarters, expected: [reinterpretU64AsF64(0x3fef_f4b1_3000_0000n), reinterpretU64AsF64(0x3ff0_05a9_9000_0000n)] },  // ~1.0
+    { input: kValue.f32.negative.pi.third, expected: [reinterpretU64AsF64(0xbffb_c16b_d000_0000n), reinterpretU64AsF64(0xbffb_ab8f_9000_0000n)] },  // ~-√3
+    { input: kValue.f32.negative.pi.quarter, expected: [reinterpretU64AsF64(0xbff0_05a9_b000_0000n), reinterpretU64AsF64(0xbfef_f4b1_5000_0000n)] },  // ~-1.0
+    { input: kValue.f32.negative.pi.sixth, expected: [reinterpretU64AsF64(0xbfe2_80f1_f000_0000n), reinterpretU64AsF64(0xbfe2_725e_d000_0000n)] },  // ~-1/√3
+    { input: 0, expected: [reinterpretU64AsF64(0xbf40_0200_b000_0000n), reinterpretU64AsF64(0x3f40_0200_b000_0000n)] },  // ~0.0
+    { input: kValue.f32.positive.pi.sixth, expected: [reinterpretU64AsF64(0x3fe2_725e_d000_0000n), reinterpretU64AsF64(0x3fe2_80f1_f000_0000n)] },  // ~1/√3
+    { input: kValue.f32.positive.pi.quarter, expected: [reinterpretU64AsF64(0x3fef_f4b1_5000_0000n), reinterpretU64AsF64(0x3ff0_05a9_b000_0000n)] },  // ~1.0
+    { input: kValue.f32.positive.pi.third, expected: [reinterpretU64AsF64(0x3ffb_ab8f_9000_0000n), reinterpretU64AsF64(0x3ffb_c16b_d000_0000n)] },  // ~√3
+    { input: kValue.f32.positive.pi.three_quarters, expected: [reinterpretU64AsF64(0xbff0_05a9_9000_0000n), reinterpretU64AsF64(0xbfef_f4b1_3000_0000n)] },  // ~-1.0
+    { input: kValue.f32.positive.pi.whole, expected: [reinterpretU64AsF64(0xbf40_0144_f000_0000n), reinterpretU64AsF64(0x3f40_02bc_9000_0000n)] },  // ~0.0
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: kValue.f16.negative.pi.whole, expected: [reinterpretU64AsF64(0xbf7c_5600_0000_0000n), reinterpretU64AsF64(0x3f82_2e00_0000_0000n)] },  // ~0.0
+    { input: kValue.f16.negative.pi.three_quarters, expected: [reinterpretU64AsF64(0x3fef_4600_0000_0000n), reinterpretU64AsF64(0x3ff0_7200_0000_0000n)] },  // ~1.0
+    { input: kValue.f16.negative.pi.third, expected: [reinterpretU64AsF64(0xbffc_7600_0000_0000n), reinterpretU64AsF64(0xbffa_f600_0000_0000n)] },  // ~-√3
+    { input: kValue.f16.negative.pi.quarter, expected: [reinterpretU64AsF64(0xbff0_6600_0000_0000n), reinterpretU64AsF64(0xbfef_3600_0000_0000n)] },  // ~-1.0
+    { input: kValue.f16.negative.pi.sixth, expected: [reinterpretU64AsF64(0xbfe2_fe00_0000_0000n), reinterpretU64AsF64(0xbfe1_f600_0000_0000n)] },  // ~-1/√3
+    { input: 0, expected: [reinterpretU64AsF64(0xbf80_2e00_0000_0000n), reinterpretU64AsF64(0x3f80_2e00_0000_0000n)] },  // ~0.0
+    { input: kValue.f16.positive.pi.sixth, expected: [reinterpretU64AsF64(0x3fe1_f600_0000_0000n), reinterpretU64AsF64(0x3fe2_fe00_0000_0000n)] },  // ~1/√3
+    { input: kValue.f16.positive.pi.quarter, expected: [reinterpretU64AsF64(0x3fef_3600_0000_0000n), reinterpretU64AsF64(0x3ff0_6600_0000_0000n)] },  // ~1.0
+    { input: kValue.f16.positive.pi.third, expected: [reinterpretU64AsF64(0x3ffa_f600_0000_0000n), reinterpretU64AsF64(0x3ffc_7600_0000_0000n)] },  // ~√3
+    { input: kValue.f16.positive.pi.three_quarters, expected: [reinterpretU64AsF64(0xbff0_7200_0000_0000n), reinterpretU64AsF64(0xbfef_4600_0000_0000n)] },  // ~-1.0
+    { input: kValue.f16.positive.pi.whole, expected: [reinterpretU64AsF64(0xbf82_2e00_0000_0000n), reinterpretU64AsF64(0x3f7c_5600_0000_0000n)] },  // ~0.0
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('tanInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kTanIntervalCases[p.trait],
+
+          // Cases that result in unbounded interval.
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: constants.negative.pi.half, expected: kUnboundedBounds },
+          { input: constants.positive.pi.half, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: kUnboundedBounds },
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.tanInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.tanInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.tanInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.tanInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index f848e87498b7..343588216719 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1349,7 +1349,7 @@
   "webgpu:shader,execution,expression,call,builtin,storageBarrier:barrier:*": { "subcaseMS": 0.801 },
   "webgpu:shader,execution,expression,call,builtin,storageBarrier:stage:*": { "subcaseMS": 2.402 },
   "webgpu:shader,execution,expression,call,builtin,tan:abstract_float:*": { "subcaseMS": 31.007 },
-  "webgpu:shader,execution,expression,call,builtin,tan:f16:*": { "subcaseMS": 31.306 },
+  "webgpu:shader,execution,expression,call,builtin,tan:f16:*": { "subcaseMS": 116.157 },
   "webgpu:shader,execution,expression,call,builtin,tan:f32:*": { "subcaseMS": 13.532 },
   "webgpu:shader,execution,expression,call,builtin,tanh:abstract_float:*": { "subcaseMS": 18.406 },
   "webgpu:shader,execution,expression,call,builtin,tanh:f16:*": { "subcaseMS": 25.211 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/tan.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/tan.spec.ts
index 03a0830073f9..be3bdee04662 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/tan.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/tan.spec.ts
@@ -9,9 +9,9 @@ Returns the tangent of e. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, linearRange } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range, linearRange } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -31,6 +31,17 @@ export const d = makeCaseCache('tan', {
       FP.f32.tanInterval
     );
   },
+  f16: () => {
+    return FP.f16.generateScalarToIntervalCases(
+      [
+        // Defined accuracy range
+        ...linearRange(-Math.PI, Math.PI, 100),
+        ...fullF16Range(),
+      ],
+      'unfiltered',
+      FP.f16.tanInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -58,4 +69,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('tan'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 1519c2db630f..9039fd165d86 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5282,7 +5282,7 @@ class F16Traits extends FPTraits {
   public readonly subtractionMatrixMatrixInterval = this.subtractionMatrixMatrixIntervalImpl.bind(
     this
   );
-  public readonly tanInterval = this.unimplementedScalarToInterval.bind(this, 'tanInterval');
+  public readonly tanInterval = this.tanIntervalImpl.bind(this);
   public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this, 'tanhInterval');
   public readonly transposeInterval = this.transposeIntervalImpl.bind(this);
   public readonly truncInterval = this.truncIntervalImpl.bind(this);

From fdbc6735c548c554b0a32d0d7a0e009d13f3b039 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 26 Sep 2023 11:04:08 +0800
Subject: [PATCH 076/166] wgsl: add f16 execution test for builtin smoothstep
 (#2989)

This PR add execution test for f16 built-in smoothstep.

Issue: #1248, #2533
---
 src/unittests/floating_point.spec.ts          | 126 ++++++++++++------
 src/webgpu/listing_meta.json                  |   2 +-
 .../call/builtin/smoothstep.spec.ts           |  30 ++++-
 src/webgpu/util/floating_point.ts             |   5 +-
 4 files changed, 111 insertions(+), 52 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 910e382deac6..2eaea70f097d 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5301,58 +5301,96 @@ g.test('mixPreciseInterval_f32')
     );
   });
 
-g.test('smoothStepInterval_f32')
-  .paramsSubcasesOnly<ScalarTripleToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kSmoothStepIntervalCases = {
+  f32: [
+    // Normals
+    { input: [0, 1, 0], expected: [0, kValue.f32.subnormal.positive.min] },
+    { input: [0, 1, 1], expected: [reinterpretU32AsF32(0x3f7ffffa), reinterpretU32AsF32(0x3f800003)] },  // ~1
+    { input: [0, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [0, 2, 0.5], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
+    { input: [2, 0, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [2, 0, 1.5], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
+    { input: [0, 100, 50], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [0, 100, 25], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
+    { input: [0, -2, -1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [0, -2, -0.5], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
+    // Subnormals
+    { input: [kValue.f32.subnormal.positive.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [kValue.f32.subnormal.positive.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [kValue.f32.subnormal.negative.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [kValue.f32.subnormal.negative.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [0, 2, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.min] },
+    { input: [0, 2, kValue.f32.subnormal.positive.min], expected: [0, kValue.f32.subnormal.positive.min] },
+    { input: [0, 2, kValue.f32.subnormal.negative.max], expected: [0, kValue.f32.subnormal.positive.min] },
+    { input: [0, 2, kValue.f32.subnormal.negative.min], expected: [0, kValue.f32.subnormal.positive.min] },
+  ] as ScalarTripleToIntervalCase[],
+  f16: [
+    // Normals
+    { input: [0, 1, 0], expected: [0, reinterpretU16AsF16(0x0002)] },
+    { input: [0, 1, 1], expected: [reinterpretU16AsF16(0x3bfa), reinterpretU16AsF16(0x3c03)] },  // ~1
+    { input: [0, 2, 1], expected: [reinterpretU16AsF16(0x37f8), reinterpretU16AsF16(0x3807)] },  // ~0.5
+    { input: [0, 2, 0.5], expected: [reinterpretU16AsF16(0x30fb), reinterpretU16AsF16(0x3107)] },  // ~0.15625...
+    { input: [2, 0, 1], expected: [reinterpretU16AsF16(0x37f8), reinterpretU16AsF16(0x3807)] },  // ~0.5
+    { input: [2, 0, 1.5], expected: [reinterpretU16AsF16(0x30fb), reinterpretU16AsF16(0x3107)] },  // ~0.15625...
+    { input: [0, 100, 50], expected: [reinterpretU16AsF16(0x37f8), reinterpretU16AsF16(0x3807)] },  // ~0.5
+    { input: [0, 100, 25], expected: [reinterpretU16AsF16(0x30fb), reinterpretU16AsF16(0x3107)] },  // ~0.15625...
+    { input: [0, -2, -1], expected: [reinterpretU16AsF16(0x37f8), reinterpretU16AsF16(0x3807)] },  // ~0.5
+    { input: [0, -2, -0.5], expected: [reinterpretU16AsF16(0x30fb), reinterpretU16AsF16(0x3107)] },  // ~0.15625...
+    // Subnormals
+    { input: [kValue.f16.subnormal.positive.max, 2, 1], expected: [reinterpretU16AsF16(0x37f4), reinterpretU16AsF16(0x380b)] },  // ~0.5
+    { input: [kValue.f16.subnormal.positive.min, 2, 1], expected: [reinterpretU16AsF16(0x37f4), reinterpretU16AsF16(0x380b)] },  // ~0.5
+    { input: [kValue.f16.subnormal.negative.max, 2, 1], expected: [reinterpretU16AsF16(0x37f2), reinterpretU16AsF16(0x380c)] },  // ~0.5
+    { input: [kValue.f16.subnormal.negative.min, 2, 1], expected: [reinterpretU16AsF16(0x37f2), reinterpretU16AsF16(0x380c)] },  // ~0.5
+    { input: [0, 2, kValue.f16.subnormal.positive.max], expected: [0, reinterpretU16AsF16(0x0002)] },
+    { input: [0, 2, kValue.f16.subnormal.positive.min], expected: [0, reinterpretU16AsF16(0x0002)] },
+    { input: [0, 2, kValue.f32.subnormal.negative.max], expected: [0, reinterpretU16AsF16(0x0002)] },
+    { input: [0, 2, kValue.f32.subnormal.negative.min], expected: [0, reinterpretU16AsF16(0x0002)] },
+  ] as ScalarTripleToIntervalCase[],
+} as const;
 
-      // Normals
-      { input: [0, 1, 0], expected: [0, kValue.f32.subnormal.positive.min] },
-      { input: [0, 1, 1], expected: [reinterpretU32AsF32(0x3f7ffffa), reinterpretU32AsF32(0x3f800003)] },  // ~1
-      { input: [0, 1, 10], expected: 1 },
-      { input: [0, 1, -10], expected: 0 },
-      { input: [0, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-      { input: [0, 2, 0.5], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
-      { input: [2, 0, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-      { input: [2, 0, 1.5], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
-      { input: [0, 100, 50], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-      { input: [0, 100, 25], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
-      { input: [0, -2, -1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-      { input: [0, -2, -0.5], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
+g.test('smoothStepInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarTripleToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kSmoothStepIntervalCases[p.trait],
 
-      // Subnormals
-      { input: [0, 2, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.min] },
-      { input: [0, 2, kValue.f32.subnormal.positive.min], expected: [0, kValue.f32.subnormal.positive.min] },
-      { input: [0, 2, kValue.f32.subnormal.negative.max], expected: [0, kValue.f32.subnormal.positive.min] },
-      { input: [0, 2, kValue.f32.subnormal.negative.min], expected: [0, kValue.f32.subnormal.positive.min] },
-      { input: [kValue.f32.subnormal.positive.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-      { input: [kValue.f32.subnormal.positive.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-      { input: [kValue.f32.subnormal.negative.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-      { input: [kValue.f32.subnormal.negative.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-      { input: [0, kValue.f32.subnormal.positive.max, 1], expected: kUnboundedBounds },
-      { input: [0, kValue.f32.subnormal.positive.min, 1], expected: kUnboundedBounds },
-      { input: [0, kValue.f32.subnormal.negative.max, 1], expected: kUnboundedBounds },
-      { input: [0, kValue.f32.subnormal.negative.min, 1], expected: kUnboundedBounds },
+          // Normals
+          { input: [0, 1, 10], expected: 1 },
+          { input: [0, 1, -10], expected: 0 },
 
-      // Infinities
-      { input: [0, 2, Number.POSITIVE_INFINITY], expected: kUnboundedBounds },
-      { input: [0, 2, Number.NEGATIVE_INFINITY], expected: kUnboundedBounds },
-      { input: [Number.POSITIVE_INFINITY, 2, 1], expected: kUnboundedBounds },
-      { input: [Number.NEGATIVE_INFINITY, 2, 1], expected: kUnboundedBounds },
-      { input: [0, Number.POSITIVE_INFINITY, 1], expected: kUnboundedBounds },
-      { input: [0, Number.NEGATIVE_INFINITY, 1], expected: kUnboundedBounds },
-    ]
+          // Subnormals
+          { input: [0, constants.positive.subnormal.max, 1], expected: kUnboundedBounds },
+          { input: [0, constants.positive.subnormal.min, 1], expected: kUnboundedBounds },
+          { input: [0, constants.negative.subnormal.max, 1], expected: kUnboundedBounds },
+          { input: [0, constants.negative.subnormal.min, 1], expected: kUnboundedBounds },
+
+          // Infinities
+          { input: [0, 2, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [0, 2, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [constants.positive.infinity, 2, 1], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, 2, 1], expected: kUnboundedBounds },
+          { input: [0, constants.positive.infinity, 1], expected: kUnboundedBounds },
+          { input: [0, constants.negative.infinity, 1], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
     const [low, high, x] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.smoothStepInterval(low, high, x);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.smoothStepInterval(low, high, x);
     t.expect(
       objectEquals(expected, got),
-      `f32.smoothStepInterval(${low}, ${high}, ${x}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.smoothStepInterval(${low}, ${high}, ${x}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 343588216719..f11e7ffb3af4 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1338,7 +1338,7 @@
   "webgpu:shader,execution,expression,call,builtin,sinh:f16:*": { "subcaseMS": 23.905 },
   "webgpu:shader,execution,expression,call,builtin,sinh:f32:*": { "subcaseMS": 11.038 },
   "webgpu:shader,execution,expression,call,builtin,smoothstep:abstract_float:*": { "subcaseMS": 23.807 },
-  "webgpu:shader,execution,expression,call,builtin,smoothstep:f16:*": { "subcaseMS": 23.404 },
+  "webgpu:shader,execution,expression,call,builtin,smoothstep:f16:*": { "subcaseMS": 616.457 },
   "webgpu:shader,execution,expression,call,builtin,smoothstep:f32:*": { "subcaseMS": 88.063 },
   "webgpu:shader,execution,expression,call,builtin,sqrt:abstract_float:*": { "subcaseMS": 19.004 },
   "webgpu:shader,execution,expression,call,builtin,sqrt:f16:*": { "subcaseMS": 22.908 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/smoothstep.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/smoothstep.spec.ts
index 77ff501f54d2..20d2a4edbce0 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/smoothstep.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/smoothstep.spec.ts
@@ -11,9 +11,9 @@ For scalar T, the result is t * t * (3.0 - 2.0 * t), where t = clamp((x - low) /
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseF32Range } from '../../../../../util/math.js';
+import { sparseF32Range, sparseF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -40,6 +40,24 @@ export const d = makeCaseCache('smoothstep', {
       FP.f32.smoothStepInterval
     );
   },
+  f16_const: () => {
+    return FP.f16.generateScalarTripleToIntervalCases(
+      sparseF16Range(),
+      sparseF16Range(),
+      sparseF16Range(),
+      'finite',
+      FP.f16.smoothStepInterval
+    );
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarTripleToIntervalCases(
+      sparseF16Range(),
+      sparseF16Range(),
+      sparseF16Range(),
+      'unfiltered',
+      FP.f16.smoothStepInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -67,4 +85,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('smoothstep'), [TypeF16, TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 9039fd165d86..9aea422ca212 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5272,10 +5272,7 @@ class F16Traits extends FPTraits {
   public readonly signInterval = this.signIntervalImpl.bind(this);
   public readonly sinInterval = this.sinIntervalImpl.bind(this);
   public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this, 'sinhInterval');
-  public readonly smoothStepInterval = this.unimplementedScalarTripleToInterval.bind(
-    this,
-    'smoothStepInterval'
-  );
+  public readonly smoothStepInterval = this.smoothStepIntervalImpl.bind(this);
   public readonly sqrtInterval = this.sqrtIntervalImpl.bind(this);
   public readonly stepInterval = this.stepIntervalImpl.bind(this);
   public readonly subtractionInterval = this.subtractionIntervalImpl.bind(this);

From c799cfdfdcbbd90a1a19b7ae2302b66913390fd8 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 26 Sep 2023 11:11:41 +0800
Subject: [PATCH 077/166] wgsl: add f16 execution test for builtin fma (#2990)

This PR add execution test for f16 built-in fma.

Issue: #1248, #2549
---
 src/unittests/floating_point.spec.ts          | 102 +++++++++++-------
 src/webgpu/listing_meta.json                  |   2 +-
 .../expression/call/builtin/fma.spec.ts       |  30 +++++-
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 91 insertions(+), 45 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 2eaea70f097d..98f4e05f866b 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5094,52 +5094,74 @@ g.test('clampMinMaxInterval')
     );
   });
 
-g.test('fmaInterval_f32')
-  .paramsSubcasesOnly<ScalarTripleToIntervalCase>(
-    // prettier-ignore
-    [
-      // Normals
-      { input: [0, 0, 0], expected: 0 },
-      { input: [1, 0, 0], expected: 0 },
-      { input: [0, 1, 0], expected: 0 },
-      { input: [0, 0, 1], expected: 1 },
-      { input: [1, 0, 1], expected: 1 },
-      { input: [1, 1, 0], expected: 1 },
-      { input: [0, 1, 1], expected: 1 },
-      { input: [1, 1, 1], expected: 2 },
-      { input: [1, 10, 100], expected: 110 },
-      { input: [10, 1, 100], expected: 110 },
-      { input: [100, 1, 10], expected: 110 },
-      { input: [-10, 1, 100], expected: 90 },
-      { input: [10, 1, -100], expected: -90 },
-      { input: [-10, 1, -100], expected: -110 },
-      { input: [-10, -10, -10], expected: 90 },
+g.test('fmaInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarTripleToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          // Normals
+          { input: [0, 0, 0], expected: 0 },
+          { input: [1, 0, 0], expected: 0 },
+          { input: [0, 1, 0], expected: 0 },
+          { input: [0, 0, 1], expected: 1 },
+          { input: [1, 0, 1], expected: 1 },
+          { input: [1, 1, 0], expected: 1 },
+          { input: [0, 1, 1], expected: 1 },
+          { input: [1, 1, 1], expected: 2 },
+          { input: [1, 10, 100], expected: 110 },
+          { input: [10, 1, 100], expected: 110 },
+          { input: [100, 1, 10], expected: 110 },
+          { input: [-10, 1, 100], expected: 90 },
+          { input: [10, 1, -100], expected: -90 },
+          { input: [-10, 1, -100], expected: -110 },
+          { input: [-10, -10, -10], expected: 90 },
 
-      // Subnormals
-      { input: [kValue.f32.subnormal.positive.max, 0, 0], expected: 0 },
-      { input: [0, kValue.f32.subnormal.positive.max, 0], expected: 0 },
-      { input: [0, 0, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, 0, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, 0], expected: [0, kValue.f32.subnormal.positive.min] },
-      { input: [0, kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.positive.min] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.negative.max], expected: [kValue.f32.subnormal.negative.max, kValue.f32.subnormal.positive.min] },
-      { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max], expected: [reinterpretU32AsF32(0x80000002), 0] },
+          // Subnormals
+          { input: [constants.positive.subnormal.max, 0, 0], expected: 0 },
+          { input: [0, constants.positive.subnormal.max, 0], expected: 0 },
+          { input: [0, 0, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          { input: [constants.positive.subnormal.max, 0, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          // positive.subnormal.max * positive.subnormal.max is much smaller than positive.subnormal.min but larger than 0, rounded to [0, positive.subnormal.min]
+          { input: [constants.positive.subnormal.max, constants.positive.subnormal.max, 0], expected: [0, constants.positive.subnormal.min] },
+          { input: [0, constants.positive.subnormal.max, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
+          // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
+          // 0 + constants.positive.subnormal.max rounded to [0, constants.positive.subnormal.max],
+          // positive.subnormal.min + constants.positive.subnormal.max = constants.positive.min.
+          { input: [constants.positive.subnormal.max, constants.positive.subnormal.max, constants.positive.subnormal.max], expected: [0, constants.positive.min] },
+          // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
+          // negative.subnormal.max may flushed to 0,
+          // minimum case: 0 + negative.subnormal.max rounded to [negative.subnormal.max, 0],
+          // maximum case: positive.subnormal.min + 0 rounded to [0, positive.subnormal.min].
+          { input: [constants.positive.subnormal.max, constants.positive.subnormal.min, constants.negative.subnormal.max], expected: [constants.negative.subnormal.max, constants.positive.subnormal.min] },
+          // positive.subnormal.max * negative.subnormal.min rounded to -0.0 or negative.subnormal.max = -1 * [subnormal ulp],
+          // negative.subnormal.max = -1 * [subnormal ulp] may flushed to -0.0,
+          // minimum case: -1 * [subnormal ulp] + -1 * [subnormal ulp] rounded to [-2 * [subnormal ulp], 0],
+          // maximum case: -0.0 + -0.0 = 0.
+          { input: [constants.positive.subnormal.max, constants.negative.subnormal.min, constants.negative.subnormal.max], expected: [-2 * FP[p.trait].oneULP(0, 'no-flush'), 0] },
 
-      // Infinities
-      { input: [0, 1, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [0, kValue.f32.infinity.positive, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [kValue.f32.positive.max, kValue.f32.positive.max, kValue.f32.subnormal.positive.min], expected: kUnboundedBounds },
-    ]
+          // Infinities
+          { input: [0, 1, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [0, constants.positive.infinity, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [constants.positive.max, constants.positive.max, constants.positive.subnormal.min], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.fmaInterval(...t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.fmaInterval(...t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.fmaInterval(${t.params.input.join(',')}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.fmaInterval(${t.params.input.join(
+        ','
+      )}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index f11e7ffb3af4..44e7c3c8d30e 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1207,7 +1207,7 @@
   "webgpu:shader,execution,expression,call,builtin,floor:f16:*": { "subcaseMS": 30.708 },
   "webgpu:shader,execution,expression,call,builtin,floor:f32:*": { "subcaseMS": 10.119 },
   "webgpu:shader,execution,expression,call,builtin,fma:abstract_float:*": { "subcaseMS": 18.208 },
-  "webgpu:shader,execution,expression,call,builtin,fma:f16:*": { "subcaseMS": 27.805 },
+  "webgpu:shader,execution,expression,call,builtin,fma:f16:*": { "subcaseMS": 485.857 },
   "webgpu:shader,execution,expression,call,builtin,fma:f32:*": { "subcaseMS": 80.388 },
   "webgpu:shader,execution,expression,call,builtin,fract:abstract_float:*": { "subcaseMS": 17.408 },
   "webgpu:shader,execution,expression,call,builtin,fract:f16:*": { "subcaseMS": 17.106 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/fma.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/fma.spec.ts
index 37b52be9b78e..d00c80b7a105 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/fma.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/fma.spec.ts
@@ -9,9 +9,9 @@ Returns e1 * e2 + e3. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseF32Range } from '../../../../../util/math.js';
+import { sparseF32Range, sparseF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -38,6 +38,24 @@ export const d = makeCaseCache('fma', {
       FP.f32.fmaInterval
     );
   },
+  f16_const: () => {
+    return FP.f16.generateScalarTripleToIntervalCases(
+      sparseF16Range(),
+      sparseF16Range(),
+      sparseF16Range(),
+      'finite',
+      FP.f16.fmaInterval
+    );
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarTripleToIntervalCases(
+      sparseF16Range(),
+      sparseF16Range(),
+      sparseF16Range(),
+      'unfiltered',
+      FP.f16.fmaInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -65,4 +83,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('fma'), [TypeF16, TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 9aea422ca212..73955d55b54c 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5218,7 +5218,7 @@ class F16Traits extends FPTraits {
   public readonly exp2Interval = this.exp2IntervalImpl.bind(this);
   public readonly faceForwardIntervals = this.unimplementedFaceForward.bind(this);
   public readonly floorInterval = this.floorIntervalImpl.bind(this);
-  public readonly fmaInterval = this.unimplementedScalarTripleToInterval.bind(this, 'fmaInterval');
+  public readonly fmaInterval = this.fmaIntervalImpl.bind(this);
   public readonly fractInterval = this.unimplementedScalarToInterval.bind(this, 'fractInterval');
   public readonly inverseSqrtInterval = this.inverseSqrtIntervalImpl.bind(this);
   public readonly ldexpInterval = this.unimplementedScalarPairToInterval.bind(

From b09db5caddb7dee596d69aceccb7280c4aa5f4f5 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 26 Sep 2023 11:17:07 +0800
Subject: [PATCH 078/166] wgsl: f32 execution tests for builtin mix with
 non-matching parameters (#2991)

This PR add execution tests for f32 built-in mix with non-matching
parameters, i.e. two vector input and a scalar input,
mix(e0: vecN<f32>, e1: vecN<f32>, e2: f32) -> vecN<f32>,
by adding generateVectorPairScalarToVectorComponentWiseCase which take
ScalarTripleToInterval operator to generate component-wise interval for
result vector.

Issue: #2039
---
 src/webgpu/listing_meta.json                  |  18 ++-
 .../expression/call/builtin/mix.spec.ts       | 122 +++++++++++++++---
 src/webgpu/util/floating_point.ts             |  78 +++++++++++
 3 files changed, 196 insertions(+), 22 deletions(-)

diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 44e7c3c8d30e..80da217beea8 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1265,12 +1265,18 @@
   "webgpu:shader,execution,expression,call,builtin,min:f32:*": { "subcaseMS": 298.463 },
   "webgpu:shader,execution,expression,call,builtin,min:i32:*": { "subcaseMS": 7.825 },
   "webgpu:shader,execution,expression,call,builtin,min:u32:*": { "subcaseMS": 6.932 },
-  "webgpu:shader,execution,expression,call,builtin,mix:matching_abstract_float:*": { "subcaseMS": 23.706 },
-  "webgpu:shader,execution,expression,call,builtin,mix:matching_f16:*": { "subcaseMS": 21.910 },
-  "webgpu:shader,execution,expression,call,builtin,mix:matching_f32:*": { "subcaseMS": 100.907 },
-  "webgpu:shader,execution,expression,call,builtin,mix:monmatching_f16:*": { "subcaseMS": 10.408 },
-  "webgpu:shader,execution,expression,call,builtin,mix:nonmatching_abstract_float:*": { "subcaseMS": 24.605 },
-  "webgpu:shader,execution,expression,call,builtin,mix:nonmatching_f32:*": { "subcaseMS": 14.205 },
+  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_matching:*": { "subcaseMS": 198.806 },
+  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_nonmatching_vec2:*": { "subcaseMS": 13.302 },
+  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_nonmatching_vec3:*": { "subcaseMS": 13.302 },
+  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_nonmatching_vec4:*": { "subcaseMS": 4.000 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f16_matching:*": { "subcaseMS": 69.810 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f16_nonmatching_vec2:*": { "subcaseMS": 13.200 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f16_nonmatching_vec3:*": { "subcaseMS": 32.401 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f16_nonmatching_vec4:*": { "subcaseMS": 37.303 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f32_matching:*": { "subcaseMS": 4018.920 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec2:*": { "subcaseMS": 494.701 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec3:*": { "subcaseMS": 580.525 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec4:*": { "subcaseMS": 677.226 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_fract:*": { "subcaseMS": 4.202 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_fract:*": { "subcaseMS": 9.200 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_whole:*": { "subcaseMS": 8.404 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/mix.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/mix.spec.ts
index 3ee173fc5024..de4c3a24dc1e 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/mix.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/mix.spec.ts
@@ -16,9 +16,9 @@ Same as mix(e1,e2,T2(e3)).
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeVec, TypeF32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseF32Range } from '../../../../../util/math.js';
+import { sparseF32Range, sparseVectorF32Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -26,6 +26,23 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
+// Cases: f32_vecN_scalar_[non_]const
+const f32_vec_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f32_vec${n}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorPairScalarToVectorComponentWiseCase(
+          sparseVectorF32Range(n),
+          sparseVectorF32Range(n),
+          sparseF32Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          ...FP.f32.mixIntervals
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('mix', {
   f32_const: () => {
     return FP.f32.generateScalarTripleToIntervalCases(
@@ -45,17 +62,36 @@ export const d = makeCaseCache('mix', {
       ...FP.f32.mixIntervals
     );
   },
+  ...f32_vec_scalar_cases,
 });
 
-g.test('matching_abstract_float')
+g.test('abstract_float_matching')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
-  .desc(`abstract float tests with matching params`)
+  .desc(`abstract_float test with matching third param`)
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
   .unimplemented();
 
-g.test('matching_f32')
+g.test('abstract_float_nonmatching_vec2')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(`abstract_float tests with two vec2<abstract_float> params and scalar third param`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .unimplemented();
+
+g.test('abstract_float_nonmatching_vec3')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(`abstract_float tests with two vec3<abstract_float> params and scalar third param`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .unimplemented();
+
+g.test('abstract_float_nonmatching_vec4')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(`abstract_float tests with two vec4<abstract_float> params and scalar third param`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .unimplemented();
+
+g.test('f32_matching')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`f32 test with matching third param`)
   .params(u =>
@@ -66,28 +102,82 @@ g.test('matching_f32')
     await run(t, builtin('mix'), [TypeF32, TypeF32, TypeF32], TypeF32, t.params, cases);
   });
 
-g.test('matching_f16')
+g.test('f32_nonmatching_vec2')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(`f32 tests with two vec2<f32> params and scalar third param`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f32_vec2_scalar_const' : 'f32_vec2_scalar_non_const'
+    );
+    await run(
+      t,
+      builtin('mix'),
+      [TypeVec(2, TypeF32), TypeVec(2, TypeF32), TypeF32],
+      TypeVec(2, TypeF32),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f32_nonmatching_vec3')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(`f32 tests with two vec3<f32> params and scalar third param`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f32_vec3_scalar_const' : 'f32_vec3_scalar_non_const'
+    );
+    await run(
+      t,
+      builtin('mix'),
+      [TypeVec(3, TypeF32), TypeVec(3, TypeF32), TypeF32],
+      TypeVec(3, TypeF32),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f32_nonmatching_vec4')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(`f32 tests with two vec4<f32> params and scalar third param`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f32_vec4_scalar_const' : 'f32_vec4_scalar_non_const'
+    );
+    await run(
+      t,
+      builtin('mix'),
+      [TypeVec(4, TypeF32), TypeVec(4, TypeF32), TypeF32],
+      TypeVec(4, TypeF32),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_matching')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
-  .desc(`f16 tests with matching third param`)
+  .desc(`f16 test with matching third param`)
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
   .unimplemented();
 
-g.test('nonmatching_abstract_float')
+g.test('f16_nonmatching_vec2')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
-  .desc(`abstract float tests with vector params and scalar third param`)
-  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .desc(`f16 tests with two vec2<f16> params and scalar third param`)
+  .params(u => u.combine('inputSource', allInputSources))
   .unimplemented();
 
-g.test('nonmatching_f32')
+g.test('f16_nonmatching_vec3')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
-  .desc(`f32 tests with vector params and scalar third param`)
-  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .desc(`f16 tests with two vec3<f16> params and scalar third param`)
+  .params(u => u.combine('inputSource', allInputSources))
   .unimplemented();
 
-g.test('monmatching_f16')
+g.test('f16_nonmatching_vec4')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
-  .desc(`f16 tests with vector params and scalar third param`)
-  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
+  .desc(`f16 tests with two vec4<f16> params and scalar third param`)
+  .params(u => u.combine('inputSource', allInputSources))
   .unimplemented();
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 73955d55b54c..ea6ca306357a 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -1480,6 +1480,84 @@ export abstract class FPTraits {
     }, new Array<Case>());
   }
 
+  /**
+   * @returns a Case for the params and the component-wise interval generator provided.
+   * The Case will use an interval comparator for matching results.
+   * @param param0 the first vector param to pass in
+   * @param param1 the second vector param to pass in
+   * @param param2 the scalar param to pass in
+   * @param filter what interval filtering to apply
+   * @param componentWiseOps callbacks that implement generating a component-wise acceptance interval,
+   *                         one component result at a time.
+   */
+  private makeVectorPairScalarToVectorComponentWiseCase(
+    param0: number[],
+    param1: number[],
+    param2: number,
+    filter: IntervalFilter,
+    ...componentWiseOps: ScalarTripleToInterval[]
+  ): Case | undefined {
+    // Width of input vector
+    const width = param0.length;
+    assert(2 <= width && width <= 4, 'input vector width must between 2 and 4');
+    assert(param1.length === width, 'two input vectors must have the same width');
+    param0 = param0.map(this.quantize);
+    param1 = param1.map(this.quantize);
+    param2 = this.quantize(param2);
+
+    // Call the component-wise interval generator and build the expectation FPVector
+    const results = componentWiseOps.map(o => {
+      return param0.map((el0, index) => o(el0, param1[index], param2)) as FPVector;
+    });
+    if (filter === 'finite' && results.some(r => r.some(e => !e.isFinite()))) {
+      return undefined;
+    }
+    return {
+      input: [
+        toVector(param0, this.scalarBuilder),
+        toVector(param1, this.scalarBuilder),
+        this.scalarBuilder(param2),
+      ],
+      expected: anyOf(...results),
+    };
+  }
+
+  /**
+   * @returns an array of Cases for operations over a range of inputs
+   * @param param0s array of first vector inputs to try
+   * @param param1s array of second vector inputs to try
+   * @param param2s array of scalar inputs to try
+   * @param filter what interval filtering to apply
+   * @param componentWiseOpscallbacks that implement generating a component-wise acceptance interval
+   */
+  public generateVectorPairScalarToVectorComponentWiseCase(
+    param0s: number[][],
+    param1s: number[][],
+    param2s: number[],
+    filter: IntervalFilter,
+    ...componentWiseOps: ScalarTripleToInterval[]
+  ): Case[] {
+    // Cannot use cartesianProduct here, due to heterogeneous types
+    const cases: Case[] = [];
+    param0s.forEach(param0 => {
+      param1s.forEach(param1 => {
+        param2s.forEach(param2 => {
+          const c = this.makeVectorPairScalarToVectorComponentWiseCase(
+            param0,
+            param1,
+            param2,
+            filter,
+            ...componentWiseOps
+          );
+          if (c !== undefined) {
+            cases.push(c);
+          }
+        });
+      });
+    });
+    return cases;
+  }
+
   /**
    * @returns a Case for the param and an array of interval generators provided
    * @param param the param to pass in

From d9760bdaa62ed672d7037d915d78c3294a3633fc Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 26 Sep 2023 11:26:22 +0800
Subject: [PATCH 079/166] wgsl: add f16 execution test for builtin pow (#2986)

This PR add execution test for f16 built-in pow.

Issue: #1248, #2573
---
 src/unittests/floating_point.spec.ts          | 76 +++++++++++++------
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/pow.spec.ts       | 28 ++++++-
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 78 insertions(+), 30 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 98f4e05f866b..8ff2e641a9e8 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -4677,36 +4677,62 @@ g.test('multiplicationInterval')
     );
   });
 
-g.test('powInterval_f32')
-  .paramsSubcasesOnly<ScalarPairToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-      { input: [-1, 0], expected: kUnboundedBounds },
-      { input: [0, 0], expected: kUnboundedBounds },
-      { input: [1, 0], expected: [kMinusNULPFunctions['f32'](1, 3), reinterpretU64AsF64(0x3ff0_0000_3000_0000n)] },  // ~1
-      { input: [2, 0], expected: [kMinusNULPFunctions['f32'](1, 3), reinterpretU64AsF64(0x3ff0_0000_3000_0000n)] },  // ~1
-      { input: [kValue.f32.positive.max, 0], expected: [kMinusNULPFunctions['f32'](1, 3), reinterpretU64AsF64(0x3ff0_0000_3000_0000n)] },  // ~1
-      { input: [0, 1], expected: kUnboundedBounds },
-      { input: [1, 1], expected: [reinterpretU64AsF64(0x3fef_fffe_dfff_fe00n), reinterpretU64AsF64(0x3ff0_0000_c000_0200n)] },  // ~1
-      { input: [1, 100], expected: [reinterpretU64AsF64(0x3fef_ffba_3fff_3800n), reinterpretU64AsF64(0x3ff0_0023_2000_c800n)] },  // ~1
-      { input: [1, kValue.f32.positive.max], expected: kUnboundedBounds },
-      { input: [2, 1], expected: [reinterpretU64AsF64(0x3fff_fffe_a000_0200n), reinterpretU64AsF64(0x4000_0001_0000_0200n)] },  // ~2
-      { input: [2, 2], expected: [reinterpretU64AsF64(0x400f_fffd_a000_0400n), reinterpretU64AsF64(0x4010_0001_a000_0400n)] },  // ~4
-      { input: [10, 10], expected: [reinterpretU64AsF64(0x4202_a04f_51f7_7000n), reinterpretU64AsF64(0x4202_a070_ee08_e000n)] },  // ~10000000000
-      { input: [10, 1], expected: [reinterpretU64AsF64(0x4023_fffe_0b65_8b00n), reinterpretU64AsF64(0x4024_0002_149a_7c00n)] },  // ~10
-      { input: [kValue.f32.positive.max, 1], expected: kUnboundedBounds },
-    ]
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kPowIntervalCases = {
+  f32 : [
+    { input: [1, 0], expected: [kMinusNULPFunctions['f32'](1, 3), reinterpretU64AsF64(0x3ff0_0000_3000_0000n)] },  // ~1
+    { input: [2, 0], expected: [kMinusNULPFunctions['f32'](1, 3), reinterpretU64AsF64(0x3ff0_0000_3000_0000n)] },  // ~1
+    { input: [kValue.f32.positive.max, 0], expected: [kMinusNULPFunctions['f32'](1, 3), reinterpretU64AsF64(0x3ff0_0000_3000_0000n)] },  // ~1
+    { input: [1, 1], expected: [reinterpretU64AsF64(0x3fef_fffe_dfff_fe00n), reinterpretU64AsF64(0x3ff0_0000_c000_0200n)] },  // ~1
+    { input: [1, 100], expected: [reinterpretU64AsF64(0x3fef_ffba_3fff_3800n), reinterpretU64AsF64(0x3ff0_0023_2000_c800n)] },  // ~1
+    { input: [2, 1], expected: [reinterpretU64AsF64(0x3fff_fffe_a000_0200n), reinterpretU64AsF64(0x4000_0001_0000_0200n)] },  // ~2
+    { input: [2, 2], expected: [reinterpretU64AsF64(0x400f_fffd_a000_0400n), reinterpretU64AsF64(0x4010_0001_a000_0400n)] },  // ~4
+    { input: [10, 10], expected: [reinterpretU64AsF64(0x4202_a04f_51f7_7000n), reinterpretU64AsF64(0x4202_a070_ee08_e000n)] },  // ~10000000000
+    { input: [10, 1], expected: [reinterpretU64AsF64(0x4023_fffe_0b65_8b00n), reinterpretU64AsF64(0x4024_0002_149a_7c00n)] },  // ~10
+  ] as ScalarPairToIntervalCase[],
+  f16 : [
+    { input: [1, 0], expected: [reinterpretU64AsF64(0x3fef_fc00_0000_0000n), reinterpretU64AsF64(0x3ff0_0200_0000_0000n)] },  // ~1
+    { input: [2, 0], expected: [reinterpretU64AsF64(0x3fef_fc00_0000_0000n), reinterpretU64AsF64(0x3ff0_0200_0000_0000n)] },  // ~1
+    { input: [kValue.f16.positive.max, 0], expected: [reinterpretU64AsF64(0x3fef_fc00_0000_0000n), reinterpretU64AsF64(0x3ff0_0200_0000_0000n)] },  // ~1
+    { input: [1, 1], expected: [reinterpretU64AsF64(0x3fef_cbf0_0000_0000n), reinterpretU64AsF64(0x3ff0_1c10_0000_0000n)] },  // ~1
+    { input: [1, 100], expected: [reinterpretU64AsF64(0x3fe2_91c0_0000_0000n), reinterpretU64AsF64(0x3ffb_8a40_0000_0000n)] },  // ~1
+    { input: [2, 1], expected: [reinterpretU64AsF64(0x3fff_c410_0000_0000n), reinterpretU64AsF64(0x4000_2410_0000_0000n)] },  // ~2
+    { input: [2, 2], expected: [reinterpretU64AsF64(0x400f_9020_0000_0000n), reinterpretU64AsF64(0x4010_4420_0000_0000n)] },  // ~4
+    { input: [5, 5], expected: [reinterpretU64AsF64(0x40a7_5f70_0000_0000n), reinterpretU64AsF64(0x40a9_5520_0000_0000n)] },  // ~3125
+    { input: [10, 1], expected: [reinterpretU64AsF64(0x4023_c57c_0000_0000n), reinterpretU64AsF64(0x4024_36a0_0000_0000n)] },  // ~10
+  ] as ScalarPairToIntervalCase[],
+} as const;
+
+g.test('powInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarPairToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          { input: [-1, 0], expected: kUnboundedBounds },
+          { input: [0, 0], expected: kUnboundedBounds },
+          { input: [0, 1], expected: kUnboundedBounds },
+          { input: [1, constants.positive.max], expected: kUnboundedBounds },
+          { input: [constants.positive.max, 1], expected: kUnboundedBounds },
+
+          ...kPowIntervalCases[p.trait],
+        ];
+      })
   )
   .fn(t => {
     const [x, y] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.powInterval(x, y);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.powInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `f32.powInterval(${x}, ${y}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.powInterval(${x}, ${y}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 80da217beea8..1135cf286548 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1306,7 +1306,7 @@
   "webgpu:shader,execution,expression,call,builtin,pack4x8snorm:pack:*": { "subcaseMS": 14.751 },
   "webgpu:shader,execution,expression,call,builtin,pack4x8unorm:pack:*": { "subcaseMS": 14.575 },
   "webgpu:shader,execution,expression,call,builtin,pow:abstract_float:*": { "subcaseMS": 23.106 },
-  "webgpu:shader,execution,expression,call,builtin,pow:f16:*": { "subcaseMS": 18.407 },
+  "webgpu:shader,execution,expression,call,builtin,pow:f16:*": { "subcaseMS": 816.063 },
   "webgpu:shader,execution,expression,call,builtin,pow:f32:*": { "subcaseMS": 151.269 },
   "webgpu:shader,execution,expression,call,builtin,quantizeToF16:f32:*": { "subcaseMS": 11.063 },
   "webgpu:shader,execution,expression,call,builtin,radians:abstract_float:*": { "subcaseMS": 492.827 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/pow.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/pow.spec.ts
index abfefa31579a..f9b4fe1cfa28 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/pow.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/pow.spec.ts
@@ -9,9 +9,9 @@ Returns e1 raised to the power e2. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -36,6 +36,22 @@ export const d = makeCaseCache('pow', {
       FP.f32.powInterval
     );
   },
+  f16_const: () => {
+    return FP.f16.generateScalarPairToIntervalCases(
+      fullF16Range(),
+      fullF16Range(),
+      'finite',
+      FP.f16.powInterval
+    );
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarPairToIntervalCases(
+      fullF16Range(),
+      fullF16Range(),
+      'unfiltered',
+      FP.f16.powInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -63,4 +79,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('pow'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index ea6ca306357a..ac3b9b23ff44 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5336,7 +5336,7 @@ class F16Traits extends FPTraits {
   );
   public readonly negationInterval = this.negationIntervalImpl.bind(this);
   public readonly normalizeInterval = this.normalizeIntervalImpl.bind(this);
-  public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this, 'powInterval');
+  public readonly powInterval = this.powIntervalImpl.bind(this);
   public readonly quantizeToF16Interval = this.quantizeToF16IntervalNotAvailable.bind(this);
   public readonly radiansInterval = this.radiansIntervalImpl.bind(this);
   public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(

From 121e6711d9f3d84c2c537791fd49de317a6046f6 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 26 Sep 2023 14:04:27 +0800
Subject: [PATCH 080/166] wgsl: add f16 builtin mix execution test (#2992)

This PR add execution tests for f16 built-in mix.

Issue: #1248, #2567
---
 src/unittests/floating_point.spec.ts          | 334 +++++++++++-------
 src/webgpu/listing_meta.json                  |  24 +-
 .../expression/call/builtin/mix.spec.ts       | 104 +++++-
 src/webgpu/util/floating_point.ts             |  10 +-
 4 files changed, 324 insertions(+), 148 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 8ff2e641a9e8..e659047da4de 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5191,161 +5191,251 @@ g.test('fmaInterval')
     );
   });
 
-g.test('mixImpreciseInterval_f32')
-  .paramsSubcasesOnly<ScalarTripleToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kMixImpreciseIntervalCases = {
+  f32: [
       // [0.0, 1.0] cases
-      { input: [0.0, 1.0, -1.0], expected: -1.0 },
-      { input: [0.0, 1.0, 0.0], expected: 0.0 },
       { input: [0.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0x3fb9_9999_8000_0000n), reinterpretU64AsF64(0x3fb9_9999_a000_0000n)] },  // ~0.1
-      { input: [0.0, 1.0, 0.5], expected: 0.5 },
       { input: [0.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fec_cccc_c000_0000n), reinterpretU64AsF64(0x3fec_cccc_e000_0000n)] },  // ~0.9
-      { input: [0.0, 1.0, 1.0], expected: 1.0 },
-      { input: [0.0, 1.0, 2.0], expected: 2.0 },
-
       // [1.0, 0.0] cases
-      { input: [1.0, 0.0, -1.0], expected: 2.0 },
-      { input: [1.0, 0.0, 0.0], expected: 1.0 },
       { input: [1.0, 0.0, 0.1], expected: [reinterpretU64AsF64(0x3fec_cccc_c000_0000n), reinterpretU64AsF64(0x3fec_cccc_e000_0000n)] },  // ~0.9
-      { input: [1.0, 0.0, 0.5], expected: 0.5 },
       { input: [1.0, 0.0, 0.9], expected: [reinterpretU64AsF64(0x3fb9_9999_0000_0000n), reinterpretU64AsF64(0x3fb9_999a_0000_0000n)] },  // ~0.1
-      { input: [1.0, 0.0, 1.0], expected: 0.0 },
-      { input: [1.0, 0.0, 2.0], expected: -1.0 },
-
       // [0.0, 10.0] cases
-      { input: [0.0, 10.0, -1.0], expected: -10.0 },
-      { input: [0.0, 10.0, 0.0], expected: 0.0 },
       { input: [0.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x3fef_ffff_e000_0000n), reinterpretU64AsF64(0x3ff0_0000_2000_0000n)] },  // ~1
-      { input: [0.0, 10.0, 0.5], expected: 5.0 },
       { input: [0.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4021_ffff_e000_0000n), reinterpretU64AsF64(0x4022_0000_2000_0000n)] },  // ~9
-      { input: [0.0, 10.0, 1.0], expected: 10.0 },
-      { input: [0.0, 10.0, 2.0], expected: 20.0 },
-
       // [2.0, 10.0] cases
-      { input: [2.0, 10.0, -1.0], expected: -6.0 },
-      { input: [2.0, 10.0, 0.0], expected: 2.0 },
       { input: [2.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x4006_6666_6000_0000n), reinterpretU64AsF64(0x4006_6666_8000_0000n)] },  // ~2.8
-      { input: [2.0, 10.0, 0.5], expected: 6.0 },
       { input: [2.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4022_6666_6000_0000n), reinterpretU64AsF64(0x4022_6666_8000_0000n)] },  // ~9.2
-      { input: [2.0, 10.0, 1.0], expected: 10.0 },
-      { input: [2.0, 10.0, 2.0], expected: 18.0 },
-
       // [-1.0, 1.0] cases
-      { input: [-1.0, 1.0, -2.0], expected: -5.0 },
-      { input: [-1.0, 1.0, 0.0], expected: -1.0 },
       { input: [-1.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0xbfe9_9999_a000_0000n), reinterpretU64AsF64(0xbfe9_9999_8000_0000n)] },  // ~-0.8
-      { input: [-1.0, 1.0, 0.5], expected: 0.0 },
       { input: [-1.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fe9_9999_8000_0000n), reinterpretU64AsF64(0x3fe9_9999_c000_0000n)] },  // ~0.8
-      { input: [-1.0, 1.0, 1.0], expected: 1.0 },
-      { input: [-1.0, 1.0, 2.0], expected: 3.0 },
-
-      // Infinities
-      { input: [0.0, kValue.f32.infinity.positive, 0.5], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.positive, 0.0, 0.5], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, 1.0, 0.5], expected: kUnboundedBounds },
-      { input: [1.0, kValue.f32.infinity.negative, 0.5], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive, 0.5], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.positive, kValue.f32.infinity.negative, 0.5], expected: kUnboundedBounds },
-      { input: [0.0, 1.0, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [1.0, 0.0, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [0.0, 1.0, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [1.0, 0.0, kValue.f32.infinity.positive], expected: kUnboundedBounds },
 
       // Showing how precise and imprecise versions diff
+      // Note that this expectation is 0 only in f32 as 10.0 is much smaller that f32.negative.min,
+      // So that 10 - f32.negative.min == f32.negative.min even in f64. But for f16, there is not
+      // a exactly-represenatble f16 value v that make v - f16.negative.min == f16.negative.min
+      // in f64, in fact that require v being smaller than 2**-37.
       { input: [kValue.f32.negative.min, 10.0, 1.0], expected: 0.0 },
-    ]
+      // -10.0 is the same, much smaller than f32.negative.min
+      { input: [kValue.f32.negative.min, -10.0, 1.0], expected: 0.0 },
+  ] as ScalarTripleToIntervalCase[],
+  f16: [
+      // [0.0, 1.0] cases
+      { input: [0.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0x3fb9_9800_0000_0000n), reinterpretU64AsF64(0x3fb9_9c00_0000_0000n)] },  // ~0.1
+      { input: [0.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fec_cc00_0000_0000n), reinterpretU64AsF64(0x3fec_d000_0000_0000n)] },  // ~0.9
+      // [1.0, 0.0] cases
+      { input: [1.0, 0.0, 0.1], expected: [reinterpretU64AsF64(0x3fec_cc00_0000_0000n), reinterpretU64AsF64(0x3fec_d000_0000_0000n)] },  // ~0.9
+      { input: [1.0, 0.0, 0.9], expected: [reinterpretU64AsF64(0x3fb9_8000_0000_0000n), reinterpretU64AsF64(0x3fb9_a000_0000_0000n)] },  // ~0.1
+      // [0.0, 10.0] cases
+      { input: [0.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x3fef_fc00_0000_0000n), reinterpretU64AsF64(0x3ff0_0400_0000_0000n)] },  // ~1
+      { input: [0.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4021_fc00_0000_0000n), reinterpretU64AsF64(0x4022_0400_0000_0000n)] },  // ~9
+      // [2.0, 10.0] cases
+      { input: [2.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x4006_6400_0000_0000n), reinterpretU64AsF64(0x4006_6800_0000_0000n)] },  // ~2.8
+      { input: [2.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4022_6400_0000_0000n), reinterpretU64AsF64(0x4022_6800_0000_0000n)] },  // ~9.2
+      // [-1.0, 1.0] cases
+      { input: [-1.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0xbfe9_9c00_0000_0000n), reinterpretU64AsF64(0xbfe9_9800_0000_0000n)] },  // ~-0.8
+      { input: [-1.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fe9_9800_0000_0000n), reinterpretU64AsF64(0x3fe9_a000_0000_0000n)] },  // ~0.8
+
+      // Showing how precise and imprecise versions diff
+      // In imprecise version, we compute (y - x), where y = 10 and x = -65504, the result is 65514
+      // and cause an overflow in f16.
+      { input: [kValue.f16.negative.min, 10.0, 1.0], expected: kUnboundedBounds },
+      // (y - x) * 1.0, where y = -10 and x = -65504, the result is 65494 rounded to 65472 or 65504.
+      // The result is -65504 + 65472 = -32 or -65504 + 65504 = 0.
+      { input: [kValue.f16.negative.min, -10.0, 1.0], expected: [-32, 0] },
+  ] as ScalarTripleToIntervalCase[],
+} as const;
+
+g.test('mixImpreciseInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarTripleToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kMixImpreciseIntervalCases[p.trait],
+
+          // [0.0, 1.0] cases
+          { input: [0.0, 1.0, -1.0], expected: -1.0 },
+          { input: [0.0, 1.0, 0.0], expected: 0.0 },
+          { input: [0.0, 1.0, 0.5], expected: 0.5 },
+          { input: [0.0, 1.0, 1.0], expected: 1.0 },
+          { input: [0.0, 1.0, 2.0], expected: 2.0 },
+
+          // [1.0, 0.0] cases
+          { input: [1.0, 0.0, -1.0], expected: 2.0 },
+          { input: [1.0, 0.0, 0.0], expected: 1.0 },
+          { input: [1.0, 0.0, 0.5], expected: 0.5 },
+          { input: [1.0, 0.0, 1.0], expected: 0.0 },
+          { input: [1.0, 0.0, 2.0], expected: -1.0 },
+
+          // [0.0, 10.0] cases
+          { input: [0.0, 10.0, -1.0], expected: -10.0 },
+          { input: [0.0, 10.0, 0.0], expected: 0.0 },
+          { input: [0.0, 10.0, 0.5], expected: 5.0 },
+          { input: [0.0, 10.0, 1.0], expected: 10.0 },
+          { input: [0.0, 10.0, 2.0], expected: 20.0 },
+
+          // [2.0, 10.0] cases
+          { input: [2.0, 10.0, -1.0], expected: -6.0 },
+          { input: [2.0, 10.0, 0.0], expected: 2.0 },
+          { input: [2.0, 10.0, 0.5], expected: 6.0 },
+          { input: [2.0, 10.0, 1.0], expected: 10.0 },
+          { input: [2.0, 10.0, 2.0], expected: 18.0 },
+
+          // [-1.0, 1.0] cases
+          { input: [-1.0, 1.0, -2.0], expected: -5.0 },
+          { input: [-1.0, 1.0, 0.0], expected: -1.0 },
+          { input: [-1.0, 1.0, 0.5], expected: 0.0 },
+          { input: [-1.0, 1.0, 1.0], expected: 1.0 },
+          { input: [-1.0, 1.0, 2.0], expected: 3.0 },
+
+          // Infinities
+          { input: [0.0, constants.positive.infinity, 0.5], expected: kUnboundedBounds },
+          { input: [constants.positive.infinity, 0.0, 0.5], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, 1.0, 0.5], expected: kUnboundedBounds },
+          { input: [1.0, constants.negative.infinity, 0.5], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity, 0.5], expected: kUnboundedBounds },
+          { input: [constants.positive.infinity, constants.negative.infinity, 0.5], expected: kUnboundedBounds },
+          { input: [0.0, 1.0, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [1.0, 0.0, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [0.0, 1.0, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [1.0, 0.0, constants.positive.infinity], expected: kUnboundedBounds },
+
+          // The [negative.min, +/-10.0, 1.0] cases has different result for different trait on
+          // imprecise version.
+        ];
+      })
   )
   .fn(t => {
     const [x, y, z] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.mixImpreciseInterval(x, y, z);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.mixImpreciseInterval(x, y, z);
     t.expect(
       objectEquals(expected, got),
-      `f32.mixImpreciseInterval(${x}, ${y}, ${z}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.mixImpreciseInterval(${x}, ${y}, ${z}) returned ${got}. Expected ${expected}`
     );
   });
 
-g.test('mixPreciseInterval_f32')
-  .paramsSubcasesOnly<ScalarTripleToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-
-      // [0.0, 1.0] cases
-      { input: [0.0, 1.0, -1.0], expected: -1.0 },
-      { input: [0.0, 1.0, 0.0], expected: 0.0 },
-      { input: [0.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0x3fb9_9999_8000_0000n), reinterpretU64AsF64(0x3fb9_9999_a000_0000n)] },  // ~0.1
-      { input: [0.0, 1.0, 0.5], expected: 0.5 },
-      { input: [0.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fec_cccc_c000_0000n), reinterpretU64AsF64(0x3fec_cccc_e000_0000n)] },  // ~0.9
-      { input: [0.0, 1.0, 1.0], expected: 1.0 },
-      { input: [0.0, 1.0, 2.0], expected: 2.0 },
-
-      // [1.0, 0.0] cases
-      { input: [1.0, 0.0, -1.0], expected: 2.0 },
-      { input: [1.0, 0.0, 0.0], expected: 1.0 },
-      { input: [1.0, 0.0, 0.1], expected: [reinterpretU64AsF64(0x3fec_cccc_c000_0000n), reinterpretU64AsF64(0x3fec_cccc_e000_0000n)] },  // ~0.9
-      { input: [1.0, 0.0, 0.5], expected: 0.5 },
-      { input: [1.0, 0.0, 0.9], expected: [reinterpretU64AsF64(0x3fb9_9999_0000_0000n), reinterpretU64AsF64(0x3fb9_999a_0000_0000n)] },  // ~0.1
-      { input: [1.0, 0.0, 1.0], expected: 0.0 },
-      { input: [1.0, 0.0, 2.0], expected: -1.0 },
-
-      // [0.0, 10.0] cases
-      { input: [0.0, 10.0, -1.0], expected: -10.0 },
-      { input: [0.0, 10.0, 0.0], expected: 0.0 },
-      { input: [0.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x3fef_ffff_e000_0000n), reinterpretU64AsF64(0x3ff0_0000_2000_0000n)] },  // ~1
-      { input: [0.0, 10.0, 0.5], expected: 5.0 },
-      { input: [0.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4021_ffff_e000_0000n), reinterpretU64AsF64(0x4022_0000_2000_0000n)] },  // ~9
-      { input: [0.0, 10.0, 1.0], expected: 10.0 },
-      { input: [0.0, 10.0, 2.0], expected: 20.0 },
-
-      // [2.0, 10.0] cases
-      { input: [2.0, 10.0, -1.0], expected: -6.0 },
-      { input: [2.0, 10.0, 0.0], expected: 2.0 },
-      { input: [2.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x4006_6666_4000_0000n), reinterpretU64AsF64(0x4006_6666_8000_0000n)] },  // ~2.8
-      { input: [2.0, 10.0, 0.5], expected: 6.0 },
-      { input: [2.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4022_6666_4000_0000n), reinterpretU64AsF64(0x4022_6666_a000_0000n)] },  // ~9.2
-      { input: [2.0, 10.0, 1.0], expected: 10.0 },
-      { input: [2.0, 10.0, 2.0], expected: 18.0 },
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kMixPreciseIntervalCases = {
+  f32: [
+    // [0.0, 1.0] cases
+    { input: [0.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0x3fb9_9999_8000_0000n), reinterpretU64AsF64(0x3fb9_9999_a000_0000n)] },  // ~0.1
+    { input: [0.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fec_cccc_c000_0000n), reinterpretU64AsF64(0x3fec_cccc_e000_0000n)] },  // ~0.9
+    // [1.0, 0.0] cases
+    { input: [1.0, 0.0, 0.1], expected: [reinterpretU64AsF64(0x3fec_cccc_c000_0000n), reinterpretU64AsF64(0x3fec_cccc_e000_0000n)] },  // ~0.9
+    { input: [1.0, 0.0, 0.9], expected: [reinterpretU64AsF64(0x3fb9_9999_0000_0000n), reinterpretU64AsF64(0x3fb9_999a_0000_0000n)] },  // ~0.1
+    // [0.0, 10.0] cases
+    { input: [0.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x3fef_ffff_e000_0000n), reinterpretU64AsF64(0x3ff0_0000_2000_0000n)] },  // ~1
+    { input: [0.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4021_ffff_e000_0000n), reinterpretU64AsF64(0x4022_0000_2000_0000n)] },  // ~9
+    // [2.0, 10.0] cases
+    { input: [2.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x4006_6666_4000_0000n), reinterpretU64AsF64(0x4006_6666_8000_0000n)] },  // ~2.8
+    { input: [2.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4022_6666_4000_0000n), reinterpretU64AsF64(0x4022_6666_a000_0000n)] },  // ~9.2
+    // [-1.0, 1.0] cases
+    { input: [-1.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0xbfe9_9999_c000_0000n), reinterpretU64AsF64(0xbfe9_9999_8000_0000n)] },  // ~-0.8
+    { input: [-1.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fe9_9999_8000_0000n), reinterpretU64AsF64(0x3fe9_9999_c000_0000n)] },  // ~0.8
+  ] as ScalarTripleToIntervalCase[],
+  f16: [
+    // [0.0, 1.0] cases
+    { input: [0.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0x3fb9_9800_0000_0000n), reinterpretU64AsF64(0x3fb9_9c00_0000_0000n)] },  // ~0.1
+    { input: [0.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fec_cc00_0000_0000n), reinterpretU64AsF64(0x3fec_d000_0000_0000n)] },  // ~0.9
+    // [1.0, 0.0] cases
+    { input: [1.0, 0.0, 0.1], expected: [reinterpretU64AsF64(0x3fec_cc00_0000_0000n), reinterpretU64AsF64(0x3fec_d000_0000_0000n)] },  // ~0.9
+    { input: [1.0, 0.0, 0.9], expected: [reinterpretU64AsF64(0x3fb9_8000_0000_0000n), reinterpretU64AsF64(0x3fb9_a000_0000_0000n)] },  // ~0.1
+    // [0.0, 10.0] cases
+    { input: [0.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x3fef_fc00_0000_0000n), reinterpretU64AsF64(0x3ff0_0400_0000_0000n)] },  // ~1
+    { input: [0.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4021_fc00_0000_0000n), reinterpretU64AsF64(0x4022_0400_0000_0000n)] },  // ~9
+    // [2.0, 10.0] cases
+    { input: [2.0, 10.0, 0.1], expected: [reinterpretU64AsF64(0x4006_6400_0000_0000n), reinterpretU64AsF64(0x4006_6c00_0000_0000n)] },  // ~2.8
+    { input: [2.0, 10.0, 0.9], expected: [reinterpretU64AsF64(0x4022_6000_0000_0000n), reinterpretU64AsF64(0x4022_6c00_0000_0000n)] },  // ~9.2
+    // [-1.0, 1.0] cases
+    { input: [-1.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0xbfe9_a000_0000_0000n), reinterpretU64AsF64(0xbfe9_9800_0000_0000n)] },  // ~-0.8
+    { input: [-1.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fe9_9800_0000_0000n), reinterpretU64AsF64(0x3fe9_a000_0000_0000n)] },  // ~0.8
+  ] as ScalarTripleToIntervalCase[],
+} as const;
 
-      // [-1.0, 1.0] cases
-      { input: [-1.0, 1.0, -2.0], expected: -5.0 },
-      { input: [-1.0, 1.0, 0.0], expected: -1.0 },
-      { input: [-1.0, 1.0, 0.1], expected: [reinterpretU64AsF64(0xbfe9_9999_c000_0000n), reinterpretU64AsF64(0xbfe9_9999_8000_0000n)] },  // ~-0.8
-      { input: [-1.0, 1.0, 0.5], expected: 0.0 },
-      { input: [-1.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fe9_9999_8000_0000n), reinterpretU64AsF64(0x3fe9_9999_c000_0000n)] },  // ~0.8
-      { input: [-1.0, 1.0, 1.0], expected: 1.0 },
-      { input: [-1.0, 1.0, 2.0], expected: 3.0 },
-
-      // Infinities
-      { input: [0.0, kValue.f32.infinity.positive, 0.5], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.positive, 0.0, 0.5], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, 1.0, 0.5], expected: kUnboundedBounds },
-      { input: [1.0, kValue.f32.infinity.negative, 0.5], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.negative, kValue.f32.infinity.positive, 0.5], expected: kUnboundedBounds },
-      { input: [kValue.f32.infinity.positive, kValue.f32.infinity.negative, 0.5], expected: kUnboundedBounds },
-      { input: [0.0, 1.0, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [1.0, 0.0, kValue.f32.infinity.negative], expected: kUnboundedBounds },
-      { input: [0.0, 1.0, kValue.f32.infinity.positive], expected: kUnboundedBounds },
-      { input: [1.0, 0.0, kValue.f32.infinity.positive], expected: kUnboundedBounds },
+g.test('mixPreciseInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarTripleToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kMixPreciseIntervalCases[p.trait],
+
+          // [0.0, 1.0] cases
+          { input: [0.0, 1.0, -1.0], expected: -1.0 },
+          { input: [0.0, 1.0, 0.0], expected: 0.0 },
+          { input: [0.0, 1.0, 0.5], expected: 0.5 },
+          { input: [0.0, 1.0, 1.0], expected: 1.0 },
+          { input: [0.0, 1.0, 2.0], expected: 2.0 },
+
+          // [1.0, 0.0] cases
+          { input: [1.0, 0.0, -1.0], expected: 2.0 },
+          { input: [1.0, 0.0, 0.0], expected: 1.0 },
+          { input: [1.0, 0.0, 0.5], expected: 0.5 },
+          { input: [1.0, 0.0, 1.0], expected: 0.0 },
+          { input: [1.0, 0.0, 2.0], expected: -1.0 },
+
+          // [0.0, 10.0] cases
+          { input: [0.0, 10.0, -1.0], expected: -10.0 },
+          { input: [0.0, 10.0, 0.0], expected: 0.0 },
+          { input: [0.0, 10.0, 0.5], expected: 5.0 },
+          { input: [0.0, 10.0, 1.0], expected: 10.0 },
+          { input: [0.0, 10.0, 2.0], expected: 20.0 },
+
+          // [2.0, 10.0] cases
+          { input: [2.0, 10.0, -1.0], expected: -6.0 },
+          { input: [2.0, 10.0, 0.0], expected: 2.0 },
+          { input: [2.0, 10.0, 0.5], expected: 6.0 },
+          { input: [2.0, 10.0, 1.0], expected: 10.0 },
+          { input: [2.0, 10.0, 2.0], expected: 18.0 },
+
+          // [-1.0, 1.0] cases
+          { input: [-1.0, 1.0, -2.0], expected: -5.0 },
+          { input: [-1.0, 1.0, 0.0], expected: -1.0 },
+          { input: [-1.0, 1.0, 0.5], expected: 0.0 },
+          { input: [-1.0, 1.0, 1.0], expected: 1.0 },
+          { input: [-1.0, 1.0, 2.0], expected: 3.0 },
 
-      // Showing how precise and imprecise versions diff
-      { input: [kValue.f32.negative.min, 10.0, 1.0], expected: 10.0 },
-    ]
+          // Infinities
+          { input: [0.0, constants.positive.infinity, 0.5], expected: kUnboundedBounds },
+          { input: [constants.positive.infinity, 0.0, 0.5], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, 1.0, 0.5], expected: kUnboundedBounds },
+          { input: [1.0, constants.negative.infinity, 0.5], expected: kUnboundedBounds },
+          { input: [constants.negative.infinity, constants.positive.infinity, 0.5], expected: kUnboundedBounds },
+          { input: [constants.positive.infinity, constants.negative.infinity, 0.5], expected: kUnboundedBounds },
+          { input: [0.0, 1.0, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [1.0, 0.0, constants.negative.infinity], expected: kUnboundedBounds },
+          { input: [0.0, 1.0, constants.positive.infinity], expected: kUnboundedBounds },
+          { input: [1.0, 0.0, constants.positive.infinity], expected: kUnboundedBounds },
+
+          // Showing how precise and imprecise versions diff
+          { input: [constants.negative.min, 10.0, 1.0], expected: 10.0 },
+          { input: [constants.negative.min, -10.0, 1.0], expected: -10.0 },
+        ];
+      })
   )
   .fn(t => {
     const [x, y, z] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.mixPreciseInterval(x, y, z);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.mixPreciseInterval(x, y, z);
     t.expect(
       objectEquals(expected, got),
-      `f32.mixPreciseInterval(${x}, ${y}, ${z}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.mixPreciseInterval(${x}, ${y}, ${z}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 1135cf286548..320bad7eaa37 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1265,18 +1265,18 @@
   "webgpu:shader,execution,expression,call,builtin,min:f32:*": { "subcaseMS": 298.463 },
   "webgpu:shader,execution,expression,call,builtin,min:i32:*": { "subcaseMS": 7.825 },
   "webgpu:shader,execution,expression,call,builtin,min:u32:*": { "subcaseMS": 6.932 },
-  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_matching:*": { "subcaseMS": 198.806 },
-  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_nonmatching_vec2:*": { "subcaseMS": 13.302 },
-  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_nonmatching_vec3:*": { "subcaseMS": 13.302 },
-  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_nonmatching_vec4:*": { "subcaseMS": 4.000 },
-  "webgpu:shader,execution,expression,call,builtin,mix:f16_matching:*": { "subcaseMS": 69.810 },
-  "webgpu:shader,execution,expression,call,builtin,mix:f16_nonmatching_vec2:*": { "subcaseMS": 13.200 },
-  "webgpu:shader,execution,expression,call,builtin,mix:f16_nonmatching_vec3:*": { "subcaseMS": 32.401 },
-  "webgpu:shader,execution,expression,call,builtin,mix:f16_nonmatching_vec4:*": { "subcaseMS": 37.303 },
-  "webgpu:shader,execution,expression,call,builtin,mix:f32_matching:*": { "subcaseMS": 4018.920 },
-  "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec2:*": { "subcaseMS": 494.701 },
-  "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec3:*": { "subcaseMS": 580.525 },
-  "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec4:*": { "subcaseMS": 677.226 },
+  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_matching:*": { "subcaseMS": 215.206 },
+  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_nonmatching_vec2:*": { "subcaseMS": 14.601 },
+  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_nonmatching_vec3:*": { "subcaseMS": 18.302 },
+  "webgpu:shader,execution,expression,call,builtin,mix:abstract_float_nonmatching_vec4:*": { "subcaseMS": 12.602 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f16_matching:*": { "subcaseMS": 321.700 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f16_nonmatching_vec2:*": { "subcaseMS": 653.851 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f16_nonmatching_vec3:*": { "subcaseMS": 832.076 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f16_nonmatching_vec4:*": { "subcaseMS": 1021.126 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f32_matching:*": { "subcaseMS": 4306.763 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec2:*": { "subcaseMS": 503.551 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec3:*": { "subcaseMS": 590.326 },
+  "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec4:*": { "subcaseMS": 679.901 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_fract:*": { "subcaseMS": 4.202 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_fract:*": { "subcaseMS": 9.200 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_whole:*": { "subcaseMS": 8.404 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/mix.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/mix.spec.ts
index de4c3a24dc1e..95e9f6b31017 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/mix.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/mix.spec.ts
@@ -16,9 +16,14 @@ Same as mix(e1,e2,T2(e3)).
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeVec, TypeF32 } from '../../../../../util/conversion.js';
+import { TypeVec, TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseF32Range, sparseVectorF32Range } from '../../../../../util/math.js';
+import {
+  sparseF32Range,
+  sparseF16Range,
+  sparseVectorF32Range,
+  sparseVectorF16Range,
+} from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -43,6 +48,23 @@ const f32_vec_scalar_cases = ([2, 3, 4] as const)
   )
   .reduce((a, b) => ({ ...a, ...b }), {});
 
+// Cases: f16_vecN_scalar_[non_]const
+const f16_vec_scalar_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f16_vec${n}_scalar_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorPairScalarToVectorComponentWiseCase(
+          sparseVectorF16Range(n),
+          sparseVectorF16Range(n),
+          sparseF16Range(),
+          nonConst ? 'unfiltered' : 'finite',
+          ...FP.f16.mixIntervals
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('mix', {
   f32_const: () => {
     return FP.f32.generateScalarTripleToIntervalCases(
@@ -63,6 +85,25 @@ export const d = makeCaseCache('mix', {
     );
   },
   ...f32_vec_scalar_cases,
+  f16_const: () => {
+    return FP.f16.generateScalarTripleToIntervalCases(
+      sparseF16Range(),
+      sparseF16Range(),
+      sparseF16Range(),
+      'finite',
+      ...FP.f16.mixIntervals
+    );
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarTripleToIntervalCases(
+      sparseF16Range(),
+      sparseF16Range(),
+      sparseF16Range(),
+      'unfiltered',
+      ...FP.f16.mixIntervals
+    );
+  },
+  ...f16_vec_scalar_cases,
 });
 
 g.test('abstract_float_matching')
@@ -162,22 +203,73 @@ g.test('f16_matching')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('mix'), [TypeF16, TypeF16, TypeF16], TypeF16, t.params, cases);
+  });
 
 g.test('f16_nonmatching_vec2')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`f16 tests with two vec2<f16> params and scalar third param`)
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec2_scalar_const' : 'f16_vec2_scalar_non_const'
+    );
+    await run(
+      t,
+      builtin('mix'),
+      [TypeVec(2, TypeF16), TypeVec(2, TypeF16), TypeF16],
+      TypeVec(2, TypeF16),
+      t.params,
+      cases
+    );
+  });
 
 g.test('f16_nonmatching_vec3')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`f16 tests with two vec3<f16> params and scalar third param`)
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec3_scalar_const' : 'f16_vec3_scalar_non_const'
+    );
+    await run(
+      t,
+      builtin('mix'),
+      [TypeVec(3, TypeF16), TypeVec(3, TypeF16), TypeF16],
+      TypeVec(3, TypeF16),
+      t.params,
+      cases
+    );
+  });
 
 g.test('f16_nonmatching_vec4')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`f16 tests with two vec4<f16> params and scalar third param`)
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec4_scalar_const' : 'f16_vec4_scalar_non_const'
+    );
+    await run(
+      t,
+      builtin('mix'),
+      [TypeVec(4, TypeF16), TypeVec(4, TypeF16), TypeF16],
+      TypeVec(4, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index ac3b9b23ff44..7958148363dc 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5308,14 +5308,8 @@ class F16Traits extends FPTraits {
   public readonly log2Interval = this.log2IntervalImpl.bind(this);
   public readonly maxInterval = this.maxIntervalImpl.bind(this);
   public readonly minInterval = this.minIntervalImpl.bind(this);
-  public readonly mixImpreciseInterval = this.unimplementedScalarTripleToInterval.bind(
-    this,
-    'mixImpreciseInterval'
-  );
-  public readonly mixPreciseInterval = this.unimplementedScalarTripleToInterval.bind(
-    this,
-    'mixPreciseInterval'
-  );
+  public readonly mixImpreciseInterval = this.mixImpreciseIntervalImpl.bind(this);
+  public readonly mixPreciseInterval = this.mixPreciseIntervalImpl.bind(this);
   public readonly mixIntervals = [this.mixImpreciseInterval, this.mixPreciseInterval];
   public readonly modfInterval = this.unimplementedModf.bind(this);
   public readonly multiplicationInterval = this.multiplicationIntervalImpl.bind(this);

From 8e6c5acbfc1540ea932a38c1ff8ad7064fdad7c5 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 14:29:26 -0700
Subject: [PATCH 081/166] Compat: Make setBindGroup tests handle different
 limits

---
 .../encoding/cmds/setBindGroup.spec.ts        | 45 +++++++------------
 1 file changed, 17 insertions(+), 28 deletions(-)

diff --git a/src/webgpu/api/validation/encoding/cmds/setBindGroup.spec.ts b/src/webgpu/api/validation/encoding/cmds/setBindGroup.spec.ts
index 272499b0fc86..ebc015bd5427 100644
--- a/src/webgpu/api/validation/encoding/cmds/setBindGroup.spec.ts
+++ b/src/webgpu/api/validation/encoding/cmds/setBindGroup.spec.ts
@@ -11,11 +11,10 @@ TODO: merge these notes and implement.
 `;
 
 import { makeTestGroup } from '../../../../../common/framework/test_group.js';
-import { range, unreachable } from '../../../../../common/util/util.js';
+import { makeValueTestVariant, range, unreachable } from '../../../../../common/util/util.js';
 import {
   kBufferBindingTypes,
   kMinDynamicBufferOffsetAlignment,
-  kLimitInfo,
 } from '../../../../capability_info.js';
 import { kResourceStates, ResourceState } from '../../../../gpu_test.js';
 import {
@@ -389,28 +388,24 @@ g.test('buffer_dynamic_offsets')
       .combine('type', kBufferBindingTypes)
       .combine('encoderType', kProgrammableEncoderTypes)
       .beginSubcases()
-      .expand('dynamicOffset', ({ type }) =>
-        type === 'uniform'
-          ? [
-              kLimitInfo.minUniformBufferOffsetAlignment.default,
-              kLimitInfo.minUniformBufferOffsetAlignment.default * 0.5,
-              kLimitInfo.minUniformBufferOffsetAlignment.default * 1.5,
-              kLimitInfo.minUniformBufferOffsetAlignment.default * 2,
-              kLimitInfo.minUniformBufferOffsetAlignment.default + 2,
-            ]
-          : [
-              kLimitInfo.minStorageBufferOffsetAlignment.default,
-              kLimitInfo.minStorageBufferOffsetAlignment.default * 0.5,
-              kLimitInfo.minStorageBufferOffsetAlignment.default * 1.5,
-              kLimitInfo.minStorageBufferOffsetAlignment.default * 2,
-              kLimitInfo.minStorageBufferOffsetAlignment.default + 2,
-            ]
-      )
+      .combine('dynamicOffsetVariant', [
+        { mult: 1, add: 0 },
+        { mult: 0.5, add: 0 },
+        { mult: 1.5, add: 0 },
+        { mult: 2, add: 0 },
+        { mult: 1, add: 2 },
+      ])
   )
   .fn(t => {
-    const { type, dynamicOffset, encoderType } = t.params;
+    const { type, dynamicOffsetVariant, encoderType } = t.params;
     const kBindingSize = 12;
 
+    const minAlignment =
+      t.device.limits[
+        type === 'uniform' ? 'minUniformBufferOffsetAlignment' : 'minStorageBufferOffsetAlignment'
+      ];
+    const dynamicOffset = makeValueTestVariant(minAlignment, dynamicOffsetVariant);
+
     const bindGroupLayout = t.device.createBindGroupLayout({
       entries: [
         {
@@ -421,14 +416,8 @@ g.test('buffer_dynamic_offsets')
       ],
     });
 
-    let usage, isValid;
-    if (type === 'uniform') {
-      usage = GPUBufferUsage.UNIFORM;
-      isValid = dynamicOffset % kLimitInfo.minUniformBufferOffsetAlignment.default === 0;
-    } else {
-      usage = GPUBufferUsage.STORAGE;
-      isValid = dynamicOffset % kLimitInfo.minStorageBufferOffsetAlignment.default === 0;
-    }
+    const usage = type === 'uniform' ? GPUBufferUsage.UNIFORM : GPUBufferUsage.STORAGE;
+    const isValid = dynamicOffset % minAlignment === 0;
 
     const buffer = t.device.createBuffer({
       size: 3 * kMinDynamicBufferOffsetAlignment,

From a55f58ec9dbde2c7f2775383c39bc5ec9e50405b Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 15:00:19 -0700
Subject: [PATCH 082/166] Compat: make device allocation test handle different
 limits

---
 src/stress/adapter/device_allocation.spec.ts | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/stress/adapter/device_allocation.spec.ts b/src/stress/adapter/device_allocation.spec.ts
index 6f98cd5137a1..0e6abf68b0d0 100644
--- a/src/stress/adapter/device_allocation.spec.ts
+++ b/src/stress/adapter/device_allocation.spec.ts
@@ -8,7 +8,7 @@ import { attemptGarbageCollection } from '../../common/util/collect_garbage.js';
 import { keysOf } from '../../common/util/data_tables.js';
 import { getGPU } from '../../common/util/navigator_gpu.js';
 import { assert, iterRange } from '../../common/util/util.js';
-import { kLimitInfo } from '../../webgpu/capability_info.js';
+import { getDefaultLimitsForAdapter } from '../../webgpu/capability_info.js';
 
 export const g = makeTestGroup(Fixture);
 
@@ -33,10 +33,11 @@ async function createDeviceAndComputeCommands(adapter: GPUAdapter) {
   // Constants are computed such that per run, this function should allocate roughly 2G
   // worth of data. This should be sufficient as we run these creation functions many
   // times. If the data backing the created objects is not recycled we should OOM.
+  const limitInfo = getDefaultLimitsForAdapter(adapter);
   const kNumPipelines = 64;
   const kNumBindgroups = 128;
   const kNumBufferElements =
-    kLimitInfo.maxComputeWorkgroupSizeX.default * kLimitInfo.maxComputeWorkgroupSizeY.default;
+    limitInfo.maxComputeWorkgroupSizeX.default * limitInfo.maxComputeWorkgroupSizeY.default;
   const kBufferSize = kNumBufferElements * 4;
   const kBufferData = new Uint32Array([...iterRange(kNumBufferElements, x => x)]);
 
@@ -54,8 +55,8 @@ async function createDeviceAndComputeCommands(adapter: GPUAdapter) {
               @group(0) @binding(0) var<storage, read_write> buffer: Buffer;
               @compute @workgroup_size(1) fn main(
                   @builtin(global_invocation_id) id: vec3<u32>) {
-                buffer.data[id.x * ${kLimitInfo.maxComputeWorkgroupSizeX.default}u + id.y] =
-                  buffer.data[id.x * ${kLimitInfo.maxComputeWorkgroupSizeX.default}u + id.y] +
+                buffer.data[id.x * ${limitInfo.maxComputeWorkgroupSizeX.default}u + id.y] =
+                  buffer.data[id.x * ${limitInfo.maxComputeWorkgroupSizeX.default}u + id.y] +
                     ${pipelineIndex}u;
               }
             `,
@@ -79,8 +80,8 @@ async function createDeviceAndComputeCommands(adapter: GPUAdapter) {
       pass.setPipeline(pipeline);
       pass.setBindGroup(0, bindgroup);
       pass.dispatchWorkgroups(
-        kLimitInfo.maxComputeWorkgroupSizeX.default,
-        kLimitInfo.maxComputeWorkgroupSizeY.default
+        limitInfo.maxComputeWorkgroupSizeX.default,
+        limitInfo.maxComputeWorkgroupSizeY.default
       );
       pass.end();
       commands.push(encoder.finish());

From 206d3fb2ac32b43f3643ef8408a37f3b140f77cc Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 14:24:25 -0700
Subject: [PATCH 083/166] Compat: Make setVertexBuffer test handle different
 limits

---
 .../cmds/render/setVertexBuffer.spec.ts         | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/webgpu/api/validation/encoding/cmds/render/setVertexBuffer.spec.ts b/src/webgpu/api/validation/encoding/cmds/render/setVertexBuffer.spec.ts
index 7ba92eb4db1a..2faa3b58b98d 100644
--- a/src/webgpu/api/validation/encoding/cmds/render/setVertexBuffer.spec.ts
+++ b/src/webgpu/api/validation/encoding/cmds/render/setVertexBuffer.spec.ts
@@ -3,7 +3,7 @@ Validation tests for setVertexBuffer on render pass and render bundle.
 `;
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
-import { kLimitInfo } from '../../../../../capability_info.js';
+import { makeValueTestVariant } from '../../../../../../common/util/util.js';
 import { GPUConst } from '../../../../../constants.js';
 import { kResourceStates } from '../../../../../gpu_test.js';
 import { ValidationTest } from '../../../validation_test.js';
@@ -19,14 +19,17 @@ Tests slot must be less than the maxVertexBuffers in device limits.
   `
   )
   .paramsSubcasesOnly(
-    kRenderEncodeTypeParams.combine('slot', [
-      0,
-      kLimitInfo.maxVertexBuffers.default - 1,
-      kLimitInfo.maxVertexBuffers.default,
+    kRenderEncodeTypeParams.combine('slotVariant', [
+      { mult: 0, add: 0 },
+      { mult: 1, add: -1 },
+      { mult: 1, add: 0 },
     ] as const)
   )
   .fn(t => {
-    const { encoderType, slot } = t.params;
+    const { encoderType, slotVariant } = t.params;
+    const maxVertexBuffers = t.device.limits.maxVertexBuffers;
+    const slot = makeValueTestVariant(maxVertexBuffers, slotVariant);
+
     const vertexBuffer = t.createBufferWithState('valid', {
       size: 16,
       usage: GPUBufferUsage.VERTEX,
@@ -34,7 +37,7 @@ Tests slot must be less than the maxVertexBuffers in device limits.
 
     const { encoder, validateFinish } = t.createEncoder(encoderType);
     encoder.setVertexBuffer(slot, vertexBuffer);
-    validateFinish(slot < kLimitInfo.maxVertexBuffers.default);
+    validateFinish(slot < maxVertexBuffers);
   });
 
 g.test('vertex_buffer_state')

From cd6bc786956f800c9d91a4aa2eb4f6caa0ebb8bf Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 14:20:12 -0700
Subject: [PATCH 084/166] Compat: Make compute pass tests handle different
 limits

---
 .../encoding/cmds/compute_pass.spec.ts        | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/src/webgpu/api/validation/encoding/cmds/compute_pass.spec.ts b/src/webgpu/api/validation/encoding/cmds/compute_pass.spec.ts
index d58d45c3d3b7..a73e142a5a4b 100644
--- a/src/webgpu/api/validation/encoding/cmds/compute_pass.spec.ts
+++ b/src/webgpu/api/validation/encoding/cmds/compute_pass.spec.ts
@@ -5,7 +5,8 @@ Does **not** test usage scopes (resource_usages/) or programmable pass stuff (pr
 `;
 
 import { makeTestGroup } from '../../../../../common/framework/test_group.js';
-import { kBufferUsages, kLimitInfo } from '../../../../capability_info.js';
+import { makeValueTestVariant } from '../../../../../common/util/util.js';
+import { kBufferUsages } from '../../../../capability_info.js';
 import { GPUConst } from '../../../../constants.js';
 import { kResourceStates, ResourceState } from '../../../../gpu_test.js';
 import { ValidationTest } from '../../validation_test.js';
@@ -88,7 +89,6 @@ g.test('pipeline,device_mismatch')
     validateFinish(!mismatched);
   });
 
-const kMaxDispatch = kLimitInfo.maxComputeWorkgroupsPerDimension.default;
 g.test('dispatch_sizes')
   .desc(
     `Test 'direct' and 'indirect' dispatch with various sizes.
@@ -104,13 +104,22 @@ g.test('dispatch_sizes')
   .params(u =>
     u
       .combine('dispatchType', ['direct', 'indirect'] as const)
-      .combine('largeDimValue', [0, 1, kMaxDispatch, kMaxDispatch + 1, 0x7fff_ffff, 0xffff_ffff])
+      .combine('largeDimValueVariant', [
+        { mult: 0, add: 0 },
+        { mult: 0, add: 1 },
+        { mult: 1, add: 0 },
+        { mult: 1, add: 1 },
+        { mult: 0, add: 0x7fff_ffff },
+        { mult: 0, add: 0xffff_ffff },
+      ])
       .beginSubcases()
       .combine('largeDimIndex', [0, 1, 2] as const)
       .combine('smallDimValue', [0, 1])
   )
   .fn(t => {
-    const { dispatchType, largeDimIndex, smallDimValue, largeDimValue } = t.params;
+    const { dispatchType, largeDimIndex, smallDimValue, largeDimValueVariant } = t.params;
+    const maxDispatch = t.device.limits.maxComputeWorkgroupsPerDimension;
+    const largeDimValue = makeValueTestVariant(maxDispatch, largeDimValueVariant);
 
     const pipeline = t.createNoOpComputePipeline();
 
@@ -131,7 +140,7 @@ g.test('dispatch_sizes')
 
     const shouldError =
       dispatchType === 'direct' &&
-      (workSizes[0] > kMaxDispatch || workSizes[1] > kMaxDispatch || workSizes[2] > kMaxDispatch);
+      (workSizes[0] > maxDispatch || workSizes[1] > maxDispatch || workSizes[2] > maxDispatch);
 
     validateFinishAndSubmit(!shouldError, true);
   });

From ee7ac5514ae4c7d6f492e188cdf891f50eacd3e2 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 26 Sep 2023 11:02:45 -0400
Subject: [PATCH 085/166] wgsl: Add AbstractFloat `fma` execution tests (#2996)

Fixes #2548

Co-authored-by: jzm-intel <zhaoming.jiang@intel.com>
---
 src/unittests/floating_point.spec.ts          | 67 ++++++++++++++-----
 .../expression/call/builtin/fma.spec.ts       | 33 +++++++--
 src/webgpu/util/floating_point.ts             |  2 +-
 3 files changed, 78 insertions(+), 24 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index e659047da4de..0ad3d272deeb 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -5120,10 +5120,58 @@ g.test('clampMinMaxInterval')
     );
   });
 
+// prettier-ignore
+const kFmaIntervalCases = {
+  f32: [
+    // positive.subnormal.max * positive.subnormal.max is much smaller than positive.subnormal.min but larger than 0, rounded to [0, positive.subnormal.min]
+    { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, 0], expected: [0, kValue.f32.subnormal.positive.min] },
+    // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
+    // 0 + constants.positive.subnormal.max rounded to [0, constants.positive.subnormal.max],
+    // positive.subnormal.min + constants.positive.subnormal.max = constants.positive.min.
+    { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.positive.min] },
+    // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
+    // negative.subnormal.max may flushed to 0,
+    // minimum case: 0 + negative.subnormal.max rounded to [negative.subnormal.max, 0],
+    // maximum case: positive.subnormal.min + 0 rounded to [0, positive.subnormal.min].
+    { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.negative.max], expected: [kValue.f32.subnormal.negative.max, kValue.f32.subnormal.positive.min] },
+    // positive.subnormal.max * negative.subnormal.min rounded to -0.0 or negative.subnormal.max = -1 * [subnormal ulp],
+    // negative.subnormal.max = -1 * [subnormal ulp] may flushed to -0.0,
+    // minimum case: -1 * [subnormal ulp] + -1 * [subnormal ulp] rounded to [-2 * [subnormal ulp], 0],
+    // maximum case: -0.0 + -0.0 = 0.
+    { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max], expected: [-2 * FP['f32'].oneULP(0, 'no-flush'), 0] },
+  ] as ScalarTripleToIntervalCase[],
+  f16: [
+    // positive.subnormal.max * positive.subnormal.max is much smaller than positive.subnormal.min but larger than 0, rounded to [0, positive.subnormal.min]
+    { input: [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.positive.max, 0], expected: [0, kValue.f16.subnormal.positive.min] },
+    // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
+    // 0 + constants.positive.subnormal.max rounded to [0, constants.positive.subnormal.max],
+    // positive.subnormal.min + constants.positive.subnormal.max = constants.positive.min.
+    { input: [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.positive.max, kValue.f16.subnormal.positive.max], expected: [0, kValue.f16.positive.min] },
+    // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
+    // negative.subnormal.max may flushed to 0,
+    // minimum case: 0 + negative.subnormal.max rounded to [negative.subnormal.max, 0],
+    // maximum case: positive.subnormal.min + 0 rounded to [0, positive.subnormal.min].
+    { input: [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.negative.max], expected: [kValue.f16.subnormal.negative.max, kValue.f16.subnormal.positive.min] },
+    // positive.subnormal.max * negative.subnormal.min rounded to -0.0 or negative.subnormal.max = -1 * [subnormal ulp],
+    // negative.subnormal.max = -1 * [subnormal ulp] may flushed to -0.0,
+    // minimum case: -1 * [subnormal ulp] + -1 * [subnormal ulp] rounded to [-2 * [subnormal ulp], 0],
+    // maximum case: -0.0 + -0.0 = 0.
+    { input: [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max], expected: [-2 * FP['f16'].oneULP(0, 'no-flush'), 0] },  ] as ScalarTripleToIntervalCase[],
+  abstract: [
+    // These operations break down in the CTS, because `number` is a f64 under the hood, so precision is sometimes lost
+    // if intermediate results are  closer to 0 than the smallest subnormal will be precisely 0.
+    // See https://github.com/gpuweb/cts/issues/2993 for details
+    { input: [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.positive.max, 0], expected: 0 },
+    { input: [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.positive.max, kValue.f64.subnormal.positive.max], expected: [0, kValue.f64.subnormal.positive.max] },
+    { input: [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.positive.min, kValue.f64.subnormal.negative.max], expected: [kValue.f64.subnormal.negative.max, 0] },
+    { input: [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.negative.min, kValue.f64.subnormal.negative.max], expected: [kValue.f64.subnormal.negative.max, 0] },
+  ] as ScalarTripleToIntervalCase[],
+} as const;
+
 g.test('fmaInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarTripleToIntervalCase>(p => {
         const trait = FP[p.trait];
@@ -5152,23 +5200,7 @@ g.test('fmaInterval')
           { input: [0, constants.positive.subnormal.max, 0], expected: 0 },
           { input: [0, 0, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
           { input: [constants.positive.subnormal.max, 0, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
-          // positive.subnormal.max * positive.subnormal.max is much smaller than positive.subnormal.min but larger than 0, rounded to [0, positive.subnormal.min]
-          { input: [constants.positive.subnormal.max, constants.positive.subnormal.max, 0], expected: [0, constants.positive.subnormal.min] },
           { input: [0, constants.positive.subnormal.max, constants.positive.subnormal.max], expected: [0, constants.positive.subnormal.max] },
-          // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
-          // 0 + constants.positive.subnormal.max rounded to [0, constants.positive.subnormal.max],
-          // positive.subnormal.min + constants.positive.subnormal.max = constants.positive.min.
-          { input: [constants.positive.subnormal.max, constants.positive.subnormal.max, constants.positive.subnormal.max], expected: [0, constants.positive.min] },
-          // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
-          // negative.subnormal.max may flushed to 0,
-          // minimum case: 0 + negative.subnormal.max rounded to [negative.subnormal.max, 0],
-          // maximum case: positive.subnormal.min + 0 rounded to [0, positive.subnormal.min].
-          { input: [constants.positive.subnormal.max, constants.positive.subnormal.min, constants.negative.subnormal.max], expected: [constants.negative.subnormal.max, constants.positive.subnormal.min] },
-          // positive.subnormal.max * negative.subnormal.min rounded to -0.0 or negative.subnormal.max = -1 * [subnormal ulp],
-          // negative.subnormal.max = -1 * [subnormal ulp] may flushed to -0.0,
-          // minimum case: -1 * [subnormal ulp] + -1 * [subnormal ulp] rounded to [-2 * [subnormal ulp], 0],
-          // maximum case: -0.0 + -0.0 = 0.
-          { input: [constants.positive.subnormal.max, constants.negative.subnormal.min, constants.negative.subnormal.max], expected: [-2 * FP[p.trait].oneULP(0, 'no-flush'), 0] },
 
           // Infinities
           { input: [0, 1, constants.positive.infinity], expected: kUnboundedBounds },
@@ -5176,6 +5208,7 @@ g.test('fmaInterval')
           { input: [constants.negative.infinity, constants.positive.infinity, constants.positive.infinity], expected: kUnboundedBounds },
           { input: [constants.negative.infinity, constants.positive.infinity, constants.negative.infinity], expected: kUnboundedBounds },
           { input: [constants.positive.max, constants.positive.max, constants.positive.subnormal.min], expected: kUnboundedBounds },
+          ...kFmaIntervalCases[p.trait],
         ];
       })
   )
diff --git a/src/webgpu/shader/execution/expression/call/builtin/fma.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/fma.spec.ts
index d00c80b7a105..701f9d7ca970 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/fma.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/fma.spec.ts
@@ -9,13 +9,13 @@ Returns e1 * e2 + e3. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16, TypeAbstractFloat } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseF32Range, sparseF16Range } from '../../../../../util/math.js';
+import { sparseF32Range, sparseF16Range, sparseF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -56,15 +56,36 @@ export const d = makeCaseCache('fma', {
       FP.f16.fmaInterval
     );
   },
+  abstract: () => {
+    return FP.abstract.generateScalarTripleToIntervalCases(
+      sparseF64Range(),
+      sparseF64Range(),
+      sparseF64Range(),
+      'finite',
+      FP.abstract.fmaInterval
+    );
+  },
 });
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(
+      t,
+      abstractBuiltin('fma'),
+      [TypeAbstractFloat, TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 7958148363dc..615f3b17b63a 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4968,7 +4968,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly exp2Interval = this.unimplementedScalarToInterval.bind(this, 'exp2Interval');
   public readonly faceForwardIntervals = this.unimplementedFaceForward.bind(this);
   public readonly floorInterval = this.unimplementedScalarToInterval.bind(this, 'floorInterval');
-  public readonly fmaInterval = this.unimplementedScalarTripleToInterval.bind(this, 'fmaInterval');
+  public readonly fmaInterval = this.fmaIntervalImpl.bind(this);
   public readonly fractInterval = this.unimplementedScalarToInterval.bind(this, 'fractInterval');
   public readonly inverseSqrtInterval = this.unimplementedScalarToInterval.bind(
     this,

From af8a364be1675b906bcdb351cde8fa34f6260f1d Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 16:43:49 -0700
Subject: [PATCH 086/166] Compat: make maxXXXBufferBindingSize tests handle
 different limits

---
 .../limits/maxStorageBufferBindingSize.spec.ts           | 3 +--
 .../limits/maxUniformBufferBindingSize.spec.ts           | 9 ++-------
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts
index b7a504a2b3b0..15fca54445a6 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts
@@ -4,7 +4,6 @@ import {
   kMaximumLimitBaseParams,
   makeLimitTestGroup,
   LimitMode,
-  getDefaultLimit,
   MaximumLimitValueTest,
   MaximumTestValue,
 } from './limit_utils.js';
@@ -149,6 +148,6 @@ g.test('validate,maxBufferSize')
   .desc(`Test that ${limit} <= maxBufferSize`)
   .fn(t => {
     const { adapter, defaultLimit, adapterLimit } = t;
-    t.expect(defaultLimit <= getDefaultLimit('maxBufferSize'));
+    t.expect(defaultLimit <= t.getDefaultLimit('maxBufferSize'));
     t.expect(adapterLimit <= adapter.limits.maxBufferSize);
   });
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxUniformBufferBindingSize.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxUniformBufferBindingSize.spec.ts
index c5c3dfa5799c..c5ac1514043d 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxUniformBufferBindingSize.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxUniformBufferBindingSize.spec.ts
@@ -1,9 +1,4 @@
-import {
-  LimitMode,
-  getDefaultLimit,
-  kMaximumLimitBaseParams,
-  makeLimitTestGroup,
-} from './limit_utils.js';
+import { LimitMode, kMaximumLimitBaseParams, makeLimitTestGroup } from './limit_utils.js';
 
 const kBufferParts = ['wholeBuffer', 'biggerBufferWithOffset'] as const;
 type BufferPart = typeof kBufferParts[number];
@@ -90,6 +85,6 @@ g.test('validate,maxBufferSize')
   .desc(`Test that ${limit} <= maxBufferSize`)
   .fn(t => {
     const { adapter, defaultLimit, adapterLimit } = t;
-    t.expect(defaultLimit <= getDefaultLimit('maxBufferSize'));
+    t.expect(defaultLimit <= t.getDefaultLimit('maxBufferSize'));
     t.expect(adapterLimit <= adapter.limits.maxBufferSize);
   });

From 055b78eab0cef552ba15d0a8babb551c1348d486 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 16:36:49 -0700
Subject: [PATCH 087/166] Compat: make maxDynamicXXX tests handle different
 limits

---
 .../limits/maxDynamicStorageBuffersPerPipelineLayout.spec.ts     | 1 +
 .../limits/maxDynamicUniformBuffersPerPipelineLayout.spec.ts     | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/webgpu/api/validation/capability_checks/limits/maxDynamicStorageBuffersPerPipelineLayout.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxDynamicStorageBuffersPerPipelineLayout.spec.ts
index 61bc42ed0fe9..efd6c871964a 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxDynamicStorageBuffersPerPipelineLayout.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxDynamicStorageBuffersPerPipelineLayout.spec.ts
@@ -21,6 +21,7 @@ g.test('createBindGroupLayout,at_over')
       limitTest,
       testValueName,
       async ({ device, testValue, shouldError }) => {
+        shouldError ||= testValue > t.device.limits.maxStorageBuffersPerShaderStage;
         await t.expectValidationError(() => {
           device.createBindGroupLayout({
             entries: range(testValue, i => ({
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxDynamicUniformBuffersPerPipelineLayout.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxDynamicUniformBuffersPerPipelineLayout.spec.ts
index 39efb1c991ed..0491d071919d 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxDynamicUniformBuffersPerPipelineLayout.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxDynamicUniformBuffersPerPipelineLayout.spec.ts
@@ -25,6 +25,7 @@ g.test('createBindGroupLayout,at_over')
       limitTest,
       testValueName,
       async ({ device, testValue, shouldError }) => {
+        shouldError ||= testValue > t.device.limits.maxUniformBuffersPerShaderStage;
         await t.expectValidationError(() => {
           device.createBindGroupLayout({
             entries: range(testValue, i => ({

From 3b3b2229939d2adc7c8fbeb0478b9684d38d52ba Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 17:37:37 -0700
Subject: [PATCH 088/166] add computeBytesPerSample helpers

---
 src/webgpu/format_info.ts | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/webgpu/format_info.ts b/src/webgpu/format_info.ts
index 58cdfd5f7c6c..89b6c4704e7d 100644
--- a/src/webgpu/format_info.ts
+++ b/src/webgpu/format_info.ts
@@ -1,6 +1,7 @@
 import { keysOf } from '../common/util/data_tables.js';
 import { assert } from '../common/util/util.js';
 
+import { align } from './util/math.js';
 import { ImageCopyType } from './util/texture/layout.js';
 
 //
@@ -1240,3 +1241,23 @@ export function isCompressedTextureFormat(format: GPUTextureFormat) {
 }
 
 export const kFeaturesForFormats = getFeaturesForFormats(kTextureFormats);
+
+/**
+ * Given an array of texture formats return the number of bytes per sample.
+ */
+export function computeBytesPerSampleFromFormats(formats: GPUTextureFormat[]) {
+  let bytesPerSample = 0;
+  for (const format of formats) {
+    const info = kTextureFormatInfo[format];
+    const alignedBytesPerSample = align(bytesPerSample, info.colorRender!.alignment);
+    bytesPerSample = alignedBytesPerSample + info.colorRender!.byteCost;
+  }
+  return bytesPerSample;
+}
+
+/**
+ * Given an array of GPUColorTargetState return the number of bytes per sample
+ */
+export function computeBytesPerSample(targets: GPUColorTargetState[]) {
+  return computeBytesPerSampleFromFormats(targets.map(({ format }) => format));
+}

From 369bb8b6660cad1700da0c9153e83cc96de4b483 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 17:37:50 -0700
Subject: [PATCH 089/166] Compat: make pipline-output-targets tests handle
 different limits

---
 .../pipeline_output_targets.spec.ts           | 23 +++++++++++--------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts b/src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts
index d5212165f7c4..12cc86bd4cb5 100644
--- a/src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts
+++ b/src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts
@@ -4,8 +4,11 @@ export const description = `
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
 import { range } from '../../../../common/util/util.js';
-import { kLimitInfo } from '../../../capability_info.js';
-import { kRenderableColorTextureFormats, kTextureFormatInfo } from '../../../format_info.js';
+import {
+  computeBytesPerSampleFromFormats,
+  kRenderableColorTextureFormats,
+  kTextureFormatInfo,
+} from '../../../format_info.js';
 import { GPUTest, TextureTestMixin } from '../../../gpu_test.js';
 import { getFragmentShaderCodeWithOutput, getPlainTypeInfo } from '../../../util/shader.js';
 import { kTexelRepresentationInfo } from '../../../util/texture/texel_data.js';
@@ -47,14 +50,6 @@ g.test('color,attachments')
       .combine('format', kRenderableColorTextureFormats)
       .beginSubcases()
       .combine('attachmentCount', [2, 3, 4])
-      .filter(t => {
-        // We only need to test formats that have a valid color attachment bytes per sample.
-        const pixelByteCost = kTextureFormatInfo[t.format].colorRender?.byteCost;
-        return (
-          pixelByteCost !== undefined &&
-          pixelByteCost * t.attachmentCount <= kLimitInfo.maxColorAttachmentBytesPerSample.default
-        );
-      })
       .expand('emptyAttachmentId', p => range(p.attachmentCount, i => i))
   )
   .beforeAllSubcases(t => {
@@ -67,6 +62,14 @@ g.test('color,attachments')
     const componentCount = kTexelRepresentationInfo[format].componentOrder.length;
     const info = kTextureFormatInfo[format];
 
+    // We only need to test formats that have a valid color attachment bytes per sample.
+    const pixelByteCost = kTextureFormatInfo[format].colorRender?.byteCost;
+    t.skipIf(
+      pixelByteCost === undefined ||
+        computeBytesPerSampleFromFormats(range(attachmentCount, () => format)) >
+          t.device.limits.maxColorAttachmentBytesPerSample
+    );
+
     const writeValues =
       info.color.type === 'sint' || info.color.type === 'uint'
         ? attachmentsIntWriteValues

From 1120e90b243dc9c1b29c4fd2e40fd3a5a583ec9d Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 14:46:08 -0700
Subject: [PATCH 090/166] Compat: make render pass descriptor tests handle
 different limits

---
 .../render_pass_descriptor.spec.ts            | 45 ++++++++++++++-----
 1 file changed, 33 insertions(+), 12 deletions(-)

diff --git a/src/webgpu/api/validation/render_pass/render_pass_descriptor.spec.ts b/src/webgpu/api/validation/render_pass/render_pass_descriptor.spec.ts
index 0b621744e68e..9713beea5262 100644
--- a/src/webgpu/api/validation/render_pass/render_pass_descriptor.spec.ts
+++ b/src/webgpu/api/validation/render_pass/render_pass_descriptor.spec.ts
@@ -6,9 +6,10 @@ TODO: review for completeness
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
 import { range } from '../../../../common/util/util.js';
-import { kMaxColorAttachments, kQueryTypes } from '../../../capability_info.js';
+import { kMaxColorAttachmentsToTest, kQueryTypes } from '../../../capability_info.js';
 import { GPUConst } from '../../../constants.js';
 import {
+  computeBytesPerSampleFromFormats,
   kDepthStencilFormats,
   kRenderableColorTextureFormats,
   kTextureFormatInfo,
@@ -122,7 +123,7 @@ g.test('color_attachments,empty')
   )
   .paramsSubcasesOnly(u =>
     u
-      .combine('colorAttachments', [
+      .combine('unclampedColorAttachments', [
         [],
         [undefined],
         [undefined, undefined],
@@ -132,7 +133,11 @@ g.test('color_attachments,empty')
       .combine('hasDepthStencilAttachment', [false, true])
   )
   .fn(t => {
-    const { colorAttachments, hasDepthStencilAttachment } = t.params;
+    const { unclampedColorAttachments, hasDepthStencilAttachment } = t.params;
+    const colorAttachments = unclampedColorAttachments.slice(
+      0,
+      t.device.limits.maxColorAttachments
+    );
 
     let isEmptyColorTargets = true;
     for (let i = 0; i < colorAttachments.length; i++) {
@@ -160,11 +165,15 @@ g.test('color_attachments,limits,maxColorAttachments')
   `
   )
   .paramsSimple([
-    { colorAttachmentsCount: 8, _success: true }, // Control case
-    { colorAttachmentsCount: 9, _success: false }, // Out of bounds
+    { colorAttachmentsCountVariant: { mult: 1, add: 0 }, _success: true }, // Control case
+    { colorAttachmentsCountVariant: { mult: 1, add: 1 }, _success: false }, // Out of bounds
   ])
   .fn(t => {
-    const { colorAttachmentsCount, _success } = t.params;
+    const { colorAttachmentsCountVariant, _success } = t.params;
+    const colorAttachmentsCount = t.makeLimitVariant(
+      'maxColorAttachments',
+      colorAttachmentsCountVariant
+    );
 
     const colorAttachments = [];
     for (let i = 0; i < colorAttachmentsCount; i++) {
@@ -188,7 +197,7 @@ g.test('color_attachments,limits,maxColorAttachmentBytesPerSample,aligned')
       .beginSubcases()
       .combine(
         'attachmentCount',
-        range(kMaxColorAttachments, i => i + 1)
+        range(kMaxColorAttachmentsToTest, i => i + 1)
       )
   )
   .beforeAllSubcases(t => {
@@ -198,6 +207,11 @@ g.test('color_attachments,limits,maxColorAttachmentBytesPerSample,aligned')
     const { format, attachmentCount } = t.params;
     const info = kTextureFormatInfo[format];
 
+    t.skipIf(
+      attachmentCount > t.device.limits.maxColorAttachments,
+      `attachmentCount: ${attachmentCount} > maxColorAttachments: ${t.device.limits.maxColorAttachments}`
+    );
+
     const colorAttachments = [];
     for (let i = 0; i < attachmentCount; i++) {
       const colorTexture = t.createTexture({ format });
@@ -205,7 +219,7 @@ g.test('color_attachments,limits,maxColorAttachmentBytesPerSample,aligned')
     }
     const shouldError =
       info.colorRender === undefined ||
-      info.colorRender.byteCost * attachmentCount >
+      computeBytesPerSampleFromFormats(range(attachmentCount, () => format)) >
         t.device.limits.maxColorAttachmentBytesPerSample;
 
     t.tryRenderPass(!shouldError, { colorAttachments });
@@ -232,7 +246,6 @@ g.test('color_attachments,limits,maxColorAttachmentBytesPerSample,unaligned')
           'rgba32float',
           'r8unorm',
         ] as GPUTextureFormat[],
-        _success: false,
       },
       {
         formats: [
@@ -242,19 +255,27 @@ g.test('color_attachments,limits,maxColorAttachmentBytesPerSample,unaligned')
           'r8unorm',
           'r8unorm',
         ] as GPUTextureFormat[],
-        _success: true,
       },
     ])
   )
   .fn(t => {
-    const { formats, _success } = t.params;
+    const { formats } = t.params;
+
+    t.skipIf(
+      formats.length > t.device.limits.maxColorAttachments,
+      `numColorAttachments: ${formats.length} > maxColorAttachments: ${t.device.limits.maxColorAttachments}`
+    );
 
     const colorAttachments = [];
     for (const format of formats) {
       const colorTexture = t.createTexture({ format });
       colorAttachments.push(t.getColorAttachment(colorTexture));
     }
-    t.tryRenderPass(_success, { colorAttachments });
+
+    const success =
+      computeBytesPerSampleFromFormats(formats) <= t.device.limits.maxColorAttachmentBytesPerSample;
+
+    t.tryRenderPass(success, { colorAttachments });
   });
 
 g.test('attachments,same_size')

From 37ff0cbedbda91a30ed9ca420a609e64348a6412 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 15:26:55 -0700
Subject: [PATCH 091/166] Compat: make maxComputeInvocationsPerWorkgroup test
 handle different limits

---
 .../maxComputeInvocationsPerWorkgroup.spec.ts | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/webgpu/api/validation/capability_checks/limits/maxComputeInvocationsPerWorkgroup.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxComputeInvocationsPerWorkgroup.spec.ts
index 392879b37ca2..a3858a62214d 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxComputeInvocationsPerWorkgroup.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxComputeInvocationsPerWorkgroup.spec.ts
@@ -1,6 +1,7 @@
+import { GPUTestBase } from '../../../../gpu_test.js';
+
 import {
   kMaximumLimitBaseParams,
-  getDefaultLimit,
   MaximumLimitValueTest,
   MaximumTestValue,
   makeLimitTestGroup,
@@ -75,11 +76,15 @@ function getDeviceLimitToRequest(
   }
 }
 
-function getTestWorkgroupSize(testValueName: MaximumTestValue, requestedLimit: number) {
+function getTestWorkgroupSize(
+  t: GPUTestBase,
+  testValueName: MaximumTestValue,
+  requestedLimit: number
+) {
   const maxDimensions = [
-    getDefaultLimit('maxComputeWorkgroupSizeX'),
-    getDefaultLimit('maxComputeWorkgroupSizeY'),
-    getDefaultLimit('maxComputeWorkgroupSizeZ'),
+    t.getDefaultLimit('maxComputeWorkgroupSizeX'),
+    t.getDefaultLimit('maxComputeWorkgroupSizeY'),
+    t.getDefaultLimit('maxComputeWorkgroupSizeZ'),
   ];
 
   switch (testValueName) {
@@ -91,13 +96,14 @@ function getTestWorkgroupSize(testValueName: MaximumTestValue, requestedLimit: n
 }
 
 function getDeviceLimitToRequestAndValueToTest(
+  t: GPUTestBase,
   limitValueTest: MaximumLimitValueTest,
   testValueName: MaximumTestValue,
   defaultLimit: number,
   maximumLimit: number
 ) {
   const requestedLimit = getDeviceLimitToRequest(limitValueTest, defaultLimit, maximumLimit);
-  const workgroupSize = getTestWorkgroupSize(testValueName, requestedLimit);
+  const workgroupSize = getTestWorkgroupSize(t, testValueName, requestedLimit);
   return {
     requestedLimit,
     workgroupSize,
@@ -115,6 +121,7 @@ g.test('createComputePipeline,at_over')
     const { defaultLimit, adapterLimit: maximumLimit } = t;
 
     const { requestedLimit, workgroupSize } = getDeviceLimitToRequestAndValueToTest(
+      t,
       limitTest,
       testValueName,
       defaultLimit,

From 47fd41c1dd5d9492d0bf5a8c8b6ac171a9541a74 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 27 Sep 2023 14:22:40 +0800
Subject: [PATCH 092/166] wgsl: add f16 execution test for builtin
 sinh/cosh/tanh/asinh/acosh/atanh (#3012)

This PR add execution tests for f16 built-in sinh, cosh, tanh, asinh, acosh,
and atanh.

Issue: #1248, #2559, #2561, #2563, #2538, #2535, #2527
---
 src/unittests/floating_point.spec.ts          | 402 ++++++++++++------
 src/webgpu/listing_meta.json                  |  12 +-
 .../expression/call/builtin/acosh.spec.ts     |  28 +-
 .../expression/call/builtin/asinh.spec.ts     |  15 +-
 .../expression/call/builtin/atanh.spec.ts     |  31 +-
 .../expression/call/builtin/cosh.spec.ts      |  18 +-
 .../expression/call/builtin/sinh.spec.ts      |  18 +-
 .../expression/call/builtin/tanh.spec.ts      |  15 +-
 src/webgpu/util/floating_point.ts             |  20 +-
 9 files changed, 384 insertions(+), 175 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 0ad3d272deeb..d4dafc9616dc 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -2292,57 +2292,95 @@ g.test('acosInterval')
     );
   });
 
-g.test('acoshAlternativeInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: -1, expected: kUnboundedBounds },
-      { input: 0, expected: kUnboundedBounds },
-      { input: 1, expected: kUnboundedBounds },  // 1/0 occurs in inverseSqrt in this formulation
-      { input: 1.1, expected: [reinterpretU64AsF64(0x3fdc_6368_8000_0000n), reinterpretU64AsF64(0x3fdc_636f_2000_0000n)] },  // ~0.443..., differs from the primary in the later digits
-      { input: 10, expected: [reinterpretU64AsF64(0x4007_f21e_4000_0000n), reinterpretU64AsF64(0x4007_f21f_6000_0000n)] },  // ~2.993...
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kAcoshAlternativeIntervalCases = {
+  f32: [
+    { input: 1.1, expected: [reinterpretU64AsF64(0x3fdc_6368_8000_0000n), reinterpretU64AsF64(0x3fdc_636f_2000_0000n)] },  // ~0.443..., differs from the primary in the later digits
+    { input: 10, expected: [reinterpretU64AsF64(0x4007_f21e_4000_0000n), reinterpretU64AsF64(0x4007_f21f_6000_0000n)] },  // ~2.993...
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: 1.1, expected: [reinterpretU64AsF64(0x3fdb_bc00_0000_0000n), reinterpretU64AsF64(0x3fdd_1000_0000_0000n)] },  // ~0.443..., differs from the primary in the later digits
+    { input: 10, expected: [reinterpretU64AsF64(0x4007_e000_0000_0000n), reinterpretU64AsF64(0x4008_0400_0000_0000n)] },  // ~2.993...
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('acoshAlternativeInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kAcoshAlternativeIntervalCases[p.trait],
+
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: -1, expected: kUnboundedBounds },
+          { input: 0, expected: kUnboundedBounds },
+          { input: 1, expected: kUnboundedBounds },  // 1/0 occurs in inverseSqrt in this formulation
+          { input: constants.positive.max, expected: kUnboundedBounds },
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.acoshAlternativeInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.acoshAlternativeInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.acoshInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.acoshAlternativeInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
-g.test('acoshPrimaryInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: -1, expected: kUnboundedBounds },
-      { input: 0, expected: kUnboundedBounds },
-      { input: 1, expected: kUnboundedBounds },  // 1/0 occurs in inverseSqrt in this formulation
-      { input: 1.1, expected: [reinterpretU64AsF64(0x3fdc_6368_2000_0000n), reinterpretU64AsF64(0x3fdc_636f_8000_0000n)] }, // ~0.443..., differs from the alternative in the later digits
-      { input: 10, expected: [reinterpretU64AsF64(0x4007_f21e_4000_0000n), reinterpretU64AsF64(0x4007_f21f_6000_0000n)] },  // ~2.993...
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kAcoshPrimaryIntervalCases = {
+  f32: [
+    { input: 1.1, expected: [reinterpretU64AsF64(0x3fdc_6368_2000_0000n), reinterpretU64AsF64(0x3fdc_636f_8000_0000n)] }, // ~0.443..., differs from the alternative in the later digits
+    { input: 10, expected: [reinterpretU64AsF64(0x4007_f21e_4000_0000n), reinterpretU64AsF64(0x4007_f21f_6000_0000n)] },  // ~2.993...
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: 1.1, expected: [reinterpretU64AsF64(0x3fdb_bc00_0000_0000n), reinterpretU64AsF64(0x3fdd_1c00_0000_0000n)] },  // ~0.443..., differs from the primary in the later digits
+    { input: 10, expected: [reinterpretU64AsF64(0x4007_e000_0000_0000n), reinterpretU64AsF64(0x4008_0400_0000_0000n)] },  // ~2.993...
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('acoshPrimaryInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kAcoshPrimaryIntervalCases[p.trait],
+
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: -1, expected: kUnboundedBounds },
+          { input: 0, expected: kUnboundedBounds },
+          { input: 1, expected: kUnboundedBounds },  // 1/0 occurs in inverseSqrt in this formulation
+          { input: constants.positive.max, expected: kUnboundedBounds },
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.acoshPrimaryInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.acoshPrimaryInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.acoshInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.acoshPrimaryInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -2406,28 +2444,48 @@ g.test('asinInterval')
     );
   });
 
-g.test('asinhInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: -1, expected: [reinterpretU64AsF64(0xbfec_343a_8000_0000n), reinterpretU64AsF64(0xbfec_3432_8000_0000n)] },  // ~-0.88137...
-      { input: 0, expected: [reinterpretU64AsF64(0xbeaa_0000_2000_0000n), reinterpretU64AsF64(0x3eb1_ffff_d000_0000n)] },  // ~0
-      { input: 1, expected: [reinterpretU64AsF64(0x3fec_3435_4000_0000n), reinterpretU64AsF64(0x3fec_3437_8000_0000n)] },  // ~0.88137...
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kAsinhIntervalCases = {
+  f32: [
+    { input: -1, expected: [reinterpretU64AsF64(0xbfec_343a_8000_0000n), reinterpretU64AsF64(0xbfec_3432_8000_0000n)] },  // ~-0.88137...
+    { input: 0, expected: [reinterpretU64AsF64(0xbeaa_0000_2000_0000n), reinterpretU64AsF64(0x3eb1_ffff_d000_0000n)] },  // ~0
+    { input: 1, expected: [reinterpretU64AsF64(0x3fec_3435_4000_0000n), reinterpretU64AsF64(0x3fec_3437_8000_0000n)] },  // ~0.88137...
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: -1, expected: [reinterpretU64AsF64(0xbfec_b800_0000_0000n), reinterpretU64AsF64(0xbfeb_b800_0000_0000n)] },  // ~-0.88137...
+    { input: 0, expected: [reinterpretU64AsF64(0xbf85_0200_0000_0000n), reinterpretU64AsF64(0x3f89_fa00_0000_0000n)] },  // ~0
+    { input: 1, expected: [reinterpretU64AsF64(0x3fec_1000_0000_0000n), reinterpretU64AsF64(0x3fec_5400_0000_0000n)] },  // ~0.88137...
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('asinhInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kAsinhIntervalCases[p.trait],
+
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: kUnboundedBounds },
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.asinhInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.asinhInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.asinhInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.asinhInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -2506,29 +2564,50 @@ g.test('atanInterval')
     );
   });
 
-g.test('atanhInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature of the errors.
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: -1, expected: kUnboundedBounds },
-      { input: -0.1, expected: [reinterpretU64AsF64(0xbfb9_af9a_6000_0000n), reinterpretU64AsF64(0xbfb9_af8c_c000_0000n)] },  // ~-0.1003...
-      { input: 0, expected: [reinterpretU64AsF64(0xbe96_0000_2000_0000n), reinterpretU64AsF64(0x3e98_0000_0000_0000n)] },  // ~0
-      { input: 0.1, expected: [reinterpretU64AsF64(0x3fb9_af8b_8000_0000n), reinterpretU64AsF64(0x3fb9_af9b_0000_0000n)] },  // ~0.1003...
-      { input: 1, expected: kUnboundedBounds },
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kAtanhIntervalCases = {
+  f32: [
+    { input: -0.1, expected: [reinterpretU64AsF64(0xbfb9_af9a_6000_0000n), reinterpretU64AsF64(0xbfb9_af8c_c000_0000n)] },  // ~-0.1003...
+    { input: 0, expected: [reinterpretU64AsF64(0xbe96_0000_2000_0000n), reinterpretU64AsF64(0x3e98_0000_0000_0000n)] },  // ~0
+    { input: 0.1, expected: [reinterpretU64AsF64(0x3fb9_af8b_8000_0000n), reinterpretU64AsF64(0x3fb9_af9b_0000_0000n)] },  // ~0.1003...
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: -0.1, expected: [reinterpretU64AsF64(0xbfbb_0c00_0000_0000n), reinterpretU64AsF64(0xbfb8_5800_0000_0000n)] },  // ~-0.1003...
+    { input: 0, expected: [reinterpretU64AsF64(0xbf73_0400_0000_0000n), reinterpretU64AsF64(0x3f74_0000_0000_0000n)] },  // ~0
+    { input: 0.1, expected: [reinterpretU64AsF64(0x3fb8_3800_0000_0000n), reinterpretU64AsF64(0x3fbb_2400_0000_0000n)] },  // ~0.1003...
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('atanhInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kAtanhIntervalCases[p.trait],
+
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: -1, expected: kUnboundedBounds },
+          { input: 1, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: kUnboundedBounds },
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.atanhInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.atanhInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.atanhInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.atanhInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -2663,29 +2742,48 @@ g.test('cosInterval')
     );
   });
 
-g.test('coshInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: -1, expected: [ reinterpretU32AsF32(0x3fc583a4), reinterpretU32AsF32(0x3fc583b1)] },  // ~1.1543...
-      { input: 0, expected: [reinterpretU32AsF32(0x3f7ffffd), reinterpretU32AsF32(0x3f800002)] },  // ~1
-      { input: 1, expected: [ reinterpretU32AsF32(0x3fc583a4), reinterpretU32AsF32(0x3fc583b1)] },  // ~1.1543...
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kCoshIntervalCases = {
+  f32: [
+    { input: -1, expected: [reinterpretU32AsF32(0x3fc583a4), reinterpretU32AsF32(0x3fc583b1)] },  // ~1.1543...
+    { input: 0, expected: [reinterpretU32AsF32(0x3f7ffffd), reinterpretU32AsF32(0x3f800002)] },  // ~1
+    { input: 1, expected: [reinterpretU32AsF32(0x3fc583a4), reinterpretU32AsF32(0x3fc583b1)] },  // ~1.1543...
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: -1, expected: [reinterpretU16AsF16(0x3e27), reinterpretU16AsF16(0x3e30)] },  // ~1.1543...
+    { input: 0, expected: [reinterpretU16AsF16(0x3bff), reinterpretU16AsF16(0x3c01)] },  // ~1
+    { input: 1, expected: [reinterpretU16AsF16(0x3e27), reinterpretU16AsF16(0x3e30)] },  // ~1.1543...
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('coshInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kCoshIntervalCases[p.trait],
+
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: kUnboundedBounds },
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-
-    const got = FP.f32.coshInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.coshInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.coshInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.coshInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -3647,28 +3745,48 @@ g.test('sinInterval')
     );
   });
 
-g.test('sinhInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: -1, expected: [ reinterpretU32AsF32(0xbf966d05), reinterpretU32AsF32(0xbf966cf8)] },  // ~-1.175...
-      { input: 0, expected: [reinterpretU32AsF32(0xb4600000), reinterpretU32AsF32(0x34600000)] },  // ~0
-      { input: 1, expected: [ reinterpretU32AsF32(0x3f966cf8), reinterpretU32AsF32(0x3f966d05)] },  // ~1.175...
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kSinhIntervalCases = {
+  f32: [
+    { input: -1, expected: [reinterpretU32AsF32(0xbf966d05), reinterpretU32AsF32(0xbf966cf8)] },  // ~-1.175...
+    { input: 0, expected: [reinterpretU32AsF32(0xb4600000), reinterpretU32AsF32(0x34600000)] },  // ~0
+    { input: 1, expected: [reinterpretU32AsF32(0x3f966cf8), reinterpretU32AsF32(0x3f966d05)] },  // ~1.175...
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: -1, expected: [reinterpretU16AsF16(0xbcb8), reinterpretU16AsF16(0xbcaf)] },  // ~-1.175...
+    { input: 0, expected: [reinterpretU16AsF16(0x9200), reinterpretU16AsF16(0x1200)] },  // ~0
+    { input: 1, expected: [reinterpretU16AsF16(0x3caf), reinterpretU16AsF16(0x3cb8)] },  // ~1.175...
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('sinhInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kSinhIntervalCases[p.trait],
+
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: kUnboundedBounds },
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.sinhInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.sinhInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.sinhInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.sinhInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
@@ -3838,28 +3956,48 @@ g.test('tanInterval')
     );
   });
 
-g.test('tanhInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.negative.min, expected: kUnboundedBounds },
-      { input: -1, expected: [reinterpretU64AsF64(0xbfe8_5efd_1000_0000n), reinterpretU64AsF64(0xbfe8_5ef8_9000_0000n)] },  // ~-0.7615...
-      { input: 0, expected: [reinterpretU64AsF64(0xbe8c_0000_b000_0000n), reinterpretU64AsF64(0x3e8c_0000_b000_0000n)] },  // ~0
-      { input: 1, expected: [reinterpretU64AsF64(0x3fe8_5ef8_9000_0000n), reinterpretU64AsF64(0x3fe8_5efd_1000_0000n)] },  // ~0.7615...
-      { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    ]
+// Some of these are hard coded, since the error intervals are difficult to express in a closed
+// human-readable form due to the inherited nature of the errors.
+// prettier-ignore
+const kTanhIntervalCases = {
+  f32: [
+    { input: -1, expected: [reinterpretU64AsF64(0xbfe8_5efd_1000_0000n), reinterpretU64AsF64(0xbfe8_5ef8_9000_0000n)] },  // ~-0.7615...
+    { input: 0, expected: [reinterpretU64AsF64(0xbe8c_0000_b000_0000n), reinterpretU64AsF64(0x3e8c_0000_b000_0000n)] },  // ~0
+    { input: 1, expected: [reinterpretU64AsF64(0x3fe8_5ef8_9000_0000n), reinterpretU64AsF64(0x3fe8_5efd_1000_0000n)] },  // ~0.7615...
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: -1, expected: [reinterpretU64AsF64(0xbfe8_9600_0000_0000n), reinterpretU64AsF64(0xbfe8_2e00_0000_0000n)] },  // ~-0.7615...
+    { input: 0, expected: [reinterpretU64AsF64(0xbf48_0e00_0000_0000n), reinterpretU64AsF64(0x3f48_0e00_0000_0000n)] },  // ~0
+    { input: 1, expected: [reinterpretU64AsF64(0x3fe8_2e00_0000_0000n), reinterpretU64AsF64(0x3fe8_9600_0000_0000n)] },  // ~0.7615...
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('tanhInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kTanhIntervalCases[p.trait],
+
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.min, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: kUnboundedBounds },
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.tanhInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.tanhInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.tanhInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.tanhInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 320bad7eaa37..76ada42b493c 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1057,7 +1057,7 @@
   "webgpu:shader,execution,expression,call,builtin,acos:f16:*": { "subcaseMS": 26.005 },
   "webgpu:shader,execution,expression,call,builtin,acos:f32:*": { "subcaseMS": 33.063 },
   "webgpu:shader,execution,expression,call,builtin,acosh:abstract_float:*": { "subcaseMS": 17.210 },
-  "webgpu:shader,execution,expression,call,builtin,acosh:f16:*": { "subcaseMS": 23.306 },
+  "webgpu:shader,execution,expression,call,builtin,acosh:f16:*": { "subcaseMS": 140.494 },
   "webgpu:shader,execution,expression,call,builtin,acosh:f32:*": { "subcaseMS": 12.588 },
   "webgpu:shader,execution,expression,call,builtin,all:bool:*": { "subcaseMS": 6.938 },
   "webgpu:shader,execution,expression,call,builtin,any:bool:*": { "subcaseMS": 6.475 },
@@ -1070,7 +1070,7 @@
   "webgpu:shader,execution,expression,call,builtin,asin:f16:*": { "subcaseMS": 6.708 },
   "webgpu:shader,execution,expression,call,builtin,asin:f32:*": { "subcaseMS": 33.969 },
   "webgpu:shader,execution,expression,call,builtin,asinh:abstract_float:*": { "subcaseMS": 23.305 },
-  "webgpu:shader,execution,expression,call,builtin,asinh:f16:*": { "subcaseMS": 16.509 },
+  "webgpu:shader,execution,expression,call,builtin,asinh:f16:*": { "subcaseMS": 59.538 },
   "webgpu:shader,execution,expression,call,builtin,asinh:f32:*": { "subcaseMS": 9.731 },
   "webgpu:shader,execution,expression,call,builtin,atan2:abstract_float:*": { "subcaseMS": 24.705 },
   "webgpu:shader,execution,expression,call,builtin,atan2:f16:*": { "subcaseMS": 32.506 },
@@ -1079,7 +1079,7 @@
   "webgpu:shader,execution,expression,call,builtin,atan:f16:*": { "subcaseMS": 21.106 },
   "webgpu:shader,execution,expression,call,builtin,atan:f32:*": { "subcaseMS": 10.251 },
   "webgpu:shader,execution,expression,call,builtin,atanh:abstract_float:*": { "subcaseMS": 16.807 },
-  "webgpu:shader,execution,expression,call,builtin,atanh:f16:*": { "subcaseMS": 26.507 },
+  "webgpu:shader,execution,expression,call,builtin,atanh:f16:*": { "subcaseMS": 81.619 },
   "webgpu:shader,execution,expression,call,builtin,atanh:f32:*": { "subcaseMS": 12.332 },
   "webgpu:shader,execution,expression,call,builtin,atomics,atomicAdd:add_storage:*": { "subcaseMS": 6.482 },
   "webgpu:shader,execution,expression,call,builtin,atomics,atomicAdd:add_workgroup:*": { "subcaseMS": 7.222 },
@@ -1144,7 +1144,7 @@
   "webgpu:shader,execution,expression,call,builtin,cos:f16:*": { "subcaseMS": 23.905 },
   "webgpu:shader,execution,expression,call,builtin,cos:f32:*": { "subcaseMS": 25.275 },
   "webgpu:shader,execution,expression,call,builtin,cosh:abstract_float:*": { "subcaseMS": 22.909 },
-  "webgpu:shader,execution,expression,call,builtin,cosh:f16:*": { "subcaseMS": 17.409 },
+  "webgpu:shader,execution,expression,call,builtin,cosh:f16:*": { "subcaseMS": 58.475 },
   "webgpu:shader,execution,expression,call,builtin,cosh:f32:*": { "subcaseMS": 9.694 },
   "webgpu:shader,execution,expression,call,builtin,countLeadingZeros:i32:*": { "subcaseMS": 7.494 },
   "webgpu:shader,execution,expression,call,builtin,countLeadingZeros:u32:*": { "subcaseMS": 8.088 },
@@ -1341,7 +1341,7 @@
   "webgpu:shader,execution,expression,call,builtin,sin:f16:*": { "subcaseMS": 8.707 },
   "webgpu:shader,execution,expression,call,builtin,sin:f32:*": { "subcaseMS": 26.826 },
   "webgpu:shader,execution,expression,call,builtin,sinh:abstract_float:*": { "subcaseMS": 22.009 },
-  "webgpu:shader,execution,expression,call,builtin,sinh:f16:*": { "subcaseMS": 23.905 },
+  "webgpu:shader,execution,expression,call,builtin,sinh:f16:*": { "subcaseMS": 58.288 },
   "webgpu:shader,execution,expression,call,builtin,sinh:f32:*": { "subcaseMS": 11.038 },
   "webgpu:shader,execution,expression,call,builtin,smoothstep:abstract_float:*": { "subcaseMS": 23.807 },
   "webgpu:shader,execution,expression,call,builtin,smoothstep:f16:*": { "subcaseMS": 616.457 },
@@ -1358,7 +1358,7 @@
   "webgpu:shader,execution,expression,call,builtin,tan:f16:*": { "subcaseMS": 116.157 },
   "webgpu:shader,execution,expression,call,builtin,tan:f32:*": { "subcaseMS": 13.532 },
   "webgpu:shader,execution,expression,call,builtin,tanh:abstract_float:*": { "subcaseMS": 18.406 },
-  "webgpu:shader,execution,expression,call,builtin,tanh:f16:*": { "subcaseMS": 25.211 },
+  "webgpu:shader,execution,expression,call,builtin,tanh:f16:*": { "subcaseMS": 75.982 },
   "webgpu:shader,execution,expression,call,builtin,tanh:f32:*": { "subcaseMS": 32.719 },
   "webgpu:shader,execution,expression,call,builtin,textureDimension:depth:*": { "subcaseMS": 20.801 },
   "webgpu:shader,execution,expression,call,builtin,textureDimension:external:*": { "subcaseMS": 1.700 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/acosh.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/acosh.spec.ts
index a5781f0cbe10..cc78ce3eee4f 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/acosh.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/acosh.spec.ts
@@ -13,9 +13,9 @@ Note: The result is not mathematically meaningful when e < 1.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { biasedRange, fullF32Range } from '../../../../../util/math.js';
+import { biasedRange, fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -23,17 +23,27 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
-const inputs = [
+const f32_inputs = [
   ...biasedRange(1, 2, 100), // x near 1 can be problematic to implement
   ...fullF32Range(),
 ];
+const f16_inputs = [
+  ...biasedRange(1, 2, 100), // x near 1 can be problematic to implement
+  ...fullF16Range(),
+];
 
 export const d = makeCaseCache('acosh', {
   f32_const: () => {
-    return FP.f32.generateScalarToIntervalCases(inputs, 'finite', ...FP.f32.acoshIntervals);
+    return FP.f32.generateScalarToIntervalCases(f32_inputs, 'finite', ...FP.f32.acoshIntervals);
   },
   f32_non_const: () => {
-    return FP.f32.generateScalarToIntervalCases(inputs, 'unfiltered', ...FP.f32.acoshIntervals);
+    return FP.f32.generateScalarToIntervalCases(f32_inputs, 'unfiltered', ...FP.f32.acoshIntervals);
+  },
+  f16_const: () => {
+    return FP.f16.generateScalarToIntervalCases(f16_inputs, 'finite', ...FP.f16.acoshIntervals);
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarToIntervalCases(f16_inputs, 'unfiltered', ...FP.f16.acoshIntervals);
   },
 });
 
@@ -62,4 +72,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('acosh'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/asinh.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/asinh.spec.ts
index 6acc0ec8621d..9a8384e09034 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/asinh.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/asinh.spec.ts
@@ -12,9 +12,9 @@ Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -26,6 +26,9 @@ export const d = makeCaseCache('asinh', {
   f32: () => {
     return FP.f32.generateScalarToIntervalCases(fullF32Range(), 'unfiltered', FP.f32.asinhInterval);
   },
+  f16: () => {
+    return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'unfiltered', FP.f16.asinhInterval);
+  },
 });
 
 g.test('abstract_float')
@@ -53,4 +56,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('asinh'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/atanh.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/atanh.spec.ts
index 9bffdc1efecf..90f322a7eaa0 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/atanh.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/atanh.spec.ts
@@ -13,9 +13,9 @@ Note: The result is not mathematically meaningful when abs(e) >= 1.
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { kValue } from '../../../../../util/constants.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { biasedRange, fullF32Range } from '../../../../../util/math.js';
+import { biasedRange, fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -23,20 +23,33 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
-const inputs = [
+const f32_inputs = [
   ...biasedRange(kValue.f32.negative.less_than_one, -0.9, 20), // discontinuity at x = -1
   -1,
   ...biasedRange(kValue.f32.positive.less_than_one, 0.9, 20), // discontinuity at x = 1
   1,
   ...fullF32Range(),
 ];
+const f16_inputs = [
+  ...biasedRange(kValue.f16.negative.less_than_one, -0.9, 20), // discontinuity at x = -1
+  -1,
+  ...biasedRange(kValue.f16.positive.less_than_one, 0.9, 20), // discontinuity at x = 1
+  1,
+  ...fullF16Range(),
+];
 
 export const d = makeCaseCache('atanh', {
   f32_const: () => {
-    return FP.f32.generateScalarToIntervalCases(inputs, 'finite', FP.f32.atanhInterval);
+    return FP.f32.generateScalarToIntervalCases(f32_inputs, 'finite', FP.f32.atanhInterval);
   },
   f32_non_const: () => {
-    return FP.f32.generateScalarToIntervalCases(inputs, 'unfiltered', FP.f32.atanhInterval);
+    return FP.f32.generateScalarToIntervalCases(f32_inputs, 'unfiltered', FP.f32.atanhInterval);
+  },
+  f16_const: () => {
+    return FP.f16.generateScalarToIntervalCases(f16_inputs, 'finite', FP.f16.atanhInterval);
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarToIntervalCases(f16_inputs, 'unfiltered', FP.f16.atanhInterval);
   },
 });
 
@@ -65,4 +78,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('atanh'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/cosh.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/cosh.spec.ts
index 00f8ac0e7cfe..37fb961c984d 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/cosh.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/cosh.spec.ts
@@ -9,9 +9,9 @@ Returns the hyperbolic cosine of e. Component-wise when T is a vector
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -26,6 +26,12 @@ export const d = makeCaseCache('cosh', {
   f32_non_const: () => {
     return FP.f32.generateScalarToIntervalCases(fullF32Range(), 'unfiltered', FP.f32.coshInterval);
   },
+  f16_const: () => {
+    return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'finite', FP.f16.coshInterval);
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'unfiltered', FP.f16.coshInterval);
+  },
 });
 
 g.test('abstract_float')
@@ -53,4 +59,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('cosh'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/sinh.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/sinh.spec.ts
index 3504f69eb7dd..d9b93a3dc81c 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/sinh.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/sinh.spec.ts
@@ -9,9 +9,9 @@ Returns the hyperbolic sine of e. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -26,6 +26,12 @@ export const d = makeCaseCache('sinh', {
   f32_non_const: () => {
     return FP.f32.generateScalarToIntervalCases(fullF32Range(), 'unfiltered', FP.f32.sinhInterval);
   },
+  f16_const: () => {
+    return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'finite', FP.f16.sinhInterval);
+  },
+  f16_non_const: () => {
+    return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'unfiltered', FP.f16.sinhInterval);
+  },
 });
 
 g.test('abstract_float')
@@ -53,4 +59,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('sinh'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/tanh.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/tanh.spec.ts
index 5874d9339cf8..3aca5b924bf2 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/tanh.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/tanh.spec.ts
@@ -9,9 +9,9 @@ Returns the hyperbolic tangent of e. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -23,6 +23,9 @@ export const d = makeCaseCache('tanh', {
   f32: () => {
     return FP.f32.generateScalarToIntervalCases(fullF32Range(), 'unfiltered', FP.f32.tanhInterval);
   },
+  f16: () => {
+    return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'unfiltered', FP.f16.tanhInterval);
+  },
 });
 
 g.test('abstract_float')
@@ -50,4 +53,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('tanh'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 615f3b17b63a..b16fe3a8f210 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5261,28 +5261,22 @@ class F16Traits extends FPTraits {
   // Framework - API - Overrides
   public readonly absInterval = this.absIntervalImpl.bind(this);
   public readonly acosInterval = this.acosIntervalImpl.bind(this);
-  public readonly acoshAlternativeInterval = this.unimplementedScalarToInterval.bind(
-    this,
-    'acoshAlternativeInterval'
-  );
-  public readonly acoshPrimaryInterval = this.unimplementedScalarToInterval.bind(
-    this,
-    'acoshPrimaryInterval'
-  );
+  public readonly acoshAlternativeInterval = this.acoshAlternativeIntervalImpl.bind(this);
+  public readonly acoshPrimaryInterval = this.acoshPrimaryIntervalImpl.bind(this);
   public readonly acoshIntervals = [this.acoshAlternativeInterval, this.acoshPrimaryInterval];
   public readonly additionInterval = this.additionIntervalImpl.bind(this);
   public readonly additionMatrixMatrixInterval = this.additionMatrixMatrixIntervalImpl.bind(this);
   public readonly asinInterval = this.asinIntervalImpl.bind(this);
-  public readonly asinhInterval = this.unimplementedScalarToInterval.bind(this, 'asinhInterval');
+  public readonly asinhInterval = this.asinhIntervalImpl.bind(this);
   public readonly atanInterval = this.atanIntervalImpl.bind(this);
   public readonly atan2Interval = this.atan2IntervalImpl.bind(this);
-  public readonly atanhInterval = this.unimplementedScalarToInterval.bind(this, 'atanhInterval');
+  public readonly atanhInterval = this.atanhIntervalImpl.bind(this);
   public readonly ceilInterval = this.ceilIntervalImpl.bind(this);
   public readonly clampMedianInterval = this.clampMedianIntervalImpl.bind(this);
   public readonly clampMinMaxInterval = this.clampMinMaxIntervalImpl.bind(this);
   public readonly clampIntervals = [this.clampMedianInterval, this.clampMinMaxInterval];
   public readonly cosInterval = this.cosIntervalImpl.bind(this);
-  public readonly coshInterval = this.unimplementedScalarToInterval.bind(this, 'coshInterval');
+  public readonly coshInterval = this.coshIntervalImpl.bind(this);
   public readonly crossInterval = this.crossIntervalImpl.bind(this);
   public readonly degreesInterval = this.degreesIntervalImpl.bind(this);
   public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(
@@ -5343,7 +5337,7 @@ class F16Traits extends FPTraits {
   public readonly saturateInterval = this.saturateIntervalImpl.bind(this);
   public readonly signInterval = this.signIntervalImpl.bind(this);
   public readonly sinInterval = this.sinIntervalImpl.bind(this);
-  public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this, 'sinhInterval');
+  public readonly sinhInterval = this.sinhIntervalImpl.bind(this);
   public readonly smoothStepInterval = this.smoothStepIntervalImpl.bind(this);
   public readonly sqrtInterval = this.sqrtIntervalImpl.bind(this);
   public readonly stepInterval = this.stepIntervalImpl.bind(this);
@@ -5352,7 +5346,7 @@ class F16Traits extends FPTraits {
     this
   );
   public readonly tanInterval = this.tanIntervalImpl.bind(this);
-  public readonly tanhInterval = this.unimplementedScalarToInterval.bind(this, 'tanhInterval');
+  public readonly tanhInterval = this.tanhIntervalImpl.bind(this);
   public readonly transposeInterval = this.transposeIntervalImpl.bind(this);
   public readonly truncInterval = this.truncIntervalImpl.bind(this);
 

From 245e263a48d2b217a00c9820539b5cc6afdbbe20 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 27 Sep 2023 14:26:45 +0800
Subject: [PATCH 093/166] wgsl: add f16 builtin execution test for determinant
 (#3013)

This PR add execution tests for f16 built-in determinant.

Issue: #1248, #2522
---
 src/unittests/floating_point.spec.ts          | 214 +++++++++---------
 src/webgpu/listing_meta.json                  |   4 +-
 .../call/builtin/determinant.spec.ts          |  37 ++-
 src/webgpu/util/floating_point.ts             |   5 +-
 4 files changed, 146 insertions(+), 114 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index d4dafc9616dc..1053dc4a6382 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -6405,113 +6405,121 @@ interface MatrixToScalarCase {
   expected: number | IntervalBounds;
 }
 
-g.test('determinantInterval_f32')
-  .paramsSubcasesOnly<MatrixToScalarCase>([
-    // Extreme values, i.e. subnormals, very large magnitudes, and those lead to
-    // non-precise products, are intentionally not tested, since the accuracy of
-    // determinant is restricted to well behaving inputs. Handling all cases
-    // requires ~23! options to be calculated in the 4x4 case, so is not
-    // feasible.
-    {
-      input: [
-        [1, 2],
-        [3, 4],
-      ],
-      expected: -2,
-    },
-    {
-      input: [
-        [-1, 2],
-        [-3, 4],
-      ],
-      expected: 2,
-    },
-    {
-      input: [
-        [11, 22],
-        [33, 44],
-      ],
-      expected: -242,
-    },
-    {
-      input: [
-        [5, 6],
-        [8, 9],
-      ],
-      expected: -3,
-    },
-    {
-      input: [
-        [4, 6],
-        [7, 9],
-      ],
-      expected: -6,
-    },
-    {
-      input: [
-        [4, 5],
-        [7, 8],
-      ],
-      expected: -3,
-    },
-    {
-      input: [
-        [1, 2, 3],
-        [4, 5, 6],
-        [7, 8, 9],
-      ],
-      expected: 0,
-    },
-    {
-      input: [
-        [-1, 2, 3],
-        [-4, 5, 6],
-        [-7, 8, 9],
-      ],
-      expected: 0,
-    },
-    {
-      input: [
-        [11, 22, 33],
-        [44, 55, 66],
-        [77, 88, 99],
-      ],
-      expected: 0,
-    },
-    {
-      input: [
-        [4, 1, -1],
-        [-3, 0, 5],
-        [5, 3, 2],
-      ],
-      expected: -20,
-    },
-    {
-      input: [
-        [1, 2, 3, 4],
-        [5, 6, 7, 8],
-        [9, 10, 11, 12],
-        [13, 14, 15, 16],
-      ],
-      expected: 0,
-    },
-    {
-      input: [
-        [4, 0, 0, 0],
-        [3, 1, -1, 3],
-        [2, -3, 3, 1],
-        [2, 3, 3, 1],
-      ],
-      expected: -240,
-    },
-  ])
+g.test('determinantInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .combineWithParams<MatrixToScalarCase>([
+        // Extreme values, i.e. subnormals, very large magnitudes, and those lead to
+        // non-precise products, are intentionally not tested, since the accuracy of
+        // determinant is restricted to well behaving inputs. Handling all cases
+        // requires ~23! options to be calculated in the 4x4 case, so is not
+        // feasible.
+        {
+          input: [
+            [1, 2],
+            [3, 4],
+          ],
+          expected: -2,
+        },
+        {
+          input: [
+            [-1, 2],
+            [-3, 4],
+          ],
+          expected: 2,
+        },
+        {
+          input: [
+            [11, 22],
+            [33, 44],
+          ],
+          expected: -242,
+        },
+        {
+          input: [
+            [5, 6],
+            [8, 9],
+          ],
+          expected: -3,
+        },
+        {
+          input: [
+            [4, 6],
+            [7, 9],
+          ],
+          expected: -6,
+        },
+        {
+          input: [
+            [4, 5],
+            [7, 8],
+          ],
+          expected: -3,
+        },
+        {
+          input: [
+            [1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9],
+          ],
+          expected: 0,
+        },
+        {
+          input: [
+            [-1, 2, 3],
+            [-4, 5, 6],
+            [-7, 8, 9],
+          ],
+          expected: 0,
+        },
+        {
+          input: [
+            [1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9],
+          ],
+          expected: 0,
+        },
+        {
+          input: [
+            [4, 1, -1],
+            [-3, 0, 5],
+            [5, 3, 2],
+          ],
+          expected: -20,
+        },
+        {
+          input: [
+            [1, 2, 3, 4],
+            [5, 6, 7, 8],
+            [9, 10, 11, 12],
+            [13, 14, 15, 16],
+          ],
+          expected: 0,
+        },
+        {
+          input: [
+            [4, 0, 0, 0],
+            [3, 1, -1, 3],
+            [2, -3, 3, 1],
+            [2, 3, 3, 1],
+          ],
+          expected: -240,
+        },
+      ])
+  )
   .fn(t => {
     const input = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.determinantInterval(input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.determinantInterval(input);
     t.expect(
       objectEquals(expected, got),
-      `f32.determinantInterval([${JSON.stringify(input)}]) returned '${got}. Expected '${expected}'`
+      `${t.params.trait}.determinantInterval([${JSON.stringify(
+        input
+      )}]) returned '${got}. Expected '${expected}'`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 76ada42b493c..d99c5c95b05e 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -285,8 +285,8 @@
   "webgpu:api,validation,capability_checks,limits,maxColorAttachments:beginRenderPass,at_over:*": { "subcaseMS": 10.320 },
   "webgpu:api,validation,capability_checks,limits,maxColorAttachments:createRenderBundle,at_over:*": { "subcaseMS": 12.681 },
   "webgpu:api,validation,capability_checks,limits,maxColorAttachments:createRenderPipeline,at_over:*": { "subcaseMS": 10.450 },
-  "webgpu:api,validation,capability_checks,limits,maxColorAttachments:validate,maxColorAttachmentBytesPerSample:*": { "subcaseMS": 1.101 },
   "webgpu:api,validation,capability_checks,limits,maxColorAttachments:validate,kMaxColorAttachmentsToTest:*": { "subcaseMS": 1.101 },
+  "webgpu:api,validation,capability_checks,limits,maxColorAttachments:validate,maxColorAttachmentBytesPerSample:*": { "subcaseMS": 1.101 },
   "webgpu:api,validation,capability_checks,limits,maxComputeInvocationsPerWorkgroup:createComputePipeline,at_over:*": { "subcaseMS": 13.735 },
   "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeX:createComputePipeline,at_over:*": { "subcaseMS": 14.465 },
   "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeY:createComputePipeline,at_over:*": { "subcaseMS": 14.131 },
@@ -1159,7 +1159,7 @@
   "webgpu:shader,execution,expression,call,builtin,degrees:f16:*": { "subcaseMS": 29.308 },
   "webgpu:shader,execution,expression,call,builtin,degrees:f32:*": { "subcaseMS": 79.525 },
   "webgpu:shader,execution,expression,call,builtin,determinant:abstract_float:*": { "subcaseMS": 15.306 },
-  "webgpu:shader,execution,expression,call,builtin,determinant:f16:*": { "subcaseMS": 22.806 },
+  "webgpu:shader,execution,expression,call,builtin,determinant:f16:*": { "subcaseMS": 37.192 },
   "webgpu:shader,execution,expression,call,builtin,determinant:f32:*": { "subcaseMS": 10.742 },
   "webgpu:shader,execution,expression,call,builtin,distance:abstract_float:*": { "subcaseMS": 14.503 },
   "webgpu:shader,execution,expression,call,builtin,distance:f16:*": { "subcaseMS": 6675.626 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/determinant.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/determinant.spec.ts
index 466d1dc02276..f08f4f0b6b25 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/determinant.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/determinant.spec.ts
@@ -8,7 +8,7 @@ Returns the determinant of e.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeMat } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16, TypeMat } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
@@ -26,7 +26,7 @@ export const g = makeTestGroup(GPUTest);
 // quadroot, but using the tighter 4x4 limits for all cases for simplicity.
 const kDeterminantValues = [-38, -10, -5, -1, 0, 1, 5, 10, 38];
 
-const kDeterminantMatrixF32Values = {
+const kDeterminantMatrixValues = {
   2: kDeterminantValues.map((f, idx) => [
     [idx % 4 === 0 ? f : idx, idx % 4 === 1 ? f : -idx],
     [idx % 4 === 2 ? f : -idx, idx % 4 === 3 ? f : idx],
@@ -70,7 +70,7 @@ const f32_cases = ([2, 3, 4] as const)
     ([true, false] as const).map(nonConst => ({
       [`f32_mat${dim}x${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
         return FP.f32.generateMatrixToScalarCases(
-          kDeterminantMatrixF32Values[dim],
+          kDeterminantMatrixValues[dim],
           nonConst ? 'unfiltered' : 'finite',
           FP.f32.determinantInterval
         );
@@ -79,8 +79,24 @@ const f32_cases = ([2, 3, 4] as const)
   )
   .reduce((a, b) => ({ ...a, ...b }), {});
 
+// Cases: f16_matDxD_[non_]const
+const f16_cases = ([2, 3, 4] as const)
+  .flatMap(dim =>
+    ([true, false] as const).map(nonConst => ({
+      [`f16_mat${dim}x${dim}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateMatrixToScalarCases(
+          kDeterminantMatrixValues[dim],
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f16.determinantInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('determinant', {
   ...f32_cases,
+  ...f16_cases,
 });
 
 g.test('abstract_float')
@@ -106,5 +122,16 @@ g.test('f32')
 g.test('f16')
   .specURL('https://www.w3.org/TR/WGSL/#matrix-builtin-functions')
   .desc(`f16 tests`)
-  .params(u => u.combine('inputSource', allInputSources).combine('dimension', [2, 3, 4] as const))
-  .unimplemented();
+  .params(u => u.combine('inputSource', allInputSources).combine('dim', [2, 3, 4] as const))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(
+      t.params.inputSource === 'const'
+        ? `f16_mat${dim}x${dim}_const`
+        : `f16_mat${dim}x${dim}_non_const`
+    );
+    await run(t, builtin('determinant'), [TypeMat(dim, dim, TypeF16)], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index b16fe3a8f210..79941eead1bb 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5279,10 +5279,7 @@ class F16Traits extends FPTraits {
   public readonly coshInterval = this.coshIntervalImpl.bind(this);
   public readonly crossInterval = this.crossIntervalImpl.bind(this);
   public readonly degreesInterval = this.degreesIntervalImpl.bind(this);
-  public readonly determinantInterval = this.unimplementedMatrixToInterval.bind(
-    this,
-    'determinantInterval'
-  );
+  public readonly determinantInterval = this.determinantIntervalImpl.bind(this);
   public readonly distanceInterval = this.distanceIntervalImpl.bind(this);
   public readonly divisionInterval = this.divisionIntervalImpl.bind(this);
   public readonly dotInterval = this.dotIntervalImpl.bind(this);

From 43a704e4adf323a4983566d7c5f6c76972dcb7bc Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 27 Sep 2023 14:33:33 +0800
Subject: [PATCH 094/166] wgsl: add f16 builtin execution test for reflect and
 refract (#3014)

This PR add execution tests for f16 built-in reflect and refract.

Issue: #1248, #2579, #2580
---
 src/unittests/floating_point.spec.ts          | 263 +++++++++++-------
 src/webgpu/listing_meta.json                  |  24 +-
 .../expression/call/builtin/reflect.spec.ts   | 153 ++++++----
 .../expression/call/builtin/refract.spec.ts   | 168 ++++++-----
 src/webgpu/util/floating_point.ts             |   9 +-
 5 files changed, 385 insertions(+), 232 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 1053dc4a6382..17dead2f5520 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -6339,62 +6339,89 @@ g.test('crossInterval')
     );
   });
 
-g.test('reflectInterval_f32')
-  .paramsSubcasesOnly<VectorPairToVectorCase>(
-    // prettier-ignore
-    [
-      // vec2s
-      { input: [[1.0, 0.0], [1.0, 0.0]], expected: [-1.0, 0.0] },
-      { input: [[1.0, 0.0], [0.0, 1.0]], expected: [1.0, 0.0] },
-      { input: [[0.0, 1.0], [0.0, 1.0]], expected: [0.0, -1.0] },
-      { input: [[0.0, 1.0], [1.0, 0.0]], expected: [0.0, 1.0] },
-      { input: [[1.0, 1.0], [1.0, 1.0]], expected: [-3.0, -3.0] },
-      { input: [[-1.0, -1.0], [1.0, 1.0]], expected: [3.0, 3.0] },
-      { input: [[0.1, 0.1], [1.0, 1.0]], expected: [[reinterpretU32AsF32(0xbe99999a), reinterpretU32AsF32(0xbe999998)], [reinterpretU32AsF32(0xbe99999a), reinterpretU32AsF32(0xbe999998)]] },  // [~-0.3, ~-0.3]
-      { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max], [1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0]
-
-      // vec3s
-      { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [-1.0, 0.0, 0.0] },
-      { input: [[0.0, 1.0, 0.0], [1.0, 0.0, 0.0]], expected: [0.0, 1.0, 0.0] },
-      { input: [[0.0, 0.0, 1.0], [1.0, 0.0, 0.0]], expected: [0.0, 0.0, 1.0] },
-      { input: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], expected: [1.0, 0.0, 0.0] },
-      { input: [[1.0, 0.0, 0.0], [0.0, 0.0, 1.0]], expected: [1.0, 0.0, 0.0] },
-      { input: [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], expected: [-5.0, -5.0, -5.0] },
-      { input: [[-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], expected: [5.0, 5.0, 5.0] },
-      { input: [[0.1, 0.1, 0.1], [1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0xbf000001), reinterpretU32AsF32(0xbefffffe)], [reinterpretU32AsF32(0xbf000001), reinterpretU32AsF32(0xbefffffe)], [reinterpretU32AsF32(0xbf000001), reinterpretU32AsF32(0xbefffffe)]] },  // [~-0.5, ~-0.5, ~-0.5]
-      { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max, 0.0], [1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0, ~0.0]
-
-      // vec4s
-      { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [-1.0, 0.0, 0.0, 0.0] },
-      { input: [[0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [0.0, 1.0, 0.0, 0.0] },
-      { input: [[0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [0.0, 0.0, 1.0, 0.0] },
-      { input: [[0.0, 0.0, 0.0, 1.0], [1.0, 0.0, 0.0, 0.0]], expected: [0.0, 0.0, 0.0, 1.0] },
-      { input: [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], expected: [1.0, 0.0, 0.0, 0.0] },
-      { input: [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]], expected: [1.0, 0.0, 0.0, 0.0] },
-      { input: [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]], expected: [1.0, 0.0, 0.0, 0.0] },
-      { input: [[-1.0, -1.0, -1.0, -1.0], [1.0, 1.0, 1.0, 1.0]], expected: [7.0, 7.0, 7.0, 7.0] },
-      { input: [[0.1, 0.1, 0.1, 0.1], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)], [reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)], [reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)], [reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)]] },  // [~-0.7, ~-0.7, ~-0.7, ~-0.7]
-      { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0, ~0.0, ~0.0]
-
-      // Test that dot going OOB bounds in the intermediate calculations propagates
-      { input: [[kValue.f32.positive.nearest_max, kValue.f32.positive.max, kValue.f32.negative.min], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-      { input: [[kValue.f32.positive.nearest_max, kValue.f32.negative.min, kValue.f32.positive.max], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-      { input: [[kValue.f32.positive.max, kValue.f32.positive.nearest_max, kValue.f32.negative.min], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-      { input: [[kValue.f32.negative.min, kValue.f32.positive.nearest_max, kValue.f32.positive.max], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-      { input: [[kValue.f32.positive.max, kValue.f32.negative.min, kValue.f32.positive.nearest_max], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-      { input: [[kValue.f32.negative.min, kValue.f32.positive.max, kValue.f32.positive.nearest_max], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-
-      // Test that post-dot going OOB propagates
-      { input: [[kValue.f32.positive.max, 1.0, 2.0, 3.0], [-1.0, kValue.f32.positive.max, -2.0, -3.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-    ]
+// prettier-ignore
+const kReflectIntervalCases = {
+  f32: [
+    // vec2s
+    { input: [[0.1, 0.1], [1.0, 1.0]], expected: [[reinterpretU32AsF32(0xbe99999a), reinterpretU32AsF32(0xbe999998)], [reinterpretU32AsF32(0xbe99999a), reinterpretU32AsF32(0xbe999998)]] },  // [~-0.3, ~-0.3]
+    { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max], [1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0]
+    // vec3s
+    { input: [[0.1, 0.1, 0.1], [1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0xbf000001), reinterpretU32AsF32(0xbefffffe)], [reinterpretU32AsF32(0xbf000001), reinterpretU32AsF32(0xbefffffe)], [reinterpretU32AsF32(0xbf000001), reinterpretU32AsF32(0xbefffffe)]] },  // [~-0.5, ~-0.5, ~-0.5]
+    { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max, 0.0], [1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0, ~0.0]
+    // vec4s
+    { input: [[0.1, 0.1, 0.1, 0.1], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)], [reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)], [reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)], [reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)]] },  // [~-0.7, ~-0.7, ~-0.7, ~-0.7]
+    { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0, ~0.0, ~0.0]
+  ] as VectorPairToVectorCase[],
+  f16: [
+    // vec2s
+    { input: [[0.1, 0.1], [1.0, 1.0]], expected: [[reinterpretU16AsF16(0xb4ce), reinterpretU16AsF16(0xb4cc)], [reinterpretU16AsF16(0xb4ce), reinterpretU16AsF16(0xb4cc)]] },  // [~-0.3, ~-0.3]
+    { input: [[kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.max], [1.0, 1.0]], expected: [[reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0401)], [reinterpretU16AsF16(0x87ff), reinterpretU16AsF16(0x0002)]] },  // [~0.0, ~0.0]
+    // vec3s
+    { input: [[0.1, 0.1, 0.1], [1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0xb802), reinterpretU16AsF16(0xb7fe)], [reinterpretU16AsF16(0xb802), reinterpretU16AsF16(0xb7fe)], [reinterpretU16AsF16(0xb802), reinterpretU16AsF16(0xb7fe)]] },  // [~-0.5, ~-0.5, ~-0.5]
+    { input: [[kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.max, 0.0], [1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0401)], [reinterpretU16AsF16(0x87ff), reinterpretU16AsF16(0x0002)], [reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0002)]] },  // [~0.0, ~0.0, ~0.0]
+    // vec4s
+    { input: [[0.1, 0.1, 0.1, 0.1], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0xb99c), reinterpretU16AsF16(0xb998)], [reinterpretU16AsF16(0xb99c), reinterpretU16AsF16(0xb998)], [reinterpretU16AsF16(0xb99c), reinterpretU16AsF16(0xb998)], [reinterpretU16AsF16(0xb99c), reinterpretU16AsF16(0xb998)]] },  // [~-0.7, ~-0.7, ~-0.7, ~-0.7]
+    { input: [[kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.max, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0401)], [reinterpretU16AsF16(0x87ff), reinterpretU16AsF16(0x0002)], [reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0002)], [reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0002)]] },  // [~0.0, ~0.0, ~0.0, ~0.0]
+  ] as VectorPairToVectorCase[],
+} as const;
+
+g.test('reflectInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<VectorPairToVectorCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          ...kReflectIntervalCases[p.trait],
+
+          // vec2s
+          { input: [[1.0, 0.0], [1.0, 0.0]], expected: [-1.0, 0.0] },
+          { input: [[1.0, 0.0], [0.0, 1.0]], expected: [1.0, 0.0] },
+          { input: [[0.0, 1.0], [0.0, 1.0]], expected: [0.0, -1.0] },
+          { input: [[0.0, 1.0], [1.0, 0.0]], expected: [0.0, 1.0] },
+          { input: [[1.0, 1.0], [1.0, 1.0]], expected: [-3.0, -3.0] },
+          { input: [[-1.0, -1.0], [1.0, 1.0]], expected: [3.0, 3.0] },
+          // vec3s
+          { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [-1.0, 0.0, 0.0] },
+          { input: [[0.0, 1.0, 0.0], [1.0, 0.0, 0.0]], expected: [0.0, 1.0, 0.0] },
+          { input: [[0.0, 0.0, 1.0], [1.0, 0.0, 0.0]], expected: [0.0, 0.0, 1.0] },
+          { input: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], expected: [1.0, 0.0, 0.0] },
+          { input: [[1.0, 0.0, 0.0], [0.0, 0.0, 1.0]], expected: [1.0, 0.0, 0.0] },
+          { input: [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], expected: [-5.0, -5.0, -5.0] },
+          { input: [[-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], expected: [5.0, 5.0, 5.0] },
+          // vec4s
+          { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [-1.0, 0.0, 0.0, 0.0] },
+          { input: [[0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [0.0, 1.0, 0.0, 0.0] },
+          { input: [[0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [0.0, 0.0, 1.0, 0.0] },
+          { input: [[0.0, 0.0, 0.0, 1.0], [1.0, 0.0, 0.0, 0.0]], expected: [0.0, 0.0, 0.0, 1.0] },
+          { input: [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], expected: [1.0, 0.0, 0.0, 0.0] },
+          { input: [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]], expected: [1.0, 0.0, 0.0, 0.0] },
+          { input: [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]], expected: [1.0, 0.0, 0.0, 0.0] },
+          { input: [[-1.0, -1.0, -1.0, -1.0], [1.0, 1.0, 1.0, 1.0]], expected: [7.0, 7.0, 7.0, 7.0] },
+          // Test that dot going OOB bounds in the intermediate calculations propagates
+          { input: [[constants.positive.nearest_max, constants.positive.max, constants.negative.min], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+          { input: [[constants.positive.nearest_max, constants.negative.min, constants.positive.max], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+          { input: [[constants.positive.max, constants.positive.nearest_max, constants.negative.min], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+          { input: [[constants.negative.min, constants.positive.nearest_max, constants.positive.max], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+          { input: [[constants.positive.max, constants.negative.min, constants.positive.nearest_max], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+          { input: [[constants.negative.min, constants.positive.max, constants.positive.nearest_max], [1.0, 1.0, 1.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+
+          // Test that post-dot going OOB propagates
+          { input: [[constants.positive.max, 1.0, 2.0, 3.0], [-1.0, constants.positive.max, -2.0, -3.0]], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+        ];
+      })
   )
   .fn(t => {
     const [x, y] = t.params.input;
-    const expected = FP.f32.toVector(t.params.expected);
-    const got = FP.f32.reflectInterval(x, y);
+    const trait = FP[t.params.trait];
+    const expected = trait.toVector(t.params.expected);
+    const got = trait.reflectInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `f32.reflectInterval([${x}], [${y}]) returned ${JSON.stringify(
+      `${t.params.trait}.reflectInterval([${x}], [${y}]) returned ${JSON.stringify(
         got
       )}. Expected ${JSON.stringify(expected)}`
     );
@@ -8136,60 +8163,98 @@ interface RefractCase {
 // Scope for refractInterval tests so that they can have constants for magic
 // numbers that don't pollute the global namespace or have unwieldy long names.
 {
-  const kNegativeOneBounds: IntervalBounds = [
-    reinterpretU64AsF64(0xbff0_0000_c000_0000n),
-    reinterpretU64AsF64(0xbfef_ffff_4000_0000n),
-  ];
-
-  g.test('refractInterval_f32')
-    .paramsSubcasesOnly<RefractCase>(
-      // Some of these are hard coded, since the error intervals are difficult
-      // to express in a closed human-readable form due to the inherited nature
-      // of the errors.
+  const kNegativeOneBounds = {
+    f32: [
+      reinterpretU64AsF64(0xbff0_0000_c000_0000n),
+      reinterpretU64AsF64(0xbfef_ffff_4000_0000n),
+    ] as IntervalBounds,
+    f16: [reinterpretU16AsF16(0xbc06), reinterpretU16AsF16(0xbbfa)] as IntervalBounds,
+  } as const;
 
-      // prettier-ignore
-      [
-        // k < 0
-        { input: [[1, 1], [0.1, 0], 10], expected: [0, 0] },
-
-        // k contains 0
-        { input: [[1, 1], [0.1, 0], 1.005038], expected: [kUnboundedBounds, kUnboundedBounds] },
-
-        // k > 0
-        // vec2
-        { input: [[1, 1], [1, 0], 1], expected: [kNegativeOneBounds, 1] },
-        { input: [[1, -2], [3, 4], 5], expected: [[reinterpretU32AsF32(0x40ce87a4), reinterpretU32AsF32(0x40ce8840)],  // ~6.454...
-            [reinterpretU32AsF32(0xc100fae8), reinterpretU32AsF32(0xc100fa80)]] },  // ~-8.061...
-
-        // vec3
-        { input: [[1, 1, 1], [1, 0, 0], 1], expected: [kNegativeOneBounds, 1, 1] },
-        { input: [[1, -2, 3], [-4, 5, -6], 7], expected: [[reinterpretU32AsF32(0x40d24480), reinterpretU32AsF32(0x40d24c00)],  // ~6.571...
-            [reinterpretU32AsF32(0xc1576f80), reinterpretU32AsF32(0xc1576ad0)],  // ~-13.464...
-            [reinterpretU32AsF32(0x41a2d9b0), reinterpretU32AsF32(0x41a2dc80)]] },  // ~20.356...
-
-        // vec4
-        { input: [[1, 1, 1, 1], [1, 0, 0, 0], 1], expected: [kNegativeOneBounds, 1, 1, 1] },
-        { input: [[1, -2, 3,-4], [-5, 6, -7, 8], 9], expected: [[reinterpretU32AsF32(0x410ae480), reinterpretU32AsF32(0x410af240)],  // ~8.680...
-            [reinterpretU32AsF32(0xc18cf7c0), reinterpretU32AsF32(0xc18cef80)],  // ~-17.620...
-            [reinterpretU32AsF32(0x41d46cc0), reinterpretU32AsF32(0x41d47660)],  // ~26.553...
-            [reinterpretU32AsF32(0xc20dfa80), reinterpretU32AsF32(0xc20df500)]] },  // ~-35.494...
-
-        // Test that dot going OOB bounds in the intermediate calculations propagates
-        { input: [[kValue.f32.positive.nearest_max, kValue.f32.positive.max, kValue.f32.negative.min], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-        { input: [[kValue.f32.positive.nearest_max, kValue.f32.negative.min, kValue.f32.positive.max], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-        { input: [[kValue.f32.positive.max, kValue.f32.positive.nearest_max, kValue.f32.negative.min], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-        { input: [[kValue.f32.negative.min, kValue.f32.positive.nearest_max, kValue.f32.positive.max], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-        { input: [[kValue.f32.positive.max, kValue.f32.negative.min, kValue.f32.positive.nearest_max], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-        { input: [[kValue.f32.negative.min, kValue.f32.positive.max, kValue.f32.positive.nearest_max], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
-      ]
+  // prettier-ignore
+  const kRefractIntervalCases = {
+    f32: [
+      // k > 0
+      // vec2
+      { input: [[1, -2], [3, 4], 5], expected: [[reinterpretU32AsF32(0x40ce87a4), reinterpretU32AsF32(0x40ce8840)],  // ~6.454...
+          [reinterpretU32AsF32(0xc100fae8), reinterpretU32AsF32(0xc100fa80)]] },  // ~-8.061...
+      // vec3
+      { input: [[1, -2, 3], [-4, 5, -6], 7], expected: [[reinterpretU32AsF32(0x40d24480), reinterpretU32AsF32(0x40d24c00)],  // ~6.571...
+          [reinterpretU32AsF32(0xc1576f80), reinterpretU32AsF32(0xc1576ad0)],  // ~-13.464...
+          [reinterpretU32AsF32(0x41a2d9b0), reinterpretU32AsF32(0x41a2dc80)]] },  // ~20.356...
+      // vec4
+      { input: [[1, -2, 3, -4], [-5, 6, -7, 8], 9], expected: [[reinterpretU32AsF32(0x410ae480), reinterpretU32AsF32(0x410af240)],  // ~8.680...
+          [reinterpretU32AsF32(0xc18cf7c0), reinterpretU32AsF32(0xc18cef80)],  // ~-17.620...
+          [reinterpretU32AsF32(0x41d46cc0), reinterpretU32AsF32(0x41d47660)],  // ~26.553...
+          [reinterpretU32AsF32(0xc20dfa80), reinterpretU32AsF32(0xc20df500)]] },  // ~-35.494...
+    ] as RefractCase[],
+    f16: [
+      // k > 0
+      // vec2
+      { input: [[1, -2], [3, 4], 5], expected: [[reinterpretU16AsF16(0x4620), reinterpretU16AsF16(0x46bc)],  // ~6.454...
+          [reinterpretU16AsF16(0xc840), reinterpretU16AsF16(0xc7b0)]] },  // ~-8.061...
+      // vec3
+      { input: [[1, -2, 3], [-4, 5, -6], 7], expected: [[reinterpretU16AsF16(0x4100), reinterpretU16AsF16(0x4940)],  // ~6.571...
+      [reinterpretU16AsF16(0xcc98), reinterpretU16AsF16(0xc830)],  // ~-13.464...
+      [reinterpretU16AsF16(0x4b20), reinterpretU16AsF16(0x4e90)]] },  // ~20.356...
+      // vec4
+      // x = [1, -2, 3, -4], y = [-5, 6, -7, 8], z = 9,
+      // dot(y, x) = -71, k = 1.0 - 9 * 9 * (1.0 - 71 * 71) = 408241 overflow f16.
+      { input: [[1, -2, 3, -4], [-5, 6, -7, 8], 9], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+      // x = [1, -2, 3, -4], y = [-5, 4, -3, 2], z = 2.5,
+      // dot(y, x) = -30, k = 1.0 - 2.5 * 2.5 * (1.0 - 30 * 30) = 5619.75.
+      // a = z * dot(y, x) + sqrt(k) = ~-0.035, result is about z * x - a * y = [~2.325, ~-4.86, ~7.4025, ~-9.93]
+      { input: [[1, -2, 3, -4], [-5, 4, -3, 2], 2.5], expected: [[reinterpretU16AsF16(0x3900), reinterpretU16AsF16(0x4410)],  // ~2.325
+          [reinterpretU16AsF16(0xc640), reinterpretU16AsF16(0xc300)],  // ~-4.86
+          [reinterpretU16AsF16(0x4660), reinterpretU16AsF16(0x4838)],  // ~7.4025
+          [reinterpretU16AsF16(0xc950), reinterpretU16AsF16(0xc8a0)]] },  // ~-9.93
+    ] as RefractCase[],
+  } as const;
+
+  g.test('refractInterval')
+    .params(u =>
+      u
+        .combine('trait', ['f32', 'f16'] as const)
+        .beginSubcases()
+        .expandWithParams<RefractCase>(p => {
+          const trait = FP[p.trait];
+          const constants = trait.constants();
+          // prettier-ignore
+          return [
+            ...kRefractIntervalCases[p.trait],
+
+            // k < 0
+            { input: [[1, 1], [0.1, 0], 10], expected: [0, 0] },
+
+            // k contains 0
+            { input: [[1, 1], [0.1, 0], 1.005038], expected: [kUnboundedBounds, kUnboundedBounds] },
+
+            // k > 0
+            // vec2
+            { input: [[1, 1], [1, 0], 1], expected: [kNegativeOneBounds[p.trait], 1] },
+            // vec3
+            { input: [[1, 1, 1], [1, 0, 0], 1], expected: [kNegativeOneBounds[p.trait], 1, 1] },
+            // vec4
+            { input: [[1, 1, 1, 1], [1, 0, 0, 0], 1], expected: [kNegativeOneBounds[p.trait], 1, 1, 1] },
+
+            // Test that dot going OOB bounds in the intermediate calculations propagates
+            { input: [[constants.positive.nearest_max, constants.positive.max, constants.negative.min], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+            { input: [[constants.positive.nearest_max, constants.negative.min, constants.positive.max], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+            { input: [[constants.positive.max, constants.positive.nearest_max, constants.negative.min], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+            { input: [[constants.negative.min, constants.positive.nearest_max, constants.positive.max], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+            { input: [[constants.positive.max, constants.negative.min, constants.positive.nearest_max], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+            { input: [[constants.negative.min, constants.positive.max, constants.positive.nearest_max], [1.0, 1.0, 1.0], 1], expected: [kUnboundedBounds, kUnboundedBounds, kUnboundedBounds] },
+          ];
+        })
     )
     .fn(t => {
       const [i, s, r] = t.params.input;
-      const expected = FP.f32.toVector(t.params.expected);
-      const got = FP.f32.refractInterval(i, s, r);
+      const trait = FP[t.params.trait];
+      const expected = trait.toVector(t.params.expected);
+      const got = trait.refractInterval(i, s, r);
       t.expect(
         objectEquals(expected, got),
-        `refractIntervals([${i}], [${s}], ${r}) returned [${got}]. Expected [${expected}]`
+        `${t.params.trait}.refractIntervals([${i}], [${s}], ${r}) returned [${got}]. Expected [${expected}]`
       );
     });
 }
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index d99c5c95b05e..befb1807aea8 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1312,16 +1312,20 @@
   "webgpu:shader,execution,expression,call,builtin,radians:abstract_float:*": { "subcaseMS": 492.827 },
   "webgpu:shader,execution,expression,call,builtin,radians:f16:*": { "subcaseMS": 18.707 },
   "webgpu:shader,execution,expression,call,builtin,radians:f32:*": { "subcaseMS": 74.432 },
-  "webgpu:shader,execution,expression,call,builtin,reflect:abstract_float:*": { "subcaseMS": 20.405 },
-  "webgpu:shader,execution,expression,call,builtin,reflect:f16:*": { "subcaseMS": 15.806 },
-  "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec2:*": { "subcaseMS": 116.425 },
-  "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec3:*": { "subcaseMS": 14.575 },
-  "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec4:*": { "subcaseMS": 14.601 },
-  "webgpu:shader,execution,expression,call,builtin,refract:abstract_float:*": { "subcaseMS": 21.305 },
-  "webgpu:shader,execution,expression,call,builtin,refract:f16:*": { "subcaseMS": 31.104 },
-  "webgpu:shader,execution,expression,call,builtin,refract:f32_vec2:*": { "subcaseMS": 3235.401 },
-  "webgpu:shader,execution,expression,call,builtin,refract:f32_vec3:*": { "subcaseMS": 228.150 },
-  "webgpu:shader,execution,expression,call,builtin,refract:f32_vec4:*": { "subcaseMS": 235.700 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:abstract_float:*": { "subcaseMS": 47.108 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f16_vec2:*": { "subcaseMS": 76.975 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f16_vec3:*": { "subcaseMS": 69.451 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f16_vec4:*": { "subcaseMS": 79.826 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec2:*": { "subcaseMS": 1182.226 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec3:*": { "subcaseMS": 56.326 },
+  "webgpu:shader,execution,expression,call,builtin,reflect:f32_vec4:*": { "subcaseMS": 65.250 },
+  "webgpu:shader,execution,expression,call,builtin,refract:abstract_float:*": { "subcaseMS": 114.404 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f16_vec2:*": { "subcaseMS": 536.225 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f16_vec3:*": { "subcaseMS": 627.450 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f16_vec4:*": { "subcaseMS": 699.801 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f32_vec2:*": { "subcaseMS": 33934.000 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f32_vec3:*": { "subcaseMS": 503.976 },
+  "webgpu:shader,execution,expression,call,builtin,refract:f32_vec4:*": { "subcaseMS": 610.150 },
   "webgpu:shader,execution,expression,call,builtin,reverseBits:i32:*": { "subcaseMS": 9.594 },
   "webgpu:shader,execution,expression,call,builtin,reverseBits:u32:*": { "subcaseMS": 7.969 },
   "webgpu:shader,execution,expression,call,builtin,round:abstract_float:*": { "subcaseMS": 19.408 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/reflect.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/reflect.spec.ts
index 128240cc580f..2614c4e6864f 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/reflect.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/reflect.spec.ts
@@ -9,9 +9,9 @@ direction e1-2*dot(e2,e1)*e2.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { sparseVectorF32Range } from '../../../../../util/math.js';
+import { sparseVectorF32Range, sparseVectorF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -19,55 +19,41 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
+// Cases: f32_vecN_[non_]const
+const f32_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f32_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f32.generateVectorPairToVectorCases(
+          sparseVectorF32Range(n),
+          sparseVectorF32Range(n),
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f32.reflectInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_vecN_[non_]const
+const f16_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f16_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return FP.f16.generateVectorPairToVectorCases(
+          sparseVectorF16Range(n),
+          sparseVectorF16Range(n),
+          nonConst ? 'unfiltered' : 'finite',
+          FP.f16.reflectInterval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('reflect', {
-  f32_vec2_const: () => {
-    return FP.f32.generateVectorPairToVectorCases(
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      'finite',
-      FP.f32.reflectInterval
-    );
-  },
-  f32_vec2_non_const: () => {
-    return FP.f32.generateVectorPairToVectorCases(
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      'unfiltered',
-      FP.f32.reflectInterval
-    );
-  },
-  f32_vec3_const: () => {
-    return FP.f32.generateVectorPairToVectorCases(
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      'finite',
-      FP.f32.reflectInterval
-    );
-  },
-  f32_vec3_non_const: () => {
-    return FP.f32.generateVectorPairToVectorCases(
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      'unfiltered',
-      FP.f32.reflectInterval
-    );
-  },
-  f32_vec4_const: () => {
-    return FP.f32.generateVectorPairToVectorCases(
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      'finite',
-      FP.f32.reflectInterval
-    );
-  },
-  f32_vec4_non_const: () => {
-    return FP.f32.generateVectorPairToVectorCases(
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      'unfiltered',
-      FP.f32.reflectInterval
-    );
-  },
+  ...f32_vec_cases,
+  ...f16_vec_cases,
 });
 
 g.test('abstract_float')
@@ -130,8 +116,65 @@ g.test('f32_vec4')
     );
   });
 
-g.test('f16')
-  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
-  .desc(`f16 tests`)
-  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
-  .unimplemented();
+g.test('f16_vec2')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec2s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec2_const' : 'f16_vec2_non_const'
+    );
+    await run(
+      t,
+      builtin('reflect'),
+      [TypeVec(2, TypeF16), TypeVec(2, TypeF16)],
+      TypeVec(2, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec3')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec3s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec3_const' : 'f16_vec3_non_const'
+    );
+    await run(
+      t,
+      builtin('reflect'),
+      [TypeVec(3, TypeF16), TypeVec(3, TypeF16)],
+      TypeVec(3, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec4')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec4s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec4_const' : 'f16_vec4_non_const'
+    );
+    await run(
+      t,
+      builtin('reflect'),
+      [TypeVec(4, TypeF16), TypeVec(4, TypeF16)],
+      TypeVec(4, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
index c52d169c9552..9cc726276b42 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
@@ -12,9 +12,14 @@ vector e3*e1- (e3* dot(e2,e1) + sqrt(k)) *e2.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { toVector, TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { toVector, TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
 import { FP, FPKind } from '../../../../../util/floating_point.js';
-import { sparseVectorF32Range, sparseF32Range } from '../../../../../util/math.js';
+import {
+  sparseVectorF32Range,
+  sparseVectorF16Range,
+  sparseF32Range,
+  sparseF16Range,
+} from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, Case, IntervalFilter, run } from '../../expression.js';
 
@@ -77,68 +82,50 @@ function generateCases(
     .flatMap(i => {
       return param_ss.flatMap(s => {
         return param_rs.map(r => {
-          return makeCase('f32', i, s, r, check);
+          return makeCase(kind, i, s, r, check);
         });
       });
     })
     .filter((c): c is Case => c !== undefined);
 }
 
+// Cases: f32_vecN_[non_]const
+const f32_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f32_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return generateCases(
+          'f32',
+          sparseVectorF32Range(n),
+          sparseVectorF32Range(n),
+          sparseF32Range(),
+          nonConst ? 'unfiltered' : 'finite'
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_vecN_[non_]const
+const f16_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f16_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return generateCases(
+          'f16',
+          sparseVectorF16Range(n),
+          sparseVectorF16Range(n),
+          sparseF16Range(),
+          nonConst ? 'unfiltered' : 'finite'
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('refract', {
-  f32_vec2_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'finite'
-    );
-  },
-  f32_vec2_non_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      sparseF32Range(),
-      'unfiltered'
-    );
-  },
-  f32_vec3_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'finite'
-    );
-  },
-  f32_vec3_non_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      sparseF32Range(),
-      'unfiltered'
-    );
-  },
-  f32_vec4_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'finite'
-    );
-  },
-  f32_vec4_non_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      sparseF32Range(),
-      'unfiltered'
-    );
-  },
+  ...f32_vec_cases,
+  ...f16_vec_cases,
 });
 
 g.test('abstract_float')
@@ -201,8 +188,65 @@ g.test('f32_vec4')
     );
   });
 
-g.test('f16')
-  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
-  .desc(`f16 tests`)
-  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
-  .unimplemented();
+g.test('f16_vec2')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec2s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec2_const' : 'f16_vec2_non_const'
+    );
+    await run(
+      t,
+      builtin('refract'),
+      [TypeVec(2, TypeF16), TypeVec(2, TypeF16), TypeF16],
+      TypeVec(2, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec3')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec3s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec3_const' : 'f16_vec3_non_const'
+    );
+    await run(
+      t,
+      builtin('refract'),
+      [TypeVec(3, TypeF16), TypeVec(3, TypeF16), TypeF16],
+      TypeVec(3, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec4')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec4s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec4_const' : 'f16_vec4_non_const'
+    );
+    await run(
+      t,
+      builtin('refract'),
+      [TypeVec(4, TypeF16), TypeVec(4, TypeF16), TypeF16],
+      TypeVec(4, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 79941eead1bb..9cc311f31592 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -3908,7 +3908,7 @@ export abstract class FPTraits {
 
   /**
    * refract is a singular function in the sense that it is the only builtin that
-   * takes in (FPVector, FPVector, F32) and returns FPVector and is basically
+   * takes in (FPVector, FPVector, F32/F16) and returns FPVector and is basically
    * defined in terms of other functions.
    *
    * Instead of implementing all the framework code to integrate it with its
@@ -5324,11 +5324,8 @@ class F16Traits extends FPTraits {
   public readonly powInterval = this.powIntervalImpl.bind(this);
   public readonly quantizeToF16Interval = this.quantizeToF16IntervalNotAvailable.bind(this);
   public readonly radiansInterval = this.radiansIntervalImpl.bind(this);
-  public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(
-    this,
-    'reflectInterval'
-  );
-  public readonly refractInterval = this.unimplementedRefract.bind(this);
+  public readonly reflectInterval = this.reflectIntervalImpl.bind(this);
+  public readonly refractInterval = this.refractIntervalImpl.bind(this);
   public readonly remainderInterval = this.remainderIntervalImpl.bind(this);
   public readonly roundInterval = this.roundIntervalImpl.bind(this);
   public readonly saturateInterval = this.saturateIntervalImpl.bind(this);

From 04a32acf704d4d1e52c23f7e0ff865fe85a99214 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 27 Sep 2023 14:38:13 +0800
Subject: [PATCH 095/166] wgsl: add f16 builtin execution test for faceForward
 (#3015)

This PR add execution tests for f16 built-in faceForward.

Issue: #1248, #2547
---
 src/unittests/floating_point.spec.ts          | 123 +++++++------
 src/webgpu/listing_meta.json                  |  12 +-
 .../call/builtin/faceForward.spec.ts          | 169 +++++++++++-------
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 179 insertions(+), 127 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 17dead2f5520..04464b542851 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -7922,7 +7922,7 @@ interface VectorMatrixToVectorCase {
   expected: (number | IntervalBounds)[];
 }
 
-g.test('multiplicationVectorMatrixInterval_f32')
+g.test('multiplicationVectorMatrixInterval')
   .params(u =>
     u
       .combine('trait', ['f32', 'f16'] as const)
@@ -8041,70 +8041,77 @@ interface FaceForwardCase {
   expected: ((number | IntervalBounds)[] | undefined)[];
 }
 
-g.test('faceForwardIntervals_f32')
-  .paramsSubcasesOnly<FaceForwardCase>(
-    // prettier-ignore
-    [
-      // vec2
-      { input: [[1.0, 0.0], [1.0, 0.0], [1.0, 0.0]], expected: [[-1.0, 0.0]] },
-      { input: [[-1.0, 0.0], [1.0, 0.0], [1.0, 0.0]], expected: [[1.0, 0.0]] },
-      { input: [[1.0, 0.0], [-1.0, 1.0], [1.0, -1.0]], expected: [[1.0, 0.0]] },
-      { input: [[-1.0, 0.0], [-1.0, 1.0], [1.0, -1.0]], expected: [[-1.0, 0.0]] },
-      { input: [[10.0, 0.0], [10.0, 0.0], [10.0, 0.0]], expected: [[-10.0, 0.0]] },
-      { input: [[-10.0, 0.0], [10.0, 0.0], [10.0, 0.0]], expected: [[10.0, 0.0]] },
-      { input: [[10.0, 0.0], [-10.0, 10.0], [10.0, -10.0]], expected: [[10.0, 0.0]] },
-      { input: [[-10.0, 0.0], [-10.0, 10.0], [10.0, -10.0]], expected: [[-10.0, 0.0]] },
-      { input: [[0.1, 0.0], [0.1, 0.0], [0.1, 0.0]], expected: [[[reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)], 0.0]] },
-      { input: [[-0.1, 0.0], [0.1, 0.0], [0.1, 0.0]], expected: [[[reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)], 0.0]] },
-      { input: [[0.1, 0.0], [-0.1, 0.1], [0.1, -0.1]], expected: [[[reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)], 0.0]] },
-      { input: [[-0.1, 0.0], [-0.1, 0.1], [0.1, -0.1]], expected: [[[reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)], 0.0]] },
-
-      // vec3
-      { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [[-1.0, 0.0, 0.0]] },
-      { input: [[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [[1.0, 0.0, 0.0]] },
-      { input: [[1.0, 0.0, 0.0], [-1.0, 1.0, 0.0], [1.0, -1.0, 0.0]], expected: [[1.0, 0.0, 0.0]] },
-      { input: [[-1.0, 0.0, 0.0], [-1.0, 1.0, 0.0], [1.0, -1.0, 0.0]], expected: [[-1.0, 0.0, 0.0]] },
-      { input: [[10.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 0.0, 0.0]], expected: [[-10.0, 0.0, 0.0]] },
-      { input: [[-10.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 0.0, 0.0]], expected: [[10.0, 0.0, 0.0]] },
-      { input: [[10.0, 0.0, 0.0], [-10.0, 10.0, 0.0], [10.0, -10.0, 0.0]], expected: [[10.0, 0.0, 0.0]] },
-      { input: [[-10.0, 0.0, 0.0], [-10.0, 10.0, 0.0], [10.0, -10.0, 0.0]], expected: [[-10.0, 0.0, 0.0]] },
-      { input: [[0.1, 0.0, 0.0], [0.1, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: [[[reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)], 0.0, 0.0]] },
-      { input: [[-0.1, 0.0, 0.0], [0.1, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: [[[reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)], 0.0, 0.0]] },
-      { input: [[0.1, 0.0, 0.0], [-0.1, 0.0, 0.0], [0.1, -0.0, 0.0]], expected: [[[reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)], 0.0, 0.0]] },
-      { input: [[-0.1, 0.0, 0.0], [-0.1, 0.0, 0.0], [0.1, -0.0, 0.0]], expected: [[[reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)], 0.0, 0.0]] },
+g.test('faceForwardIntervals')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<FaceForwardCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          // vec2
+          { input: [[1.0, 0.0], [1.0, 0.0], [1.0, 0.0]], expected: [[-1.0, 0.0]] },
+          { input: [[-1.0, 0.0], [1.0, 0.0], [1.0, 0.0]], expected: [[1.0, 0.0]] },
+          { input: [[1.0, 0.0], [-1.0, 1.0], [1.0, -1.0]], expected: [[1.0, 0.0]] },
+          { input: [[-1.0, 0.0], [-1.0, 1.0], [1.0, -1.0]], expected: [[-1.0, 0.0]] },
+          { input: [[10.0, 0.0], [10.0, 0.0], [10.0, 0.0]], expected: [[-10.0, 0.0]] },
+          { input: [[-10.0, 0.0], [10.0, 0.0], [10.0, 0.0]], expected: [[10.0, 0.0]] },
+          { input: [[10.0, 0.0], [-10.0, 10.0], [10.0, -10.0]], expected: [[10.0, 0.0]] },
+          { input: [[-10.0, 0.0], [-10.0, 10.0], [10.0, -10.0]], expected: [[-10.0, 0.0]] },
+          { input: [[0.1, 0.0], [0.1, 0.0], [0.1, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0]] },
+          { input: [[-0.1, 0.0], [0.1, 0.0], [0.1, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0]] },
+          { input: [[0.1, 0.0], [-0.1, 0.1], [0.1, -0.1]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0]] },
+          { input: [[-0.1, 0.0], [-0.1, 0.1], [0.1, -0.1]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0]] },
 
-      // vec4
-      { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [[-1.0, 0.0, 0.0, 0.0]] },
-      { input: [[-1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [[1.0, 0.0, 0.0, 0.0]] },
-      { input: [[1.0, 0.0, 0.0, 0.0], [-1.0, 1.0, 0.0, 0.0], [1.0, -1.0, 0.0, 0.0]], expected: [[1.0, 0.0, 0.0, 0.0]] },
-      { input: [[-1.0, 0.0, 0.0, 0.0], [-1.0, 1.0, 0.0, 0.0], [1.0, -1.0, 0.0, 0.0]], expected: [[-1.0, 0.0, 0.0, 0.0]] },
-      { input: [[10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0]], expected: [[-10.0, 0.0, 0.0, 0.0]] },
-      { input: [[-10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0]], expected: [[10.0, 0.0, 0.0, 0.0]] },
-      { input: [[10.0, 0.0, 0.0, 0.0], [-10.0, 10.0, 0.0, 0.0], [10.0, -10.0, 0.0, 0.0]], expected: [[10.0, 0.0, 0.0, 0.0]] },
-      { input: [[-10.0, 0.0, 0.0, 0.0], [-10.0, 10.0, 0.0, 0.0], [10.0, -10.0, 0.0, 0.0]], expected: [[-10.0, 0.0, 0.0, 0.0]] },
-      { input: [[0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: [[[reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)], 0.0, 0.0, 0.0]] },
-      { input: [[-0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: [[[reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)], 0.0, 0.0, 0.0]] },
-      { input: [[0.1, 0.0, 0.0, 0.0], [-0.1, 0.0, 0.0, 0.0], [0.1, -0.0, 0.0, 0.0]], expected: [[[reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)], 0.0, 0.0, 0.0]] },
-      { input: [[-0.1, 0.0, 0.0, 0.0], [-0.1, 0.0, 0.0, 0.0], [0.1, -0.0, 0.0, 0.0]], expected: [[[reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)], 0.0, 0.0, 0.0]] },
-
-      // dot(y, z) === 0
-      { input: [[1.0, 1.0], [1.0, 0.0], [0.0, 1.0]], expected:  [[-1.0, -1.0]] },
-
-      // subnormals, also dot(y, z) spans 0
-      { input: [[kValue.f32.subnormal.positive.max, 0.0], [kValue.f32.subnormal.positive.min, 0.0], [kValue.f32.subnormal.negative.min, 0.0]], expected:  [[[0.0, kValue.f32.subnormal.positive.max], 0.0], [[kValue.f32.subnormal.negative.min, 0], 0.0]] },
-
-      // dot going OOB returns [undefined, x, -x]
-      { input: [[1.0, 1.0], [kValue.f32.positive.max, kValue.f32.positive.max], [kValue.f32.positive.max, kValue.f32.positive.max]], expected: [undefined, [1, 1], [-1, -1]] },
+          // vec3
+          { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [[-1.0, 0.0, 0.0]] },
+          { input: [[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [[1.0, 0.0, 0.0]] },
+          { input: [[1.0, 0.0, 0.0], [-1.0, 1.0, 0.0], [1.0, -1.0, 0.0]], expected: [[1.0, 0.0, 0.0]] },
+          { input: [[-1.0, 0.0, 0.0], [-1.0, 1.0, 0.0], [1.0, -1.0, 0.0]], expected: [[-1.0, 0.0, 0.0]] },
+          { input: [[10.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 0.0, 0.0]], expected: [[-10.0, 0.0, 0.0]] },
+          { input: [[-10.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 0.0, 0.0]], expected: [[10.0, 0.0, 0.0]] },
+          { input: [[10.0, 0.0, 0.0], [-10.0, 10.0, 0.0], [10.0, -10.0, 0.0]], expected: [[10.0, 0.0, 0.0]] },
+          { input: [[-10.0, 0.0, 0.0], [-10.0, 10.0, 0.0], [10.0, -10.0, 0.0]], expected: [[-10.0, 0.0, 0.0]] },
+          { input: [[0.1, 0.0, 0.0], [0.1, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0, 0.0]] },
+          { input: [[-0.1, 0.0, 0.0], [0.1, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0, 0.0]] },
+          { input: [[0.1, 0.0, 0.0], [-0.1, 0.0, 0.0], [0.1, -0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0, 0.0]] },
+          { input: [[-0.1, 0.0, 0.0], [-0.1, 0.0, 0.0], [0.1, -0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0, 0.0]] },
 
-    ]
+          // vec4
+          { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [[-1.0, 0.0, 0.0, 0.0]] },
+          { input: [[-1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [[1.0, 0.0, 0.0, 0.0]] },
+          { input: [[1.0, 0.0, 0.0, 0.0], [-1.0, 1.0, 0.0, 0.0], [1.0, -1.0, 0.0, 0.0]], expected: [[1.0, 0.0, 0.0, 0.0]] },
+          { input: [[-1.0, 0.0, 0.0, 0.0], [-1.0, 1.0, 0.0, 0.0], [1.0, -1.0, 0.0, 0.0]], expected: [[-1.0, 0.0, 0.0, 0.0]] },
+          { input: [[10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0]], expected: [[-10.0, 0.0, 0.0, 0.0]] },
+          { input: [[-10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0]], expected: [[10.0, 0.0, 0.0, 0.0]] },
+          { input: [[10.0, 0.0, 0.0, 0.0], [-10.0, 10.0, 0.0, 0.0], [10.0, -10.0, 0.0, 0.0]], expected: [[10.0, 0.0, 0.0, 0.0]] },
+          { input: [[-10.0, 0.0, 0.0, 0.0], [-10.0, 10.0, 0.0, 0.0], [10.0, -10.0, 0.0, 0.0]], expected: [[-10.0, 0.0, 0.0, 0.0]] },
+          { input: [[0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0, 0.0, 0.0]] },
+          { input: [[-0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0, 0.0, 0.0]] },
+          { input: [[0.1, 0.0, 0.0, 0.0], [-0.1, 0.0, 0.0, 0.0], [0.1, -0.0, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0, 0.0, 0.0]] },
+          { input: [[-0.1, 0.0, 0.0, 0.0], [-0.1, 0.0, 0.0, 0.0], [0.1, -0.0, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0, 0.0, 0.0]] },
+
+          // dot(y, z) === 0
+          { input: [[1.0, 1.0], [1.0, 0.0], [0.0, 1.0]], expected:  [[-1.0, -1.0]] },
+
+          // subnormals, also dot(y, z) spans 0
+          { input: [[constants.positive.subnormal.max, 0.0], [constants.positive.subnormal.min, 0.0], [constants.negative.subnormal.min, 0.0]], expected:  [[[0.0, constants.positive.subnormal.max], 0.0], [[constants.negative.subnormal.min, 0], 0.0]] },
+
+          // dot going OOB returns [undefined, x, -x]
+          { input: [[1.0, 1.0], [constants.positive.max, constants.positive.max], [constants.positive.max, constants.positive.max]], expected: [undefined, [1, 1], [-1, -1]] },
+        ];
+      })
   )
   .fn(t => {
     const [x, y, z] = t.params.input;
-    const expected = t.params.expected.map(e => (e !== undefined ? FP.f32.toVector(e) : undefined));
-    const got = FP.f32.faceForwardIntervals(x, y, z);
+    const trait = FP[t.params.trait];
+    const expected = t.params.expected.map(e => (e !== undefined ? trait.toVector(e) : undefined));
+    const got = trait.faceForwardIntervals(x, y, z);
     t.expect(
       objectEquals(expected, got),
-      `f32.faceForwardInterval([${x}], [${y}], [${z}]) returned [${got}]. Expected [${expected}]`
+      `${t.params.trait}.faceForwardInterval([${x}], [${y}], [${z}]) returned [${got}]. Expected [${expected}]`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index befb1807aea8..549e90b7d85c 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1194,11 +1194,13 @@
   "webgpu:shader,execution,expression,call,builtin,exp:f32:*": { "subcaseMS": 12.557 },
   "webgpu:shader,execution,expression,call,builtin,extractBits:i32:*": { "subcaseMS": 8.125 },
   "webgpu:shader,execution,expression,call,builtin,extractBits:u32:*": { "subcaseMS": 7.838 },
-  "webgpu:shader,execution,expression,call,builtin,faceForward:abstract_float:*": { "subcaseMS": 14.306 },
-  "webgpu:shader,execution,expression,call,builtin,faceForward:f16:*": { "subcaseMS": 7.906 },
-  "webgpu:shader,execution,expression,call,builtin,faceForward:f32_vec2:*": { "subcaseMS": 1054.800 },
-  "webgpu:shader,execution,expression,call,builtin,faceForward:f32_vec3:*": { "subcaseMS": 162.675 },
-  "webgpu:shader,execution,expression,call,builtin,faceForward:f32_vec4:*": { "subcaseMS": 180.325 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:abstract_float:*": { "subcaseMS": 120.702 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f16_vec2:*": { "subcaseMS": 485.775 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f16_vec3:*": { "subcaseMS": 560.225 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f16_vec4:*": { "subcaseMS": 670.325 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f32_vec2:*": { "subcaseMS": 12009.850 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f32_vec3:*": { "subcaseMS": 440.001 },
+  "webgpu:shader,execution,expression,call,builtin,faceForward:f32_vec4:*": { "subcaseMS": 500.675 },
   "webgpu:shader,execution,expression,call,builtin,firstLeadingBit:i32:*": { "subcaseMS": 20.613 },
   "webgpu:shader,execution,expression,call,builtin,firstLeadingBit:u32:*": { "subcaseMS": 9.363 },
   "webgpu:shader,execution,expression,call,builtin,firstTrailingBit:i32:*": { "subcaseMS": 8.132 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/faceForward.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/faceForward.spec.ts
index 1dd524be72bc..f2a6b9584e96 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/faceForward.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/faceForward.spec.ts
@@ -9,9 +9,13 @@ Returns e1 if dot(e2,e3) is negative, and -e1 otherwise.
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { anyOf } from '../../../../../util/compare.js';
-import { toVector, TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { toVector, TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
 import { FP, FPKind, FPVector } from '../../../../../util/floating_point.js';
-import { cartesianProduct, sparseVectorF32Range } from '../../../../../util/math.js';
+import {
+  cartesianProduct,
+  sparseVectorF32Range,
+  sparseVectorF16Range,
+} from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, Case, IntervalFilter, run } from '../../expression.js';
 
@@ -47,7 +51,7 @@ function makeCase(
   y = y.map(fp.quantize);
   z = z.map(fp.quantize);
 
-  const results = FP.f32.faceForwardIntervals(x, y, z);
+  const results = FP[kind].faceForwardIntervals(x, y, z);
   if (check === 'finite' && results.some(r => r === undefined)) {
     return undefined;
   }
@@ -84,65 +88,47 @@ function generateCases(
 ): Case[] {
   // Cannot use `cartesianProduct` here due to heterogeneous param types
   return cartesianProduct(xs, ys, zs)
-    .map(e => makeCase('f32', e[0], e[1], e[2], check))
+    .map(e => makeCase(kind, e[0], e[1], e[2], check))
     .filter((c): c is Case => c !== undefined);
 }
 
+// Cases: f32_vecN_[non_]const
+const f32_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f32_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return generateCases(
+          'f32',
+          sparseVectorF32Range(n),
+          sparseVectorF32Range(n),
+          sparseVectorF32Range(n),
+          nonConst ? 'unfiltered' : 'finite'
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_vecN_[non_]const
+const f16_vec_cases = ([2, 3, 4] as const)
+  .flatMap(n =>
+    ([true, false] as const).map(nonConst => ({
+      [`f16_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        return generateCases(
+          'f16',
+          sparseVectorF16Range(n),
+          sparseVectorF16Range(n),
+          sparseVectorF16Range(n),
+          nonConst ? 'unfiltered' : 'finite'
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
 export const d = makeCaseCache('faceForward', {
-  f32_vec2_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      'finite'
-    );
-  },
-  f32_vec2_non_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      sparseVectorF32Range(2),
-      'unfiltered'
-    );
-  },
-  f32_vec3_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      'finite'
-    );
-  },
-  f32_vec3_non_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      sparseVectorF32Range(3),
-      'unfiltered'
-    );
-  },
-  f32_vec4_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      'finite'
-    );
-  },
-  f32_vec4_non_const: () => {
-    return generateCases(
-      'f32',
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      sparseVectorF32Range(4),
-      'unfiltered'
-    );
-  },
+  ...f32_vec_cases,
+  ...f16_vec_cases,
 });
 
 g.test('abstract_float')
@@ -205,8 +191,65 @@ g.test('f32_vec4')
     );
   });
 
-g.test('f16')
-  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
-  .desc(`f16 tests`)
-  .params(u => u.combine('inputSource', allInputSources).combine('vectorize', [2, 3, 4] as const))
-  .unimplemented();
+g.test('f16_vec2')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec2s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec2_const' : 'f16_vec2_non_const'
+    );
+    await run(
+      t,
+      builtin('faceForward'),
+      [TypeVec(2, TypeF16), TypeVec(2, TypeF16), TypeVec(2, TypeF16)],
+      TypeVec(2, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec3')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec3s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec3_const' : 'f16_vec3_non_const'
+    );
+    await run(
+      t,
+      builtin('faceForward'),
+      [TypeVec(3, TypeF16), TypeVec(3, TypeF16), TypeVec(3, TypeF16)],
+      TypeVec(3, TypeF16),
+      t.params,
+      cases
+    );
+  });
+
+g.test('f16_vec4')
+  .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+  .desc(`f16 tests using vec4s`)
+  .params(u => u.combine('inputSource', allInputSources))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(
+      t.params.inputSource === 'const' ? 'f16_vec4_const' : 'f16_vec4_non_const'
+    );
+    await run(
+      t,
+      builtin('faceForward'),
+      [TypeVec(4, TypeF16), TypeVec(4, TypeF16), TypeVec(4, TypeF16)],
+      TypeVec(4, TypeF16),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 9cc311f31592..d1469561a8f7 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5285,7 +5285,7 @@ class F16Traits extends FPTraits {
   public readonly dotInterval = this.dotIntervalImpl.bind(this);
   public readonly expInterval = this.expIntervalImpl.bind(this);
   public readonly exp2Interval = this.exp2IntervalImpl.bind(this);
-  public readonly faceForwardIntervals = this.unimplementedFaceForward.bind(this);
+  public readonly faceForwardIntervals = this.faceForwardIntervalsImpl.bind(this);
   public readonly floorInterval = this.floorIntervalImpl.bind(this);
   public readonly fmaInterval = this.fmaIntervalImpl.bind(this);
   public readonly fractInterval = this.unimplementedScalarToInterval.bind(this, 'fractInterval');

From 0dc8224531e294f02577ff022b3d3f53dc9478f1 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 27 Sep 2023 15:05:46 +0800
Subject: [PATCH 096/166] wgsl: refactor and add f16 execution test for builtin
 ldexp (#3018)

This PR refactor the ldexpInterval to better handle the expectation for
built-in ldexp(e1: f32|f16, e2: i32) in cases of e2 + bias <= 0 or
e2 > bias + 1, and add f16 execution tests for ldexp built-in.

Issue: #1248
---
 src/unittests/floating_point.spec.ts          | 130 ++++++++++++------
 src/webgpu/listing_meta.json                  |   6 +-
 .../expression/call/builtin/ldexp.spec.ts     |  79 +++++++----
 src/webgpu/util/floating_point.ts             |  68 +++++----
 4 files changed, 187 insertions(+), 96 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 04464b542851..dfafb36c4616 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -4455,51 +4455,101 @@ g.test('divisionInterval')
     );
   });
 
-g.test('ldexpInterval_f32')
-  .paramsSubcasesOnly<ScalarPairToIntervalCase>(
-    // prettier-ignore
-    [
-      // 32-bit normals
-      { input: [0, 0], expected: 0 },
-      { input: [0, 1], expected: 0 },
-      { input: [0, -1], expected: 0 },
-      { input: [1, 1], expected: 2 },
-      { input: [1, -1], expected: 0.5 },
-      { input: [-1, 1], expected: -2 },
-      { input: [-1, -1], expected: -0.5 },
-
-      // 64-bit normals
-      { input: [0, 0.1], expected: 0 },
-      { input: [0, -0.1], expected: 0 },
-      { input: [1.0000000001, 1], expected: [2, kPlusNULPFunctions['f32'](2, 2)] },  // ~2, additional ULP error due to first param not being f32 precise
-      { input: [-1.0000000001, 1], expected: [kMinusNULPFunctions['f32'](-2, 2), -2] },  // ~-2, additional ULP error due to first param not being f32 precise
-
-      // Edge Cases
-      { input: [1.9999998807907104, 127], expected: kValue.f32.positive.max },
-      { input: [1, -126], expected: kValue.f32.positive.min },
-      { input: [0.9999998807907104, -126], expected: [0, kValue.f32.subnormal.positive.max] },
-      { input: [1.1920928955078125e-07, -126], expected: [0, kValue.f32.subnormal.positive.min] },
-      { input: [-1.1920928955078125e-07, -126], expected: [kValue.f32.subnormal.negative.max, 0] },
-      { input: [-0.9999998807907104, -126], expected: [kValue.f32.subnormal.negative.min, 0] },
-      { input: [-1, -126], expected: kValue.f32.negative.max },
-      { input: [-1.9999998807907104, 127], expected: kValue.f32.negative.min },
-
-      // Out of Bounds
-      { input: [1, 128], expected: kUnboundedBounds },
-      { input: [-1, 128], expected: kUnboundedBounds },
-      { input: [100, 126], expected: kUnboundedBounds },
-      { input: [-100, 126], expected: kUnboundedBounds },
-      { input: [kValue.f32.positive.max, kValue.i32.positive.max], expected: kUnboundedBounds },
-      { input: [kValue.f32.negative.min, kValue.i32.positive.max], expected: kUnboundedBounds },
-    ]
+const kLdexpIntervalCases = {
+  f32: [
+    // 64-bit normals
+    { input: [1.0000000001, 1], expected: [2, kPlusNULPFunctions['f32'](2, 2)] }, // ~2, additional ULP error due to first param not being f32 precise
+    { input: [-1.0000000001, 1], expected: [kMinusNULPFunctions['f32'](-2, 2), -2] }, // ~-2, additional ULP error due to first param not being f32 precise
+    // Edge Cases
+    // f32 0b0_01111111_11111111111111111111111 = 1.9999998807907104,
+    // 1.9999998807907104 * 2 ** 127 = f32.positive.max
+    { input: [1.9999998807907104, 127], expected: kValue.f32.positive.max },
+    // f32.positive.min = 1 * 2 ** -126
+    { input: [1, -126], expected: kValue.f32.positive.min },
+    // f32.subnormal.positive.max = 0.9999998807907104 * 2 ** -126
+    { input: [0.9999998807907104, -126], expected: [0, kValue.f32.subnormal.positive.max] },
+    // f32.subnormal.positive.min = 1.1920928955078125e-07 * 2 ** -126
+    { input: [1.1920928955078125e-7, -126], expected: [0, kValue.f32.subnormal.positive.min] },
+    { input: [-1.1920928955078125e-7, -126], expected: [kValue.f32.subnormal.negative.max, 0] },
+    { input: [-0.9999998807907104, -126], expected: [kValue.f32.subnormal.negative.min, 0] },
+    { input: [-1, -126], expected: kValue.f32.negative.max },
+    { input: [-1.9999998807907104, 127], expected: kValue.f32.negative.min },
+    // e2 + bias <= 0, expect correctly rounded intervals.
+    { input: [2 ** 120, -130], expected: 2 ** -10 },
+    // Out of Bounds
+    { input: [1, 128], expected: kUnboundedBounds },
+    { input: [-1, 128], expected: kUnboundedBounds },
+    { input: [100, 126], expected: kUnboundedBounds },
+    { input: [-100, 126], expected: kUnboundedBounds },
+    { input: [2 ** 100, 100], expected: kUnboundedBounds },
+  ] as ScalarPairToIntervalCase[],
+  f16: [
+    // 64-bit normals
+    { input: [1.0000000001, 1], expected: [2, kPlusNULPFunctions['f16'](2, 2)] }, // ~2, additional ULP error due to first param not being f16 precise
+    { input: [-1.0000000001, 1], expected: [kMinusNULPFunctions['f16'](-2, 2), -2] }, // ~-2, additional ULP error due to first param not being f16 precise
+    // Edge Cases
+    // f16 0b0_01111_1111111111 = 1.9990234375, 1.9990234375 * 2 ** 15 = f16.positive.max
+    { input: [1.9990234375, 15], expected: kValue.f16.positive.max },
+    // f16.positive.min = 1 * 2 ** -14
+    { input: [1, -14], expected: kValue.f16.positive.min },
+    // f16.subnormal.positive.max = 0.9990234375 * 2 ** -14
+    { input: [0.9990234375, -14], expected: [0, kValue.f16.subnormal.positive.max] },
+    // f16.subnormal.positive.min = 1 * 2 ** -10 * 2 ** -14 = 0.0009765625 * 2 ** -14
+    { input: [0.0009765625, -14], expected: [0, kValue.f16.subnormal.positive.min] },
+    { input: [-0.0009765625, -14], expected: [kValue.f16.subnormal.negative.max, 0] },
+    { input: [-0.9990234375, -14], expected: [kValue.f16.subnormal.negative.min, 0] },
+    { input: [-1, -14], expected: kValue.f16.negative.max },
+    { input: [-1.9990234375, 15], expected: kValue.f16.negative.min },
+    // e2 + bias <= 0, expect correctly rounded intervals.
+    { input: [2 ** 12, -18], expected: 2 ** -6 },
+    // Out of Bounds
+    { input: [1, 16], expected: kUnboundedBounds },
+    { input: [-1, 16], expected: kUnboundedBounds },
+    { input: [100, 14], expected: kUnboundedBounds },
+    { input: [-100, 14], expected: kUnboundedBounds },
+    { input: [2 ** 10, 10], expected: kUnboundedBounds },
+  ] as ScalarPairToIntervalCase[],
+} as const;
+
+g.test('ldexpInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarPairToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
+        // prettier-ignore
+        return [
+          // always exactly represeantable cases
+          { input: [0, 0], expected: 0 },
+          { input: [0, 1], expected: 0 },
+          { input: [0, -1], expected: 0 },
+          { input: [1, 1], expected: 2 },
+          { input: [1, -1], expected: 0.5 },
+          { input: [-1, 1], expected: -2 },
+          { input: [-1, -1], expected: -0.5 },
+
+          ...kLdexpIntervalCases[p.trait],
+
+          // Extremely negative e2, any float value should be scale to 0.0 as the ground truth
+          // f64 e1 * 2 ** e2 would be 0.0 for e2 = -2147483648.
+          { input: [constants.positive.max, kValue.i32.negative.min], expected: 0 },
+          { input: [constants.negative.min, kValue.i32.negative.min], expected: 0 },
+          // Out of Bounds
+          { input: [constants.positive.max, kValue.i32.positive.max], expected: kUnboundedBounds },
+          { input: [constants.negative.min, kValue.i32.positive.max], expected: kUnboundedBounds },
+        ];
+      })
   )
   .fn(t => {
     const [x, y] = t.params.input;
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.ldexpInterval(x, y);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.ldexpInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `f32.ldexpInterval(${x}, ${y}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.ldexpInterval(${x}, ${y}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 549e90b7d85c..23b33e835de8 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1237,9 +1237,9 @@
   "webgpu:shader,execution,expression,call,builtin,inversesqrt:abstract_float:*": { "subcaseMS": 24.310 },
   "webgpu:shader,execution,expression,call,builtin,inversesqrt:f16:*": { "subcaseMS": 21.411 },
   "webgpu:shader,execution,expression,call,builtin,inversesqrt:f32:*": { "subcaseMS": 50.125 },
-  "webgpu:shader,execution,expression,call,builtin,ldexp:abstract_float:*": { "subcaseMS": 32.909 },
-  "webgpu:shader,execution,expression,call,builtin,ldexp:f16:*": { "subcaseMS": 36.705 },
-  "webgpu:shader,execution,expression,call,builtin,ldexp:f32:*": { "subcaseMS": 66.419 },
+  "webgpu:shader,execution,expression,call,builtin,ldexp:abstract_float:*": { "subcaseMS": 142.805 },
+  "webgpu:shader,execution,expression,call,builtin,ldexp:f16:*": { "subcaseMS": 271.038 },
+  "webgpu:shader,execution,expression,call,builtin,ldexp:f32:*": { "subcaseMS": 161.250 },
   "webgpu:shader,execution,expression,call,builtin,length:abstract_float:*": { "subcaseMS": 31.303 },
   "webgpu:shader,execution,expression,call,builtin,length:f16:*": { "subcaseMS": 490.450 },
   "webgpu:shader,execution,expression,call,builtin,length:f16_vec2:*": { "subcaseMS": 33.551 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/ldexp.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/ldexp.spec.ts
index f50c7c3b794f..792c7e8513ad 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/ldexp.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/ldexp.spec.ts
@@ -13,12 +13,15 @@ Returns e1 * 2^e2. Component-wise when T is a vector.
 `;
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
+import { assert } from '../../../../../../common/util/util.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { i32, TypeF32, TypeI32 } from '../../../../../util/conversion.js';
+import { anyOf } from '../../../../../util/compare.js';
+import { i32, TypeF32, TypeF16, TypeI32 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
 import {
   biasedRange,
   fullF32Range,
+  fullF16Range,
   fullI32Range,
   quantizeToI32,
 } from '../../../../../util/math.js';
@@ -29,35 +32,55 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
-function makeCaseF32(e1: number, e2: number): Case {
-  // Due to the heterogeneous types of the params to ldexp (f32 & i32),
-  // makeBinaryToF32IntervalCase cannot be used here.
-  e1 = FP.f32.quantize(e1);
+const bias = {
+  f32: 127,
+  f16: 15,
+} as const;
+
+// ldexpInterval's return interval doesn't cover the flush-to-zero cases when e2 + bias <= 0, thus
+// special examination is required.
+// See the comment block on ldexpInterval for more details
+// e2 is an integer (i32) while e1 is float.
+const makeCase = (trait: 'f32' | 'f16', e1: number, e2: number): Case => {
+  const FPTrait = FP[trait];
+  e1 = FPTrait.quantize(e1);
+  // e2 should be in i32 range for the convinience.
+  assert(-2147483648 <= e2 && e2 <= 2147483647, 'e2 should be in i32 range');
   e2 = quantizeToI32(e2);
-  const expected = FP.f32.ldexpInterval(e1, e2);
-  return { input: [FP.f32.scalarBuilder(e1), i32(e2)], expected };
-}
+
+  const expected = FPTrait.ldexpInterval(e1, e2);
+
+  // Result may be zero if e2 + bias <= 0
+  if (e2 + bias[trait] <= 0) {
+    return {
+      input: [FPTrait.scalarBuilder(e1), i32(e2)],
+      expected: anyOf(expected, FPTrait.constants().zeroInterval),
+    };
+  }
+
+  return { input: [FPTrait.scalarBuilder(e1), i32(e2)], expected };
+};
 
 export const d = makeCaseCache('ldexp', {
   f32_non_const: () => {
-    const cases: Array<Case> = [];
-    fullF32Range().forEach(e1 => {
-      fullI32Range().forEach(e2 => {
-        cases.push(makeCaseF32(e1, e2));
-      });
-    });
-    return cases;
+    return fullF32Range().flatMap(e1 => fullI32Range().map(e2 => makeCase('f32', e1, e2)));
   },
   f32_const: () => {
-    const cases: Array<Case> = [];
-    fullF32Range().forEach(e1 => {
-      biasedRange(-128, 128, 10).forEach(e2 => {
-        if (FP.f32.isFinite(e1 * Math.pow(2, e2))) {
-          cases.push(makeCaseF32(e1, e2));
-        }
-      });
-    });
-    return cases;
+    return fullF32Range().flatMap(e1 =>
+      biasedRange(-bias.f32 - 10, bias.f32 + 1, 10).flatMap(e2 =>
+        FP.f32.isFinite(e1 * 2 ** quantizeToI32(e2)) ? makeCase('f32', e1, e2) : []
+      )
+    );
+  },
+  f16_non_const: () => {
+    return fullF16Range().flatMap(e1 => fullI32Range().map(e2 => makeCase('f16', e1, e2)));
+  },
+  f16_const: () => {
+    return fullF16Range().flatMap(e1 =>
+      biasedRange(-bias.f16 - 10, bias.f16 + 1, 10).flatMap(e2 =>
+        FP.f16.isFinite(e1 * 2 ** quantizeToI32(e2)) ? makeCase('f16', e1, e2) : []
+      )
+    );
   },
 });
 
@@ -89,4 +112,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+    await run(t, builtin('ldexp'), [TypeF16, TypeI32], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index d1469561a8f7..b454678a8874 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -3485,37 +3485,52 @@ export abstract class FPTraits {
   /** Calculate an acceptance interval of inverseSqrt(x) */
   public abstract readonly inverseSqrtInterval: (n: number | FPInterval) => FPInterval;
 
-  // This op should be implemented differently for f32 and f16.
   private readonly LdexpIntervalOp: ScalarPairToIntervalOp = {
-    impl: this.limitScalarPairToIntervalDomain(
-      // Implementing SPIR-V's more restrictive domain until
-      // https://github.com/gpuweb/gpuweb/issues/3134 is resolved
-      {
-        x: [this.toInterval([kValue.f32.negative.min, kValue.f32.positive.max])],
-        y: [this.toInterval([-126, 128])],
-      },
-      (e1: number, e2: number): FPInterval => {
-        // Though the spec says the result of ldexp(e1, e2) = e1 * 2 ^ e2, the
-        // accuracy is listed as correctly rounded to the true value, so the
-        // inheritance framework does not need to be invoked to determine
-        // bounds.
-        // Instead, the value at a higher precision is calculated and passed to
-        // correctlyRoundedInterval.
-        const result = e1 * 2 ** e2;
-        if (Number.isNaN(result)) {
-          // Overflowed TS's number type, so definitely out of bounds for f32
-          return this.constants().unboundedInterval;
-        }
-        return this.correctlyRoundedInterval(result);
+    impl: (e1: number, e2: number) => {
+      assert(this.kind === 'f32' || this.kind === 'f16');
+      assert(Number.isInteger(e2), 'the second param of ldexp must be an integer');
+      const bias = this.kind === 'f32' ? 127 : 15;
+      // Spec explicitly calls indeterminate value if e2 > bias + 1
+      if (e2 > bias + 1) {
+        return this.constants().unboundedInterval;
       }
-    ),
+      // The spec says the result of ldexp(e1, e2) = e1 * 2 ^ e2, and the accuracy is correctly
+      // rounded to the true value, so the inheritance framework does not need to be invoked to
+      // determine bounds.
+      // Instead, the value at a higher precision is calculated and passed to
+      // correctlyRoundedInterval.
+      const result = e1 * 2 ** e2;
+      if (!Number.isFinite(result)) {
+        // Overflowed TS's number type, so definitely out of bounds for f32/f16
+        return this.constants().unboundedInterval;
+      }
+      // The result may be zero if e2 + bias <= 0, but we can't simply span the interval to 0.0.
+      // For example, for f32 input e1 = 2**120 and e2 = -130, e2 + bias = -3 <= 0, but
+      // e1 * 2 ** e2 = 2**-10, so the valid result is 2**-10 or 0.0, instead of [0.0, 2**-10].
+      // Always return the correctly-rounded interval, and special examination should be taken when
+      // using the result.
+      return this.correctlyRoundedInterval(result);
+    },
   };
 
   protected ldexpIntervalImpl(e1: number, e2: number): FPInterval {
-    return this.roundAndFlushScalarPairToInterval(e1, e2, this.LdexpIntervalOp);
+    // Only round and flush e1, as e2 is of integer type (i32 or abstract integer) and should be
+    // precise.
+    return this.roundAndFlushScalarToInterval(e1, {
+      impl: (e1: number) => this.LdexpIntervalOp.impl(e1, e2),
+    });
   }
 
-  /** Calculate an acceptance interval of ldexp(e1, e2) */
+  /**
+   * Calculate an acceptance interval of ldexp(e1, e2), where e2 is integer
+   *
+   * Spec indicate that the result may be zero if e2 + bias <= 0, no matter how large
+   * was e1 * 2 ** e2, i.e. the actual valid result is correctlyRounded(e1 * 2 ** e2) or 0.0, if
+   * e2 + bias <= 0. Such discontinious flush-to-zero behavior is hard to be expressed using
+   * FPInterval, therefore in the situation of e2 + bias <= 0 the returned interval would be just
+   * correctlyRounded(e1 * 2 ** e2), and special examination should be taken when using the result.
+   *
+   */
   public abstract readonly ldexpInterval: (e1: number, e2: number) => FPInterval;
 
   private readonly LengthIntervalScalarOp: ScalarToIntervalOp = {
@@ -5290,10 +5305,7 @@ class F16Traits extends FPTraits {
   public readonly fmaInterval = this.fmaIntervalImpl.bind(this);
   public readonly fractInterval = this.unimplementedScalarToInterval.bind(this, 'fractInterval');
   public readonly inverseSqrtInterval = this.inverseSqrtIntervalImpl.bind(this);
-  public readonly ldexpInterval = this.unimplementedScalarPairToInterval.bind(
-    this,
-    'ldexpInterval'
-  );
+  public readonly ldexpInterval = this.ldexpIntervalImpl.bind(this);
   public readonly lengthInterval = this.lengthIntervalImpl.bind(this);
   public readonly logInterval = this.logIntervalImpl.bind(this);
   public readonly log2Interval = this.log2IntervalImpl.bind(this);

From c2d24f1b2593d4d4a0e4953e23b1e5bb8fff9919 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 27 Sep 2023 15:21:25 +0800
Subject: [PATCH 097/166] wgsl: add f16 execution test for builtin fract
 (#3017)

This PR add execution test for f16 built-in fract.

Issue: #1248
---
 src/unittests/floating_point.spec.ts          | 80 ++++++++++++-------
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/fract.spec.ts     | 35 +++++++-
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 86 insertions(+), 33 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index dfafb36c4616..bf788a0c3b4d 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3045,38 +3045,62 @@ g.test('floorInterval')
     );
   });
 
-g.test('fractInterval_f32')
-  .paramsSubcasesOnly<ScalarToIntervalCase>(
-    // prettier-ignore
-    [
-      { input: 0, expected: 0 },
-      { input: 0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] }, // ~0.1
-      { input: 0.9, expected: [reinterpretU32AsF32(0x3f666666), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0x3f666666))] },  // ~0.9
-      { input: 1.0, expected: 0 },
-      { input: 1.1, expected: [reinterpretU64AsF64(0x3fb9_9998_0000_0000n), reinterpretU64AsF64(0x3fb9_999a_0000_0000n)] }, // ~0.1
-      { input: -0.1, expected: [reinterpretU32AsF32(0x3f666666), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0x3f666666))] },  // ~0.9
-      { input: -0.9, expected: [reinterpretU64AsF64(0x3fb9_9999_0000_0000n), reinterpretU64AsF64(0x3fb9_999a_0000_0000n)] }, // ~0.1
-      { input: -1.0, expected: 0 },
-      { input: -1.1, expected: [reinterpretU64AsF64(0x3fec_cccc_c000_0000n), reinterpretU64AsF64(0x3fec_cccd_0000_0000n), ] }, // ~0.9
-
-      // Edge cases
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-      { input: kValue.f32.positive.max, expected: 0 },
-      { input: kValue.f32.positive.min, expected: [kValue.f32.positive.min, kValue.f32.positive.min] },
-      { input: kValue.f32.negative.min, expected: 0 },
-      { input: kValue.f32.negative.max, expected: [kValue.f32.positive.less_than_one, 1.0] },
-
-      // https://github.com/gpuweb/cts/issues/2766
-      { input: 0x80000000, expected: 0 },
-]
+// prettier-ignore
+const kFractIntervalCases = {
+  f32: [
+    { input: 0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] }, // ~0.1
+    { input: 0.9, expected: [reinterpretU32AsF32(0x3f666666), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0x3f666666))] },  // ~0.9
+    { input: 1.1, expected: [reinterpretU32AsF32(0x3dccccc0), reinterpretU32AsF32(0x3dccccd0)] }, // ~0.1
+    { input: -0.1, expected: [reinterpretU32AsF32(0x3f666666), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0x3f666666))] },  // ~0.9
+    { input: -0.9, expected: [reinterpretU32AsF32(0x3dccccc8), reinterpretU32AsF32(0x3dccccd0)] }, // ~0.1
+    { input: -1.1, expected: [reinterpretU32AsF32(0x3f666666), reinterpretU32AsF32(0x3f666668)] }, // ~0.9
+
+    // https://github.com/gpuweb/cts/issues/2766
+    { input: 0x80000000, expected: 0 },
+  ] as ScalarToIntervalCase[],
+  f16: [
+    { input: 0.1, expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)] }, // ~0.1
+    { input: 0.9, expected: [reinterpretU16AsF16(0x3b33), reinterpretU16AsF16(0x3b34)] },  // ~0.9
+    { input: 1.1, expected: [reinterpretU16AsF16(0x2e60), reinterpretU16AsF16(0x2e70)] }, // ~0.1
+    { input: -0.1, expected: [reinterpretU16AsF16(0x3b33), reinterpretU16AsF16(0x3b34)] },  // ~0.9
+    { input: -0.9, expected: [reinterpretU16AsF16(0x2e60), reinterpretU16AsF16(0x2e68)] }, // ~0.1
+    { input: -1.1, expected: [reinterpretU16AsF16(0x3b32), reinterpretU16AsF16(0x3b34)] }, // ~0.9
+    { input: 658.5, expected: 0.5 },
+  ] as ScalarToIntervalCase[],
+} as const;
+
+g.test('fractInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ScalarToIntervalCase>(p => {
+        const constants = FP[p.trait].constants();
+        // prettier-ignore
+        return [
+          { input: 0, expected: 0 },
+          { input: 1.0, expected: 0 },
+          { input: -1.0, expected: 0 },
+
+          ...kFractIntervalCases[p.trait],
+
+          // Edge cases
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: 0 },
+          { input: constants.positive.min, expected: constants.positive.min },
+          { input: constants.negative.min, expected: 0 },
+          { input: constants.negative.max, expected: [constants.positive.less_than_one, 1.0] },
+        ];
+      })
   )
   .fn(t => {
-    const expected = FP.f32.toInterval(t.params.expected);
-    const got = FP.f32.fractInterval(t.params.input);
+    const trait = FP[t.params.trait];
+    const expected = trait.toInterval(t.params.expected);
+    const got = trait.fractInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.fractInterval(${t.params.input}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.fractInterval(${t.params.input}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 23b33e835de8..16a5cb5509b3 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1212,7 +1212,7 @@
   "webgpu:shader,execution,expression,call,builtin,fma:f16:*": { "subcaseMS": 485.857 },
   "webgpu:shader,execution,expression,call,builtin,fma:f32:*": { "subcaseMS": 80.388 },
   "webgpu:shader,execution,expression,call,builtin,fract:abstract_float:*": { "subcaseMS": 17.408 },
-  "webgpu:shader,execution,expression,call,builtin,fract:f16:*": { "subcaseMS": 17.106 },
+  "webgpu:shader,execution,expression,call,builtin,fract:f16:*": { "subcaseMS": 46.500 },
   "webgpu:shader,execution,expression,call,builtin,fract:f32:*": { "subcaseMS": 12.269 },
   "webgpu:shader,execution,expression,call,builtin,frexp:f16_exp:*": { "subcaseMS": 8.503 },
   "webgpu:shader,execution,expression,call,builtin,frexp:f16_fract:*": { "subcaseMS": 17.900 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/fract.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/fract.spec.ts
index eb3f15518fe2..44ea31fde29f 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/fract.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/fract.spec.ts
@@ -10,9 +10,9 @@ Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run } from '../../expression.js';
 
@@ -44,6 +44,29 @@ export const d = makeCaseCache('fract', {
       FP.f32.fractInterval
     );
   },
+  f16: () => {
+    return FP.f16.generateScalarToIntervalCases(
+      [
+        0.5, // 0.5 -> 0.5
+        0.9, // ~0.9 -> ~0.9
+        1, // 1 -> 0
+        2, // 2 -> 0
+        1.11, // ~1.11 -> ~0.11
+        10.0078125, // 10.0078125 -> 0.0078125
+        -0.1, // ~-0.1 -> ~0.9
+        -0.5, // -0.5 -> 0.5
+        -0.9, // ~-0.9 -> ~0.1
+        -1, // -1 -> 0
+        -2, // -2 -> 0
+        -1.11, // ~-1.11 -> ~0.89
+        -10.0078125, // -10.0078125 -> 0.9921875
+        658.5, // 658.5 -> 0.5
+        ...fullF16Range(),
+      ],
+      'unfiltered',
+      FP.f16.fractInterval
+    );
+  },
 });
 
 g.test('abstract_float')
@@ -71,4 +94,10 @@ g.test('f16')
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(async t => {
+    const cases = await d.get('f16');
+    await run(t, builtin('fract'), [TypeF16], TypeF16, t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index b454678a8874..d68ac2e31fa8 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5303,7 +5303,7 @@ class F16Traits extends FPTraits {
   public readonly faceForwardIntervals = this.faceForwardIntervalsImpl.bind(this);
   public readonly floorInterval = this.floorIntervalImpl.bind(this);
   public readonly fmaInterval = this.fmaIntervalImpl.bind(this);
-  public readonly fractInterval = this.unimplementedScalarToInterval.bind(this, 'fractInterval');
+  public readonly fractInterval = this.fractIntervalImpl.bind(this);
   public readonly inverseSqrtInterval = this.inverseSqrtIntervalImpl.bind(this);
   public readonly ldexpInterval = this.ldexpIntervalImpl.bind(this);
   public readonly lengthInterval = this.lengthIntervalImpl.bind(this);

From cbe0d927d049872d9405e3de3e81365098a91015 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Wed, 27 Sep 2023 15:42:55 +0800
Subject: [PATCH 098/166] unittest: FP use correctly rounded dict for frequent
 number constant (#3016)

This PR replaces the correctly rounded expectation of frequently used
JS number constant with a dictionary in FP unittests `floating_point.spec.ts`
to improve readability.
---
 src/unittests/floating_point.spec.ts | 406 +++++++++------------------
 1 file changed, 127 insertions(+), 279 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index bf788a0c3b4d..5b1280e8ae97 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -2156,31 +2156,46 @@ g.test('ulpInterval')
   });
 
 // API - Acceptance Intervals
+// List of frequently used JS number in test cases, which are not exactly representable in f32 or f16.
+type ConstantNumberFrequentlyUsedInCases = '0.1' | '-0.1' | '1.9' | '-1.9';
+
+// Correctly rounded expectation of frequently used JS Number value in test cases
+const kConstantCorrectlyRoundedExpectation = {
+  f32: {
+    // 0.1 falls between f32 0x3DCCCCCC and 0x3DCCCCCD
+    '0.1': [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)],
+    // -0.1 falls between f32 0xBDCCCCCD and 0xBDCCCCCC
+    '-0.1': [reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)],
+    // 1.9 falls between f32 0x3FF33333 and 0x3FF33334
+    '1.9': [reinterpretU32AsF32(0x3ff33333), reinterpretU32AsF32(0x3ff33334)],
+    // -1.9 falls between f32 0xBFF33334 and 0xBFF33333
+    '-1.9': [reinterpretU32AsF32(0xbff33334), reinterpretU32AsF32(0xbff33333)],
+  } as { [value in ConstantNumberFrequentlyUsedInCases]: IntervalBounds },
+  f16: {
+    // 0.1 falls between f16 0x2E66 and 0x2E67
+    '0.1': [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)],
+    // -0.1 falls between f16 0xAE67 and 0xAE66
+    '-0.1': [reinterpretU16AsF16(0xae67), reinterpretU16AsF16(0xae66)],
+    // 1.9 falls between f16 0x3F99 and 0x3F9A
+    '1.9': [reinterpretU16AsF16(0x3f99), reinterpretU16AsF16(0x3f9a)],
+    // 1.9 falls between f16 0xBF9A and 0xBF99
+    '-1.9': [reinterpretU16AsF16(0xbf9a), reinterpretU16AsF16(0xbf99)],
+  } as { [value in ConstantNumberFrequentlyUsedInCases]: IntervalBounds },
+  // Since abstract is actually f64 and JS number is also f64, the JS number value will map to
+  // identical abstracty value without rounded.
+  abstract: {
+    '0.1': 0.1,
+    '-0.1': -0.1,
+    '1.9': 1.9,
+    '-1.9': -1.9,
+  } as { [value in ConstantNumberFrequentlyUsedInCases]: number },
+} as const;
 
 interface ScalarToIntervalCase {
   input: number;
   expected: number | IntervalBounds;
 }
 
-const kAbsIntervalCases = [
-  {
-    input: 0.1,
-    expected: {
-      f32: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)],
-      f16: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)],
-      abstract: 0.1,
-    },
-  },
-  {
-    input: -0.1,
-    expected: {
-      f32: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)],
-      f16: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)],
-      abstract: 0.1,
-    },
-  },
-] as const;
-
 g.test('absInterval')
   .params(u =>
     u
@@ -2193,7 +2208,12 @@ g.test('absInterval')
           // Common usages
           { input: 1, expected: 1 },
           { input: -1, expected: 1 },
-          ...kAbsIntervalCases.map(t => {return {input: t.input, expected: t.expected[p.trait]} as ScalarToIntervalCase}),
+          // abs(+/-0.1) is correctly rounded interval of 0.1
+          { input: 0.1, expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1']},
+          { input: -0.1, expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1']},
+          // abs(+/-1.9) is correctly rounded interval of 1.9
+          { input: 1.9, expected: kConstantCorrectlyRoundedExpectation[p.trait]['1.9']},
+          { input: -1.9, expected: kConstantCorrectlyRoundedExpectation[p.trait]['1.9']},
 
           // Edge cases
           { input: constants.positive.infinity, expected: kUnboundedBounds },
@@ -3111,8 +3131,6 @@ const kInverseSqrtIntervalCases = {
     // 1/sqrt(0x3D23D70B)=4.9999998230487200185270893769213 rounded to f32 0x409FFFFF or 0x40A00000,
     // 1/sqrt(0x3D23D70A)=5.0000000558793553117506910583908 rounded to f32 0x40A00000 or 0x40A00001.
     { input: 0.04, expected: [reinterpretU32AsF32(0x409FFFFF), reinterpretU32AsF32(0x40A00001)] },  // ~5.0
-    // 1/sqrt(100.0)=0.1 rounded to f32 0x3DCCCCCC or 0x3DCCCCCD
-    { input: 100, expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)] },  // ~0.1
     // Maximium f32 0x7F7FFFFF = 3.4028234663852886e+38,
     // 1/sqrt(0x7F7FFFFF)=5.4210110239862427800382690921791e-20 rounded to f32 0x1F800000 or 0x1F800001
     { input: kValue.f32.positive.max, expected: [reinterpretU32AsF32(0x1f800000), reinterpretU32AsF32(0x1f800001)] },  // ~5.421...e-20
@@ -3122,8 +3140,6 @@ const kInverseSqrtIntervalCases = {
     // 1/sqrt(0x291F)=4.9994660279328446295684795818427 rounded to f16 0x44FF or 0x4500,
     // 1/sqrt(0x291E)=5.001373857053206453045376503367 rounded to f16 0x4500 or 0x4501.
     { input: 0.04, expected: [reinterpretU16AsF16(0x44FF), reinterpretU16AsF16(0x4501)] },  // ~5.0
-    // 1/sqrt(100.0)=0.1 rounded to f16 0x2E66 or 0x2E67
-    { input: 100, expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)] },  // ~0.1
     // Maximium f16 0x7BFF = 65504,
     // 1/sqrt(0x7BFF)=0.00390720402370454101997160826062 rounded to f16 0x1C00 or 0x1C01
     { input: kValue.f16.positive.max, expected: [reinterpretU16AsF16(0x1c00), reinterpretU16AsF16(0x1c01)] },  // ~3.9072...e-3
@@ -3138,6 +3154,7 @@ g.test('inverseSqrtInterval')
       .expandWithParams<ScalarToIntervalCase>(p => {
         const trait = FP[p.trait];
         const constants = trait.constants();
+        // Note that the 2 ULP error is not included here.
         // prettier-ignore
         return [
           // Exactly representable cases
@@ -3147,6 +3164,8 @@ g.test('inverseSqrtInterval')
 
           // Cases that input and/or result not exactly representable
           ...kInverseSqrtIntervalCases[p.trait],
+          // 1/sqrt(100.0)=0.1, rounded to corresponding trait
+          { input: 100, expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },  // ~0.1
 
           // Out of definition domain
           { input: -1, expected: kUnboundedBounds },
@@ -3348,85 +3367,38 @@ g.test('log2Interval')
     );
   });
 
-// prettier-ignore
-const kNegationIntervalCases = {
-  f32: [
-    // Edge cases
-    { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
-    { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
-    { input: kValue.f32.positive.max, expected: kValue.f32.negative.min },
-    { input: kValue.f32.positive.min, expected: kValue.f32.negative.max },
-    { input: kValue.f32.negative.min, expected: kValue.f32.positive.max },
-    { input: kValue.f32.negative.max, expected: kValue.f32.positive.min },
-
-    // Normals
-    { input: 0.1, expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] }, // ~-0.1
-    { input: 1.9, expected: [reinterpretU32AsF32(0xbff33334), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbff33334))] },  // ~-1.9
-    { input: -0.1, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] }, // ~0.1
-    { input: -1.9, expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3ff33334)), reinterpretU32AsF32(0x3ff33334)] },  // ~1.9
-
-    // Subnormals
-    { input: kValue.f32.subnormal.positive.max, expected: [kValue.f32.subnormal.negative.min, 0] },
-    { input: kValue.f32.subnormal.positive.min, expected: [kValue.f32.subnormal.negative.max, 0] },
-    { input: kValue.f32.subnormal.negative.min, expected: [0, kValue.f32.subnormal.positive.max] },
-    { input: kValue.f32.subnormal.negative.max, expected: [0, kValue.f32.subnormal.positive.min] },
-  ] as ScalarToIntervalCase[],
-  f16: [
-    // Edge cases
-    { input: kValue.f16.infinity.positive, expected: kUnboundedBounds },
-    { input: kValue.f16.infinity.negative, expected: kUnboundedBounds },
-    { input: kValue.f16.positive.max, expected: kValue.f16.negative.min },
-    { input: kValue.f16.positive.min, expected: kValue.f16.negative.max },
-    { input: kValue.f16.negative.min, expected: kValue.f16.positive.max },
-    { input: kValue.f16.negative.max, expected: kValue.f16.positive.min },
-
-    // Normals
-    { input: 0.1, expected: [kMinusOneULPFunctions['f16'](reinterpretU16AsF16(0xae66)), reinterpretU16AsF16(0xae66)] }, // ~-0.1
-    { input: 1.9, expected: [reinterpretU16AsF16(0xbf9a), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xbf9a))] },  // ~-1.9
-    { input: -0.1, expected: [reinterpretU16AsF16(0x2e66), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66))] }, // ~0.1
-    { input: -1.9, expected: [kMinusOneULPFunctions['f16'](reinterpretU16AsF16(0x3f9a)), reinterpretU16AsF16(0x3f9a)] },  // ~1.9
-
-    // Subnormals
-    { input: kValue.f16.subnormal.positive.max, expected: [kValue.f16.subnormal.negative.min, 0] },
-    { input: kValue.f16.subnormal.positive.min, expected: [kValue.f16.subnormal.negative.max, 0] },
-    { input: kValue.f16.subnormal.negative.min, expected: [0, kValue.f16.subnormal.positive.max] },
-    { input: kValue.f16.subnormal.negative.max, expected: [0, kValue.f16.subnormal.positive.min] },
-  ] as ScalarToIntervalCase[],
-  abstract: [
-    // Edge cases
-    { input: kValue.f64.infinity.positive, expected: kUnboundedBounds },
-    { input: kValue.f64.infinity.negative, expected: kUnboundedBounds },
-    { input: kValue.f64.positive.max, expected: kValue.f64.negative.min },
-    { input: kValue.f64.positive.min, expected: kValue.f64.negative.max },
-    { input: kValue.f64.negative.min, expected: kValue.f64.positive.max },
-    { input: kValue.f64.negative.max, expected: kValue.f64.positive.min },
-
-    // Normals
-    { input: 0.1, expected: -0.1 },
-    { input: 1.9, expected: -1.9 },
-    { input: -0.1, expected: 0.1 },
-    { input: -1.9, expected: 1.9 },
-
-    // Subnormals
-    { input: kValue.f64.subnormal.positive.max, expected: [kValue.f64.subnormal.negative.min, 0] },
-    { input: kValue.f64.subnormal.positive.min, expected: [kValue.f64.subnormal.negative.max, 0] },
-    { input: kValue.f64.subnormal.negative.min, expected: [0, kValue.f64.subnormal.positive.max] },
-    { input: kValue.f64.subnormal.negative.max, expected: [0, kValue.f64.subnormal.positive.min] },
-  ] as ScalarToIntervalCase[],
-} as const;
-
 g.test('negationInterval')
   .params(u =>
     u
       .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarToIntervalCase>(p => {
+        const trait = FP[p.trait];
+        const constants = trait.constants();
         // prettier-ignore
         return [
+          // Edge cases
+          { input: constants.positive.infinity, expected: kUnboundedBounds },
+          { input: constants.negative.infinity, expected: kUnboundedBounds },
+          { input: constants.positive.max, expected: constants.negative.min },
+          { input: constants.positive.min, expected: constants.negative.max },
+          { input: constants.negative.min, expected: constants.positive.max },
+          { input: constants.negative.max, expected: constants.positive.min },
+
+          // Normals
           { input: 0, expected: 0 },
           { input: 1.0, expected: -1.0 },
           { input: -1.0, expected: 1 },
-          ...kNegationIntervalCases[p.trait],
+          { input: 0.1, expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] }, // ~-0.1
+          { input: 1.9, expected: kConstantCorrectlyRoundedExpectation[p.trait]['-1.9'] },  // ~-1.9
+          { input: -0.1, expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] }, // ~0.1
+          { input: -1.9, expected: kConstantCorrectlyRoundedExpectation[p.trait]['1.9'] },  // ~1.9
+
+          // Subnormals
+          { input: constants.positive.subnormal.max, expected: [constants.negative.subnormal.min, 0] },
+          { input: constants.positive.subnormal.min, expected: [constants.negative.subnormal.max, 0] },
+          { input: constants.negative.subnormal.min, expected: [0, constants.positive.subnormal.max] },
+          { input: constants.negative.subnormal.max, expected: [0, constants.positive.subnormal.min] },
         ];
       })
   )
@@ -3447,8 +3419,9 @@ g.test('quantizeToF16Interval_f32')
       { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
       { input: kValue.f32.negative.min, expected: kUnboundedBounds },
       { input: kValue.f16.negative.min, expected: kValue.f16.negative.min },
+      { input: -1.9, expected: kConstantCorrectlyRoundedExpectation['f16']['-1.9'] },  // ~-1.9
       { input: -1, expected: -1 },
-      { input: -0.1, expected: [reinterpretU32AsF32(0xbdcce000), reinterpretU32AsF32(0xbdccc000)] },  // ~-0.1
+      { input: -0.1, expected: kConstantCorrectlyRoundedExpectation['f16']['-0.1'] },  // ~-0.1
       { input: kValue.f16.negative.max, expected: kValue.f16.negative.max },
       { input: kValue.f16.subnormal.negative.min, expected: [kValue.f16.subnormal.negative.min, 0] },
       { input: kValue.f16.subnormal.negative.max, expected: [kValue.f16.subnormal.negative.max, 0] },
@@ -3458,8 +3431,9 @@ g.test('quantizeToF16Interval_f32')
       { input: kValue.f16.subnormal.positive.min, expected: [0, kValue.f16.subnormal.positive.min] },
       { input: kValue.f16.subnormal.positive.max, expected: [0, kValue.f16.subnormal.positive.max] },
       { input: kValue.f16.positive.min, expected: kValue.f16.positive.min },
-      { input: 0.1, expected: [reinterpretU32AsF32(0x3dccc000), reinterpretU32AsF32(0x3dcce000)] },  // ~0.1
+      { input: 0.1, expected: kConstantCorrectlyRoundedExpectation['f16']['0.1'] },  // ~0.1
       { input: 1, expected: 1 },
+      { input: 1.9, expected: kConstantCorrectlyRoundedExpectation['f16']['1.9'] },  // ~1.9
       { input: kValue.f16.positive.max, expected: kValue.f16.positive.max },
       { input: kValue.f32.positive.max, expected: kUnboundedBounds },
       { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
@@ -3614,35 +3588,6 @@ g.test('roundInterval')
     );
   });
 
-// Need to explicitly coerce expected value to IntervalBounds, because TS
-// doesn't correctly infer the type later.
-const kSaturateIntervalCases = {
-  f32: [
-    {
-      input: 0.1,
-      expected: [
-        kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)),
-        reinterpretU32AsF32(0x3dcccccd),
-      ],
-    }, // ~0.1
-  ] as ScalarToIntervalCase[],
-  f16: [
-    {
-      input: 0.1,
-      expected: [
-        reinterpretU16AsF16(0x2e66),
-        kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66)),
-      ],
-    }, // ~0.1
-  ] as ScalarToIntervalCase[],
-  abstract: [
-    {
-      input: 0.1,
-      expected: 0.1,
-    }, // ~0.1
-  ] as ScalarToIntervalCase[],
-} as const;
-
 g.test('saturateInterval')
   .params(u =>
     u
@@ -3654,6 +3599,7 @@ g.test('saturateInterval')
         return [
           // Normals
           { input: 0, expected: 0 },
+          { input: 0.1, expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },
           { input: 1, expected: 1.0 },
           { input: -0.1, expected: 0 },
           { input: -1, expected: 0 },
@@ -3674,7 +3620,6 @@ g.test('saturateInterval')
           // Infinities
           { input: constants.positive.infinity, expected: kUnboundedBounds },
           { input: constants.negative.infinity, expected: kUnboundedBounds },
-          ...kSaturateIntervalCases[p.trait],
         ];
       })
   )
@@ -3905,7 +3850,7 @@ g.test('sqrtInterval')
   });
 
 // All of these are hard coded, since the error intervals are difficult to express in a closed
-// human--readable form.
+// human-readable form.
 // Some easy looking cases like f(x = -π|π) = 0 are actually quite difficult. This is because the
 // interval is calculated from the results of sin(x)/cos(x), which becomes very messy at x = -π|π,
 // since π is irrational, thus does not have an exact representation as a float.
@@ -4084,12 +4029,7 @@ interface ScalarPairToIntervalCase {
 // prettier-ignore
 const kAdditionInterval64BitsNormalCases = {
   f32: [
-    // 0.1 falls between f32 0x3DCCCCCC and 0x3DCCCCCD
-    { input: [0.1, 0], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)] },
-    { input: [0, 0.1], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)] },
-    // -0.1 falls between f32 0xBDCCCCCD and 0xBDCCCCCC
-    { input: [-0.1, 0], expected: [reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)] },
-    { input: [0, -0.1], expected: [reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)] },
+    // 0.1 falls between f32 0x3DCCCCCC and 0x3DCCCCCD, -0.1 falls between f32 0xBDCCCCCD and 0xBDCCCCCC
     // f32 0x3DCCCCCC+0x3DCCCCCC=0x3E4CCCCC, 0x3DCCCCCD+0x3DCCCCCD=0x3E4CCCCD
     { input: [0.1, 0.1], expected: [reinterpretU32AsF32(0x3e4ccccc), reinterpretU32AsF32(0x3e4ccccd)] },  // ~0.2
     // f32 0xBDCCCCCD+0xBDCCCCCD=0xBE4CCCCD, 0xBDCCCCCC+0xBDCCCCCC=0xBE4CCCCD
@@ -4100,12 +4040,7 @@ const kAdditionInterval64BitsNormalCases = {
     { input: [-0.1, 0.1], expected: [reinterpretU32AsF32(0xbdcccccd)+reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0xbdcccccc)+reinterpretU32AsF32(0x3dcccccd)] },  // ~0.0
   ] as ScalarPairToIntervalCase[],
   f16: [
-    // 0.1 falls between f16 0x2E66 and 0x2E67
-    { input: [0.1, 0], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)] },
-    { input: [0, 0.1], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)] },
-    // -0.1 falls between f16 0xAE67 and 0xAE66
-    { input: [-0.1, 0], expected: [reinterpretU16AsF16(0xae67), reinterpretU16AsF16(0xae66)] },
-    { input: [0, -0.1], expected: [reinterpretU16AsF16(0xae67), reinterpretU16AsF16(0xae66)] },
+    // 0.1 falls between f16 0x2E66 and 0x2E67, -0.1 falls between f16 0xAE67 and 0xAE66
     // f16 0x2E66+0x2E66=0x3266, 0x2E67+0x2E67=0x3267
     { input: [0.1, 0.1], expected: [reinterpretU16AsF16(0x3266), reinterpretU16AsF16(0x3267)] },  // ~0.2
     // f16 0xAE67+0xAE67=0xB267, 0xAE66+0xAE66=0xB266
@@ -4119,10 +4054,6 @@ const kAdditionInterval64BitsNormalCases = {
     // 0.1 isn't exactly representable in f64, but will be quantized to an
     // exact value when storing to a 'number' (0x3FB999999999999A).
     // This is why below the expectations are not intervals.
-    { input: [0.1, 0], expected: 0.1 },
-    { input: [0, 0.1], expected: 0.1 },
-    { input: [-0.1, 0], expected: -0.1 },
-    { input: [0, -0.1], expected: -0.1 },
     // f64 0x3FB999999999999A+0x3FB999999999999A = 0x3FC999999999999A
     { input: [0.1, 0.1], expected: reinterpretU64AsF64(0x3FC999999999999An) },  // ~0.2
     // f64 0xBFB999999999999A+0xBFB999999999999A = 0xBFC999999999999A
@@ -4153,6 +4084,13 @@ g.test('additionInterval')
           { input: [-1, 1], expected: 0 },
           { input: [-1, -1], expected: -2 },
 
+          // 0.1 should be correctly rounded
+          { input: [0.1, 0], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },
+          { input: [0, 0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },
+          // -0.1 should be correctly rounded
+          { input: [-0.1, 0], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },
+          { input: [0, -0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },
+
           // 64-bit normals that can not be exactly represented
           ...kAdditionInterval64BitsNormalCases[p.trait],
 
@@ -4577,36 +4515,6 @@ g.test('ldexpInterval')
     );
   });
 
-// prettier-ignore
-const kMaxInterval64BitsCases = {
-  f32: [
-    // 0.1 rounded to f32 0x3DCCCCCC or 0x3DCCCCCD, -0.1 rounded to f32 0xBDCCCCCD or 0xBDCCCCCC
-    { input: [0.1, 0], expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] },  // ~0.1
-    { input: [0, 0.1], expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] },  // ~0.1
-    { input: [0.1, 0.1], expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] },  // ~0.1
-    { input: [0.1, -0.1], expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] },  // ~0.1
-    { input: [-0.1, 0.1], expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] },  // ~0.1
-    { input: [-0.1, -0.1], expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] },  // ~-0.1
-  ] as ScalarPairToIntervalCase[],
-  f16: [
-    // 0.1 rounded to f16 0x2E66 or 0x2E67, -0.1 rounded to f16 0xAE67 or 0xAE66
-    { input: [0.1, 0], expected: [reinterpretU16AsF16(0x2e66), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66))] },  // ~0.1
-    { input: [0, 0.1], expected: [reinterpretU16AsF16(0x2e66), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66))] },  // ~0.1
-    { input: [0.1, 0.1], expected: [reinterpretU16AsF16(0x2e66), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66))] },  // ~0.1
-    { input: [0.1, -0.1], expected: [reinterpretU16AsF16(0x2e66), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66))] },  // ~0.1
-    { input: [-0.1, 0.1], expected: [reinterpretU16AsF16(0x2e66), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66))] },  // ~0.1
-    { input: [-0.1, -0.1], expected: [reinterpretU16AsF16(0xae67), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xae67))] },  // ~-0.1
-  ] as ScalarPairToIntervalCase[],
-  abstract: [
-    { input: [0.1, 0], expected: 0.1 },
-    { input: [0, 0.1], expected: 0.1 },
-    { input: [0.1, 0.1], expected: 0.1 },
-    { input: [0.1, -0.1], expected: 0.1 },
-    { input: [-0.1, 0.1], expected: 0.1 },
-    { input: [-0.1, -0.1], expected: -0.1 },
-  ] as ScalarPairToIntervalCase[],
-} as const;
-
 g.test('maxInterval')
   .params(u =>
     u
@@ -4628,10 +4536,15 @@ g.test('maxInterval')
           { input: [-1, 1], expected: 1 },
           { input: [-1, -1], expected: -1 },
 
-          // 64-bit normals that not exactly representable
+          // 0.1 and -0.1 should be correctly rounded
           { input: [-0.1, 0], expected: 0 },
           { input: [0, -0.1], expected: 0 },
-          ...kMaxInterval64BitsCases[p.trait],
+          { input: [0.1, 0], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },  // ~0.1
+          { input: [0, 0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },  // ~0.1
+          { input: [0.1, 0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },  // ~0.1
+          { input: [0.1, -0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },  // ~0.1
+          { input: [-0.1, 0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },  // ~0.1
+          { input: [-0.1, -0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },  // ~-0.1
 
           // Representable subnormals
           { input: [constants.positive.subnormal.max, 0], expected: [0, constants.positive.subnormal.max] },
@@ -4668,36 +4581,6 @@ g.test('maxInterval')
     );
   });
 
-// prettier-ignore
-const kMinInterval64BitsCases = {
-  f32: [
-    // 0.1 rounded to f32 0x3DCCCCCC or 0x3DCCCCCD, -0.1 rounded to f32 0xBDCCCCCD or 0xBDCCCCCC
-    { input: [-0.1, 0], expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] },  // ~-0.1
-    { input: [0, -0.1], expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] },  // ~-0.1
-    { input: [0.1, 0.1], expected: [kMinusOneULPFunctions['f32'](reinterpretU32AsF32(0x3dcccccd)), reinterpretU32AsF32(0x3dcccccd)] },  // ~0.1
-    { input: [0.1, -0.1], expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] },  // ~-0.1
-    { input: [-0.1, 0.1], expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] },  // ~-0.1
-    { input: [-0.1, -0.1], expected: [reinterpretU32AsF32(0xbdcccccd), kPlusOneULPFunctions['f32'](reinterpretU32AsF32(0xbdcccccd))] },  // ~-0.1
-  ] as ScalarPairToIntervalCase[],
-  f16: [
-    // 0.1 rounded to f16 0x2E66 or 0x2E67, -0.1 rounded to f16 0xAE67 or 0xAE66
-    { input: [-0.1, 0], expected: [reinterpretU16AsF16(0xae67), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xae67))] },  // ~-0.1
-    { input: [0, -0.1], expected: [reinterpretU16AsF16(0xae67), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xae67))] },  // ~-0.1
-    { input: [0.1, 0.1], expected: [reinterpretU16AsF16(0x2e66), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0x2e66))] },  // ~0.1
-    { input: [0.1, -0.1], expected: [reinterpretU16AsF16(0xae67), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xae67))] },  // ~-0.1
-    { input: [-0.1, 0.1], expected: [reinterpretU16AsF16(0xae67), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xae67))] },  // ~-0.1
-    { input: [-0.1, -0.1], expected: [reinterpretU16AsF16(0xae67), kPlusOneULPFunctions['f16'](reinterpretU16AsF16(0xae67))] },  // ~-0.1
-  ] as ScalarPairToIntervalCase[],
-  abstract: [
-    { input: [-0.1, 0], expected: -0.1 },
-    { input: [0, -0.1], expected: -0.1 },
-    { input: [0.1, 0.1], expected: 0.1 },
-    { input: [0.1, -0.1], expected: -0.1 },
-    { input: [-0.1, 0.1], expected: -0.1 },
-    { input: [-0.1, -0.1], expected: -0.1 },
-  ] as ScalarPairToIntervalCase[],
-} as const;
-
 g.test('minInterval')
   .params(u =>
     u
@@ -4722,7 +4605,12 @@ g.test('minInterval')
           // 64-bit normals that not exactly representable
           { input: [0.1, 0], expected: 0 },
           { input: [0, 0.1], expected: 0 },
-          ...kMinInterval64BitsCases[p.trait],
+          { input: [-0.1, 0], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },  // ~-0.1
+          { input: [0, -0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },  // ~-0.1
+          { input: [0.1, 0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },  // ~0.1
+          { input: [0.1, -0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },  // ~-0.1
+          { input: [-0.1, 0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },  // ~-0.1
+          { input: [-0.1, -0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },  // ~-0.1
 
           // Representable subnormals
           { input: [constants.positive.subnormal.max, 0], expected: [0, constants.positive.subnormal.max] },
@@ -4762,18 +4650,7 @@ g.test('minInterval')
 // prettier-ignore
 const kMultiplicationInterval64BitsNormalCases = {
   f32: [
-    // Finite values multiply zero result in zero
-    { input: [0.1, 0], expected: 0 },
-    { input: [0, 0.1], expected: 0 },
-    { input: [-0.1, 0], expected: 0 },
-    { input: [0, -0.1], expected: 0 },
-    // 0.1 falls between f32 0x3DCCCCCC and 0x3DCCCCCD
-    { input: [0.1, 1], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)] },
-    { input: [-1, -0.1], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)] },
-    // -0.1 falls between f32 0xBDCCCCCD and 0xBDCCCCCC
-    { input: [-0.1, 1], expected: [reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)] },
-    { input: [-1, 0.1], expected: [reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)] },
-    // 0.1*0.1,
+    // 0.1*0.1, 0.1 falls between f32 0x3DCCCCCC and 0x3DCCCCCD,
     // min result 0x3DCCCCCC*0x3DCCCCCC=0.00999999880790713952713681734167 rounded to f32 0x3C23D708 or 0x3C23D709,
     // max result 0x3DCCCCCD*0x3DCCCCCD=0.01000000029802322622044605108385 rounded to f32 0x3C23D70A or 0x3C23D70B.
     { input: [0.1, 0.1], expected: [reinterpretU32AsF32(0x3c23d708), reinterpretU32AsF32(0x3c23d70b)] },  // ~0.01
@@ -4784,18 +4661,7 @@ const kMultiplicationInterval64BitsNormalCases = {
     { input: [-0.1, 0.1], expected: [reinterpretU32AsF32(0xbc23d70b), reinterpretU32AsF32(0xbc23d708)] },  // ~-0.01
   ] as ScalarPairToIntervalCase[],
   f16: [
-    // Finite values multiply zero result in zero
-    { input: [0.1, 0], expected: 0 },
-    { input: [0, 0.1], expected: 0 },
-    { input: [-0.1, 0], expected: 0 },
-    { input: [0, -0.1], expected: 0 },
-    // 0.1 falls between f16 0x2E66 and 0x2E67
-    { input: [0.1, 1], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)] },
-    { input: [-1, -0.1], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)] },
-    // -0.1 falls between f16 0xAE67 and 0xAE66
-    { input: [-0.1, 1], expected: [reinterpretU16AsF16(0xae67), reinterpretU16AsF16(0xae66)] },
-    { input: [-1, 0.1], expected: [reinterpretU16AsF16(0xae67), reinterpretU16AsF16(0xae66)] },
-    // 0.1*0.1,
+    // 0.1*0.1, 0.1 falls between f16 0x2E66 and 0x2E67,
     // min result 0x2E66*0x2E66=0.00999511778354644775390625 rounded to f16 0x211E or 0x211F,
     // max result 0x2E67*0x2E67=0.0100073255598545074462890625 rounded to f16 0x211F or 0x2120.
     { input: [0.1, 0.1], expected: [reinterpretU16AsF16(0x211e), reinterpretU16AsF16(0x2120)] },  // ~0.01
@@ -4809,15 +4675,6 @@ const kMultiplicationInterval64BitsNormalCases = {
     // 0.1 isn't exactly representable in f64, but will be quantized to an
     // exact value when storing to a 'number' (0x3FB999999999999A).
     // This is why below the expectations are not intervals.
-    // Finite values multiply zero result in zero
-    { input: [0.1, 0], expected: 0 },
-    { input: [0, 0.1], expected: 0 },
-    { input: [-0.1, 0], expected: 0 },
-    { input: [0, -0.1], expected: 0 },
-    { input: [0.1, 1], expected: 0.1 },
-    { input: [-1, -0.1], expected: 0.1 },
-    { input: [-0.1, 1], expected: -0.1 },
-    { input: [-1, 0.1], expected: -0.1 },
     // f64 0.1 * 0.1 = 0x3f847ae147ae147c,
     { input: [0.1, 0.1], expected: reinterpretU64AsF64(0x3f847ae147ae147cn) },  // ~0.01
     { input: [-0.1, -0.1], expected: reinterpretU64AsF64(0x3f847ae147ae147cn) },  // ~0.01
@@ -4856,6 +4713,17 @@ g.test('multiplicationInterval')
           { input: [-2, -2], expected: 4 },
 
           // 64-bit normals that can not be exactly represented
+          // Finite values multiply zero result in zero
+          { input: [0.1, 0], expected: 0 },
+          { input: [0, 0.1], expected: 0 },
+          { input: [-0.1, 0], expected: 0 },
+          { input: [0, -0.1], expected: 0 },
+          // Finite value multiply +/-1.0
+          { input: [0.1, 1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },
+          { input: [-1, -0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },
+          { input: [-0.1, 1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },
+          { input: [-1, 0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },
+          // Other cases
           ...kMultiplicationInterval64BitsNormalCases[p.trait],
 
           // Infinities
@@ -5105,12 +4973,7 @@ g.test('stepInterval')
 // prettier-ignore
 const kSubtractionInterval64BitsNormalCases = {
   f32: [
-    // 0.1 falls between f32 0x3DCCCCCC and 0x3DCCCCCD
-    { input: [0.1, 0], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)] },
-    { input: [0, -0.1], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)] },
-    // -0.1 falls between f32 0xBDCCCCCD and 0xBDCCCCCC
-    { input: [-0.1, 0], expected: [reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)] },
-    { input: [0, 0.1], expected: [reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0xbdcccccc)] },
+    // 0.1 falls between f32 0x3DCCCCCC and 0x3DCCCCCD, -0.1 falls between f32 0xBDCCCCCD and 0xBDCCCCCC
     // Expect f32 interval [0x3DCCCCCC-0x3DCCCCCD, 0x3DCCCCCD-0x3DCCCCCC]
     { input: [0.1, 0.1], expected: [reinterpretU32AsF32(0x3dcccccc)-reinterpretU32AsF32(0x3dcccccd), reinterpretU32AsF32(0x3dcccccd)-reinterpretU32AsF32(0x3dcccccc)] },
     // Expect f32 interval [0xBDCCCCCD-0xBDCCCCCC, 0xBDCCCCCC-0xBDCCCCCD]
@@ -5121,12 +4984,7 @@ const kSubtractionInterval64BitsNormalCases = {
     { input: [-0.1, 0.1], expected: [reinterpretU32AsF32(0xbdcccccd)-reinterpretU32AsF32(0x3dcccccd), reinterpretU32AsF32(0xbdcccccc)-reinterpretU32AsF32(0x3dcccccc)] },
   ] as ScalarPairToIntervalCase[],
   f16: [
-    // 0.1 falls between f16 0x2E66 and 0x2E67
-    { input: [0.1, 0], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)] },
-    { input: [0, -0.1], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)] },
-    // -0.1 falls between f16 0xAE67 and 0xAE66
-    { input: [-0.1, 0], expected: [reinterpretU16AsF16(0xae67), reinterpretU16AsF16(0xae66)] },
-    { input: [0, 0.1], expected: [reinterpretU16AsF16(0xae67), reinterpretU16AsF16(0xae66)] },
+    // 0.1 falls between f16 0x2E66 and 0x2E67, -0.1 falls between f16 0xAE67 and 0xAE66
     // Expect f16 interval [0x2E66-0x2E67, 0x2E67-0x2E66]
     { input: [0.1, 0.1], expected: [reinterpretU16AsF16(0x2e66)-reinterpretU16AsF16(0x2e67), reinterpretU16AsF16(0x2e67)-reinterpretU16AsF16(0x2e66)] },
     // Expect f16 interval [0xAE67-0xAE66, 0xAE66-0xAE67]
@@ -5140,11 +4998,6 @@ const kSubtractionInterval64BitsNormalCases = {
     // 0.1 isn't exactly representable in f64, but will be quantized to an
     // exact value when storing to a 'number' (0x3FB999999999999A).
     // This is why below the expectations are not intervals.
-    { input: [0.1, 0], expected: 0.1 },
-    { input: [0, -0.1], expected: 0.1 },
-    { input: [-0.1, 0], expected: -0.1 },
-    { input: [0, 0.1], expected: -0.1 },
-
     { input: [0.1, 0.1], expected: 0 },
     { input: [-0.1, -0.1], expected: 0 },
     // f64 0x3FB999999999999A - 0xBFB999999999999A = 0x3FC999999999999A
@@ -5175,7 +5028,11 @@ g.test('subtractionInterval')
           { input: [-1, 1], expected: -2 },
           { input: [-1, -1], expected: 0 },
 
-          // 64-bit normals that can not be exactly represented
+          // 64-bit normals that can not be exactly represented in f32/f16
+          { input: [0.1, 0], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },
+          { input: [0, -0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1'] },
+          { input: [-0.1, 0], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },
+          { input: [0, 0.1], expected: kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'] },
           ...kSubtractionInterval64BitsNormalCases[p.trait],
 
           // Subnormals
@@ -6144,12 +6001,6 @@ g.test('distanceIntervalVector')
 // prettier-ignore
 const kDotIntervalCases = {
   f32: [
-    // vec2
-    { input: [[0.1, 0.0], [1.0, 0.0]], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)]},  // ~0.1
-    // vec3
-    { input: [[0.1, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)]},  // ~0.1
-    // vec4
-    { input: [[0.1, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0x3dcccccd)]},  // ~0.1
     // Inputs with large values but cancel out to finite result. In these cases, 2.0*2.0 = 4.0 and
     // 3.0*3.0 = 9.0 is much smaller than kValue.f32.positive.max, as a result
     // kValue.f32.positive.max + 9.0 = kValue.f32.positive.max in f32 and even f64. So, if the
@@ -6160,12 +6011,6 @@ const kDotIntervalCases = {
     { input: [[kValue.f32.positive.max, 1.0, 2.0, 3.0], [1.0, kValue.f32.negative.min, 2.0, 3.0]], expected: [0, 13] },
   ] as VectorPairToIntervalCase[],
   f16: [
-    // vec2
-    { input: [[0.1, 0.0], [1.0, 0.0]], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)]},  // ~0.1
-    // vec3
-    { input: [[0.1, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)]},  // ~0.1
-    // vec4
-    { input: [[0.1, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [reinterpretU16AsF16(0x2e66), reinterpretU16AsF16(0x2e67)]},  // ~0.1
     // Inputs with large values but cancel out to finite result. In these cases, 2.0*2.0 = 4.0 and
     // 3.0*3.0 = 9.0 is not small enough comparing to kValue.f16.positive.max = 65504, as a result
     // kValue.f16.positive.max + 9.0 = 65513 is exactly representable in f32 and f64. So, if the
@@ -6193,6 +6038,7 @@ g.test('dotInterval')
           { input: [[1.0, 1.0], [1.0, 1.0]], expected: 2.0 },
           { input: [[-1.0, -1.0], [-1.0, -1.0]], expected: 2.0 },
           { input: [[-1.0, 1.0], [1.0, -1.0]], expected: -2.0 },
+          { input: [[0.1, 0.0], [1.0, 0.0]], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1']},  // correclt rounded of 0.1
 
           // vec3
           { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: 1.0 },
@@ -6201,6 +6047,7 @@ g.test('dotInterval')
           { input: [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], expected: 3.0 },
           { input: [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]], expected: 3.0 },
           { input: [[1.0, -1.0, -1.0], [-1.0, 1.0, -1.0]], expected: -1.0 },
+          { input: [[0.1, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1']},  // correclt rounded of 0.1
 
           // vec4
           { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: 1.0 },
@@ -6210,6 +6057,7 @@ g.test('dotInterval')
           { input: [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], expected: 4.0 },
           { input: [[-1.0, -1.0, -1.0, -1.0], [-1.0, -1.0, -1.0, -1.0]], expected: 4.0 },
           { input: [[-1.0, 1.0, -1.0, 1.0], [1.0, -1.0, 1.0, -1.0]], expected: -4.0 },
+          { input: [[0.1, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: kConstantCorrectlyRoundedExpectation[p.trait]['0.1']},  // correclt rounded of 0.1
 
           ...kDotIntervalCases[p.trait],
 
@@ -8134,10 +7982,10 @@ g.test('faceForwardIntervals')
           { input: [[-10.0, 0.0], [10.0, 0.0], [10.0, 0.0]], expected: [[10.0, 0.0]] },
           { input: [[10.0, 0.0], [-10.0, 10.0], [10.0, -10.0]], expected: [[10.0, 0.0]] },
           { input: [[-10.0, 0.0], [-10.0, 10.0], [10.0, -10.0]], expected: [[-10.0, 0.0]] },
-          { input: [[0.1, 0.0], [0.1, 0.0], [0.1, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0]] },
-          { input: [[-0.1, 0.0], [0.1, 0.0], [0.1, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0]] },
-          { input: [[0.1, 0.0], [-0.1, 0.1], [0.1, -0.1]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0]] },
-          { input: [[-0.1, 0.0], [-0.1, 0.1], [0.1, -0.1]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0]] },
+          { input: [[0.1, 0.0], [0.1, 0.0], [0.1, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'], 0.0]] },
+          { input: [[-0.1, 0.0], [0.1, 0.0], [0.1, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['0.1'], 0.0]] },
+          { input: [[0.1, 0.0], [-0.1, 0.1], [0.1, -0.1]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['0.1'], 0.0]] },
+          { input: [[-0.1, 0.0], [-0.1, 0.1], [0.1, -0.1]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'], 0.0]] },
 
           // vec3
           { input: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]], expected: [[-1.0, 0.0, 0.0]] },
@@ -8148,10 +7996,10 @@ g.test('faceForwardIntervals')
           { input: [[-10.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 0.0, 0.0]], expected: [[10.0, 0.0, 0.0]] },
           { input: [[10.0, 0.0, 0.0], [-10.0, 10.0, 0.0], [10.0, -10.0, 0.0]], expected: [[10.0, 0.0, 0.0]] },
           { input: [[-10.0, 0.0, 0.0], [-10.0, 10.0, 0.0], [10.0, -10.0, 0.0]], expected: [[-10.0, 0.0, 0.0]] },
-          { input: [[0.1, 0.0, 0.0], [0.1, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0, 0.0]] },
-          { input: [[-0.1, 0.0, 0.0], [0.1, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0, 0.0]] },
-          { input: [[0.1, 0.0, 0.0], [-0.1, 0.0, 0.0], [0.1, -0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0, 0.0]] },
-          { input: [[-0.1, 0.0, 0.0], [-0.1, 0.0, 0.0], [0.1, -0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0, 0.0]] },
+          { input: [[0.1, 0.0, 0.0], [0.1, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'], 0.0, 0.0]] },
+          { input: [[-0.1, 0.0, 0.0], [0.1, 0.0, 0.0], [0.1, 0.0, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['0.1'], 0.0, 0.0]] },
+          { input: [[0.1, 0.0, 0.0], [-0.1, 0.0, 0.0], [0.1, -0.0, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['0.1'], 0.0, 0.0]] },
+          { input: [[-0.1, 0.0, 0.0], [-0.1, 0.0, 0.0], [0.1, -0.0, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'], 0.0, 0.0]] },
 
           // vec4
           { input: [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]], expected: [[-1.0, 0.0, 0.0, 0.0]] },
@@ -8162,10 +8010,10 @@ g.test('faceForwardIntervals')
           { input: [[-10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0], [10.0, 0.0, 0.0, 0.0]], expected: [[10.0, 0.0, 0.0, 0.0]] },
           { input: [[10.0, 0.0, 0.0, 0.0], [-10.0, 10.0, 0.0, 0.0], [10.0, -10.0, 0.0, 0.0]], expected: [[10.0, 0.0, 0.0, 0.0]] },
           { input: [[-10.0, 0.0, 0.0, 0.0], [-10.0, 10.0, 0.0, 0.0], [10.0, -10.0, 0.0, 0.0]], expected: [[-10.0, 0.0, 0.0, 0.0]] },
-          { input: [[0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0, 0.0, 0.0]] },
-          { input: [[-0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0, 0.0, 0.0]] },
-          { input: [[0.1, 0.0, 0.0, 0.0], [-0.1, 0.0, 0.0, 0.0], [0.1, -0.0, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(0.1).bounds(), 0.0, 0.0, 0.0]] },
-          { input: [[-0.1, 0.0, 0.0, 0.0], [-0.1, 0.0, 0.0, 0.0], [0.1, -0.0, 0.0, 0.0]], expected: [[trait.correctlyRoundedInterval(-0.1).bounds(), 0.0, 0.0, 0.0]] },
+          { input: [[0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'], 0.0, 0.0, 0.0]] },
+          { input: [[-0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0], [0.1, 0.0, 0.0, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['0.1'], 0.0, 0.0, 0.0]] },
+          { input: [[0.1, 0.0, 0.0, 0.0], [-0.1, 0.0, 0.0, 0.0], [0.1, -0.0, 0.0, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['0.1'], 0.0, 0.0, 0.0]] },
+          { input: [[-0.1, 0.0, 0.0, 0.0], [-0.1, 0.0, 0.0, 0.0], [0.1, -0.0, 0.0, 0.0]], expected: [[kConstantCorrectlyRoundedExpectation[p.trait]['-0.1'], 0.0, 0.0, 0.0]] },
 
           // dot(y, z) === 0
           { input: [[1.0, 1.0], [1.0, 0.0], [0.0, 1.0]], expected:  [[-1.0, -1.0]] },

From a3eaacd6d29a3fe5c3cac55a93d3e86dbdffd7ec Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 27 Sep 2023 10:56:02 -0400
Subject: [PATCH 099/166] wgsl: Add f16 `modf` execution tests (#3019)

Fixes #2568
---
 src/unittests/floating_point.spec.ts          |  69 +++----
 src/webgpu/listing_meta.json                  |  18 +-
 .../expression/call/builtin/modf.spec.ts      | 173 ++++++++++++++----
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 181 insertions(+), 81 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 5b1280e8ae97..84f92c5ce516 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -8043,44 +8043,51 @@ interface ModfCase {
   whole: number | IntervalBounds;
 }
 
-g.test('modfInterval_f32')
-  .paramsSubcasesOnly<ModfCase>(
-    // prettier-ignore
-    [
-      // Normals
-      { input: 0, fract: 0, whole: 0 },
-      { input: 1, fract: 0, whole: 1 },
-      { input: -1, fract: 0, whole: -1 },
-      { input: 0.5, fract: 0.5, whole: 0 },
-      { input: -0.5, fract: -0.5, whole: 0 },
-      { input: 2.5, fract: 0.5, whole: 2 },
-      { input: -2.5, fract: -0.5, whole: -2 },
-      { input: 10.0, fract: 0, whole: 10 },
-      { input: -10.0, fract: 0, whole: -10 },
-
-      // Subnormals
-      { input: kValue.f32.subnormal.negative.min, fract: [kValue.f32.subnormal.negative.min, 0], whole: 0 },
-      { input: kValue.f32.subnormal.negative.max, fract: [kValue.f32.subnormal.negative.max, 0], whole: 0 },
-      { input: kValue.f32.subnormal.positive.min, fract: [0, kValue.f32.subnormal.positive.min], whole: 0 },
-      { input: kValue.f32.subnormal.positive.max, fract: [0, kValue.f32.subnormal.positive.max], whole: 0 },
-
-      // Boundaries
-      { input: kValue.f32.negative.min, fract: 0, whole: kValue.f32.negative.min },
-      { input: kValue.f32.negative.max, fract: kValue.f32.negative.max, whole: 0 },
-      { input: kValue.f32.positive.min, fract: kValue.f32.positive.min, whole: 0 },
-      { input: kValue.f32.positive.max, fract: 0, whole: kValue.f32.positive.max },
-    ]
+g.test('modfInterval')
+  .params(u =>
+    u
+      .combine('trait', ['f32', 'f16'] as const)
+      .beginSubcases()
+      .expandWithParams<ModfCase>(p => {
+        const constants = FP[p.trait].constants();
+        // prettier-ignore
+        return [
+          // Normals
+          { input: 0, fract: 0, whole: 0 },
+          { input: 1, fract: 0, whole: 1 },
+          { input: -1, fract: 0, whole: -1 },
+          { input: 0.5, fract: 0.5, whole: 0 },
+          { input: -0.5, fract: -0.5, whole: 0 },
+          { input: 2.5, fract: 0.5, whole: 2 },
+          { input: -2.5, fract: -0.5, whole: -2 },
+          { input: 10.0, fract: 0, whole: 10 },
+          { input: -10.0, fract: 0, whole: -10 },
+
+          // Subnormals
+          { input: constants.positive.subnormal.min, fract: [0, constants.positive.subnormal.min], whole: 0 },
+          { input: constants.positive.subnormal.max, fract: [0, constants.positive.subnormal.max], whole: 0 },
+          { input: constants.negative.subnormal.min, fract: [constants.negative.subnormal.min, 0], whole: 0 },
+          { input: constants.negative.subnormal.max, fract: [constants.negative.subnormal.max, 0], whole: 0 },
+
+          // Boundaries
+          { input: constants.negative.min, fract: 0, whole: constants.negative.min },
+          { input: constants.negative.max, fract: constants.negative.max, whole: 0 },
+          { input: constants.positive.min, fract: constants.positive.min, whole: 0 },
+          { input: constants.positive.max, fract: 0, whole: constants.positive.max },
+        ];
+      })
   )
   .fn(t => {
+    const trait = FP[t.params.trait];
     const expected = {
-      fract: FP.f32.toInterval(t.params.fract),
-      whole: FP.f32.toInterval(t.params.whole),
+      fract: trait.toInterval(t.params.fract),
+      whole: trait.toInterval(t.params.whole),
     };
 
-    const got = FP.f32.modfInterval(t.params.input);
+    const got = trait.modfInterval(t.params.input);
     t.expect(
       objectEquals(expected, got),
-      `f32.modfInterval([${t.params.input}) returned { fract: [${got.fract}], whole: [${got.whole}] }. Expected { fract: [${expected.fract}], whole: [${expected.whole}] }`
+      `${trait}.modfInterval([${t.params.input}) returned { fract: [${got.fract}], whole: [${got.whole}] }. Expected { fract: [${expected.fract}], whole: [${expected.whole}] }`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 16a5cb5509b3..8750db5d7c92 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1279,7 +1279,7 @@
   "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec2:*": { "subcaseMS": 503.551 },
   "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec3:*": { "subcaseMS": 590.326 },
   "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec4:*": { "subcaseMS": 679.901 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f16_fract:*": { "subcaseMS": 4.202 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_fract:*": { "subcaseMS": 10.602 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_fract:*": { "subcaseMS": 9.200 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_whole:*": { "subcaseMS": 8.404 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec3_fract:*": { "subcaseMS": 3.102 },
@@ -1287,14 +1287,14 @@
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec4_fract:*": { "subcaseMS": 8.503 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec4_whole:*": { "subcaseMS": 3.001 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_whole:*": { "subcaseMS": 17.103 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f32_fract:*": { "subcaseMS": 22.850 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec2_fract:*": { "subcaseMS": 9.451 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec2_whole:*": { "subcaseMS": 10.950 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec3_fract:*": { "subcaseMS": 9.526 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec3_whole:*": { "subcaseMS": 14.950 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec4_fract:*": { "subcaseMS": 11.151 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec4_whole:*": { "subcaseMS": 13.550 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f32_whole:*": { "subcaseMS": 10.725 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_fract:*": { "subcaseMS": 298.126 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec2_fract:*": { "subcaseMS": 59.401 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec2_whole:*": { "subcaseMS": 86.501 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec3_fract:*": { "subcaseMS": 96.550 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec3_whole:*": { "subcaseMS": 94.475 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec4_fract:*": { "subcaseMS": 147.876 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_vec4_whole:*": { "subcaseMS": 134.576 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_whole:*": { "subcaseMS": 94.025 },
   "webgpu:shader,execution,expression,call,builtin,normalize:abstract_float:*": { "subcaseMS": 28.508 },
   "webgpu:shader,execution,expression,call,builtin,normalize:f16_vec2:*": { "subcaseMS": 635.100 },
   "webgpu:shader,execution,expression,call,builtin,normalize:f16_vec3:*": { "subcaseMS": 112.501 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts
index 0c1c51c1d60a..3c0aa49ff791 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts
@@ -18,9 +18,16 @@ Returns the result_struct for the given type.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { toVector, TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import { toVector, TypeF16, TypeF32, TypeVec } from '../../../../../util/conversion.js';
 import { FP, FPKind } from '../../../../../util/floating_point.js';
-import { fullF32Range, vectorF32Range } from '../../../../../util/math.js';
+import {
+  fullF16Range,
+  fullF32Range,
+  fullF64Range,
+  vectorF16Range,
+  vectorF32Range,
+  vectorF64Range,
+} from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import {
   allInputSources,
@@ -42,6 +49,24 @@ function fractBuilder(): ShaderBuilder {
   return basicExpressionBuilder(value => `modf(${value}).fract`);
 }
 
+/** @returns a fract Case for a scalar vector input */
+function makeScalarCaseFract(kind: FPKind, n: number): Case {
+  const fp = FP[kind];
+  n = fp.quantize(n);
+  const result = fp.modfInterval(n).fract;
+
+  return { input: fp.scalarBuilder(n), expected: result };
+}
+
+/** @returns a whole Case for a scalar vector input */
+function makeScalarCaseWhole(kind: FPKind, n: number): Case {
+  const fp = FP[kind];
+  n = fp.quantize(n);
+  const result = fp.modfInterval(n).whole;
+
+  return { input: fp.scalarBuilder(n), expected: result };
+}
+
 /** @returns a fract Case for a given vector input */
 function makeVectorCaseFract(kind: FPKind, v: number[]): Case {
   const fp = FP[kind];
@@ -64,39 +89,59 @@ function makeVectorCaseWhole(kind: FPKind, v: number[]): Case {
   return { input: toVector(v, fp.scalarBuilder), expected: ws };
 }
 
-export const d = makeCaseCache('modf', {
-  f32_fract: () => {
-    const makeCase = (n: number): Case => {
-      n = FP.f32.quantize(n);
-      return { input: FP.f32.scalarBuilder(n), expected: FP.f32.modfInterval(n).fract };
-    };
-    return fullF32Range().map(makeCase);
-  },
-  f32_whole: () => {
-    const makeCase = (n: number): Case => {
-      n = FP.f32.quantize(n);
-      return { input: FP.f32.scalarBuilder(n), expected: FP.f32.modfInterval(n).whole };
-    };
-    return fullF32Range().map(makeCase);
-  },
-  f32_vec2_fract: () => {
-    return vectorF32Range(2).map(makeVectorCaseFract.bind(null, 'f32'));
-  },
-  f32_vec2_whole: () => {
-    return vectorF32Range(2).map(makeVectorCaseWhole.bind(null, 'f32'));
-  },
-  f32_vec3_fract: () => {
-    return vectorF32Range(3).map(makeVectorCaseFract.bind(null, 'f32'));
+const scalar_range = {
+  f32: fullF32Range(),
+  f16: fullF16Range(),
+  abstract: fullF64Range(),
+};
+
+const vector_range = {
+  f32: {
+    2: vectorF32Range(2),
+    3: vectorF32Range(3),
+    4: vectorF32Range(4),
   },
-  f32_vec3_whole: () => {
-    return vectorF32Range(3).map(makeVectorCaseWhole.bind(null, 'f32'));
+  f16: {
+    2: vectorF16Range(2),
+    3: vectorF16Range(3),
+    4: vectorF16Range(4),
   },
-  f32_vec4_fract: () => {
-    return vectorF32Range(4).map(makeVectorCaseFract.bind(null, 'f32'));
-  },
-  f32_vec4_whole: () => {
-    return vectorF32Range(4).map(makeVectorCaseWhole.bind(null, 'f32'));
+  abstract: {
+    2: vectorF64Range(2),
+    3: vectorF64Range(3),
+    4: vectorF64Range(4),
   },
+};
+
+// Cases: [f32|f16]_[fract|whole]
+const scalar_cases = (['f32', 'f16'] as const)
+  .flatMap(kind =>
+    (['whole', 'fract'] as const).map(portion => ({
+      [`${kind}_${portion}`]: () => {
+        const makeCase = portion === 'whole' ? makeScalarCaseWhole : makeScalarCaseFract;
+        return scalar_range[kind].map(makeCase.bind(null, kind));
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: [f32|f16]_vecN_[fract|whole]
+const vec_cases = (['f32', 'f16'] as const)
+  .flatMap(kind =>
+    ([2, 3, 4] as const).flatMap(n =>
+      (['whole', 'fract'] as const).map(portion => ({
+        [`${kind}_vec${n}_${portion}`]: () => {
+          const makeCase = portion === 'whole' ? makeVectorCaseWhole : makeVectorCaseFract;
+          return vector_range[kind][n].map(makeCase.bind(null, kind));
+        },
+      }))
+    )
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('modf', {
+  ...scalar_cases,
+  ...vec_cases,
 });
 
 g.test('f32_fract')
@@ -256,7 +301,13 @@ struct __modf_result_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_fract');
+    await run(t, fractBuilder(), [TypeF16], TypeF16, t.params, cases);
+  });
 
 g.test('f16_whole')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -271,7 +322,13 @@ struct __modf_result_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_whole');
+    await run(t, wholeBuilder(), [TypeF16], TypeF16, t.params, cases);
+  });
 
 g.test('f16_vec2_fract')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -286,7 +343,13 @@ struct __modf_result_vec2_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec2_fract');
+    await run(t, fractBuilder(), [TypeVec(2, TypeF16)], TypeVec(2, TypeF16), t.params, cases);
+  });
 
 g.test('f16_vec2_whole')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -301,7 +364,13 @@ struct __modf_result_vec2_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec2_whole');
+    await run(t, wholeBuilder(), [TypeVec(2, TypeF16)], TypeVec(2, TypeF16), t.params, cases);
+  });
 
 g.test('f16_vec3_fract')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -316,7 +385,13 @@ struct __modf_result_vec3_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec3_fract');
+    await run(t, fractBuilder(), [TypeVec(3, TypeF16)], TypeVec(3, TypeF16), t.params, cases);
+  });
 
 g.test('f16_vec3_whole')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -331,7 +406,13 @@ struct __modf_result_vec3_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec3_whole');
+    await run(t, wholeBuilder(), [TypeVec(3, TypeF16)], TypeVec(3, TypeF16), t.params, cases);
+  });
 
 g.test('f16_vec4_fract')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -346,7 +427,13 @@ struct __modf_result_vec4_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec4_fract');
+    await run(t, fractBuilder(), [TypeVec(4, TypeF16)], TypeVec(4, TypeF16), t.params, cases);
+  });
 
 g.test('f16_vec4_whole')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -361,4 +448,10 @@ struct __modf_result_vec4_f16 {
 `
   )
   .params(u => u.combine('inputSource', allInputSources))
-  .unimplemented();
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
+  })
+  .fn(async t => {
+    const cases = await d.get('f16_vec4_whole');
+    await run(t, wholeBuilder(), [TypeVec(4, TypeF16)], TypeVec(4, TypeF16), t.params, cases);
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index d68ac2e31fa8..b81aa6e89787 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5314,7 +5314,7 @@ class F16Traits extends FPTraits {
   public readonly mixImpreciseInterval = this.mixImpreciseIntervalImpl.bind(this);
   public readonly mixPreciseInterval = this.mixPreciseIntervalImpl.bind(this);
   public readonly mixIntervals = [this.mixImpreciseInterval, this.mixPreciseInterval];
-  public readonly modfInterval = this.unimplementedModf.bind(this);
+  public readonly modfInterval = this.modfIntervalImpl.bind(this);
   public readonly multiplicationInterval = this.multiplicationIntervalImpl.bind(this);
   public readonly multiplicationMatrixMatrixInterval = this.multiplicationMatrixMatrixIntervalImpl.bind(
     this

From 00859ea32b99a4d38d5267e45f785c228e4ff498 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 27 Sep 2023 12:37:40 -0400
Subject: [PATCH 100/166] wgsl: Add AbstractFloat `modf` execution tests
 (#3020)

Fixes #2569

Co-authored-by: jzm-intel <zhaoming.jiang@intel.com>
---
 src/unittests/floating_point.spec.ts          |   2 +-
 src/webgpu/listing_meta.json                  |  12 +-
 .../expression/call/builtin/modf.spec.ts      | 218 +++++++++++++++++-
 src/webgpu/util/floating_point.ts             |   2 +-
 4 files changed, 223 insertions(+), 11 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 84f92c5ce516..7363bccc0be5 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -8046,7 +8046,7 @@ interface ModfCase {
 g.test('modfInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ModfCase>(p => {
         const constants = FP[p.trait].constants();
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 8750db5d7c92..96e3c3c128ce 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1279,7 +1279,15 @@
   "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec2:*": { "subcaseMS": 503.551 },
   "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec3:*": { "subcaseMS": 590.326 },
   "webgpu:shader,execution,expression,call,builtin,mix:f32_nonmatching_vec4:*": { "subcaseMS": 679.901 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f16_fract:*": { "subcaseMS": 10.602 },
+  "webgpu:shader,execution,expression,call,builtin,modf:abstract_fract:*": { "subcaseMS": 327.601 },
+  "webgpu:shader,execution,expression,call,builtin,modf:abstract_vec2_fract:*": { "subcaseMS": 435.400 },
+  "webgpu:shader,execution,expression,call,builtin,modf:abstract_vec2_whole:*": { "subcaseMS": 434.300 },
+  "webgpu:shader,execution,expression,call,builtin,modf:abstract_vec3_fract:*": { "subcaseMS": 942.701 },
+  "webgpu:shader,execution,expression,call,builtin,modf:abstract_vec3_whole:*": { "subcaseMS": 932.000 },
+  "webgpu:shader,execution,expression,call,builtin,modf:abstract_vec4_fract:*": { "subcaseMS": 1645.901 },
+  "webgpu:shader,execution,expression,call,builtin,modf:abstract_vec4_whole:*": { "subcaseMS": 1812.500 },
+  "webgpu:shader,execution,expression,call,builtin,modf:abstract_whole:*": { "subcaseMS": 296.601 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f16_fract:*": { "subcaseMS": 11.801 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_fract:*": { "subcaseMS": 9.200 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec2_whole:*": { "subcaseMS": 8.404 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec3_fract:*": { "subcaseMS": 3.102 },
@@ -1287,7 +1295,7 @@
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec4_fract:*": { "subcaseMS": 8.503 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_vec4_whole:*": { "subcaseMS": 3.001 },
   "webgpu:shader,execution,expression,call,builtin,modf:f16_whole:*": { "subcaseMS": 17.103 },
-  "webgpu:shader,execution,expression,call,builtin,modf:f32_fract:*": { "subcaseMS": 298.126 },
+  "webgpu:shader,execution,expression,call,builtin,modf:f32_fract:*": { "subcaseMS": 319.500 },
   "webgpu:shader,execution,expression,call,builtin,modf:f32_vec2_fract:*": { "subcaseMS": 59.401 },
   "webgpu:shader,execution,expression,call,builtin,modf:f32_vec2_whole:*": { "subcaseMS": 86.501 },
   "webgpu:shader,execution,expression,call,builtin,modf:f32_vec3_fract:*": { "subcaseMS": 96.550 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts
index 3c0aa49ff791..5bc4a54ab7d0 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts
@@ -1,13 +1,13 @@
 export const description = `
 Execution tests for the 'modf' builtin function
 
-T is f32 or f16
+T is f32 or f16 or AbstractFloat
 @const fn modf(e:T) -> result_struct
 Splits |e| into fractional and whole number parts.
 The whole part is (|e| % 1.0), and the fractional part is |e| minus the whole part.
 Returns the result_struct for the given type.
 
-S is f32 or f16
+S is f32 or f16 or AbstractFloat
 T is vecN<S>
 @const fn modf(e:T) -> result_struct
 Splits the components of |e| into fractional and whole number parts.
@@ -18,7 +18,13 @@ Returns the result_struct for the given type.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { toVector, TypeF16, TypeF32, TypeVec } from '../../../../../util/conversion.js';
+import {
+  toVector,
+  TypeAbstractFloat,
+  TypeF16,
+  TypeF32,
+  TypeVec,
+} from '../../../../../util/conversion.js';
 import { FP, FPKind } from '../../../../../util/floating_point.js';
 import {
   fullF16Range,
@@ -30,9 +36,11 @@ import {
 } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import {
+  abstractFloatShaderBuilder,
   allInputSources,
   basicExpressionBuilder,
   Case,
+  onlyConstInputSource,
   run,
   ShaderBuilder,
 } from '../../expression.js';
@@ -49,6 +57,16 @@ function fractBuilder(): ShaderBuilder {
   return basicExpressionBuilder(value => `modf(${value}).fract`);
 }
 
+/** @returns an ShaderBuilder that evaluates modf and returns .whole from the result structure for AbstractFloats */
+function abstractWholeBuilder(): ShaderBuilder {
+  return abstractFloatShaderBuilder(value => `modf(${value}).whole`);
+}
+
+/** @returns an ShaderBuilder that evaluates modf and returns .fract from the result structure for AbstractFloats */
+function abstractFractBuilder(): ShaderBuilder {
+  return abstractFloatShaderBuilder(value => `modf(${value}).fract`);
+}
+
 /** @returns a fract Case for a scalar vector input */
 function makeScalarCaseFract(kind: FPKind, n: number): Case {
   const fp = FP[kind];
@@ -113,8 +131,8 @@ const vector_range = {
   },
 };
 
-// Cases: [f32|f16]_[fract|whole]
-const scalar_cases = (['f32', 'f16'] as const)
+// Cases: [f32|f16|abstract]_[fract|whole]
+const scalar_cases = (['f32', 'f16', 'abstract'] as const)
   .flatMap(kind =>
     (['whole', 'fract'] as const).map(portion => ({
       [`${kind}_${portion}`]: () => {
@@ -125,8 +143,8 @@ const scalar_cases = (['f32', 'f16'] as const)
   )
   .reduce((a, b) => ({ ...a, ...b }), {});
 
-// Cases: [f32|f16]_vecN_[fract|whole]
-const vec_cases = (['f32', 'f16'] as const)
+// Cases: [f32|f16|abstract]_vecN_[fract|whole]
+const vec_cases = (['f32', 'f16', 'abstract'] as const)
   .flatMap(kind =>
     ([2, 3, 4] as const).flatMap(n =>
       (['whole', 'fract'] as const).map(portion => ({
@@ -455,3 +473,189 @@ struct __modf_result_vec4_f16 {
     const cases = await d.get('f16_vec4_whole');
     await run(t, wholeBuilder(), [TypeVec(4, TypeF16)], TypeVec(4, TypeF16), t.params, cases);
   });
+
+g.test('abstract_fract')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(
+    `
+T is AbstractFloat
+
+struct __modf_result_abstract {
+  fract : AbstractFloat, // fractional part
+  whole : AbstractFloat  // whole part
+}
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('abstract_fract');
+    await run(t, abstractFractBuilder(), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases);
+  });
+
+g.test('abstract_whole')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(
+    `
+T is AbstractFloat
+
+struct __modf_result_abstract {
+  fract : AbstractFloat, // fractional part
+  whole : AbstractFloat  // whole part
+}
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('abstract_whole');
+    await run(t, abstractWholeBuilder(), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases);
+  });
+
+g.test('abstract_vec2_fract')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(
+    `
+T is vec2<abstract>
+
+struct __modf_result_vec2_abstract {
+  fract : vec2<abstract>, // fractional part
+  whole : vec2<abstract>  // whole part
+}
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('abstract_vec2_fract');
+    await run(
+      t,
+      abstractFractBuilder(),
+      [TypeVec(2, TypeAbstractFloat)],
+      TypeVec(2, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('abstract_vec2_whole')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(
+    `
+T is vec2<abstract>
+
+struct __modf_result_vec2_abstract {
+  fract : vec2<abstract>, // fractional part
+  whole : vec2<abstract>  // whole part
+}
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('abstract_vec2_whole');
+    await run(
+      t,
+      abstractWholeBuilder(),
+      [TypeVec(2, TypeAbstractFloat)],
+      TypeVec(2, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('abstract_vec3_fract')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(
+    `
+T is vec3<abstract>
+
+struct __modf_result_vec3_abstract {
+  fract : vec3<abstract>, // fractional part
+  whole : vec3<abstract>  // whole part
+}
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('abstract_vec3_fract');
+    await run(
+      t,
+      abstractFractBuilder(),
+      [TypeVec(3, TypeAbstractFloat)],
+      TypeVec(3, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('abstract_vec3_whole')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(
+    `
+T is vec3<abstract>
+
+struct __modf_result_vec3_abstract {
+  fract : vec3<abstract>, // fractional part
+  whole : vec3<abstract>  // whole part
+}
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('abstract_vec3_whole');
+    await run(
+      t,
+      abstractWholeBuilder(),
+      [TypeVec(3, TypeAbstractFloat)],
+      TypeVec(3, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('abstract_vec4_fract')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(
+    `
+T is vec4<abstract>
+
+struct __modf_result_vec4_abstract {
+  fract : vec4<abstract>, // fractional part
+  whole : vec4<abstract>  // whole part
+}
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('abstract_vec4_fract');
+    await run(
+      t,
+      abstractFractBuilder(),
+      [TypeVec(4, TypeAbstractFloat)],
+      TypeVec(4, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('abstract_vec4_whole')
+  .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+  .desc(
+    `
+T is vec4<abstract>
+
+struct __modf_result_vec4_abstract {
+  fract : vec4<abstract>, // fractional part
+  whole : vec4<abstract>  // whole part
+}
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('abstract_vec4_whole');
+    await run(
+      t,
+      abstractWholeBuilder(),
+      [TypeVec(4, TypeAbstractFloat)],
+      TypeVec(4, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index b81aa6e89787..25a7b74da38a 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5007,7 +5007,7 @@ class FPAbstractTraits extends FPTraits {
     'mixPreciseInterval'
   );
   public readonly mixIntervals = [this.mixImpreciseInterval, this.mixPreciseInterval];
-  public readonly modfInterval = this.unimplementedModf.bind(this);
+  public readonly modfInterval = this.modfIntervalImpl.bind(this);
   public readonly multiplicationInterval = this.multiplicationIntervalImpl.bind(this);
   public readonly multiplicationMatrixMatrixInterval = this.unimplementedMatrixPairToMatrix.bind(
     this,

From 8ac24113ef6d9baa207f4bb80bb71a047e50985a Mon Sep 17 00:00:00 2001
From: Corentin Wallez <cwallez@chromium.org>
Date: Wed, 27 Sep 2023 19:26:54 +0200
Subject: [PATCH 101/166] Add rgb10a2uint GPUTextureFormat testing. (#2956)

---
 package-lock.json                             | 14 ++---
 package.json                                  |  2 +-
 .../pipeline_output_targets.spec.ts           | 11 ++--
 src/webgpu/format_info.ts                     | 10 ++++
 src/webgpu/util/texture/texel_data.ts         | 52 +++++++++++++++++++
 5 files changed, 77 insertions(+), 12 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 9ff545a79a79..d0b850245006 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -23,7 +23,7 @@
         "@types/pngjs": "^6.0.1",
         "@types/serve-index": "^1.9.1",
         "@typescript-eslint/parser": "^4.33.0",
-        "@webgpu/types": "gpuweb/types#ca1a548178567e6021fd194380b97be1bf6b07b7",
+        "@webgpu/types": "gpuweb/types#d1d74def71a13a2318828139994afd1b9c3f987c",
         "ansi-colors": "4.1.1",
         "babel-plugin-add-header-comment": "^1.0.3",
         "babel-plugin-const-enum": "^1.2.0",
@@ -1262,9 +1262,9 @@
       }
     },
     "node_modules/@webgpu/types": {
-      "version": "0.1.34",
-      "resolved": "git+ssh://git@github.com/gpuweb/types.git#ca1a548178567e6021fd194380b97be1bf6b07b7",
-      "integrity": "sha512-L3q2iZPXqb5/qHupSV4G8tphM2GnCuaAf6SQWLqMNDgMwDk/Y4UWRxSIlY98ONKa1pDOuhIsXj6s1U3rU0wqhw==",
+      "version": "0.1.35",
+      "resolved": "git+ssh://git@github.com/gpuweb/types.git#d1d74def71a13a2318828139994afd1b9c3f987c",
+      "integrity": "sha512-6mh8zm/DDdtY6c+DXRmYc/7wJ1RQitFFmQiviwV8BK1XB75lXigN8AC8netNUO4XWTm7zEZevWgdMzXgThwOtA==",
       "dev": true,
       "license": "BSD-3-Clause"
     },
@@ -9884,10 +9884,10 @@
       }
     },
     "@webgpu/types": {
-      "version": "git+ssh://git@github.com/gpuweb/types.git#ca1a548178567e6021fd194380b97be1bf6b07b7",
-      "integrity": "sha512-L3q2iZPXqb5/qHupSV4G8tphM2GnCuaAf6SQWLqMNDgMwDk/Y4UWRxSIlY98ONKa1pDOuhIsXj6s1U3rU0wqhw==",
+      "version": "git+ssh://git@github.com/gpuweb/types.git#d1d74def71a13a2318828139994afd1b9c3f987c",
+      "integrity": "sha512-6mh8zm/DDdtY6c+DXRmYc/7wJ1RQitFFmQiviwV8BK1XB75lXigN8AC8netNUO4XWTm7zEZevWgdMzXgThwOtA==",
       "dev": true,
-      "from": "@webgpu/types@gpuweb/types#ca1a548178567e6021fd194380b97be1bf6b07b7"
+      "from": "@webgpu/types@gpuweb/types#d1d74def71a13a2318828139994afd1b9c3f987c"
     },
     "abbrev": {
       "version": "1.1.1",
diff --git a/package.json b/package.json
index 173a5094e63c..2e3cc0d8ca7f 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,7 @@
     "@types/pngjs": "^6.0.1",
     "@types/serve-index": "^1.9.1",
     "@typescript-eslint/parser": "^4.33.0",
-    "@webgpu/types": "gpuweb/types#ca1a548178567e6021fd194380b97be1bf6b07b7",
+    "@webgpu/types": "gpuweb/types#d1d74def71a13a2318828139994afd1b9c3f987c",
     "ansi-colors": "4.1.1",
     "babel-plugin-add-header-comment": "^1.0.3",
     "babel-plugin-const-enum": "^1.2.0",
diff --git a/src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts b/src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts
index 12cc86bd4cb5..bfe7a6ca6b0e 100644
--- a/src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts
+++ b/src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts
@@ -30,11 +30,14 @@ export const g = makeTestGroup(TextureTestMixin(GPUTest));
 // Values to write into each attachment
 // We make values different for each attachment index and each channel
 // to make sure they didn't get mixed up
+
+// Clamp alpha to 3 to avoid comparing a large expected value with a max 3 value for rgb10a2uint
+// MAINTENANCE_TODO: Make TexelRepresentation.numericRange per-component and use that.
 const attachmentsIntWriteValues = [
-  { R: 1, G: 2, B: 3, A: 4 },
-  { R: 5, G: 6, B: 7, A: 8 },
-  { R: 9, G: 10, B: 11, A: 12 },
-  { R: 13, G: 14, B: 15, A: 16 },
+  { R: 1, G: 2, B: 3, A: 1 },
+  { R: 5, G: 6, B: 7, A: 2 },
+  { R: 9, G: 10, B: 11, A: 3 },
+  { R: 13, G: 14, B: 15, A: 0 },
 ];
 const attachmentsFloatWriteValues = [
   { R: 0.12, G: 0.34, B: 0.56, A: 0 },
diff --git a/src/webgpu/format_info.ts b/src/webgpu/format_info.ts
index 89b6c4704e7d..242549a8b6c9 100644
--- a/src/webgpu/format_info.ts
+++ b/src/webgpu/format_info.ts
@@ -408,6 +408,16 @@ const kRegularTextureFormatInfo = formatTableWithDefaults({
 
     // plain, mixed component width, 32 bits per texel
 
+    rgb10a2uint: {
+      color: { type: 'uint', copySrc: true, copyDst: true, storage: false, bytes: 4 },
+      colorRender: { blend: false, resolve: false, byteCost: 8, alignment: 4 },
+      renderable: true,
+      /*prettier-ignore*/ get renderTargetComponentAlignment() { return this.colorRender.alignment; },
+      /*prettier-ignore*/ get renderTargetPixelByteCost() { return this.colorRender.byteCost; },
+      multisample: true,
+      /*prettier-ignore*/ get sampleType() { return this.color.type; },
+      /*prettier-ignore*/ get bytesPerBlock() { return this.color.bytes; },
+    },
     rgb10a2unorm: {
       color: { type: 'float', copySrc: true, copyDst: true, storage: false, bytes: 4 },
       colorRender: { blend: true, resolve: true, byteCost: 8, alignment: 4 },
diff --git a/src/webgpu/util/texture/texel_data.ts b/src/webgpu/util/texture/texel_data.ts
index 602b68db353d..42490d800b6b 100644
--- a/src/webgpu/util/texture/texel_data.ts
+++ b/src/webgpu/util/texture/texel_data.ts
@@ -662,6 +662,58 @@ export const kTexelRepresentationInfo: {
     'rgba32float':           makeFloatInfo(     kRGBA, 32),
   },
   ...{
+    rgb10a2uint: {
+      componentOrder: kRGBA,
+      componentInfo: {
+        R: { dataType: 'uint', bitLength: 10 },
+        G: { dataType: 'uint', bitLength: 10 },
+        B: { dataType: 'uint', bitLength: 10 },
+        A: { dataType: 'uint', bitLength: 2 },
+      },
+      encode: components => {
+        assertInIntegerRange(components.R!, 10, false);
+        assertInIntegerRange(components.G!, 10, false);
+        assertInIntegerRange(components.B!, 10, false);
+        assertInIntegerRange(components.A!, 2, false);
+        return components;
+      },
+      decode: components => {
+        assertInIntegerRange(components.R!, 10, false);
+        assertInIntegerRange(components.G!, 10, false);
+        assertInIntegerRange(components.B!, 10, false);
+        assertInIntegerRange(components.A!, 2, false);
+        return components;
+      },
+      pack: components =>
+        packComponents(
+          kRGBA,
+          components,
+          {
+            R: 10,
+            G: 10,
+            B: 10,
+            A: 2,
+          },
+          'uint'
+        ),
+      unpackBits: (data: Uint8Array) =>
+        unpackComponentsBits(kRGBA, data, { R: 10, G: 10, B: 10, A: 2 }),
+      numberToBits: components => ({
+        R: components.R! & 0x3ff,
+        G: components.G! & 0x3ff,
+        B: components.B! & 0x3ff,
+        A: components.A! & 0x3,
+      }),
+      bitsToNumber: components => {
+        assertInIntegerRange(components.R!, 10, false);
+        assertInIntegerRange(components.G!, 10, false);
+        assertInIntegerRange(components.B!, 10, false);
+        assertInIntegerRange(components.A!, 2, false);
+        return components;
+      },
+      bitsToULPFromZero: components => components,
+      numericRange: null,
+    },
     rgb10a2unorm: {
       componentOrder: kRGBA,
       componentInfo: {

From 1013973325a4ed61b6f74787d65e24a6b5975d63 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Wed, 27 Sep 2023 15:27:08 -0700
Subject: [PATCH 102/166] Compat: Skip copyTextureToTexture for compressed
 textures

---
 .../api/validation/encoding/cmds/copyTextureToTexture.spec.ts    | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts b/src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts
index 558e8c65f9de..3e6ee2ddf93c 100644
--- a/src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts
+++ b/src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts
@@ -779,6 +779,7 @@ TODO: Express the offsets in "block size" so as to be able to test non-4x4 compr
   .beforeAllSubcases(t => {
     const { format } = t.params;
     t.selectDeviceOrSkipTestCase(kTextureFormatInfo[format].feature);
+    t.skipIfCopyTextureToTextureNotSupportedForFormat(format);
   })
   .fn(t => {
     const { format, dimension, copyBoxOffsets, srcCopyLevel, dstCopyLevel } = t.params;

From e61392d7df1585e56060091716a84adcf8a9fb99 Mon Sep 17 00:00:00 2001
From: Antonio Maiorano <amaiorano@google.com>
Date: Wed, 27 Sep 2023 19:34:36 -0400
Subject: [PATCH 103/166] Revert "util: Add negative zero in full F16/F32/F64
 range (#2978)" (#3029)

This reverts commit bc9f28287609e43dafce0d5da83c2093eae414b5.

Fix CTS roll: https://bugs.chromium.org/p/dawn/issues/detail?id=2098

We are still investigating the root problem. We believe this CL is not
actually at fault, but that it has exposed an issue in our infra.
Reverting this for now while we figure it out.
---
 src/unittests/maths.spec.ts | 52 ++++++++++++++++++-------------------
 src/webgpu/util/math.ts     | 12 ---------
 2 files changed, 26 insertions(+), 38 deletions(-)

diff --git a/src/unittests/maths.spec.ts b/src/unittests/maths.spec.ts
index eae2d03d4c87..fa3899e21e9a 100644
--- a/src/unittests/maths.spec.ts
+++ b/src/unittests/maths.spec.ts
@@ -1535,19 +1535,19 @@ g.test('fullF32Range')
   .paramsSimple<fullF32RangeCase>(
     // prettier-ignore
     [
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ -0.0, 0.0 ] },
-        { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -0.0, 0.0] },
-        { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, -0.0, 0.0 ] },
-        { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -1.9999998807907104, kValue.f32.negative.max, -0.0, 0.0 ] },
-        { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, -0.0, 0.0 ] },
-        { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, -0.0, 0.0 ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f32.subnormal.positive.min ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ -0.0, 0.0, kValue.f32.positive.min ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ -0.0, 0.0, kValue.f32.positive.min, kValue.f32.positive.max ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ -0.0, 0.0, kValue.f32.positive.min, 1.9999998807907104, kValue.f32.positive.max ] },
-        { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f32.negative.min, kValue.f32.subnormal.negative.min, -0.0, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.positive.min ] },
-        { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, -0.0, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max, kValue.f32.positive.min, kValue.f32.positive.max ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
+        { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, 0.0] },
+        { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, 0.0 ] },
+        { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -1.9999998807907104, kValue.f32.negative.max, 0.0 ] },
+        { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, 0.0 ] },
+        { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, 0.0 ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f32.subnormal.positive.min ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f32.positive.min ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f32.positive.min, kValue.f32.positive.max ] },
+        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f32.positive.min, 1.9999998807907104, kValue.f32.positive.max ] },
+        { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f32.negative.min, kValue.f32.subnormal.negative.min, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.positive.min ] },
+        { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max, kValue.f32.positive.min, kValue.f32.positive.max ] },
     ]
   )
   .fn(test => {
@@ -1576,19 +1576,19 @@ g.test('fullF16Range')
   .paramsSimple<fullF16RangeCase>(
     // prettier-ignore
     [
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ -0.0, 0.0 ] },
-          { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -0.0, 0.0] },
-          { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, -0.0, 0.0 ] },
-          { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -1.9990234375, kValue.f16.negative.max, -0.0, 0.0 ] },
-          { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, -0.0, 0.0 ] },
-          { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, -0.0, 0.0 ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f16.subnormal.positive.min ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ -0.0, 0.0, kValue.f16.positive.min ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ -0.0, 0.0, kValue.f16.positive.min, kValue.f16.positive.max ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ -0.0, 0.0, kValue.f16.positive.min, 1.9990234375, kValue.f16.positive.max ] },
-          { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f16.negative.min, kValue.f16.subnormal.negative.min, -0.0, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.positive.min ] },
-          { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, -0.0, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max, kValue.f16.positive.min, kValue.f16.positive.max ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
+          { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, 0.0] },
+          { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, 0.0 ] },
+          { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -1.9990234375, kValue.f16.negative.max, 0.0 ] },
+          { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, 0.0 ] },
+          { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, 0.0 ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f16.subnormal.positive.min ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f16.positive.min ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f16.positive.min, kValue.f16.positive.max ] },
+          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f16.positive.min, 1.9990234375, kValue.f16.positive.max ] },
+          { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f16.negative.min, kValue.f16.subnormal.negative.min, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.positive.min ] },
+          { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max, kValue.f16.positive.min, kValue.f16.positive.max ] },
       ]
   )
   .fn(test => {
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index cc25342b0da3..54bba7abfb71 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -920,9 +920,6 @@ export function fullF32Range(
       kBit.f32.subnormal.negative.max,
       counts.neg_sub
     ),
-    // -0.0
-    0x80000000,
-    // +0.0
     0,
     ...linearRange(
       kBit.f32.subnormal.positive.min,
@@ -987,9 +984,6 @@ export function fullF16Range(
       kBit.f16.subnormal.negative.max,
       counts.neg_sub
     ),
-    // -0.0
-    0x8000,
-    // +0.0
     0,
     ...linearRange(
       kBit.f16.subnormal.positive.min,
@@ -1038,9 +1032,6 @@ export function fullF64Range(
       kBit.f64.subnormal.negative.max,
       counts.neg_sub
     ),
-    // -0.0
-    0x8000_0000_0000_0000n,
-    // +0.0
     0n,
     ...linearRangeBigInt(
       kBit.f64.subnormal.positive.min,
@@ -1097,9 +1088,6 @@ export function filteredF64Range(
       kBit.f64.subnormal.negative.max,
       counts.neg_sub
     ),
-    // -0.0
-    0x8000_0000_0000_0000n,
-    // +0.0
     0n,
     ...linearRangeBigInt(
       kBit.f64.subnormal.positive.min,

From 6442db81ce7e8d6fb03083eeaa42e0ad25992c90 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 28 Sep 2023 00:28:09 -0400
Subject: [PATCH 104/166] Re-organize numeric constants to be consistent
 (#3025)

Moves `subnormals` and `infinity` entries down into appropriate
`positive` and `negative` locations.

e.g. kValue.f32.subnormal.positive.max becomes
kValue.f32.positive.subnormal.max

Co-authored-by: jzm-intel <zhaoming.jiang@intel.com>
---
 src/unittests/conversion.spec.ts              |  20 +-
 src/unittests/floating_point.spec.ts          | 130 +++---
 src/unittests/maths.spec.ts                   | 430 +++++++++---------
 src/unittests/serialization.spec.ts           |  60 +--
 .../expression/call/builtin/bitcast.spec.ts   |  16 +-
 .../call/builtin/quantizeToF16.spec.ts        |  16 +-
 .../shader/execution/expression/expression.ts |   4 +-
 .../expression/call/builtin/bitcast.spec.ts   |   8 +-
 src/webgpu/util/constants.ts                  | 145 +++---
 src/webgpu/util/floating_point.ts             |  42 +-
 src/webgpu/util/math.ts                       |  92 ++--
 11 files changed, 470 insertions(+), 493 deletions(-)

diff --git a/src/unittests/conversion.spec.ts b/src/unittests/conversion.spec.ts
index 589e20fdc652..8606aa871794 100644
--- a/src/unittests/conversion.spec.ts
+++ b/src/unittests/conversion.spec.ts
@@ -428,15 +428,15 @@ g.test('pack2x16float')
 
     // f32 subnormals
     // prettier-ignore
-    { inputs: [kValue.f32.subnormal.positive.max, 1], result: [0x3c000000, 0x3c008000, 0x3c000001] },
+    { inputs: [kValue.f32.positive.subnormal.max, 1], result: [0x3c000000, 0x3c008000, 0x3c000001] },
     // prettier-ignore
-    { inputs: [kValue.f32.subnormal.negative.min, 1], result: [0x3c008001, 0x3c000000, 0x3c008000] },
+    { inputs: [kValue.f32.negative.subnormal.min, 1], result: [0x3c008001, 0x3c000000, 0x3c008000] },
 
     // f16 subnormals
     // prettier-ignore
-    { inputs: [kValue.f16.subnormal.positive.max, 1], result: [0x3c0003ff, 0x3c000000, 0x3c008000] },
+    { inputs: [kValue.f16.positive.subnormal.max, 1], result: [0x3c0003ff, 0x3c000000, 0x3c008000] },
     // prettier-ignore
-    { inputs: [kValue.f16.subnormal.negative.min, 1], result: [0x03c0083ff, 0x3c000000, 0x3c008000] },
+    { inputs: [kValue.f16.negative.subnormal.min, 1], result: [0x03c0083ff, 0x3c000000, 0x3c008000] },
 
     // f16 out of bounds
     { inputs: [kValue.f16.positive.max + 1, 1], result: [undefined] },
@@ -481,8 +481,8 @@ g.test('pack2x16snorm')
     { inputs: [-0.1, -0.5], result: 0xc001f333 },
 
     // Subnormals
-    { inputs: [kValue.f32.subnormal.positive.max, 1], result: 0x7fff0000 },
-    { inputs: [kValue.f32.subnormal.negative.min, 1], result: 0x7fff0000 },
+    { inputs: [kValue.f32.positive.subnormal.max, 1], result: 0x7fff0000 },
+    { inputs: [kValue.f32.negative.subnormal.min, 1], result: 0x7fff0000 },
   ] as const)
   .fn(test => {
     const inputs = test.params.inputs;
@@ -506,7 +506,7 @@ g.test('pack2x16unorm')
     { inputs: [10, 10], result: 0xffffffff },
 
     // Subnormals
-    { inputs: [kValue.f32.subnormal.positive.max, 1], result: 0xffff0000 },
+    { inputs: [kValue.f32.positive.subnormal.max, 1], result: 0xffff0000 },
   ] as const)
   .fn(test => {
     const inputs = test.params.inputs;
@@ -542,8 +542,8 @@ g.test('pack4x8snorm')
     { inputs: [-0.1, -0.5, -0.1, -0.5], result: 0xc1f3c1f3 },
 
     // Subnormals
-    { inputs: [kValue.f32.subnormal.positive.max, 1, 1, 1], result: 0x7f7f7f00 },
-    { inputs: [kValue.f32.subnormal.negative.min, 1, 1, 1], result: 0x7f7f7f00 },
+    { inputs: [kValue.f32.positive.subnormal.max, 1, 1, 1], result: 0x7f7f7f00 },
+    { inputs: [kValue.f32.negative.subnormal.min, 1, 1, 1], result: 0x7f7f7f00 },
   ] as const)
   .fn(test => {
     const inputs = test.params.inputs;
@@ -570,7 +570,7 @@ g.test('pack4x8unorm')
     { inputs: [0.1, 0.5, 0.1, 0.5], result: 0x801a801a },
 
     // Subnormals
-    { inputs: [kValue.f32.subnormal.positive.max, 1, 1, 1], result: 0xffffff00 },
+    { inputs: [kValue.f32.positive.subnormal.max, 1, 1, 1], result: 0xffffff00 },
   ] as const)
   .fn(test => {
     const inputs = test.params.inputs;
diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 7363bccc0be5..d5a0a0ddcc75 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3416,27 +3416,27 @@ g.test('quantizeToF16Interval_f32')
   .paramsSubcasesOnly<ScalarToIntervalCase>(
     // prettier-ignore
     [
-      { input: kValue.f32.infinity.negative, expected: kUnboundedBounds },
+      { input: kValue.f32.negative.infinity, expected: kUnboundedBounds },
       { input: kValue.f32.negative.min, expected: kUnboundedBounds },
       { input: kValue.f16.negative.min, expected: kValue.f16.negative.min },
       { input: -1.9, expected: kConstantCorrectlyRoundedExpectation['f16']['-1.9'] },  // ~-1.9
       { input: -1, expected: -1 },
       { input: -0.1, expected: kConstantCorrectlyRoundedExpectation['f16']['-0.1'] },  // ~-0.1
       { input: kValue.f16.negative.max, expected: kValue.f16.negative.max },
-      { input: kValue.f16.subnormal.negative.min, expected: [kValue.f16.subnormal.negative.min, 0] },
-      { input: kValue.f16.subnormal.negative.max, expected: [kValue.f16.subnormal.negative.max, 0] },
-      { input: kValue.f32.subnormal.negative.max, expected: [kValue.f16.subnormal.negative.max, 0] },
+      { input: kValue.f16.negative.subnormal.min, expected: [kValue.f16.negative.subnormal.min, 0] },
+      { input: kValue.f16.negative.subnormal.max, expected: [kValue.f16.negative.subnormal.max, 0] },
+      { input: kValue.f32.negative.subnormal.max, expected: [kValue.f16.negative.subnormal.max, 0] },
       { input: 0, expected: 0 },
-      { input: kValue.f32.subnormal.positive.min, expected: [0, kValue.f16.subnormal.positive.min] },
-      { input: kValue.f16.subnormal.positive.min, expected: [0, kValue.f16.subnormal.positive.min] },
-      { input: kValue.f16.subnormal.positive.max, expected: [0, kValue.f16.subnormal.positive.max] },
+      { input: kValue.f32.positive.subnormal.min, expected: [0, kValue.f16.positive.subnormal.min] },
+      { input: kValue.f16.positive.subnormal.min, expected: [0, kValue.f16.positive.subnormal.min] },
+      { input: kValue.f16.positive.subnormal.max, expected: [0, kValue.f16.positive.subnormal.max] },
       { input: kValue.f16.positive.min, expected: kValue.f16.positive.min },
       { input: 0.1, expected: kConstantCorrectlyRoundedExpectation['f16']['0.1'] },  // ~0.1
       { input: 1, expected: 1 },
       { input: 1.9, expected: kConstantCorrectlyRoundedExpectation['f16']['1.9'] },  // ~1.9
       { input: kValue.f16.positive.max, expected: kValue.f16.positive.max },
       { input: kValue.f32.positive.max, expected: kUnboundedBounds },
-      { input: kValue.f32.infinity.positive, expected: kUnboundedBounds },
+      { input: kValue.f32.positive.infinity, expected: kUnboundedBounds },
     ]
   )
   .fn(t => {
@@ -4428,12 +4428,12 @@ const kLdexpIntervalCases = {
     { input: [1.9999998807907104, 127], expected: kValue.f32.positive.max },
     // f32.positive.min = 1 * 2 ** -126
     { input: [1, -126], expected: kValue.f32.positive.min },
-    // f32.subnormal.positive.max = 0.9999998807907104 * 2 ** -126
-    { input: [0.9999998807907104, -126], expected: [0, kValue.f32.subnormal.positive.max] },
-    // f32.subnormal.positive.min = 1.1920928955078125e-07 * 2 ** -126
-    { input: [1.1920928955078125e-7, -126], expected: [0, kValue.f32.subnormal.positive.min] },
-    { input: [-1.1920928955078125e-7, -126], expected: [kValue.f32.subnormal.negative.max, 0] },
-    { input: [-0.9999998807907104, -126], expected: [kValue.f32.subnormal.negative.min, 0] },
+    // f32.positive.subnormal.max = 0.9999998807907104 * 2 ** -126
+    { input: [0.9999998807907104, -126], expected: [0, kValue.f32.positive.subnormal.max] },
+    // f32.positive.subnormal.min = 1.1920928955078125e-07 * 2 ** -126
+    { input: [1.1920928955078125e-7, -126], expected: [0, kValue.f32.positive.subnormal.min] },
+    { input: [-1.1920928955078125e-7, -126], expected: [kValue.f32.negative.subnormal.max, 0] },
+    { input: [-0.9999998807907104, -126], expected: [kValue.f32.negative.subnormal.min, 0] },
     { input: [-1, -126], expected: kValue.f32.negative.max },
     { input: [-1.9999998807907104, 127], expected: kValue.f32.negative.min },
     // e2 + bias <= 0, expect correctly rounded intervals.
@@ -4454,12 +4454,12 @@ const kLdexpIntervalCases = {
     { input: [1.9990234375, 15], expected: kValue.f16.positive.max },
     // f16.positive.min = 1 * 2 ** -14
     { input: [1, -14], expected: kValue.f16.positive.min },
-    // f16.subnormal.positive.max = 0.9990234375 * 2 ** -14
-    { input: [0.9990234375, -14], expected: [0, kValue.f16.subnormal.positive.max] },
-    // f16.subnormal.positive.min = 1 * 2 ** -10 * 2 ** -14 = 0.0009765625 * 2 ** -14
-    { input: [0.0009765625, -14], expected: [0, kValue.f16.subnormal.positive.min] },
-    { input: [-0.0009765625, -14], expected: [kValue.f16.subnormal.negative.max, 0] },
-    { input: [-0.9990234375, -14], expected: [kValue.f16.subnormal.negative.min, 0] },
+    // f16.positive.subnormal.max = 0.9990234375 * 2 ** -14
+    { input: [0.9990234375, -14], expected: [0, kValue.f16.positive.subnormal.max] },
+    // f16.positive.subnormal.min = 1 * 2 ** -10 * 2 ** -14 = 0.0009765625 * 2 ** -14
+    { input: [0.0009765625, -14], expected: [0, kValue.f16.positive.subnormal.min] },
+    { input: [-0.0009765625, -14], expected: [kValue.f16.negative.subnormal.max, 0] },
+    { input: [-0.9990234375, -14], expected: [kValue.f16.negative.subnormal.min, 0] },
     { input: [-1, -14], expected: kValue.f16.negative.max },
     { input: [-1.9990234375, 15], expected: kValue.f16.negative.min },
     // e2 + bias <= 0, expect correctly rounded intervals.
@@ -5193,47 +5193,47 @@ g.test('clampMinMaxInterval')
 const kFmaIntervalCases = {
   f32: [
     // positive.subnormal.max * positive.subnormal.max is much smaller than positive.subnormal.min but larger than 0, rounded to [0, positive.subnormal.min]
-    { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, 0], expected: [0, kValue.f32.subnormal.positive.min] },
+    { input: [kValue.f32.positive.subnormal.max, kValue.f32.positive.subnormal.max, 0], expected: [0, kValue.f32.positive.subnormal.min] },
     // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
     // 0 + constants.positive.subnormal.max rounded to [0, constants.positive.subnormal.max],
     // positive.subnormal.min + constants.positive.subnormal.max = constants.positive.min.
-    { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.positive.min] },
+    { input: [kValue.f32.positive.subnormal.max, kValue.f32.positive.subnormal.max, kValue.f32.positive.subnormal.max], expected: [0, kValue.f32.positive.min] },
     // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
     // negative.subnormal.max may flushed to 0,
     // minimum case: 0 + negative.subnormal.max rounded to [negative.subnormal.max, 0],
     // maximum case: positive.subnormal.min + 0 rounded to [0, positive.subnormal.min].
-    { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.negative.max], expected: [kValue.f32.subnormal.negative.max, kValue.f32.subnormal.positive.min] },
+    { input: [kValue.f32.positive.subnormal.max, kValue.f32.positive.subnormal.min, kValue.f32.negative.subnormal.max], expected: [kValue.f32.negative.subnormal.max, kValue.f32.positive.subnormal.min] },
     // positive.subnormal.max * negative.subnormal.min rounded to -0.0 or negative.subnormal.max = -1 * [subnormal ulp],
     // negative.subnormal.max = -1 * [subnormal ulp] may flushed to -0.0,
     // minimum case: -1 * [subnormal ulp] + -1 * [subnormal ulp] rounded to [-2 * [subnormal ulp], 0],
     // maximum case: -0.0 + -0.0 = 0.
-    { input: [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max], expected: [-2 * FP['f32'].oneULP(0, 'no-flush'), 0] },
+    { input: [kValue.f32.positive.subnormal.max, kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max], expected: [-2 * FP['f32'].oneULP(0, 'no-flush'), 0] },
   ] as ScalarTripleToIntervalCase[],
   f16: [
     // positive.subnormal.max * positive.subnormal.max is much smaller than positive.subnormal.min but larger than 0, rounded to [0, positive.subnormal.min]
-    { input: [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.positive.max, 0], expected: [0, kValue.f16.subnormal.positive.min] },
+    { input: [kValue.f16.positive.subnormal.max, kValue.f16.positive.subnormal.max, 0], expected: [0, kValue.f16.positive.subnormal.min] },
     // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
     // 0 + constants.positive.subnormal.max rounded to [0, constants.positive.subnormal.max],
     // positive.subnormal.min + constants.positive.subnormal.max = constants.positive.min.
-    { input: [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.positive.max, kValue.f16.subnormal.positive.max], expected: [0, kValue.f16.positive.min] },
+    { input: [kValue.f16.positive.subnormal.max, kValue.f16.positive.subnormal.max, kValue.f16.positive.subnormal.max], expected: [0, kValue.f16.positive.min] },
     // positive.subnormal.max * positive.subnormal.max rounded to 0 or positive.subnormal.min,
     // negative.subnormal.max may flushed to 0,
     // minimum case: 0 + negative.subnormal.max rounded to [negative.subnormal.max, 0],
     // maximum case: positive.subnormal.min + 0 rounded to [0, positive.subnormal.min].
-    { input: [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.negative.max], expected: [kValue.f16.subnormal.negative.max, kValue.f16.subnormal.positive.min] },
+    { input: [kValue.f16.positive.subnormal.max, kValue.f16.positive.subnormal.min, kValue.f16.negative.subnormal.max], expected: [kValue.f16.negative.subnormal.max, kValue.f16.positive.subnormal.min] },
     // positive.subnormal.max * negative.subnormal.min rounded to -0.0 or negative.subnormal.max = -1 * [subnormal ulp],
     // negative.subnormal.max = -1 * [subnormal ulp] may flushed to -0.0,
     // minimum case: -1 * [subnormal ulp] + -1 * [subnormal ulp] rounded to [-2 * [subnormal ulp], 0],
     // maximum case: -0.0 + -0.0 = 0.
-    { input: [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max], expected: [-2 * FP['f16'].oneULP(0, 'no-flush'), 0] },  ] as ScalarTripleToIntervalCase[],
+    { input: [kValue.f16.positive.subnormal.max, kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max], expected: [-2 * FP['f16'].oneULP(0, 'no-flush'), 0] },  ] as ScalarTripleToIntervalCase[],
   abstract: [
     // These operations break down in the CTS, because `number` is a f64 under the hood, so precision is sometimes lost
     // if intermediate results are  closer to 0 than the smallest subnormal will be precisely 0.
     // See https://github.com/gpuweb/cts/issues/2993 for details
-    { input: [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.positive.max, 0], expected: 0 },
-    { input: [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.positive.max, kValue.f64.subnormal.positive.max], expected: [0, kValue.f64.subnormal.positive.max] },
-    { input: [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.positive.min, kValue.f64.subnormal.negative.max], expected: [kValue.f64.subnormal.negative.max, 0] },
-    { input: [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.negative.min, kValue.f64.subnormal.negative.max], expected: [kValue.f64.subnormal.negative.max, 0] },
+    { input: [kValue.f64.positive.subnormal.max, kValue.f64.positive.subnormal.max, 0], expected: 0 },
+    { input: [kValue.f64.positive.subnormal.max, kValue.f64.positive.subnormal.max, kValue.f64.positive.subnormal.max], expected: [0, kValue.f64.positive.subnormal.max] },
+    { input: [kValue.f64.positive.subnormal.max, kValue.f64.positive.subnormal.min, kValue.f64.negative.subnormal.max], expected: [kValue.f64.negative.subnormal.max, 0] },
+    { input: [kValue.f64.positive.subnormal.max, kValue.f64.negative.subnormal.min, kValue.f64.negative.subnormal.max], expected: [kValue.f64.negative.subnormal.max, 0] },
   ] as ScalarTripleToIntervalCase[],
 } as const;
 
@@ -5547,7 +5547,7 @@ g.test('mixPreciseInterval')
 const kSmoothStepIntervalCases = {
   f32: [
     // Normals
-    { input: [0, 1, 0], expected: [0, kValue.f32.subnormal.positive.min] },
+    { input: [0, 1, 0], expected: [0, kValue.f32.positive.subnormal.min] },
     { input: [0, 1, 1], expected: [reinterpretU32AsF32(0x3f7ffffa), reinterpretU32AsF32(0x3f800003)] },  // ~1
     { input: [0, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
     { input: [0, 2, 0.5], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
@@ -5558,14 +5558,14 @@ const kSmoothStepIntervalCases = {
     { input: [0, -2, -1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
     { input: [0, -2, -0.5], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] },  // ~0.15625...
     // Subnormals
-    { input: [kValue.f32.subnormal.positive.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-    { input: [kValue.f32.subnormal.positive.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-    { input: [kValue.f32.subnormal.negative.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-    { input: [kValue.f32.subnormal.negative.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
-    { input: [0, 2, kValue.f32.subnormal.positive.max], expected: [0, kValue.f32.subnormal.positive.min] },
-    { input: [0, 2, kValue.f32.subnormal.positive.min], expected: [0, kValue.f32.subnormal.positive.min] },
-    { input: [0, 2, kValue.f32.subnormal.negative.max], expected: [0, kValue.f32.subnormal.positive.min] },
-    { input: [0, 2, kValue.f32.subnormal.negative.min], expected: [0, kValue.f32.subnormal.positive.min] },
+    { input: [kValue.f32.positive.subnormal.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [kValue.f32.positive.subnormal.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [kValue.f32.negative.subnormal.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [kValue.f32.negative.subnormal.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] },  // ~0.5
+    { input: [0, 2, kValue.f32.positive.subnormal.max], expected: [0, kValue.f32.positive.subnormal.min] },
+    { input: [0, 2, kValue.f32.positive.subnormal.min], expected: [0, kValue.f32.positive.subnormal.min] },
+    { input: [0, 2, kValue.f32.negative.subnormal.max], expected: [0, kValue.f32.positive.subnormal.min] },
+    { input: [0, 2, kValue.f32.negative.subnormal.min], expected: [0, kValue.f32.positive.subnormal.min] },
   ] as ScalarTripleToIntervalCase[],
   f16: [
     // Normals
@@ -5580,14 +5580,14 @@ const kSmoothStepIntervalCases = {
     { input: [0, -2, -1], expected: [reinterpretU16AsF16(0x37f8), reinterpretU16AsF16(0x3807)] },  // ~0.5
     { input: [0, -2, -0.5], expected: [reinterpretU16AsF16(0x30fb), reinterpretU16AsF16(0x3107)] },  // ~0.15625...
     // Subnormals
-    { input: [kValue.f16.subnormal.positive.max, 2, 1], expected: [reinterpretU16AsF16(0x37f4), reinterpretU16AsF16(0x380b)] },  // ~0.5
-    { input: [kValue.f16.subnormal.positive.min, 2, 1], expected: [reinterpretU16AsF16(0x37f4), reinterpretU16AsF16(0x380b)] },  // ~0.5
-    { input: [kValue.f16.subnormal.negative.max, 2, 1], expected: [reinterpretU16AsF16(0x37f2), reinterpretU16AsF16(0x380c)] },  // ~0.5
-    { input: [kValue.f16.subnormal.negative.min, 2, 1], expected: [reinterpretU16AsF16(0x37f2), reinterpretU16AsF16(0x380c)] },  // ~0.5
-    { input: [0, 2, kValue.f16.subnormal.positive.max], expected: [0, reinterpretU16AsF16(0x0002)] },
-    { input: [0, 2, kValue.f16.subnormal.positive.min], expected: [0, reinterpretU16AsF16(0x0002)] },
-    { input: [0, 2, kValue.f32.subnormal.negative.max], expected: [0, reinterpretU16AsF16(0x0002)] },
-    { input: [0, 2, kValue.f32.subnormal.negative.min], expected: [0, reinterpretU16AsF16(0x0002)] },
+    { input: [kValue.f16.positive.subnormal.max, 2, 1], expected: [reinterpretU16AsF16(0x37f4), reinterpretU16AsF16(0x380b)] },  // ~0.5
+    { input: [kValue.f16.positive.subnormal.min, 2, 1], expected: [reinterpretU16AsF16(0x37f4), reinterpretU16AsF16(0x380b)] },  // ~0.5
+    { input: [kValue.f16.negative.subnormal.max, 2, 1], expected: [reinterpretU16AsF16(0x37f2), reinterpretU16AsF16(0x380c)] },  // ~0.5
+    { input: [kValue.f16.negative.subnormal.min, 2, 1], expected: [reinterpretU16AsF16(0x37f2), reinterpretU16AsF16(0x380c)] },  // ~0.5
+    { input: [0, 2, kValue.f16.positive.subnormal.max], expected: [0, reinterpretU16AsF16(0x0002)] },
+    { input: [0, 2, kValue.f16.positive.subnormal.min], expected: [0, reinterpretU16AsF16(0x0002)] },
+    { input: [0, 2, kValue.f32.negative.subnormal.max], expected: [0, reinterpretU16AsF16(0x0002)] },
+    { input: [0, 2, kValue.f32.negative.subnormal.min], expected: [0, reinterpretU16AsF16(0x0002)] },
   ] as ScalarTripleToIntervalCase[],
 } as const;
 
@@ -5656,8 +5656,8 @@ g.test('unpack2x16floatInterval')
       { input: 0xc900c900, expected: [-10, -10] },
 
       // f16 subnormals
-      { input: 0x000003ff, expected: [[0, kValue.f16.subnormal.positive.max], 0] },
-      { input: 0x000083ff, expected: [[kValue.f16.subnormal.negative.min, 0], 0] },
+      { input: 0x000003ff, expected: [[0, kValue.f16.positive.subnormal.max], 0] },
+      { input: 0x000083ff, expected: [[kValue.f16.negative.subnormal.min, 0], 0] },
 
       // f16 out of bounds
       { input: 0x7c000000, expected: [kUnboundedBounds, kUnboundedBounds] },
@@ -6162,13 +6162,13 @@ interface VectorPairToVectorCase {
 const kCrossIntervalCases = {
   f32: [
     { input: [
-        [kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max, kValue.f32.subnormal.negative.min],
-        [kValue.f32.subnormal.negative.min, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.negative.max]
+        [kValue.f32.positive.subnormal.max, kValue.f32.negative.subnormal.max, kValue.f32.negative.subnormal.min],
+        [kValue.f32.negative.subnormal.min, kValue.f32.positive.subnormal.min, kValue.f32.negative.subnormal.max]
       ],
       expected: [
         [0.0, reinterpretU32AsF32(0x00000002)], // ~0
         [0.0, reinterpretU32AsF32(0x00000002)], // ~0
-        [kValue.f32.subnormal.negative.max, kValue.f32.subnormal.positive.min] // ~0
+        [kValue.f32.negative.subnormal.max, kValue.f32.positive.subnormal.min] // ~0
       ]
     },
     { input: [
@@ -6184,13 +6184,13 @@ const kCrossIntervalCases = {
   ] as VectorPairToVectorCase[],
   f16: [
     { input: [
-        [kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.max, kValue.f16.subnormal.negative.min],
-        [kValue.f16.subnormal.negative.min, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.negative.max]
+        [kValue.f16.positive.subnormal.max, kValue.f16.negative.subnormal.max, kValue.f16.negative.subnormal.min],
+        [kValue.f16.negative.subnormal.min, kValue.f16.positive.subnormal.min, kValue.f16.negative.subnormal.max]
       ],
       expected: [
         [0.0, reinterpretU16AsF16(0x0002)], // ~0
         [0.0, reinterpretU16AsF16(0x0002)], // ~0
-        [kValue.f16.subnormal.negative.max, kValue.f16.subnormal.positive.min] // ~0
+        [kValue.f16.negative.subnormal.max, kValue.f16.positive.subnormal.min] // ~0
       ]
     },
     { input: [
@@ -6206,8 +6206,8 @@ const kCrossIntervalCases = {
   ] as VectorPairToVectorCase[],
   abstract: [
     { input: [
-        [kValue.f64.subnormal.positive.max, kValue.f64.subnormal.negative.max, kValue.f64.subnormal.negative.min],
-        [kValue.f64.subnormal.negative.min, kValue.f64.subnormal.positive.min, kValue.f64.subnormal.negative.max]
+        [kValue.f64.positive.subnormal.max, kValue.f64.negative.subnormal.max, kValue.f64.negative.subnormal.min],
+        [kValue.f64.negative.subnormal.min, kValue.f64.positive.subnormal.min, kValue.f64.negative.subnormal.max]
       ],
       expected: [0.0, 0.0, 0.0]
     },
@@ -6266,24 +6266,24 @@ const kReflectIntervalCases = {
   f32: [
     // vec2s
     { input: [[0.1, 0.1], [1.0, 1.0]], expected: [[reinterpretU32AsF32(0xbe99999a), reinterpretU32AsF32(0xbe999998)], [reinterpretU32AsF32(0xbe99999a), reinterpretU32AsF32(0xbe999998)]] },  // [~-0.3, ~-0.3]
-    { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max], [1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0]
+    { input: [[kValue.f32.positive.subnormal.max, kValue.f32.negative.subnormal.max], [1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0]
     // vec3s
     { input: [[0.1, 0.1, 0.1], [1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0xbf000001), reinterpretU32AsF32(0xbefffffe)], [reinterpretU32AsF32(0xbf000001), reinterpretU32AsF32(0xbefffffe)], [reinterpretU32AsF32(0xbf000001), reinterpretU32AsF32(0xbefffffe)]] },  // [~-0.5, ~-0.5, ~-0.5]
-    { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max, 0.0], [1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0, ~0.0]
+    { input: [[kValue.f32.positive.subnormal.max, kValue.f32.negative.subnormal.max, 0.0], [1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0, ~0.0]
     // vec4s
     { input: [[0.1, 0.1, 0.1, 0.1], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)], [reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)], [reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)], [reinterpretU32AsF32(0xbf333335), reinterpretU32AsF32(0xbf333332)]] },  // [~-0.7, ~-0.7, ~-0.7, ~-0.7]
-    { input: [[kValue.f32.subnormal.positive.max, kValue.f32.subnormal.negative.max, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0, ~0.0, ~0.0]
+    { input: [[kValue.f32.positive.subnormal.max, kValue.f32.negative.subnormal.max, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00800001)], [reinterpretU32AsF32(0x80ffffff), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)], [reinterpretU32AsF32(0x80fffffe), reinterpretU32AsF32(0x00000002)]] },  // [~0.0, ~0.0, ~0.0, ~0.0]
   ] as VectorPairToVectorCase[],
   f16: [
     // vec2s
     { input: [[0.1, 0.1], [1.0, 1.0]], expected: [[reinterpretU16AsF16(0xb4ce), reinterpretU16AsF16(0xb4cc)], [reinterpretU16AsF16(0xb4ce), reinterpretU16AsF16(0xb4cc)]] },  // [~-0.3, ~-0.3]
-    { input: [[kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.max], [1.0, 1.0]], expected: [[reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0401)], [reinterpretU16AsF16(0x87ff), reinterpretU16AsF16(0x0002)]] },  // [~0.0, ~0.0]
+    { input: [[kValue.f16.positive.subnormal.max, kValue.f16.negative.subnormal.max], [1.0, 1.0]], expected: [[reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0401)], [reinterpretU16AsF16(0x87ff), reinterpretU16AsF16(0x0002)]] },  // [~0.0, ~0.0]
     // vec3s
     { input: [[0.1, 0.1, 0.1], [1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0xb802), reinterpretU16AsF16(0xb7fe)], [reinterpretU16AsF16(0xb802), reinterpretU16AsF16(0xb7fe)], [reinterpretU16AsF16(0xb802), reinterpretU16AsF16(0xb7fe)]] },  // [~-0.5, ~-0.5, ~-0.5]
-    { input: [[kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.max, 0.0], [1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0401)], [reinterpretU16AsF16(0x87ff), reinterpretU16AsF16(0x0002)], [reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0002)]] },  // [~0.0, ~0.0, ~0.0]
+    { input: [[kValue.f16.positive.subnormal.max, kValue.f16.negative.subnormal.max, 0.0], [1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0401)], [reinterpretU16AsF16(0x87ff), reinterpretU16AsF16(0x0002)], [reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0002)]] },  // [~0.0, ~0.0, ~0.0]
     // vec4s
     { input: [[0.1, 0.1, 0.1, 0.1], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0xb99c), reinterpretU16AsF16(0xb998)], [reinterpretU16AsF16(0xb99c), reinterpretU16AsF16(0xb998)], [reinterpretU16AsF16(0xb99c), reinterpretU16AsF16(0xb998)], [reinterpretU16AsF16(0xb99c), reinterpretU16AsF16(0xb998)]] },  // [~-0.7, ~-0.7, ~-0.7, ~-0.7]
-    { input: [[kValue.f16.subnormal.positive.max, kValue.f16.subnormal.negative.max, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0401)], [reinterpretU16AsF16(0x87ff), reinterpretU16AsF16(0x0002)], [reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0002)], [reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0002)]] },  // [~0.0, ~0.0, ~0.0, ~0.0]
+    { input: [[kValue.f16.positive.subnormal.max, kValue.f16.negative.subnormal.max, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]], expected: [[reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0401)], [reinterpretU16AsF16(0x87ff), reinterpretU16AsF16(0x0002)], [reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0002)], [reinterpretU16AsF16(0x87fe), reinterpretU16AsF16(0x0002)]] },  // [~0.0, ~0.0, ~0.0, ~0.0]
   ] as VectorPairToVectorCase[],
 } as const;
 
diff --git a/src/unittests/maths.spec.ts b/src/unittests/maths.spec.ts
index fa3899e21e9a..00ea2be54d5e 100644
--- a/src/unittests/maths.spec.ts
+++ b/src/unittests/maths.spec.ts
@@ -108,10 +108,10 @@ g.test('nextAfterF64FlushToZero')
       // Edge Cases
       { val: Number.NaN, dir: 'positive', result: Number.NaN },
       { val: Number.NaN, dir: 'negative', result: Number.NaN },
-      { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f64.infinity.positive },
-      { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f64.infinity.positive },
-      { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f64.infinity.negative },
-      { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f64.infinity.negative },
+      { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f64.positive.infinity },
+      { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f64.positive.infinity },
+      { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f64.negative.infinity },
+      { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f64.negative.infinity },
 
       // Zeroes
       { val: +0, dir: 'positive', result: kValue.f64.positive.min },
@@ -120,24 +120,24 @@ g.test('nextAfterF64FlushToZero')
       { val: -0, dir: 'negative', result: kValue.f64.negative.max },
 
       // Subnormals
-      { val: kValue.f64.subnormal.positive.min, dir: 'positive', result: kValue.f64.positive.min },
-      { val: kValue.f64.subnormal.positive.min, dir: 'negative', result: kValue.f64.negative.max },
-      { val: kValue.f64.subnormal.positive.max, dir: 'positive', result: kValue.f64.positive.min },
-      { val: kValue.f64.subnormal.positive.max, dir: 'negative', result: kValue.f64.negative.max },
-      { val: kValue.f64.subnormal.negative.min, dir: 'positive', result: kValue.f64.positive.min },
-      { val: kValue.f64.subnormal.negative.min, dir: 'negative', result: kValue.f64.negative.max },
-      { val: kValue.f64.subnormal.negative.max, dir: 'positive', result: kValue.f64.positive.min },
-      { val: kValue.f64.subnormal.negative.max, dir: 'negative', result: kValue.f64.negative.max },
+      { val: kValue.f64.positive.subnormal.min, dir: 'positive', result: kValue.f64.positive.min },
+      { val: kValue.f64.positive.subnormal.min, dir: 'negative', result: kValue.f64.negative.max },
+      { val: kValue.f64.positive.subnormal.max, dir: 'positive', result: kValue.f64.positive.min },
+      { val: kValue.f64.positive.subnormal.max, dir: 'negative', result: kValue.f64.negative.max },
+      { val: kValue.f64.negative.subnormal.min, dir: 'positive', result: kValue.f64.positive.min },
+      { val: kValue.f64.negative.subnormal.min, dir: 'negative', result: kValue.f64.negative.max },
+      { val: kValue.f64.negative.subnormal.max, dir: 'positive', result: kValue.f64.positive.min },
+      { val: kValue.f64.negative.subnormal.max, dir: 'negative', result: kValue.f64.negative.max },
 
       // Normals
-      { val: kValue.f64.positive.max, dir: 'positive', result: kValue.f64.infinity.positive },
+      { val: kValue.f64.positive.max, dir: 'positive', result: kValue.f64.positive.infinity },
       { val: kValue.f64.positive.max, dir: 'negative', result: kValue.f64.positive.nearest_max },
       { val: kValue.f64.positive.min, dir: 'positive', result: reinterpretU64AsF64(0x0010_0000_0000_0001n ) },
       { val: kValue.f64.positive.min, dir: 'negative', result: 0 },
       { val: kValue.f64.negative.max, dir: 'positive', result: 0 },
       { val: kValue.f64.negative.max, dir: 'negative', result: reinterpretU64AsF64(0x8010_0000_0000_0001n) },
       { val: kValue.f64.negative.min, dir: 'positive', result: kValue.f64.negative.nearest_min },
-      { val: kValue.f64.negative.min, dir: 'negative', result: kValue.f64.infinity.negative },
+      { val: kValue.f64.negative.min, dir: 'negative', result: kValue.f64.negative.infinity },
       { val: reinterpretU64AsF64(0x0380_0000_0000_0000n), dir: 'positive', result: reinterpretU64AsF64(0x0380_0000_0000_0001n) },
       { val: reinterpretU64AsF64(0x0380_0000_0000_0000n), dir: 'negative', result: reinterpretU64AsF64(0x037f_ffff_ffff_ffffn) },
       { val: reinterpretU64AsF64(0x8380_0000_0000_0000n), dir: 'positive', result: reinterpretU64AsF64(0x837f_ffff_ffff_ffffn) },
@@ -162,36 +162,36 @@ g.test('nextAfterF64NoFlush')
       // Edge Cases
       { val: Number.NaN, dir: 'positive', result: Number.NaN },
       { val: Number.NaN, dir: 'negative', result: Number.NaN },
-      { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f64.infinity.positive },
-      { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f64.infinity.positive },
-      { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f64.infinity.negative },
-      { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f64.infinity.negative },
+      { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f64.positive.infinity },
+      { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f64.positive.infinity },
+      { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f64.negative.infinity },
+      { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f64.negative.infinity },
 
       // Zeroes
-      { val: +0, dir: 'positive', result: kValue.f64.subnormal.positive.min },
-      { val: +0, dir: 'negative', result: kValue.f64.subnormal.negative.max },
-      { val: -0, dir: 'positive', result: kValue.f64.subnormal.positive.min },
-      { val: -0, dir: 'negative', result: kValue.f64.subnormal.negative.max },
+      { val: +0, dir: 'positive', result: kValue.f64.positive.subnormal.min },
+      { val: +0, dir: 'negative', result: kValue.f64.negative.subnormal.max },
+      { val: -0, dir: 'positive', result: kValue.f64.positive.subnormal.min },
+      { val: -0, dir: 'negative', result: kValue.f64.negative.subnormal.max },
 
       // Subnormals
-      { val: kValue.f64.subnormal.positive.min, dir: 'positive', result: reinterpretU64AsF64(0x0000_0000_0000_0002n) },
-      { val: kValue.f64.subnormal.positive.min, dir: 'negative', result: 0 },
-      { val: kValue.f64.subnormal.positive.max, dir: 'positive', result: kValue.f64.positive.min },
-      { val: kValue.f64.subnormal.positive.max, dir: 'negative', result: reinterpretU64AsF64(0x000f_ffff_ffff_fffen) },
-      { val: kValue.f64.subnormal.negative.min, dir: 'positive', result: reinterpretU64AsF64(0x800f_ffff_ffff_fffen) },
-      { val: kValue.f64.subnormal.negative.min, dir: 'negative', result: kValue.f64.negative.max },
-      { val: kValue.f64.subnormal.negative.max, dir: 'positive', result: 0 },
-      { val: kValue.f64.subnormal.negative.max, dir: 'negative', result: reinterpretU64AsF64(0x8000_0000_0000_0002n) },
+      { val: kValue.f64.positive.subnormal.min, dir: 'positive', result: reinterpretU64AsF64(0x0000_0000_0000_0002n) },
+      { val: kValue.f64.positive.subnormal.min, dir: 'negative', result: 0 },
+      { val: kValue.f64.positive.subnormal.max, dir: 'positive', result: kValue.f64.positive.min },
+      { val: kValue.f64.positive.subnormal.max, dir: 'negative', result: reinterpretU64AsF64(0x000f_ffff_ffff_fffen) },
+      { val: kValue.f64.negative.subnormal.min, dir: 'positive', result: reinterpretU64AsF64(0x800f_ffff_ffff_fffen) },
+      { val: kValue.f64.negative.subnormal.min, dir: 'negative', result: kValue.f64.negative.max },
+      { val: kValue.f64.negative.subnormal.max, dir: 'positive', result: 0 },
+      { val: kValue.f64.negative.subnormal.max, dir: 'negative', result: reinterpretU64AsF64(0x8000_0000_0000_0002n) },
 
       // Normals
-      { val: kValue.f64.positive.max, dir: 'positive', result: kValue.f64.infinity.positive },
+      { val: kValue.f64.positive.max, dir: 'positive', result: kValue.f64.positive.infinity },
       { val: kValue.f64.positive.max, dir: 'negative', result: kValue.f64.positive.nearest_max },
       { val: kValue.f64.positive.min, dir: 'positive', result: reinterpretU64AsF64(0x0010_0000_0000_0001n ) },
       { val: kValue.f64.positive.min, dir: 'negative', result: reinterpretU64AsF64(0x000f_ffff_ffff_ffffn) },
       { val: kValue.f64.negative.max, dir: 'positive', result: reinterpretU64AsF64(0x800f_ffff_ffff_ffffn) },
       { val: kValue.f64.negative.max, dir: 'negative', result: reinterpretU64AsF64(0x8010_0000_0000_0001n) },
       { val: kValue.f64.negative.min, dir: 'positive', result: kValue.f64.negative.nearest_min },
-      { val: kValue.f64.negative.min, dir: 'negative', result: kValue.f64.infinity.negative },
+      { val: kValue.f64.negative.min, dir: 'negative', result: kValue.f64.negative.infinity },
       { val: reinterpretU64AsF64(0x0380_0000_0000_0000n), dir: 'positive', result: reinterpretU64AsF64(0x0380_0000_0000_0001n) },
       { val: reinterpretU64AsF64(0x0380_0000_0000_0000n), dir: 'negative', result: reinterpretU64AsF64(0x037f_ffff_ffff_ffffn) },
       { val: reinterpretU64AsF64(0x8380_0000_0000_0000n), dir: 'positive', result: reinterpretU64AsF64(0x837f_ffff_ffff_ffffn) },
@@ -218,10 +218,10 @@ g.test('nextAfterF32FlushToZero')
     // Edge Cases
     { val: Number.NaN, dir: 'positive', result: Number.NaN },
     { val: Number.NaN, dir: 'negative', result: Number.NaN },
-    { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f32.infinity.positive },
-    { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f32.infinity.positive },
-    { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f32.infinity.negative },
-    { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f32.infinity.negative },
+    { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f32.positive.infinity },
+    { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f32.positive.infinity },
+    { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f32.negative.infinity },
+    { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f32.negative.infinity },
 
     // Zeroes
     { val: +0, dir: 'positive', result: kValue.f32.positive.min },
@@ -230,24 +230,24 @@ g.test('nextAfterF32FlushToZero')
     { val: -0, dir: 'negative', result: kValue.f32.negative.max },
 
     // Subnormals
-    { val: kValue.f32.subnormal.positive.min, dir: 'positive', result: kValue.f32.positive.min },
-    { val: kValue.f32.subnormal.positive.min, dir: 'negative', result: kValue.f32.negative.max },
-    { val: kValue.f32.subnormal.positive.max, dir: 'positive', result: kValue.f32.positive.min },
-    { val: kValue.f32.subnormal.positive.max, dir: 'negative', result: kValue.f32.negative.max },
-    { val: kValue.f32.subnormal.negative.min, dir: 'positive', result: kValue.f32.positive.min },
-    { val: kValue.f32.subnormal.negative.min, dir: 'negative', result: kValue.f32.negative.max },
-    { val: kValue.f32.subnormal.negative.max, dir: 'positive', result: kValue.f32.positive.min },
-    { val: kValue.f32.subnormal.negative.max, dir: 'negative', result: kValue.f32.negative.max },
+    { val: kValue.f32.positive.subnormal.min, dir: 'positive', result: kValue.f32.positive.min },
+    { val: kValue.f32.positive.subnormal.min, dir: 'negative', result: kValue.f32.negative.max },
+    { val: kValue.f32.positive.subnormal.max, dir: 'positive', result: kValue.f32.positive.min },
+    { val: kValue.f32.positive.subnormal.max, dir: 'negative', result: kValue.f32.negative.max },
+    { val: kValue.f32.negative.subnormal.min, dir: 'positive', result: kValue.f32.positive.min },
+    { val: kValue.f32.negative.subnormal.min, dir: 'negative', result: kValue.f32.negative.max },
+    { val: kValue.f32.negative.subnormal.max, dir: 'positive', result: kValue.f32.positive.min },
+    { val: kValue.f32.negative.subnormal.max, dir: 'negative', result: kValue.f32.negative.max },
 
     // Normals
-    { val: kValue.f32.positive.max, dir: 'positive', result: kValue.f32.infinity.positive },
+    { val: kValue.f32.positive.max, dir: 'positive', result: kValue.f32.positive.infinity },
     { val: kValue.f32.positive.max, dir: 'negative', result: kValue.f32.positive.nearest_max },
     { val: kValue.f32.positive.min, dir: 'positive', result: reinterpretU32AsF32(0x00800001) },
     { val: kValue.f32.positive.min, dir: 'negative', result: 0 },
     { val: kValue.f32.negative.max, dir: 'positive', result: 0 },
     { val: kValue.f32.negative.max, dir: 'negative', result: reinterpretU32AsF32(0x80800001) },
     { val: kValue.f32.negative.min, dir: 'positive', result: reinterpretU32AsF32(0xff7ffffe) },
-    { val: kValue.f32.negative.min, dir: 'negative', result: kValue.f32.infinity.negative },
+    { val: kValue.f32.negative.min, dir: 'negative', result: kValue.f32.negative.infinity },
     { val: reinterpretU32AsF32(0x03800000), dir: 'positive', result: reinterpretU32AsF32(0x03800001) },
     { val: reinterpretU32AsF32(0x03800000), dir: 'negative', result: reinterpretU32AsF32(0x037fffff) },
     { val: reinterpretU32AsF32(0x83800000), dir: 'positive', result: reinterpretU32AsF32(0x837fffff) },
@@ -282,36 +282,36 @@ g.test('nextAfterF32NoFlush')
     // Edge Cases
     { val: Number.NaN, dir: 'positive', result: Number.NaN },
     { val: Number.NaN, dir: 'negative', result: Number.NaN },
-    { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f32.infinity.positive },
-    { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f32.infinity.positive },
-    { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f32.infinity.negative },
-    { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f32.infinity.negative },
+    { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f32.positive.infinity },
+    { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f32.positive.infinity },
+    { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f32.negative.infinity },
+    { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f32.negative.infinity },
 
     // Zeroes
-    { val: +0, dir: 'positive', result: kValue.f32.subnormal.positive.min },
-    { val: +0, dir: 'negative', result: kValue.f32.subnormal.negative.max },
-    { val: -0, dir: 'positive', result: kValue.f32.subnormal.positive.min },
-    { val: -0, dir: 'negative', result: kValue.f32.subnormal.negative.max },
+    { val: +0, dir: 'positive', result: kValue.f32.positive.subnormal.min },
+    { val: +0, dir: 'negative', result: kValue.f32.negative.subnormal.max },
+    { val: -0, dir: 'positive', result: kValue.f32.positive.subnormal.min },
+    { val: -0, dir: 'negative', result: kValue.f32.negative.subnormal.max },
 
     // Subnormals
-    { val:kValue.f32.subnormal.positive.min, dir: 'positive', result: reinterpretU32AsF32(0x00000002) },
-    { val:kValue.f32.subnormal.positive.min, dir: 'negative', result: 0 },
-    { val:kValue.f32.subnormal.positive.max, dir: 'positive', result: kValue.f32.positive.min },
-    { val:kValue.f32.subnormal.positive.max, dir: 'negative', result: reinterpretU32AsF32(0x007ffffe) },
-    { val:kValue.f32.subnormal.negative.min, dir: 'positive', result: reinterpretU32AsF32(0x807ffffe) },
-    { val:kValue.f32.subnormal.negative.min, dir: 'negative', result: kValue.f32.negative.max },
-    { val:kValue.f32.subnormal.negative.max, dir: 'positive', result: 0 },
-    { val:kValue.f32.subnormal.negative.max, dir: 'negative', result: reinterpretU32AsF32(0x80000002) },
+    { val:kValue.f32.positive.subnormal.min, dir: 'positive', result: reinterpretU32AsF32(0x00000002) },
+    { val:kValue.f32.positive.subnormal.min, dir: 'negative', result: 0 },
+    { val:kValue.f32.positive.subnormal.max, dir: 'positive', result: kValue.f32.positive.min },
+    { val:kValue.f32.positive.subnormal.max, dir: 'negative', result: reinterpretU32AsF32(0x007ffffe) },
+    { val:kValue.f32.negative.subnormal.min, dir: 'positive', result: reinterpretU32AsF32(0x807ffffe) },
+    { val:kValue.f32.negative.subnormal.min, dir: 'negative', result: kValue.f32.negative.max },
+    { val:kValue.f32.negative.subnormal.max, dir: 'positive', result: 0 },
+    { val:kValue.f32.negative.subnormal.max, dir: 'negative', result: reinterpretU32AsF32(0x80000002) },
 
     // Normals
-    { val: kValue.f32.positive.max, dir: 'positive', result: kValue.f32.infinity.positive },
+    { val: kValue.f32.positive.max, dir: 'positive', result: kValue.f32.positive.infinity },
     { val: kValue.f32.positive.max, dir: 'negative', result: kValue.f32.positive.nearest_max },
     { val: kValue.f32.positive.min, dir: 'positive', result: reinterpretU32AsF32(0x00800001) },
-    { val: kValue.f32.positive.min, dir: 'negative', result: kValue.f32.subnormal.positive.max },
-    { val: kValue.f32.negative.max, dir: 'positive', result: kValue.f32.subnormal.negative.min },
+    { val: kValue.f32.positive.min, dir: 'negative', result: kValue.f32.positive.subnormal.max },
+    { val: kValue.f32.negative.max, dir: 'positive', result: kValue.f32.negative.subnormal.min },
     { val: kValue.f32.negative.max, dir: 'negative', result: reinterpretU32AsF32(0x80800001) },
     { val: kValue.f32.negative.min, dir: 'positive', result: kValue.f32.negative.nearest_min },
-    { val: kValue.f32.negative.min, dir: 'negative', result: kValue.f32.infinity.negative },
+    { val: kValue.f32.negative.min, dir: 'negative', result: kValue.f32.negative.infinity },
     { val: reinterpretU32AsF32(0x03800000), dir: 'positive', result: reinterpretU32AsF32(0x03800001) },
     { val: reinterpretU32AsF32(0x03800000), dir: 'negative', result: reinterpretU32AsF32(0x037fffff) },
     { val: reinterpretU32AsF32(0x83800000), dir: 'positive', result: reinterpretU32AsF32(0x837fffff) },
@@ -348,10 +348,10 @@ g.test('nextAfterF16FlushToZero')
       // Edge Cases
       { val: Number.NaN, dir: 'positive', result: Number.NaN },
       { val: Number.NaN, dir: 'negative', result: Number.NaN },
-      { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f16.infinity.positive },
-      { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f16.infinity.positive },
-      { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f16.infinity.negative },
-      { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f16.infinity.negative },
+      { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f16.positive.infinity },
+      { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f16.positive.infinity },
+      { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f16.negative.infinity },
+      { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f16.negative.infinity },
 
       // Zeroes
       { val: +0, dir: 'positive', result: kValue.f16.positive.min },
@@ -360,24 +360,24 @@ g.test('nextAfterF16FlushToZero')
       { val: -0, dir: 'negative', result: kValue.f16.negative.max },
 
       // Subnormals
-      { val: kValue.f16.subnormal.positive.min, dir: 'positive', result: kValue.f16.positive.min },
-      { val: kValue.f16.subnormal.positive.min, dir: 'negative', result: kValue.f16.negative.max },
-      { val: kValue.f16.subnormal.positive.max, dir: 'positive', result: kValue.f16.positive.min },
-      { val: kValue.f16.subnormal.positive.max, dir: 'negative', result: kValue.f16.negative.max },
-      { val: kValue.f16.subnormal.negative.min, dir: 'positive', result: kValue.f16.positive.min },
-      { val: kValue.f16.subnormal.negative.min, dir: 'negative', result: kValue.f16.negative.max },
-      { val: kValue.f16.subnormal.negative.max, dir: 'positive', result: kValue.f16.positive.min },
-      { val: kValue.f16.subnormal.negative.max, dir: 'negative', result: kValue.f16.negative.max },
+      { val: kValue.f16.positive.subnormal.min, dir: 'positive', result: kValue.f16.positive.min },
+      { val: kValue.f16.positive.subnormal.min, dir: 'negative', result: kValue.f16.negative.max },
+      { val: kValue.f16.positive.subnormal.max, dir: 'positive', result: kValue.f16.positive.min },
+      { val: kValue.f16.positive.subnormal.max, dir: 'negative', result: kValue.f16.negative.max },
+      { val: kValue.f16.negative.subnormal.min, dir: 'positive', result: kValue.f16.positive.min },
+      { val: kValue.f16.negative.subnormal.min, dir: 'negative', result: kValue.f16.negative.max },
+      { val: kValue.f16.negative.subnormal.max, dir: 'positive', result: kValue.f16.positive.min },
+      { val: kValue.f16.negative.subnormal.max, dir: 'negative', result: kValue.f16.negative.max },
 
       // Normals
-      { val: kValue.f16.positive.max, dir: 'positive', result: kValue.f16.infinity.positive },
+      { val: kValue.f16.positive.max, dir: 'positive', result: kValue.f16.positive.infinity },
       { val: kValue.f16.positive.max, dir: 'negative', result: reinterpretU16AsF16(0x7bfe) },
       { val: kValue.f16.positive.min, dir: 'positive', result: reinterpretU16AsF16(0x0401) },
       { val: kValue.f16.positive.min, dir: 'negative', result: 0 },
       { val: kValue.f16.negative.max, dir: 'positive', result: 0 },
       { val: kValue.f16.negative.max, dir: 'negative', result: reinterpretU16AsF16(0x8401) },
       { val: kValue.f16.negative.min, dir: 'positive', result: reinterpretU16AsF16(0xfbfe) },
-      { val: kValue.f16.negative.min, dir: 'negative', result: kValue.f16.infinity.negative },
+      { val: kValue.f16.negative.min, dir: 'negative', result: kValue.f16.negative.infinity },
       { val: reinterpretU16AsF16(0x1380), dir: 'positive', result: reinterpretU16AsF16(0x1381) },
       { val: reinterpretU16AsF16(0x1380), dir: 'negative', result: reinterpretU16AsF16(0x137f) },
       { val: reinterpretU16AsF16(0x9380), dir: 'positive', result: reinterpretU16AsF16(0x937f) },
@@ -412,36 +412,36 @@ g.test('nextAfterF16NoFlush')
       // Edge Cases
       { val: Number.NaN, dir: 'positive', result: Number.NaN },
       { val: Number.NaN, dir: 'negative', result: Number.NaN },
-      { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f16.infinity.positive },
-      { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f16.infinity.positive },
-      { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f16.infinity.negative },
-      { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f16.infinity.negative },
+      { val: Number.POSITIVE_INFINITY, dir: 'positive', result: kValue.f16.positive.infinity },
+      { val: Number.POSITIVE_INFINITY, dir: 'negative', result: kValue.f16.positive.infinity },
+      { val: Number.NEGATIVE_INFINITY, dir: 'positive', result: kValue.f16.negative.infinity },
+      { val: Number.NEGATIVE_INFINITY, dir: 'negative', result: kValue.f16.negative.infinity },
 
       // Zeroes
-      { val: +0, dir: 'positive', result: kValue.f16.subnormal.positive.min },
-      { val: +0, dir: 'negative', result: kValue.f16.subnormal.negative.max },
-      { val: -0, dir: 'positive', result: kValue.f16.subnormal.positive.min },
-      { val: -0, dir: 'negative', result: kValue.f16.subnormal.negative.max },
+      { val: +0, dir: 'positive', result: kValue.f16.positive.subnormal.min },
+      { val: +0, dir: 'negative', result: kValue.f16.negative.subnormal.max },
+      { val: -0, dir: 'positive', result: kValue.f16.positive.subnormal.min },
+      { val: -0, dir: 'negative', result: kValue.f16.negative.subnormal.max },
 
       // Subnormals
-      { val: kValue.f16.subnormal.positive.min, dir: 'positive', result: reinterpretU16AsF16(0x0002) },
-      { val: kValue.f16.subnormal.positive.min, dir: 'negative', result: 0 },
-      { val: kValue.f16.subnormal.positive.max, dir: 'positive', result: kValue.f16.positive.min },
-      { val: kValue.f16.subnormal.positive.max, dir: 'negative', result: reinterpretU16AsF16(0x03fe) },
-      { val: kValue.f16.subnormal.negative.min, dir: 'positive', result: reinterpretU16AsF16(0x83fe) },
-      { val: kValue.f16.subnormal.negative.min, dir: 'negative', result: kValue.f16.negative.max },
-      { val: kValue.f16.subnormal.negative.max, dir: 'positive', result: 0 },
-      { val: kValue.f16.subnormal.negative.max, dir: 'negative', result: reinterpretU16AsF16(0x8002) },
+      { val: kValue.f16.positive.subnormal.min, dir: 'positive', result: reinterpretU16AsF16(0x0002) },
+      { val: kValue.f16.positive.subnormal.min, dir: 'negative', result: 0 },
+      { val: kValue.f16.positive.subnormal.max, dir: 'positive', result: kValue.f16.positive.min },
+      { val: kValue.f16.positive.subnormal.max, dir: 'negative', result: reinterpretU16AsF16(0x03fe) },
+      { val: kValue.f16.negative.subnormal.min, dir: 'positive', result: reinterpretU16AsF16(0x83fe) },
+      { val: kValue.f16.negative.subnormal.min, dir: 'negative', result: kValue.f16.negative.max },
+      { val: kValue.f16.negative.subnormal.max, dir: 'positive', result: 0 },
+      { val: kValue.f16.negative.subnormal.max, dir: 'negative', result: reinterpretU16AsF16(0x8002) },
 
       // Normals
-      { val: kValue.f16.positive.max, dir: 'positive', result: kValue.f16.infinity.positive },
+      { val: kValue.f16.positive.max, dir: 'positive', result: kValue.f16.positive.infinity },
       { val: kValue.f16.positive.max, dir: 'negative', result: reinterpretU16AsF16(0x7bfe) },
       { val: kValue.f16.positive.min, dir: 'positive', result: reinterpretU16AsF16(0x0401) },
-      { val: kValue.f16.positive.min, dir: 'negative', result: kValue.f16.subnormal.positive.max },
-      { val: kValue.f16.negative.max, dir: 'positive', result: kValue.f16.subnormal.negative.min },
+      { val: kValue.f16.positive.min, dir: 'negative', result: kValue.f16.positive.subnormal.max },
+      { val: kValue.f16.negative.max, dir: 'positive', result: kValue.f16.negative.subnormal.min },
       { val: kValue.f16.negative.max, dir: 'negative', result: reinterpretU16AsF16(0x8401) },
       { val: kValue.f16.negative.min, dir: 'positive', result: reinterpretU16AsF16(0xfbfe) },
-      { val: kValue.f16.negative.min, dir: 'negative', result: kValue.f16.infinity.negative },
+      { val: kValue.f16.negative.min, dir: 'negative', result: kValue.f16.negative.infinity },
       { val: reinterpretU16AsF16(0x1380), dir: 'positive', result: reinterpretU16AsF16(0x1381) },
       { val: reinterpretU16AsF16(0x1380), dir: 'negative', result: reinterpretU16AsF16(0x137f) },
       { val: reinterpretU16AsF16(0x9380), dir: 'positive', result: reinterpretU16AsF16(0x937f) },
@@ -452,10 +452,10 @@ g.test('nextAfterF16NoFlush')
       { val: 0.01, dir: 'negative', result: reinterpretU16AsF16(0x211e) }, // positive normal
       { val: -0.01, dir: 'positive', result: reinterpretU16AsF16(0xa11e) }, // negative normal
       { val: -0.01, dir: 'negative', result: reinterpretU16AsF16(0xa11f) }, // negative normal
-      { val: 2.82E-40, dir: 'positive', result: kValue.f16.subnormal.positive.min }, // positive subnormal
+      { val: 2.82E-40, dir: 'positive', result: kValue.f16.positive.subnormal.min }, // positive subnormal
       { val: 2.82E-40, dir: 'negative', result: 0 }, // positive subnormal
       { val: -2.82E-40, dir: 'positive', result: 0 }, // negative subnormal
-      { val: -2.82E-40, dir: 'negative', result: kValue.f16.subnormal.negative.max }, // negative subnormal
+      { val: -2.82E-40, dir: 'negative', result: kValue.f16.negative.subnormal.max }, // negative subnormal
     ]
   )
   .fn(t => {
@@ -489,19 +489,19 @@ g.test('oneULPF64FlushToZero')
 
     // Subnormals
     {
-      target: kValue.f64.subnormal.positive.min,
+      target: kValue.f64.positive.subnormal.min,
       expect: reinterpretU64AsF64(0x0010_0000_0000_0000n),
     },
     {
-      target: kValue.f64.subnormal.positive.max,
+      target: kValue.f64.positive.subnormal.max,
       expect: reinterpretU64AsF64(0x0010_0000_0000_0000n),
     },
     {
-      target: kValue.f64.subnormal.negative.min,
+      target: kValue.f64.negative.subnormal.min,
       expect: reinterpretU64AsF64(0x0010_0000_0000_0000n),
     },
     {
-      target: kValue.f64.subnormal.negative.max,
+      target: kValue.f64.negative.subnormal.max,
       expect: reinterpretU64AsF64(0x0010_0000_0000_0000n),
     },
 
@@ -542,19 +542,19 @@ g.test('oneULPF64NoFlush')
 
     // Subnormals
     {
-      target: kValue.f64.subnormal.positive.min,
+      target: kValue.f64.positive.subnormal.min,
       expect: reinterpretU64AsF64(0x0000_0000_0000_0001n),
     },
     {
-      target: kValue.f64.subnormal.positive.max,
+      target: kValue.f64.positive.subnormal.max,
       expect: reinterpretU64AsF64(0x0000_0000_0000_0001n),
     },
     {
-      target: kValue.f64.subnormal.negative.min,
+      target: kValue.f64.negative.subnormal.min,
       expect: reinterpretU64AsF64(0x0000_0000_0000_0001n),
     },
     {
-      target: kValue.f64.subnormal.negative.max,
+      target: kValue.f64.negative.subnormal.max,
       expect: reinterpretU64AsF64(0x0000_0000_0000_0001n),
     },
 
@@ -595,19 +595,19 @@ g.test('oneULPF64')
 
     // Subnormals
     {
-      target: kValue.f64.subnormal.positive.min,
+      target: kValue.f64.positive.subnormal.min,
       expect: reinterpretU64AsF64(0x0010_0000_0000_0000n),
     },
     {
-      target: kValue.f64.subnormal.positive.max,
+      target: kValue.f64.positive.subnormal.max,
       expect: reinterpretU64AsF64(0x0010_0000_0000_0000n),
     },
     {
-      target: kValue.f64.subnormal.negative.min,
+      target: kValue.f64.negative.subnormal.min,
       expect: reinterpretU64AsF64(0x0010_0000_0000_0000n),
     },
     {
-      target: kValue.f64.subnormal.negative.max,
+      target: kValue.f64.negative.subnormal.max,
       expect: reinterpretU64AsF64(0x0010_0000_0000_0000n),
     },
 
@@ -647,12 +647,12 @@ g.test('oneULPF32FlushToZero')
     { target: -0, expect: reinterpretU32AsF32(0x00800000) },
 
     // Subnormals
-    { target: kValue.f32.subnormal.positive.min, expect: reinterpretU32AsF32(0x00800000) },
+    { target: kValue.f32.positive.subnormal.min, expect: reinterpretU32AsF32(0x00800000) },
     { target: 2.82e-40, expect: reinterpretU32AsF32(0x00800000) }, // positive subnormal
-    { target: kValue.f32.subnormal.positive.max, expect: reinterpretU32AsF32(0x00800000) },
-    { target: kValue.f32.subnormal.negative.min, expect: reinterpretU32AsF32(0x00800000) },
+    { target: kValue.f32.positive.subnormal.max, expect: reinterpretU32AsF32(0x00800000) },
+    { target: kValue.f32.negative.subnormal.min, expect: reinterpretU32AsF32(0x00800000) },
     { target: -2.82e-40, expect: reinterpretU32AsF32(0x00800000) }, // negative subnormal
-    { target: kValue.f32.subnormal.negative.max, expect: reinterpretU32AsF32(0x00800000) },
+    { target: kValue.f32.negative.subnormal.max, expect: reinterpretU32AsF32(0x00800000) },
 
     // Normals
     { target: kValue.f32.positive.min, expect: reinterpretU32AsF32(0x00000001) },
@@ -696,12 +696,12 @@ g.test('oneULPF32NoFlush')
     { target: -0, expect: reinterpretU32AsF32(0x00000001) },
 
     // Subnormals
-    { target: kValue.f32.subnormal.positive.min, expect: reinterpretU32AsF32(0x00000001) },
+    { target: kValue.f32.positive.subnormal.min, expect: reinterpretU32AsF32(0x00000001) },
     { target: -2.82e-40, expect: reinterpretU32AsF32(0x00000001) }, // negative subnormal
-    { target: kValue.f32.subnormal.positive.max, expect: reinterpretU32AsF32(0x00000001) },
-    { target: kValue.f32.subnormal.negative.min, expect: reinterpretU32AsF32(0x00000001) },
+    { target: kValue.f32.positive.subnormal.max, expect: reinterpretU32AsF32(0x00000001) },
+    { target: kValue.f32.negative.subnormal.min, expect: reinterpretU32AsF32(0x00000001) },
     { target: 2.82e-40, expect: reinterpretU32AsF32(0x00000001) }, // positive subnormal
-    { target: kValue.f32.subnormal.negative.max, expect: reinterpretU32AsF32(0x00000001) },
+    { target: kValue.f32.negative.subnormal.max, expect: reinterpretU32AsF32(0x00000001) },
 
     // Normals
     { target: kValue.f32.positive.min, expect: reinterpretU32AsF32(0x00000001) },
@@ -745,12 +745,12 @@ g.test('oneULPF32')
     { target: -0, expect: reinterpretU32AsF32(0x00800000) },
 
     // Subnormals
-    { target: kValue.f32.subnormal.negative.max, expect: reinterpretU32AsF32(0x00800000) },
+    { target: kValue.f32.negative.subnormal.max, expect: reinterpretU32AsF32(0x00800000) },
     { target: -2.82e-40, expect: reinterpretU32AsF32(0x00800000) },
-    { target: kValue.f32.subnormal.negative.min, expect: reinterpretU32AsF32(0x00800000) },
-    { target: kValue.f32.subnormal.positive.max, expect: reinterpretU32AsF32(0x00800000) },
+    { target: kValue.f32.negative.subnormal.min, expect: reinterpretU32AsF32(0x00800000) },
+    { target: kValue.f32.positive.subnormal.max, expect: reinterpretU32AsF32(0x00800000) },
     { target: 2.82e-40, expect: reinterpretU32AsF32(0x00800000) },
-    { target: kValue.f32.subnormal.positive.min, expect: reinterpretU32AsF32(0x00800000) },
+    { target: kValue.f32.positive.subnormal.min, expect: reinterpretU32AsF32(0x00800000) },
 
     // Normals
     { target: kValue.f32.positive.min, expect: reinterpretU32AsF32(0x00000001) },
@@ -794,12 +794,12 @@ g.test('oneULPF16FlushToZero')
     { target: -0, expect: reinterpretU16AsF16(0x0400) },
 
     // Subnormals
-    { target: kValue.f16.subnormal.positive.min, expect: reinterpretU16AsF16(0x0400) },
+    { target: kValue.f16.positive.subnormal.min, expect: reinterpretU16AsF16(0x0400) },
     { target: 1.91e-6, expect: reinterpretU16AsF16(0x0400) }, // positive subnormal
-    { target: kValue.f16.subnormal.positive.max, expect: reinterpretU16AsF16(0x0400) },
-    { target: kValue.f16.subnormal.negative.min, expect: reinterpretU16AsF16(0x0400) },
+    { target: kValue.f16.positive.subnormal.max, expect: reinterpretU16AsF16(0x0400) },
+    { target: kValue.f16.negative.subnormal.min, expect: reinterpretU16AsF16(0x0400) },
     { target: -1.91e-6, expect: reinterpretU16AsF16(0x0400) }, // negative subnormal
-    { target: kValue.f16.subnormal.negative.max, expect: reinterpretU16AsF16(0x0400) },
+    { target: kValue.f16.negative.subnormal.max, expect: reinterpretU16AsF16(0x0400) },
 
     // Normals
     { target: kValue.f16.positive.min, expect: reinterpretU16AsF16(0x0001) },
@@ -843,12 +843,12 @@ g.test('oneULPF16NoFlush')
     { target: -0, expect: reinterpretU16AsF16(0x0001) },
 
     // Subnormals
-    { target: kValue.f16.subnormal.positive.min, expect: reinterpretU16AsF16(0x0001) },
+    { target: kValue.f16.positive.subnormal.min, expect: reinterpretU16AsF16(0x0001) },
     { target: 1.91e-6, expect: reinterpretU16AsF16(0x0001) }, // positive subnormal
-    { target: kValue.f16.subnormal.positive.max, expect: reinterpretU16AsF16(0x0001) },
-    { target: kValue.f16.subnormal.negative.min, expect: reinterpretU16AsF16(0x0001) },
+    { target: kValue.f16.positive.subnormal.max, expect: reinterpretU16AsF16(0x0001) },
+    { target: kValue.f16.negative.subnormal.min, expect: reinterpretU16AsF16(0x0001) },
     { target: -1.91e-6, expect: reinterpretU16AsF16(0x0001) }, // negative subnormal
-    { target: kValue.f16.subnormal.negative.max, expect: reinterpretU16AsF16(0x0001) },
+    { target: kValue.f16.negative.subnormal.max, expect: reinterpretU16AsF16(0x0001) },
 
     // Normals
     { target: kValue.f16.positive.min, expect: reinterpretU16AsF16(0x0001) },
@@ -892,12 +892,12 @@ g.test('oneULPF16')
     { target: -0, expect: reinterpretU16AsF16(0x0400) },
 
     // Subnormals
-    { target: kValue.f16.subnormal.positive.min, expect: reinterpretU16AsF16(0x0400) },
+    { target: kValue.f16.positive.subnormal.min, expect: reinterpretU16AsF16(0x0400) },
     { target: 1.91e-6, expect: reinterpretU16AsF16(0x0400) }, // positive subnormal
-    { target: kValue.f16.subnormal.positive.max, expect: reinterpretU16AsF16(0x0400) },
-    { target: kValue.f16.subnormal.negative.min, expect: reinterpretU16AsF16(0x0400) },
+    { target: kValue.f16.positive.subnormal.max, expect: reinterpretU16AsF16(0x0400) },
+    { target: kValue.f16.negative.subnormal.min, expect: reinterpretU16AsF16(0x0400) },
     { target: -1.91e-6, expect: reinterpretU16AsF16(0x0400) }, // negative subnormal
-    { target: kValue.f16.subnormal.negative.max, expect: reinterpretU16AsF16(0x0400) },
+    { target: kValue.f16.negative.subnormal.max, expect: reinterpretU16AsF16(0x0400) },
 
     // Normals
     { target: kValue.f16.positive.min, expect: reinterpretU16AsF16(0x0001) },
@@ -947,20 +947,20 @@ g.test('correctlyRoundedF32')
       { value: -(2 ** (kValue.f32.emax + 1)) + oneULPF64(kValue.f32.positive.max), expected: [Number.NEGATIVE_INFINITY, kValue.f32.negative.min] },
       { value: 2 ** (kValue.f32.emax + 1), expected: [Number.POSITIVE_INFINITY] },
       { value: -(2 ** (kValue.f32.emax + 1)), expected: [Number.NEGATIVE_INFINITY] },
-      { value: kValue.f32.infinity.positive, expected: [Number.POSITIVE_INFINITY] },
-      { value: kValue.f32.infinity.negative, expected: [Number.NEGATIVE_INFINITY] },
+      { value: kValue.f32.positive.infinity, expected: [Number.POSITIVE_INFINITY] },
+      { value: kValue.f32.negative.infinity, expected: [Number.NEGATIVE_INFINITY] },
 
       // 32-bit subnormals
-      { value: kValue.f32.subnormal.positive.min, expected: [kValue.f32.subnormal.positive.min] },
-      { value: kValue.f32.subnormal.positive.max, expected: [kValue.f32.subnormal.positive.max] },
-      { value: kValue.f32.subnormal.negative.min, expected: [kValue.f32.subnormal.negative.min] },
-      { value: kValue.f32.subnormal.negative.max, expected: [kValue.f32.subnormal.negative.max] },
+      { value: kValue.f32.positive.subnormal.min, expected: [kValue.f32.positive.subnormal.min] },
+      { value: kValue.f32.positive.subnormal.max, expected: [kValue.f32.positive.subnormal.max] },
+      { value: kValue.f32.negative.subnormal.min, expected: [kValue.f32.negative.subnormal.min] },
+      { value: kValue.f32.negative.subnormal.max, expected: [kValue.f32.negative.subnormal.max] },
 
       // 64-bit subnormals
-      { value: reinterpretU64AsF64(0x0000_0000_0000_0001n), expected: [0, kValue.f32.subnormal.positive.min] },
-      { value: reinterpretU64AsF64(0x0000_0000_0000_0002n), expected: [0, kValue.f32.subnormal.positive.min] },
-      { value: reinterpretU64AsF64(0x800f_ffff_ffff_ffffn), expected: [kValue.f32.subnormal.negative.max, 0] },
-      { value: reinterpretU64AsF64(0x800f_ffff_ffff_fffen), expected: [kValue.f32.subnormal.negative.max, 0] },
+      { value: reinterpretU64AsF64(0x0000_0000_0000_0001n), expected: [0, kValue.f32.positive.subnormal.min] },
+      { value: reinterpretU64AsF64(0x0000_0000_0000_0002n), expected: [0, kValue.f32.positive.subnormal.min] },
+      { value: reinterpretU64AsF64(0x800f_ffff_ffff_ffffn), expected: [kValue.f32.negative.subnormal.max, 0] },
+      { value: reinterpretU64AsF64(0x800f_ffff_ffff_fffen), expected: [kValue.f32.negative.subnormal.max, 0] },
 
       // 32-bit normals
       { value: 0, expected: [0] },
@@ -1008,20 +1008,20 @@ g.test('correctlyRoundedF16')
       { value: -(2 ** (kValue.f16.emax + 1)) + oneULPF64(kValue.f16.positive.max), expected: [Number.NEGATIVE_INFINITY, kValue.f16.negative.min] },
       { value: 2 ** (kValue.f16.emax + 1), expected: [Number.POSITIVE_INFINITY] },
       { value: -(2 ** (kValue.f16.emax + 1)), expected: [Number.NEGATIVE_INFINITY] },
-      { value: kValue.f16.infinity.positive, expected: [Number.POSITIVE_INFINITY] },
-      { value: kValue.f16.infinity.negative, expected: [Number.NEGATIVE_INFINITY] },
+      { value: kValue.f16.positive.infinity, expected: [Number.POSITIVE_INFINITY] },
+      { value: kValue.f16.negative.infinity, expected: [Number.NEGATIVE_INFINITY] },
 
       // 16-bit subnormals
-      { value: kValue.f16.subnormal.positive.min, expected: [kValue.f16.subnormal.positive.min] },
-      { value: kValue.f16.subnormal.positive.max, expected: [kValue.f16.subnormal.positive.max] },
-      { value: kValue.f16.subnormal.negative.min, expected: [kValue.f16.subnormal.negative.min] },
-      { value: kValue.f16.subnormal.negative.max, expected: [kValue.f16.subnormal.negative.max] },
+      { value: kValue.f16.positive.subnormal.min, expected: [kValue.f16.positive.subnormal.min] },
+      { value: kValue.f16.positive.subnormal.max, expected: [kValue.f16.positive.subnormal.max] },
+      { value: kValue.f16.negative.subnormal.min, expected: [kValue.f16.negative.subnormal.min] },
+      { value: kValue.f16.negative.subnormal.max, expected: [kValue.f16.negative.subnormal.max] },
 
       // 32-bit subnormals
-      { value: kValue.f32.subnormal.positive.min, expected: [0, kValue.f16.subnormal.positive.min] },
-      { value: kValue.f32.subnormal.positive.max, expected: [0, kValue.f16.subnormal.positive.min] },
-      { value: kValue.f32.subnormal.negative.max, expected: [kValue.f16.subnormal.negative.max, 0] },
-      { value: kValue.f32.subnormal.negative.min, expected: [kValue.f16.subnormal.negative.max, 0] },
+      { value: kValue.f32.positive.subnormal.min, expected: [0, kValue.f16.positive.subnormal.min] },
+      { value: kValue.f32.positive.subnormal.max, expected: [0, kValue.f16.positive.subnormal.min] },
+      { value: kValue.f32.negative.subnormal.max, expected: [kValue.f16.negative.subnormal.max, 0] },
+      { value: kValue.f32.negative.subnormal.min, expected: [kValue.f16.negative.subnormal.max, 0] },
 
       // 16-bit normals
       { value: 0, expected: [0] },
@@ -1065,30 +1065,30 @@ const kFrexpCases = {
     { input: kValue.f32.positive.min, fract: 0.5, exp: -125 },
     { input: kValue.f32.negative.max, fract: -0.5, exp: -125 },
     { input: kValue.f32.negative.min, fract: -0.9999999403953552, exp: 128 },
-    { input: kValue.f32.subnormal.positive.max, fract: 0.9999998807907104, exp: -126 },
-    { input: kValue.f32.subnormal.positive.min, fract: 0.5, exp: -148 },
-    { input: kValue.f32.subnormal.negative.max, fract: -0.5, exp: -148 },
-    { input: kValue.f32.subnormal.negative.min, fract: -0.9999998807907104, exp: -126 },
+    { input: kValue.f32.positive.subnormal.max, fract: 0.9999998807907104, exp: -126 },
+    { input: kValue.f32.positive.subnormal.min, fract: 0.5, exp: -148 },
+    { input: kValue.f32.negative.subnormal.max, fract: -0.5, exp: -148 },
+    { input: kValue.f32.negative.subnormal.min, fract: -0.9999998807907104, exp: -126 },
   ] as frexpCase[],
   f16: [
     { input: kValue.f16.positive.max, fract: 0.99951171875, exp: 16 },
     { input: kValue.f16.positive.min, fract: 0.5, exp: -13 },
     { input: kValue.f16.negative.max, fract: -0.5, exp: -13 },
     { input: kValue.f16.negative.min, fract: -0.99951171875, exp: 16 },
-    { input: kValue.f16.subnormal.positive.max, fract: 0.9990234375, exp: -14 },
-    { input: kValue.f16.subnormal.positive.min, fract: 0.5, exp: -23 },
-    { input: kValue.f16.subnormal.negative.max, fract: -0.5, exp: -23 },
-    { input: kValue.f16.subnormal.negative.min, fract: -0.9990234375, exp: -14 },
+    { input: kValue.f16.positive.subnormal.max, fract: 0.9990234375, exp: -14 },
+    { input: kValue.f16.positive.subnormal.min, fract: 0.5, exp: -23 },
+    { input: kValue.f16.negative.subnormal.max, fract: -0.5, exp: -23 },
+    { input: kValue.f16.negative.subnormal.min, fract: -0.9990234375, exp: -14 },
   ] as frexpCase[],
   f64: [
     { input: kValue.f64.positive.max, fract: reinterpretU64AsF64(0x3fef_ffff_ffff_ffffn) /* ~0.9999999999999999 */, exp: 1024 },
     { input: kValue.f64.positive.min, fract: 0.5, exp: -1021 },
     { input: kValue.f64.negative.max, fract: -0.5, exp: -1021 },
     { input: kValue.f64.negative.min, fract: reinterpretU64AsF64(0xbfef_ffff_ffff_ffffn) /* ~-0.9999999999999999 */, exp: 1024 },
-    { input: kValue.f64.subnormal.positive.max, fract: reinterpretU64AsF64(0x3fef_ffff_ffff_fffen) /* ~0.9999999999999998 */, exp: -1022 },
-    { input: kValue.f64.subnormal.positive.min, fract: 0.5, exp: -1073 },
-    { input: kValue.f64.subnormal.negative.max, fract: -0.5, exp: -1073 },
-    { input: kValue.f64.subnormal.negative.min, fract: reinterpretU64AsF64(0xbfef_ffff_ffff_fffen) /* ~-0.9999999999999998 */, exp: -1022 },
+    { input: kValue.f64.positive.subnormal.max, fract: reinterpretU64AsF64(0x3fef_ffff_ffff_fffen) /* ~0.9999999999999998 */, exp: -1022 },
+    { input: kValue.f64.positive.subnormal.min, fract: 0.5, exp: -1073 },
+    { input: kValue.f64.negative.subnormal.max, fract: -0.5, exp: -1073 },
+    { input: kValue.f64.negative.subnormal.min, fract: reinterpretU64AsF64(0xbfef_ffff_ffff_fffen) /* ~-0.9999999999999998 */, exp: -1022 },
   ] as frexpCase[],
 } as const;
 
@@ -1535,19 +1535,19 @@ g.test('fullF32Range')
   .paramsSimple<fullF32RangeCase>(
     // prettier-ignore
     [
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
-        { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, 0.0] },
-        { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, 0.0 ] },
-        { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -1.9999998807907104, kValue.f32.negative.max, 0.0 ] },
-        { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, 0.0 ] },
-        { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, 0.0 ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f32.subnormal.positive.min ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f32.positive.min ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f32.positive.min, kValue.f32.positive.max ] },
-        { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f32.positive.min, 1.9999998807907104, kValue.f32.positive.max ] },
-        { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f32.negative.min, kValue.f32.subnormal.negative.min, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.positive.min ] },
-        { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max, 0.0, kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max, kValue.f32.positive.min, kValue.f32.positive.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
+      { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, 0.0] },
+      { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, 0.0 ] },
+      { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -1.9999998807907104, kValue.f32.negative.max, 0.0 ] },
+      { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.subnormal.min, 0.0 ] },
+      { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max, 0.0 ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f32.positive.subnormal.min ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f32.positive.subnormal.min, kValue.f32.positive.subnormal.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f32.positive.min ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f32.positive.min, kValue.f32.positive.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f32.positive.min, 1.9999998807907104, kValue.f32.positive.max ] },
+      { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f32.negative.min, kValue.f32.negative.subnormal.min, 0.0, kValue.f32.positive.subnormal.min, kValue.f32.positive.min ] },
+      { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max, 0.0, kValue.f32.positive.subnormal.min, kValue.f32.positive.subnormal.max, kValue.f32.positive.min, kValue.f32.positive.max ] },
     ]
   )
   .fn(test => {
@@ -1576,20 +1576,20 @@ g.test('fullF16Range')
   .paramsSimple<fullF16RangeCase>(
     // prettier-ignore
     [
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
-          { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, 0.0] },
-          { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, 0.0 ] },
-          { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -1.9990234375, kValue.f16.negative.max, 0.0 ] },
-          { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, 0.0 ] },
-          { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, 0.0 ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f16.subnormal.positive.min ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f16.positive.min ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f16.positive.min, kValue.f16.positive.max ] },
-          { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f16.positive.min, 1.9990234375, kValue.f16.positive.max ] },
-          { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f16.negative.min, kValue.f16.subnormal.negative.min, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.positive.min ] },
-          { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, kValue.f16.subnormal.negative.min, kValue.f16.subnormal.negative.max, 0.0, kValue.f16.subnormal.positive.min, kValue.f16.subnormal.positive.max, kValue.f16.positive.min, kValue.f16.positive.max ] },
-      ]
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
+      { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, 0.0] },
+      { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, 0.0 ] },
+      { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -1.9990234375, kValue.f16.negative.max, 0.0 ] },
+      { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.subnormal.min, 0.0 ] },
+      { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max, 0.0 ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f16.positive.subnormal.min ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f16.positive.subnormal.min, kValue.f16.positive.subnormal.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f16.positive.min ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f16.positive.min, kValue.f16.positive.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f16.positive.min, 1.9990234375, kValue.f16.positive.max ] },
+      { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f16.negative.min, kValue.f16.negative.subnormal.min, 0.0, kValue.f16.positive.subnormal.min, kValue.f16.positive.min ] },
+      { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max, 0.0, kValue.f16.positive.subnormal.min, kValue.f16.positive.subnormal.max, kValue.f16.positive.min, kValue.f16.positive.max ] },
+    ]
   )
   .fn(test => {
     const neg_norm = test.params.neg_norm;
@@ -1667,12 +1667,12 @@ g.test('f64LimitsEquivalency')
     { bits: kBit.f64.negative.pi.third, value: kValue.f64.negative.pi.third },
     { bits: kBit.f64.negative.pi.quarter, value: kValue.f64.negative.pi.quarter },
     { bits: kBit.f64.negative.pi.sixth, value: kValue.f64.negative.pi.sixth },
-    { bits: kBit.f64.subnormal.positive.max, value: kValue.f64.subnormal.positive.max },
-    { bits: kBit.f64.subnormal.positive.min, value: kValue.f64.subnormal.positive.min },
-    { bits: kBit.f64.subnormal.negative.max, value: kValue.f64.subnormal.negative.max },
-    { bits: kBit.f64.subnormal.negative.min, value: kValue.f64.subnormal.negative.min },
-    { bits: kBit.f64.infinity.positive, value: kValue.f64.infinity.positive },
-    { bits: kBit.f64.infinity.negative, value: kValue.f64.infinity.negative },
+    { bits: kBit.f64.positive.subnormal.max, value: kValue.f64.positive.subnormal.max },
+    { bits: kBit.f64.positive.subnormal.min, value: kValue.f64.positive.subnormal.min },
+    { bits: kBit.f64.negative.subnormal.max, value: kValue.f64.negative.subnormal.max },
+    { bits: kBit.f64.negative.subnormal.min, value: kValue.f64.negative.subnormal.min },
+    { bits: kBit.f64.positive.infinity, value: kValue.f64.positive.infinity },
+    { bits: kBit.f64.negative.infinity, value: kValue.f64.negative.infinity },
   ])
   .fn(test => {
     const bits = test.params.bits;
@@ -1715,12 +1715,12 @@ g.test('f32LimitsEquivalency')
     { bits: kBit.f32.negative.pi.third, value: kValue.f32.negative.pi.third },
     { bits: kBit.f32.negative.pi.quarter, value: kValue.f32.negative.pi.quarter },
     { bits: kBit.f32.negative.pi.sixth, value: kValue.f32.negative.pi.sixth },
-    { bits: kBit.f32.subnormal.positive.max, value: kValue.f32.subnormal.positive.max },
-    { bits: kBit.f32.subnormal.positive.min, value: kValue.f32.subnormal.positive.min },
-    { bits: kBit.f32.subnormal.negative.max, value: kValue.f32.subnormal.negative.max },
-    { bits: kBit.f32.subnormal.negative.min, value: kValue.f32.subnormal.negative.min },
-    { bits: kBit.f32.infinity.positive, value: kValue.f32.infinity.positive },
-    { bits: kBit.f32.infinity.negative, value: kValue.f32.infinity.negative },
+    { bits: kBit.f32.positive.subnormal.max, value: kValue.f32.positive.subnormal.max },
+    { bits: kBit.f32.positive.subnormal.min, value: kValue.f32.positive.subnormal.min },
+    { bits: kBit.f32.negative.subnormal.max, value: kValue.f32.negative.subnormal.max },
+    { bits: kBit.f32.negative.subnormal.min, value: kValue.f32.negative.subnormal.min },
+    { bits: kBit.f32.positive.infinity, value: kValue.f32.positive.infinity },
+    { bits: kBit.f32.negative.infinity, value: kValue.f32.negative.infinity },
   ])
   .fn(test => {
     const bits = test.params.bits;
@@ -1758,12 +1758,12 @@ g.test('f16LimitsEquivalency')
     { bits: kBit.f16.negative.pi.third, value: kValue.f16.negative.pi.third },
     { bits: kBit.f16.negative.pi.quarter, value: kValue.f16.negative.pi.quarter },
     { bits: kBit.f16.negative.pi.sixth, value: kValue.f16.negative.pi.sixth },
-    { bits: kBit.f16.subnormal.positive.max, value: kValue.f16.subnormal.positive.max },
-    { bits: kBit.f16.subnormal.positive.min, value: kValue.f16.subnormal.positive.min },
-    { bits: kBit.f16.subnormal.negative.max, value: kValue.f16.subnormal.negative.max },
-    { bits: kBit.f16.subnormal.negative.min, value: kValue.f16.subnormal.negative.min },
-    { bits: kBit.f16.infinity.positive, value: kValue.f16.infinity.positive },
-    { bits: kBit.f16.infinity.negative, value: kValue.f16.infinity.negative },
+    { bits: kBit.f16.positive.subnormal.max, value: kValue.f16.positive.subnormal.max },
+    { bits: kBit.f16.positive.subnormal.min, value: kValue.f16.positive.subnormal.min },
+    { bits: kBit.f16.negative.subnormal.max, value: kValue.f16.negative.subnormal.max },
+    { bits: kBit.f16.negative.subnormal.min, value: kValue.f16.negative.subnormal.min },
+    { bits: kBit.f16.positive.infinity, value: kValue.f16.positive.infinity },
+    { bits: kBit.f16.negative.infinity, value: kValue.f16.negative.infinity },
   ])
   .fn(test => {
     const bits = test.params.bits;
diff --git a/src/unittests/serialization.spec.ts b/src/unittests/serialization.spec.ts
index 2b5fa535b046..1879b1e75ac7 100644
--- a/src/unittests/serialization.spec.ts
+++ b/src/unittests/serialization.spec.ts
@@ -104,12 +104,12 @@ g.test('value').fn(t => {
     f32(-0.5),
     f32(kValue.f32.positive.max),
     f32(kValue.f32.positive.min),
-    f32(kValue.f32.subnormal.positive.max),
-    f32(kValue.f32.subnormal.positive.min),
-    f32(kValue.f32.subnormal.negative.max),
-    f32(kValue.f32.subnormal.negative.min),
-    f32(kValue.f32.infinity.positive),
-    f32(kValue.f32.infinity.negative),
+    f32(kValue.f32.positive.subnormal.max),
+    f32(kValue.f32.positive.subnormal.min),
+    f32(kValue.f32.negative.subnormal.max),
+    f32(kValue.f32.negative.subnormal.min),
+    f32(kValue.f32.positive.infinity),
+    f32(kValue.f32.negative.infinity),
 
     f16(0),
     f16(-0),
@@ -119,12 +119,12 @@ g.test('value').fn(t => {
     f16(-0.5),
     f16(kValue.f32.positive.max),
     f16(kValue.f32.positive.min),
-    f16(kValue.f32.subnormal.positive.max),
-    f16(kValue.f32.subnormal.positive.min),
-    f16(kValue.f32.subnormal.negative.max),
-    f16(kValue.f32.subnormal.negative.min),
-    f16(kValue.f32.infinity.positive),
-    f16(kValue.f32.infinity.negative),
+    f16(kValue.f32.positive.subnormal.max),
+    f16(kValue.f32.positive.subnormal.min),
+    f16(kValue.f32.negative.subnormal.max),
+    f16(kValue.f32.negative.subnormal.min),
+    f16(kValue.f32.positive.infinity),
+    f16(kValue.f32.negative.infinity),
 
     bool(true),
     bool(false),
@@ -225,20 +225,20 @@ g.test('fpinterval_f32').fn(t => {
     FP.f32.toInterval(-0.5),
     FP.f32.toInterval(kValue.f32.positive.max),
     FP.f32.toInterval(kValue.f32.positive.min),
-    FP.f32.toInterval(kValue.f32.subnormal.positive.max),
-    FP.f32.toInterval(kValue.f32.subnormal.positive.min),
-    FP.f32.toInterval(kValue.f32.subnormal.negative.max),
-    FP.f32.toInterval(kValue.f32.subnormal.negative.min),
-    FP.f32.toInterval(kValue.f32.infinity.positive),
-    FP.f32.toInterval(kValue.f32.infinity.negative),
+    FP.f32.toInterval(kValue.f32.positive.subnormal.max),
+    FP.f32.toInterval(kValue.f32.positive.subnormal.min),
+    FP.f32.toInterval(kValue.f32.negative.subnormal.max),
+    FP.f32.toInterval(kValue.f32.negative.subnormal.min),
+    FP.f32.toInterval(kValue.f32.positive.infinity),
+    FP.f32.toInterval(kValue.f32.negative.infinity),
 
     FP.f32.toInterval([-0, 0]),
     FP.f32.toInterval([-1, 1]),
     FP.f32.toInterval([-0.5, 0.5]),
     FP.f32.toInterval([kValue.f32.positive.min, kValue.f32.positive.max]),
-    FP.f32.toInterval([kValue.f32.subnormal.positive.min, kValue.f32.subnormal.positive.max]),
-    FP.f32.toInterval([kValue.f32.subnormal.negative.min, kValue.f32.subnormal.negative.max]),
-    FP.f32.toInterval([kValue.f32.infinity.negative, kValue.f32.infinity.positive]),
+    FP.f32.toInterval([kValue.f32.positive.subnormal.min, kValue.f32.positive.subnormal.max]),
+    FP.f32.toInterval([kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max]),
+    FP.f32.toInterval([kValue.f32.negative.infinity, kValue.f32.positive.infinity]),
   ]) {
     const serialized = serializeFPInterval(interval);
     const deserialized = deserializeFPInterval(serialized);
@@ -259,20 +259,20 @@ g.test('fpinterval_abstract').fn(t => {
     FP.abstract.toInterval(-0.5),
     FP.abstract.toInterval(kValue.f64.positive.max),
     FP.abstract.toInterval(kValue.f64.positive.min),
-    FP.abstract.toInterval(kValue.f64.subnormal.positive.max),
-    FP.abstract.toInterval(kValue.f64.subnormal.positive.min),
-    FP.abstract.toInterval(kValue.f64.subnormal.negative.max),
-    FP.abstract.toInterval(kValue.f64.subnormal.negative.min),
-    FP.abstract.toInterval(kValue.f64.infinity.positive),
-    FP.abstract.toInterval(kValue.f64.infinity.negative),
+    FP.abstract.toInterval(kValue.f64.positive.subnormal.max),
+    FP.abstract.toInterval(kValue.f64.positive.subnormal.min),
+    FP.abstract.toInterval(kValue.f64.negative.subnormal.max),
+    FP.abstract.toInterval(kValue.f64.negative.subnormal.min),
+    FP.abstract.toInterval(kValue.f64.positive.infinity),
+    FP.abstract.toInterval(kValue.f64.negative.infinity),
 
     FP.abstract.toInterval([-0, 0]),
     FP.abstract.toInterval([-1, 1]),
     FP.abstract.toInterval([-0.5, 0.5]),
     FP.abstract.toInterval([kValue.f64.positive.min, kValue.f64.positive.max]),
-    FP.abstract.toInterval([kValue.f64.subnormal.positive.min, kValue.f64.subnormal.positive.max]),
-    FP.abstract.toInterval([kValue.f64.subnormal.negative.min, kValue.f64.subnormal.negative.max]),
-    FP.abstract.toInterval([kValue.f64.infinity.negative, kValue.f64.infinity.positive]),
+    FP.abstract.toInterval([kValue.f64.positive.subnormal.min, kValue.f64.positive.subnormal.max]),
+    FP.abstract.toInterval([kValue.f64.negative.subnormal.min, kValue.f64.negative.subnormal.max]),
+    FP.abstract.toInterval([kValue.f64.negative.infinity, kValue.f64.positive.infinity]),
   ]) {
     const serialized = serializeFPInterval(interval);
     const deserialized = deserializeFPInterval(serialized);
diff --git a/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
index 7269d0a1772f..9f0938f430c6 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
@@ -72,13 +72,13 @@ const f32InfAndNaNInU32: number[] = [
   // The positive NaN with the lowest integer representation is the integer
   // for infinity, plus one.
   // The positive NaN with the highest integer representation is i32.max (!)
-  ...linearRange(kBit.f32.infinity.positive + 1, kBit.i32.positive.max, numNaNs),
+  ...linearRange(kBit.f32.positive.infinity + 1, kBit.i32.positive.max, numNaNs),
   // The negative NaN with the lowest integer representation is the integer
   // for negative infinity, plus one.
   // The negative NaN with the highest integer representation is u32.max (!)
-  ...linearRange(kBit.f32.infinity.negative + 1, kBit.u32.max, numNaNs),
-  kBit.f32.infinity.positive,
-  kBit.f32.infinity.negative,
+  ...linearRange(kBit.f32.negative.infinity + 1, kBit.u32.max, numNaNs),
+  kBit.f32.positive.infinity,
+  kBit.f32.negative.infinity,
 ];
 const f32InfAndNaNInF32 = f32InfAndNaNInU32.map(u => reinterpretU32AsF32(u));
 const f32InfAndNaNInI32 = f32InfAndNaNInU32.map(u => reinterpretU32AsI32(u));
@@ -102,13 +102,13 @@ const f16InfAndNaNInU16: number[] = [
   // The positive NaN with the lowest integer representation is the integer
   // for infinity, plus one.
   // The positive NaN with the highest integer representation is u16 0x7fff i.e. 32767.
-  ...linearRange(kBit.f16.infinity.positive + 1, 32767, numNaNs).map(v => Math.ceil(v)),
+  ...linearRange(kBit.f16.positive.infinity + 1, 32767, numNaNs).map(v => Math.ceil(v)),
   // The negative NaN with the lowest integer representation is the integer
   // for negative infinity, plus one.
   // The negative NaN with the highest integer representation is u16 0xffff i.e. 65535
-  ...linearRange(kBit.f16.infinity.negative + 1, 65535, numNaNs).map(v => Math.floor(v)),
-  kBit.f16.infinity.positive,
-  kBit.f16.infinity.negative,
+  ...linearRange(kBit.f16.negative.infinity + 1, 65535, numNaNs).map(v => Math.floor(v)),
+  kBit.f16.positive.infinity,
+  kBit.f16.negative.infinity,
 ];
 const f16InfAndNaNInF16 = f16InfAndNaNInU16.map(u => reinterpretU16AsF16(u));
 
diff --git a/src/webgpu/shader/execution/expression/call/builtin/quantizeToF16.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/quantizeToF16.spec.ts
index 3f203429b66e..b37d4c5afb81 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/quantizeToF16.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/quantizeToF16.spec.ts
@@ -27,10 +27,10 @@ export const d = makeCaseCache('quantizeToF16', {
       [
         kValue.f16.negative.min,
         kValue.f16.negative.max,
-        kValue.f16.subnormal.negative.min,
-        kValue.f16.subnormal.negative.max,
-        kValue.f16.subnormal.positive.min,
-        kValue.f16.subnormal.positive.max,
+        kValue.f16.negative.subnormal.min,
+        kValue.f16.negative.subnormal.max,
+        kValue.f16.positive.subnormal.min,
+        kValue.f16.positive.subnormal.max,
         kValue.f16.positive.min,
         kValue.f16.positive.max,
         ...fullF16Range(),
@@ -44,10 +44,10 @@ export const d = makeCaseCache('quantizeToF16', {
       [
         kValue.f16.negative.min,
         kValue.f16.negative.max,
-        kValue.f16.subnormal.negative.min,
-        kValue.f16.subnormal.negative.max,
-        kValue.f16.subnormal.positive.min,
-        kValue.f16.subnormal.positive.max,
+        kValue.f16.negative.subnormal.min,
+        kValue.f16.negative.subnormal.max,
+        kValue.f16.positive.subnormal.min,
+        kValue.f16.positive.subnormal.max,
         kValue.f16.positive.min,
         kValue.f16.positive.max,
         ...fullF32Range(),
diff --git a/src/webgpu/shader/execution/expression/expression.ts b/src/webgpu/shader/execution/expression/expression.ts
index aaa761a6fa88..e78081e70eab 100644
--- a/src/webgpu/shader/execution/expression/expression.ts
+++ b/src/webgpu/shader/execution/expression/expression.ts
@@ -865,7 +865,7 @@ function abstractFloatSnippet(expr: string, case_idx: number, accessor: string =
   //
   //   // Detect if the value is zero or subnormal, so that FTZ behaviour
   //   // can occur
-  //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.subnormal.positive.max}) && (${expr} >= ${kValue.f64.subnormal.negative.min});
+  //   const subnormal_or_zero : bool = (${expr} <= ${kValue.f64.positive.subnormal.max}) && (${expr} >= ${kValue.f64.negative.subnormal.min});
   //
   //   // MSB of the upper u32 is 1 if the value is negative, otherwise 0
   //   // Extract the sign bit early, so that abs() can be used with
@@ -903,7 +903,7 @@ function abstractFloatSnippet(expr: string, case_idx: number, accessor: string =
   // prettier-ignore
   return `  {
     const kExponentBias = 1022;
-    const subnormal_or_zero : bool = (${expr}${accessor} <= ${kValue.f64.subnormal.positive.max}) && (${expr}${accessor} >= ${kValue.f64.subnormal.negative.min});
+    const subnormal_or_zero : bool = (${expr}${accessor} <= ${kValue.f64.positive.subnormal.max}) && (${expr}${accessor} >= ${kValue.f64.negative.subnormal.min});
     const sign_bit : u32 = select(0, 0x80000000, ${expr}${accessor} < 0);
     const f = frexp(abs(${expr}${accessor}));
     const f_fract = select(f.fract, 0, subnormal_or_zero);
diff --git a/src/webgpu/shader/validation/expression/call/builtin/bitcast.spec.ts b/src/webgpu/shader/validation/expression/call/builtin/bitcast.spec.ts
index fb38683a6d3d..6acd261552d0 100644
--- a/src/webgpu/shader/validation/expression/call/builtin/bitcast.spec.ts
+++ b/src/webgpu/shader/validation/expression/call/builtin/bitcast.spec.ts
@@ -33,13 +33,13 @@ const f32InfAndNaNInU32: number[] = [
   // The positive NaN with the lowest integer representation is the integer
   // for infinity, plus one.
   // The positive NaN with the highest integer representation is i32.max (!)
-  ...linearRange(kBit.f32.infinity.positive + 1, kBit.i32.positive.max, numNaNs),
+  ...linearRange(kBit.f32.positive.infinity + 1, kBit.i32.positive.max, numNaNs),
   // The negative NaN with the lowest integer representation is the integer
   // for negative infinity, plus one.
   // The negative NaN with the highest integer representation is u32.max (!)
-  ...linearRange(kBit.f32.infinity.negative + 1, kBit.u32.max, numNaNs),
-  kBit.f32.infinity.positive,
-  kBit.f32.infinity.negative,
+  ...linearRange(kBit.f32.negative.infinity + 1, kBit.u32.max, numNaNs),
+  kBit.f32.positive.infinity,
+  kBit.f32.negative.infinity,
 ];
 
 g.test('bad_const_to_f32')
diff --git a/src/webgpu/util/constants.ts b/src/webgpu/util/constants.ts
index 94d6eb949edf..0dec73f187c1 100644
--- a/src/webgpu/util/constants.ts
+++ b/src/webgpu/util/constants.ts
@@ -27,6 +27,11 @@ export const kBit = {
       min: BigInt(0x0010_0000_0000_0000n),
       max: BigInt(0x7fef_ffff_ffff_ffffn),
       zero: BigInt(0x0000_0000_0000_0000n),
+      subnormal: {
+        min: BigInt(0x0000_0000_0000_0001n),
+        max: BigInt(0x000f_ffff_ffff_ffffn),
+      },
+      infinity: BigInt(0x7ff0_0000_0000_0000n),
       nearest_max: BigInt(0x7fef_ffff_ffff_fffen),
       less_than_one: BigInt(0x3fef_ffff_ffff_ffffn),
       pi: {
@@ -43,6 +48,11 @@ export const kBit = {
       max: BigInt(0x8010_0000_0000_0000n),
       min: BigInt(0xffef_ffff_ffff_ffffn),
       zero: BigInt(0x8000_0000_0000_0000n),
+      subnormal: {
+        max: BigInt(0x8000_0000_0000_0001n),
+        min: BigInt(0x800f_ffff_ffff_ffffn),
+      },
+      infinity: BigInt(0xfff0_0000_0000_0000n),
       nearest_min: BigInt(0xffef_ffff_ffff_fffen),
       less_than_one: BigInt(0xbfef_ffff_ffff_ffffn),
       pi: {
@@ -54,20 +64,6 @@ export const kBit = {
         sixth: BigInt(0xbfe0_c152_382d_7365n),
       },
     },
-    subnormal: {
-      positive: {
-        min: BigInt(0x0000_0000_0000_0001n),
-        max: BigInt(0x000f_ffff_ffff_ffffn),
-      },
-      negative: {
-        max: BigInt(0x8000_0000_0000_0001n),
-        min: BigInt(0x800f_ffff_ffff_ffffn),
-      },
-    },
-    infinity: {
-      positive: BigInt(0x7ff0_0000_0000_0000n),
-      negative: BigInt(0xfff0_0000_0000_0000n),
-    },
     max_ulp: BigInt(0x7ca0_0000_0000_0000n),
   },
 
@@ -77,6 +73,11 @@ export const kBit = {
       min: 0x0080_0000,
       max: 0x7f7f_ffff,
       zero: 0x0000_0000,
+      subnormal: {
+        min: 0x0000_0001,
+        max: 0x007f_ffff,
+      },
+      infinity: 0x7f80_0000,
       nearest_max: 0x7f7f_fffe,
       less_than_one: 0x3f7f_ffff,
       pi: {
@@ -93,6 +94,11 @@ export const kBit = {
       max: 0x8080_0000,
       min: 0xff7f_ffff,
       zero: 0x8000_0000,
+      subnormal: {
+        max: 0x8000_0001,
+        min: 0x807f_ffff,
+      },
+      infinity: 0xff80_0000,
       nearest_min: 0xff7f_fffe,
       less_than_one: 0xbf7f_ffff,
       pi: {
@@ -104,20 +110,6 @@ export const kBit = {
         sixth: 0xbf06_0a92,
       },
     },
-    subnormal: {
-      positive: {
-        min: 0x0000_0001,
-        max: 0x007f_ffff,
-      },
-      negative: {
-        max: 0x8000_0001,
-        min: 0x807f_ffff,
-      },
-    },
-    infinity: {
-      positive: 0x7f80_0000,
-      negative: 0xff80_0000,
-    },
     max_ulp: 0x7380_0000,
   },
 
@@ -127,6 +119,11 @@ export const kBit = {
       min: 0x0400,
       max: 0x7bff,
       zero: 0x0000,
+      subnormal: {
+        min: 0x0001,
+        max: 0x03ff,
+      },
+      infinity: 0x7c00,
       nearest_max: 0x7bfe,
       less_than_one: 0x3bff,
       pi: {
@@ -143,6 +140,11 @@ export const kBit = {
       max: 0x8400,
       min: 0xfbff,
       zero: 0x8000,
+      subnormal: {
+        max: 0x8001,
+        min: 0x83ff,
+      },
+      infinity: 0xfc00,
       nearest_min: 0xfbfe,
       less_than_one: 0xbbff,
       pi: {
@@ -154,20 +156,6 @@ export const kBit = {
         sixth: 0xb830,
       },
     },
-    subnormal: {
-      positive: {
-        min: 0x0001,
-        max: 0x03ff,
-      },
-      negative: {
-        max: 0x8001,
-        min: 0x83ff,
-      },
-    },
-    infinity: {
-      positive: 0x7c00,
-      negative: 0xfc00,
-    },
     max_ulp: 0x5000,
   },
 
@@ -316,6 +304,11 @@ export const kValue = {
       min: reinterpretU64AsF64(kBit.f64.positive.min),
       max: reinterpretU64AsF64(kBit.f64.positive.max),
       zero: reinterpretU64AsF64(kBit.f64.positive.zero),
+      subnormal: {
+        min: reinterpretU64AsF64(kBit.f64.positive.subnormal.min),
+        max: reinterpretU64AsF64(kBit.f64.positive.subnormal.max),
+      },
+      infinity: reinterpretU64AsF64(kBit.f64.positive.infinity),
       nearest_max: reinterpretU64AsF64(kBit.f64.positive.nearest_max),
       less_than_one: reinterpretU64AsF64(kBit.f64.positive.less_than_one),
       pi: {
@@ -332,6 +325,11 @@ export const kValue = {
       max: reinterpretU64AsF64(kBit.f64.negative.max),
       min: reinterpretU64AsF64(kBit.f64.negative.min),
       zero: reinterpretU64AsF64(kBit.f64.negative.zero),
+      subnormal: {
+        max: reinterpretU64AsF64(kBit.f64.negative.subnormal.max),
+        min: reinterpretU64AsF64(kBit.f64.negative.subnormal.min),
+      },
+      infinity: reinterpretU64AsF64(kBit.f64.negative.infinity),
       nearest_min: reinterpretU64AsF64(kBit.f64.negative.nearest_min),
       less_than_one: reinterpretU64AsF64(kBit.f64.negative.less_than_one), // -0.999999940395
       pi: {
@@ -343,20 +341,6 @@ export const kValue = {
         sixth: reinterpretU64AsF64(kBit.f64.negative.pi.sixth),
       },
     },
-    subnormal: {
-      positive: {
-        min: reinterpretU64AsF64(kBit.f64.subnormal.positive.min),
-        max: reinterpretU64AsF64(kBit.f64.subnormal.positive.max),
-      },
-      negative: {
-        max: reinterpretU64AsF64(kBit.f64.subnormal.negative.max),
-        min: reinterpretU64AsF64(kBit.f64.subnormal.negative.min),
-      },
-    },
-    infinity: {
-      positive: reinterpretU64AsF64(kBit.f64.infinity.positive),
-      negative: reinterpretU64AsF64(kBit.f64.infinity.negative),
-    },
     max_ulp: reinterpretU64AsF64(kBit.f64.max_ulp),
   },
 
@@ -366,6 +350,12 @@ export const kValue = {
       min: reinterpretU32AsF32(kBit.f32.positive.min),
       max: reinterpretU32AsF32(kBit.f32.positive.max),
       zero: reinterpretU32AsF32(kBit.f32.positive.zero),
+      subnormal: {
+        min: reinterpretU32AsF32(kBit.f32.positive.subnormal.min),
+        max: reinterpretU32AsF32(kBit.f32.positive.subnormal.max),
+      },
+      infinity: reinterpretU32AsF32(kBit.f32.positive.infinity),
+
       nearest_max: reinterpretU32AsF32(kBit.f32.positive.nearest_max),
       less_than_one: reinterpretU32AsF32(kBit.f32.positive.less_than_one),
       pi: {
@@ -393,6 +383,11 @@ export const kValue = {
       max: reinterpretU32AsF32(kBit.f32.negative.max),
       min: reinterpretU32AsF32(kBit.f32.negative.min),
       zero: reinterpretU32AsF32(kBit.f32.negative.zero),
+      subnormal: {
+        max: reinterpretU32AsF32(kBit.f32.negative.subnormal.max),
+        min: reinterpretU32AsF32(kBit.f32.negative.subnormal.min),
+      },
+      infinity: reinterpretU32AsF32(kBit.f32.negative.infinity),
       nearest_min: reinterpretU32AsF32(kBit.f32.negative.nearest_min),
       less_than_one: reinterpretU32AsF32(kBit.f32.negative.less_than_one), // -0.999999940395
       pi: {
@@ -417,20 +412,6 @@ export const kValue = {
         reinterpretF64AsU64(reinterpretU32AsF32(kBit.f32.positive.max) / 2 + 2 ** 127) - BigInt(1)
       ),
     },
-    subnormal: {
-      positive: {
-        min: reinterpretU32AsF32(kBit.f32.subnormal.positive.min),
-        max: reinterpretU32AsF32(kBit.f32.subnormal.positive.max),
-      },
-      negative: {
-        max: reinterpretU32AsF32(kBit.f32.subnormal.negative.max),
-        min: reinterpretU32AsF32(kBit.f32.subnormal.negative.min),
-      },
-    },
-    infinity: {
-      positive: reinterpretU32AsF32(kBit.f32.infinity.positive),
-      negative: reinterpretU32AsF32(kBit.f32.infinity.negative),
-    },
     max_ulp: reinterpretU32AsF32(kBit.f32.max_ulp),
     emax: 127,
   },
@@ -459,6 +440,11 @@ export const kValue = {
       min: reinterpretU16AsF16(kBit.f16.positive.min),
       max: reinterpretU16AsF16(kBit.f16.positive.max),
       zero: reinterpretU16AsF16(kBit.f16.positive.zero),
+      subnormal: {
+        min: reinterpretU16AsF16(kBit.f16.positive.subnormal.min),
+        max: reinterpretU16AsF16(kBit.f16.positive.subnormal.max),
+      },
+      infinity: reinterpretU16AsF16(kBit.f16.positive.infinity),
       nearest_max: reinterpretU16AsF16(kBit.f16.positive.nearest_max),
       less_than_one: reinterpretU16AsF16(kBit.f16.positive.less_than_one),
       pi: {
@@ -486,6 +472,11 @@ export const kValue = {
       max: reinterpretU16AsF16(kBit.f16.negative.max),
       min: reinterpretU16AsF16(kBit.f16.negative.min),
       zero: reinterpretU16AsF16(kBit.f16.negative.zero),
+      subnormal: {
+        max: reinterpretU16AsF16(kBit.f16.negative.subnormal.max),
+        min: reinterpretU16AsF16(kBit.f16.negative.subnormal.min),
+      },
+      infinity: reinterpretU16AsF16(kBit.f16.negative.infinity),
       nearest_min: reinterpretU16AsF16(kBit.f16.negative.nearest_min),
       less_than_one: reinterpretU16AsF16(kBit.f16.negative.less_than_one), // -0.9996
       pi: {
@@ -510,20 +501,6 @@ export const kValue = {
         reinterpretF64AsU64(reinterpretU16AsF16(kBit.f16.positive.max) / 2 + 2 ** 15) - BigInt(1)
       ),
     },
-    subnormal: {
-      positive: {
-        min: reinterpretU16AsF16(kBit.f16.subnormal.positive.min),
-        max: reinterpretU16AsF16(kBit.f16.subnormal.positive.max),
-      },
-      negative: {
-        max: reinterpretU16AsF16(kBit.f16.subnormal.negative.max),
-        min: reinterpretU16AsF16(kBit.f16.subnormal.negative.min),
-      },
-    },
-    infinity: {
-      positive: reinterpretU16AsF16(kBit.f16.infinity.positive),
-      negative: reinterpretU16AsF16(kBit.f16.infinity.negative),
-    },
     max_ulp: reinterpretU16AsF16(kBit.f16.max_ulp),
     emax: 15,
   },
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 25a7b74da38a..461810b9e540 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4279,12 +4279,12 @@ class F32Traits extends FPTraits {
     positive: {
       min: kValue.f32.positive.min,
       max: kValue.f32.positive.max,
-      infinity: kValue.f32.infinity.positive,
+      infinity: kValue.f32.positive.infinity,
       nearest_max: kValue.f32.positive.nearest_max,
       less_than_one: kValue.f32.positive.less_than_one,
       subnormal: {
-        min: kValue.f32.subnormal.positive.min,
-        max: kValue.f32.subnormal.positive.max,
+        min: kValue.f32.positive.subnormal.min,
+        max: kValue.f32.positive.subnormal.max,
       },
       pi: {
         whole: kValue.f32.positive.pi.whole,
@@ -4299,12 +4299,12 @@ class F32Traits extends FPTraits {
     negative: {
       min: kValue.f32.negative.min,
       max: kValue.f32.negative.max,
-      infinity: kValue.f32.infinity.negative,
+      infinity: kValue.f32.negative.infinity,
       nearest_min: kValue.f32.negative.nearest_min,
       less_than_one: kValue.f32.negative.less_than_one,
       subnormal: {
-        min: kValue.f32.subnormal.negative.min,
-        max: kValue.f32.subnormal.negative.max,
+        min: kValue.f32.negative.subnormal.min,
+        max: kValue.f32.negative.subnormal.max,
       },
       pi: {
         whole: kValue.f32.negative.pi.whole,
@@ -4326,7 +4326,7 @@ class F32Traits extends FPTraits {
     ),
     greaterThanZeroInterval: new FPInterval(
       'f32',
-      kValue.f32.subnormal.positive.min,
+      kValue.f32.positive.subnormal.min,
       kValue.f32.positive.max
     ),
     zeroVector: {
@@ -4742,12 +4742,12 @@ class FPAbstractTraits extends FPTraits {
     positive: {
       min: kValue.f64.positive.min,
       max: kValue.f64.positive.max,
-      infinity: kValue.f64.infinity.positive,
+      infinity: kValue.f64.positive.infinity,
       nearest_max: kValue.f64.positive.nearest_max,
       less_than_one: kValue.f64.positive.less_than_one,
       subnormal: {
-        min: kValue.f64.subnormal.positive.min,
-        max: kValue.f64.subnormal.positive.max,
+        min: kValue.f64.positive.subnormal.min,
+        max: kValue.f64.positive.subnormal.max,
       },
       pi: {
         whole: kValue.f64.positive.pi.whole,
@@ -4762,12 +4762,12 @@ class FPAbstractTraits extends FPTraits {
     negative: {
       min: kValue.f64.negative.min,
       max: kValue.f64.negative.max,
-      infinity: kValue.f64.infinity.negative,
+      infinity: kValue.f64.negative.infinity,
       nearest_min: kValue.f64.negative.nearest_min,
       less_than_one: kValue.f64.negative.less_than_one,
       subnormal: {
-        min: kValue.f64.subnormal.negative.min,
-        max: kValue.f64.subnormal.negative.max,
+        min: kValue.f64.negative.subnormal.min,
+        max: kValue.f64.negative.subnormal.max,
       },
       pi: {
         whole: kValue.f64.negative.pi.whole,
@@ -4789,7 +4789,7 @@ class FPAbstractTraits extends FPTraits {
     ),
     greaterThanZeroInterval: new FPInterval(
       'abstract',
-      kValue.f64.subnormal.positive.min,
+      kValue.f64.positive.subnormal.min,
       kValue.f64.positive.max
     ),
     zeroVector: {
@@ -5085,12 +5085,12 @@ class F16Traits extends FPTraits {
     positive: {
       min: kValue.f16.positive.min,
       max: kValue.f16.positive.max,
-      infinity: kValue.f16.infinity.positive,
+      infinity: kValue.f16.positive.infinity,
       nearest_max: kValue.f16.positive.nearest_max,
       less_than_one: kValue.f16.positive.less_than_one,
       subnormal: {
-        min: kValue.f16.subnormal.positive.min,
-        max: kValue.f16.subnormal.positive.max,
+        min: kValue.f16.positive.subnormal.min,
+        max: kValue.f16.positive.subnormal.max,
       },
       pi: {
         whole: kValue.f16.positive.pi.whole,
@@ -5105,12 +5105,12 @@ class F16Traits extends FPTraits {
     negative: {
       min: kValue.f16.negative.min,
       max: kValue.f16.negative.max,
-      infinity: kValue.f16.infinity.negative,
+      infinity: kValue.f16.negative.infinity,
       nearest_min: kValue.f16.negative.nearest_min,
       less_than_one: kValue.f16.negative.less_than_one,
       subnormal: {
-        min: kValue.f16.subnormal.negative.min,
-        max: kValue.f16.subnormal.negative.max,
+        min: kValue.f16.negative.subnormal.min,
+        max: kValue.f16.negative.subnormal.max,
       },
       pi: {
         whole: kValue.f16.negative.pi.whole,
@@ -5132,7 +5132,7 @@ class F16Traits extends FPTraits {
     ),
     greaterThanZeroInterval: new FPInterval(
       'f16',
-      kValue.f16.subnormal.positive.min,
+      kValue.f16.positive.subnormal.min,
       kValue.f16.positive.max
     ),
     zeroVector: {
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 54bba7abfb71..3055b6d9aa96 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -122,11 +122,11 @@ export function nextAfterF64(val: number, dir: NextDirection, mode: FlushMode):
   }
 
   if (val === Number.POSITIVE_INFINITY) {
-    return kValue.f64.infinity.positive;
+    return kValue.f64.positive.infinity;
   }
 
   if (val === Number.NEGATIVE_INFINITY) {
-    return kValue.f64.infinity.negative;
+    return kValue.f64.negative.infinity;
   }
 
   assert(
@@ -139,9 +139,9 @@ export function nextAfterF64(val: number, dir: NextDirection, mode: FlushMode):
   // -/+0 === 0 returns true
   if (val === 0) {
     if (dir === 'positive') {
-      return mode === 'flush' ? kValue.f64.positive.min : kValue.f64.subnormal.positive.min;
+      return mode === 'flush' ? kValue.f64.positive.min : kValue.f64.positive.subnormal.min;
     } else {
-      return mode === 'flush' ? kValue.f64.negative.max : kValue.f64.subnormal.negative.max;
+      return mode === 'flush' ? kValue.f64.negative.max : kValue.f64.negative.subnormal.max;
     }
   }
 
@@ -156,9 +156,9 @@ export function nextAfterF64(val: number, dir: NextDirection, mode: FlushMode):
   // Checking for overflow
   if ((nextAfterF64Int[0] & 0x7ff0_0000_0000_0000n) === 0x7ff0_0000_0000_0000n) {
     if (dir === 'positive') {
-      return kValue.f64.infinity.positive;
+      return kValue.f64.positive.infinity;
     } else {
-      return kValue.f64.infinity.negative;
+      return kValue.f64.negative.infinity;
     }
   }
 
@@ -195,11 +195,11 @@ export function nextAfterF32(val: number, dir: NextDirection, mode: FlushMode):
   }
 
   if (val === Number.POSITIVE_INFINITY) {
-    return kValue.f32.infinity.positive;
+    return kValue.f32.positive.infinity;
   }
 
   if (val === Number.NEGATIVE_INFINITY) {
-    return kValue.f32.infinity.negative;
+    return kValue.f32.negative.infinity;
   }
 
   assert(
@@ -212,9 +212,9 @@ export function nextAfterF32(val: number, dir: NextDirection, mode: FlushMode):
   // -/+0 === 0 returns true
   if (val === 0) {
     if (dir === 'positive') {
-      return mode === 'flush' ? kValue.f32.positive.min : kValue.f32.subnormal.positive.min;
+      return mode === 'flush' ? kValue.f32.positive.min : kValue.f32.positive.subnormal.min;
     } else {
-      return mode === 'flush' ? kValue.f32.negative.max : kValue.f32.subnormal.negative.max;
+      return mode === 'flush' ? kValue.f32.negative.max : kValue.f32.negative.subnormal.max;
     }
   }
 
@@ -237,9 +237,9 @@ export function nextAfterF32(val: number, dir: NextDirection, mode: FlushMode):
   // Checking for overflow
   if ((nextAfterF32Int[0] & 0x7f800000) === 0x7f800000) {
     if (dir === 'positive') {
-      return kValue.f32.infinity.positive;
+      return kValue.f32.positive.infinity;
     } else {
-      return kValue.f32.infinity.negative;
+      return kValue.f32.negative.infinity;
     }
   }
 
@@ -276,11 +276,11 @@ export function nextAfterF16(val: number, dir: NextDirection, mode: FlushMode):
   }
 
   if (val === Number.POSITIVE_INFINITY) {
-    return kValue.f16.infinity.positive;
+    return kValue.f16.positive.infinity;
   }
 
   if (val === Number.NEGATIVE_INFINITY) {
-    return kValue.f16.infinity.negative;
+    return kValue.f16.negative.infinity;
   }
 
   assert(
@@ -293,9 +293,9 @@ export function nextAfterF16(val: number, dir: NextDirection, mode: FlushMode):
   // -/+0 === 0 returns true
   if (val === 0) {
     if (dir === 'positive') {
-      return mode === 'flush' ? kValue.f16.positive.min : kValue.f16.subnormal.positive.min;
+      return mode === 'flush' ? kValue.f16.positive.min : kValue.f16.positive.subnormal.min;
     } else {
-      return mode === 'flush' ? kValue.f16.negative.max : kValue.f16.subnormal.negative.max;
+      return mode === 'flush' ? kValue.f16.negative.max : kValue.f16.negative.subnormal.max;
     }
   }
 
@@ -318,9 +318,9 @@ export function nextAfterF16(val: number, dir: NextDirection, mode: FlushMode):
   // Checking for overflow
   if ((nextAfterF16Hex[0] & 0x7c00) === 0x7c00) {
     if (dir === 'positive') {
-      return kValue.f16.infinity.positive;
+      return kValue.f16.positive.infinity;
     } else {
-      return kValue.f16.infinity.negative;
+      return kValue.f16.negative.infinity;
     }
   }
 
@@ -916,14 +916,14 @@ export function fullF32Range(
   const bit_fields = [
     ...linearRange(kBit.f32.negative.min, kBit.f32.negative.max, counts.neg_norm),
     ...linearRange(
-      kBit.f32.subnormal.negative.min,
-      kBit.f32.subnormal.negative.max,
+      kBit.f32.negative.subnormal.min,
+      kBit.f32.negative.subnormal.max,
       counts.neg_sub
     ),
     0,
     ...linearRange(
-      kBit.f32.subnormal.positive.min,
-      kBit.f32.subnormal.positive.max,
+      kBit.f32.positive.subnormal.min,
+      kBit.f32.positive.subnormal.max,
       counts.pos_sub
     ),
     ...linearRange(kBit.f32.positive.min, kBit.f32.positive.max, counts.pos_norm),
@@ -980,14 +980,14 @@ export function fullF16Range(
   const bit_fields = [
     ...linearRange(kBit.f16.negative.min, kBit.f16.negative.max, counts.neg_norm),
     ...linearRange(
-      kBit.f16.subnormal.negative.min,
-      kBit.f16.subnormal.negative.max,
+      kBit.f16.negative.subnormal.min,
+      kBit.f16.negative.subnormal.max,
       counts.neg_sub
     ),
     0,
     ...linearRange(
-      kBit.f16.subnormal.positive.min,
-      kBit.f16.subnormal.positive.max,
+      kBit.f16.positive.subnormal.min,
+      kBit.f16.positive.subnormal.max,
       counts.pos_sub
     ),
     ...linearRange(kBit.f16.positive.min, kBit.f16.positive.max, counts.pos_norm),
@@ -1028,14 +1028,14 @@ export function fullF64Range(
   const bit_fields = [
     ...linearRangeBigInt(kBit.f64.negative.min, kBit.f64.negative.max, counts.neg_norm),
     ...linearRangeBigInt(
-      kBit.f64.subnormal.negative.min,
-      kBit.f64.subnormal.negative.max,
+      kBit.f64.negative.subnormal.min,
+      kBit.f64.negative.subnormal.max,
       counts.neg_sub
     ),
     0n,
     ...linearRangeBigInt(
-      kBit.f64.subnormal.positive.min,
-      kBit.f64.subnormal.positive.max,
+      kBit.f64.positive.subnormal.min,
+      kBit.f64.positive.subnormal.max,
       counts.pos_sub
     ),
     ...linearRangeBigInt(kBit.f64.positive.min, kBit.f64.positive.max, counts.pos_norm),
@@ -1084,14 +1084,14 @@ export function filteredF64Range(
   const bit_fields = [
     ...linearRangeBigInt(u64_begin, kBit.f64.negative.max, counts.neg_norm),
     ...linearRangeBigInt(
-      kBit.f64.subnormal.negative.min,
-      kBit.f64.subnormal.negative.max,
+      kBit.f64.negative.subnormal.min,
+      kBit.f64.negative.subnormal.max,
       counts.neg_sub
     ),
     0n,
     ...linearRangeBigInt(
-      kBit.f64.subnormal.positive.min,
-      kBit.f64.subnormal.positive.max,
+      kBit.f64.positive.subnormal.min,
+      kBit.f64.positive.subnormal.max,
       counts.pos_sub
     ),
     ...linearRangeBigInt(kBit.f64.positive.min, u64_end, counts.pos_norm),
@@ -1265,12 +1265,12 @@ const kInterestingF32Values: number[] = [
   -1.0,
   -0.125,
   kValue.f32.negative.max,
-  kValue.f32.subnormal.negative.min,
-  kValue.f32.subnormal.negative.max,
+  kValue.f32.negative.subnormal.min,
+  kValue.f32.negative.subnormal.max,
   -0.0,
   0.0,
-  kValue.f32.subnormal.positive.min,
-  kValue.f32.subnormal.positive.max,
+  kValue.f32.positive.subnormal.min,
+  kValue.f32.positive.subnormal.max,
   kValue.f32.positive.min,
   0.125,
   1.0,
@@ -1501,12 +1501,12 @@ const kInterestingF16Values: number[] = [
   -1.0,
   -0.125,
   kValue.f16.negative.max,
-  kValue.f16.subnormal.negative.min,
-  kValue.f16.subnormal.negative.max,
+  kValue.f16.negative.subnormal.min,
+  kValue.f16.negative.subnormal.max,
   -0.0,
   0.0,
-  kValue.f16.subnormal.positive.min,
-  kValue.f16.subnormal.positive.max,
+  kValue.f16.positive.subnormal.min,
+  kValue.f16.positive.subnormal.max,
   kValue.f16.positive.min,
   0.125,
   1.0,
@@ -1737,12 +1737,12 @@ const kInterestingF64Values: number[] = [
   -1.0,
   -0.125,
   kValue.f64.negative.max,
-  kValue.f64.subnormal.negative.min,
-  kValue.f64.subnormal.negative.max,
+  kValue.f64.negative.subnormal.min,
+  kValue.f64.negative.subnormal.max,
   -0.0,
   0.0,
-  kValue.f64.subnormal.positive.min,
-  kValue.f64.subnormal.positive.max,
+  kValue.f64.positive.subnormal.min,
+  kValue.f64.positive.subnormal.max,
   kValue.f64.positive.min,
   0.125,
   1.0,

From a5638d65c4ff52c4d7de1eba567985955f50c6c4 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Thu, 28 Sep 2023 13:13:53 +0800
Subject: [PATCH 105/166] Update subcaseMS of
 web_platform,copyToTexture,ImageBitmap (#3023)

This PR clean up web_platform,copyToTexture,ImageBitmap cases that has
subcaseMS <=0 in listing_meta.json, to reduce the validation warning.
This PR also rename some test case parameter to shorten the WPT generated
chunk file name.

Issue: #2939
---
 src/webgpu/listing_meta.json                  |  4 +-
 .../copyToTexture/ImageBitmap.spec.ts         | 68 +++++++++----------
 2 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 96e3c3c128ce..2a2cdadc75b7 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1960,8 +1960,8 @@
   "webgpu:web_platform,canvas,readbackFromWebGPUCanvas:transferToImageBitmap_zero_size:*": { "subcaseMS": 7.551 },
   "webgpu:web_platform,copyToTexture,ImageBitmap:copy_subrect_from_2D_Canvas:*": { "subcaseMS": 5.329 },
   "webgpu:web_platform,copyToTexture,ImageBitmap:copy_subrect_from_ImageData:*": { "subcaseMS": 3.295 },
-  "webgpu:web_platform,copyToTexture,ImageBitmap:from_ImageData:*": { "subcaseMS": 0.000 },
-  "webgpu:web_platform,copyToTexture,ImageBitmap:from_canvas:*": { "subcaseMS": 0.000 },
+  "webgpu:web_platform,copyToTexture,ImageBitmap:from_ImageData:*": { "subcaseMS": 15.061 },
+  "webgpu:web_platform,copyToTexture,ImageBitmap:from_canvas:*": { "subcaseMS": 21.438 },
   "webgpu:web_platform,copyToTexture,ImageData:copy_subrect_from_ImageData:*": { "subcaseMS": 3.167 },
   "webgpu:web_platform,copyToTexture,ImageData:from_ImageData:*": { "subcaseMS": 27.268 },
   "webgpu:web_platform,copyToTexture,canvas:color_space_conversion:*": { "subcaseMS": 15.391 },
diff --git a/src/webgpu/web_platform/copyToTexture/ImageBitmap.spec.ts b/src/webgpu/web_platform/copyToTexture/ImageBitmap.spec.ts
index 76607d59fb61..b378c52ee206 100644
--- a/src/webgpu/web_platform/copyToTexture/ImageBitmap.spec.ts
+++ b/src/webgpu/web_platform/copyToTexture/ImageBitmap.spec.ts
@@ -38,10 +38,10 @@ g.test('from_ImageData')
   is flipped.
 
   The tests covers:
-  - Valid dstColorFormat of copyExternalImageToTexture()
+  - Valid dstFormat of copyExternalImageToTexture()
   - Valid source image alphaMode
   - Valid dest alphaMode
-  - Valid 'flipY' config in 'GPUImageCopyExternalImage' (named 'srcDoFlipYDuringCopy' in cases)
+  - Valid 'flipY' config in 'GPUImageCopyExternalImage' (named 'srcFlipYInCopy' in cases)
 
   And the expected results are all passed.
   `
@@ -51,15 +51,15 @@ g.test('from_ImageData')
       .combine('alpha', ['none', 'premultiply'] as const)
       .combine('orientation', ['none', 'flipY'] as const)
       .combine('colorSpaceConversion', ['none', 'default'] as const)
-      .combine('srcDoFlipYDuringCopy', [true, false])
-      .combine('dstColorFormat', kValidTextureFormatsForCopyE2T)
+      .combine('srcFlipYInCopy', [true, false])
+      .combine('dstFormat', kValidTextureFormatsForCopyE2T)
       .combine('dstPremultiplied', [true, false])
       .beginSubcases()
       .combine('width', [1, 2, 4, 15, 255, 256])
       .combine('height', [1, 2, 4, 15, 255, 256])
   )
   .beforeAllSubcases(t => {
-    t.skipIfTextureFormatNotSupported(t.params.dstColorFormat);
+    t.skipIfTextureFormatNotSupported(t.params.dstFormat);
   })
   .fn(async t => {
     const {
@@ -68,9 +68,9 @@ g.test('from_ImageData')
       alpha,
       orientation,
       colorSpaceConversion,
-      dstColorFormat,
+      dstFormat,
       dstPremultiplied,
-      srcDoFlipYDuringCopy,
+      srcFlipYInCopy,
     } = t.params;
 
     const testColors = kTestColorsAll;
@@ -100,12 +100,12 @@ g.test('from_ImageData')
 
     const dst = t.device.createTexture({
       size: { width, height },
-      format: dstColorFormat,
+      format: dstFormat,
       usage:
         GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
     });
 
-    const expFormat = kTextureFormatInfo[dstColorFormat].baseFormat ?? dstColorFormat;
+    const expFormat = kTextureFormatInfo[dstFormat].baseFormat ?? dstFormat;
     const flipSrcBeforeCopy = orientation === 'flipY';
     const texelViewExpected = t.getExpectedDstPixelsFromSrcPixels({
       srcPixels: imageData.data,
@@ -116,7 +116,7 @@ g.test('from_ImageData')
       subRectSize: [width, height],
       format: expFormat,
       flipSrcBeforeCopy,
-      srcDoFlipYDuringCopy,
+      srcDoFlipYDuringCopy: srcFlipYInCopy,
       conversion: {
         srcPremultiplied: false,
         dstPremultiplied,
@@ -124,7 +124,7 @@ g.test('from_ImageData')
     });
 
     t.doTestAndCheckResult(
-      { source: imageBitmap, origin: { x: 0, y: 0 }, flipY: srcDoFlipYDuringCopy },
+      { source: imageBitmap, origin: { x: 0, y: 0 }, flipY: srcFlipYInCopy },
       {
         texture: dst,
         origin: { x: 0, y: 0 },
@@ -159,10 +159,10 @@ g.test('from_canvas')
 
   The tests covers:
   - Valid 2D canvas
-  - Valid dstColorFormat of copyExternalImageToTexture()
+  - Valid dstFormat of copyExternalImageToTexture()
   - Valid source image alphaMode
   - Valid dest alphaMode
-  - Valid 'flipY' config in 'GPUImageCopyExternalImage' (named 'srcDoFlipYDuringCopy' in cases)
+  - Valid 'flipY' config in 'GPUImageCopyExternalImage' (named 'srcFlipYInCopy' in cases)
 
   And the expected results are all passed.
   `
@@ -171,15 +171,15 @@ g.test('from_canvas')
     u
       .combine('orientation', ['none', 'flipY'] as const)
       .combine('colorSpaceConversion', ['none', 'default'] as const)
-      .combine('srcDoFlipYDuringCopy', [true, false])
-      .combine('dstColorFormat', kValidTextureFormatsForCopyE2T)
+      .combine('srcFlipYInCopy', [true, false])
+      .combine('dstFormat', kValidTextureFormatsForCopyE2T)
       .combine('dstPremultiplied', [true, false])
       .beginSubcases()
       .combine('width', [1, 2, 4, 15, 255, 256])
       .combine('height', [1, 2, 4, 15, 255, 256])
   )
   .beforeAllSubcases(t => {
-    t.skipIfTextureFormatNotSupported(t.params.dstColorFormat);
+    t.skipIfTextureFormatNotSupported(t.params.dstFormat);
   })
   .fn(async t => {
     const {
@@ -187,9 +187,9 @@ g.test('from_canvas')
       height,
       orientation,
       colorSpaceConversion,
-      dstColorFormat,
+      dstFormat,
       dstPremultiplied,
-      srcDoFlipYDuringCopy,
+      srcFlipYInCopy,
     } = t.params;
 
     // CTS sometimes runs on worker threads, where document is not available.
@@ -247,12 +247,12 @@ g.test('from_canvas')
 
     const dst = t.device.createTexture({
       size: { width, height },
-      format: dstColorFormat,
+      format: dstFormat,
       usage:
         GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
     });
 
-    const expFormat = kTextureFormatInfo[dstColorFormat].baseFormat ?? dstColorFormat;
+    const expFormat = kTextureFormatInfo[dstFormat].baseFormat ?? dstFormat;
     const flipSrcBeforeCopy = orientation === 'flipY';
     const texelViewExpected = t.getExpectedDstPixelsFromSrcPixels({
       srcPixels: imageData.data,
@@ -263,7 +263,7 @@ g.test('from_canvas')
       subRectSize: [width, height],
       format: expFormat,
       flipSrcBeforeCopy,
-      srcDoFlipYDuringCopy,
+      srcDoFlipYDuringCopy: srcFlipYInCopy,
       conversion: {
         srcPremultiplied: false,
         dstPremultiplied,
@@ -271,7 +271,7 @@ g.test('from_canvas')
     });
 
     t.doTestAndCheckResult(
-      { source: imageBitmap, origin: { x: 0, y: 0 }, flipY: srcDoFlipYDuringCopy },
+      { source: imageBitmap, origin: { x: 0, y: 0 }, flipY: srcFlipYInCopy },
       {
         texture: dst,
         origin: { x: 0, y: 0 },
@@ -307,10 +307,10 @@ g.test('copy_subrect_from_ImageData')
 
   The tests covers:
   - Source WebGPU Canvas lives in the same GPUDevice or different GPUDevice as test
-  - Valid dstColorFormat of copyExternalImageToTexture()
+  - Valid dstFormat of copyExternalImageToTexture()
   - Valid source image alphaMode
   - Valid dest alphaMode
-  - Valid 'flipY' config in 'GPUImageCopyExternalImage' (named 'srcDoFlipYDuringCopy' in cases)
+  - Valid 'flipY' config in 'GPUImageCopyExternalImage' (named 'srcFlipYInCopy' in cases)
   - Valid subrect copies.
 
   And the expected results are all passed.
@@ -321,7 +321,7 @@ g.test('copy_subrect_from_ImageData')
       .combine('alpha', ['none', 'premultiply'] as const)
       .combine('orientation', ['none', 'flipY'] as const)
       .combine('colorSpaceConversion', ['none', 'default'] as const)
-      .combine('srcDoFlipYDuringCopy', [true, false])
+      .combine('srcFlipYInCopy', [true, false])
       .combine('dstPremultiplied', [true, false])
       .beginSubcases()
       .combine('copySubRectInfo', kCopySubrectInfo)
@@ -333,7 +333,7 @@ g.test('copy_subrect_from_ImageData')
       orientation,
       colorSpaceConversion,
       dstPremultiplied,
-      srcDoFlipYDuringCopy,
+      srcFlipYInCopy,
     } = t.params;
 
     const testColors = kTestColorsAll;
@@ -380,7 +380,7 @@ g.test('copy_subrect_from_ImageData')
       subRectSize: copyExtent,
       format: kColorFormat,
       flipSrcBeforeCopy,
-      srcDoFlipYDuringCopy,
+      srcDoFlipYDuringCopy: srcFlipYInCopy,
       conversion: {
         srcPremultiplied: false,
         dstPremultiplied,
@@ -388,7 +388,7 @@ g.test('copy_subrect_from_ImageData')
     });
 
     t.doTestAndCheckResult(
-      { source: imageBitmap, origin: srcOrigin, flipY: srcDoFlipYDuringCopy },
+      { source: imageBitmap, origin: srcOrigin, flipY: srcFlipYInCopy },
       {
         texture: dst,
         origin: dstOrigin,
@@ -424,10 +424,10 @@ g.test('copy_subrect_from_2D_Canvas')
 
   The tests covers:
   - Source WebGPU Canvas lives in the same GPUDevice or different GPUDevice as test
-  - Valid dstColorFormat of copyExternalImageToTexture()
+  - Valid dstFormat of copyExternalImageToTexture()
   - Valid source image alphaMode
   - Valid dest alphaMode
-  - Valid 'flipY' config in 'GPUImageCopyExternalImage' (named 'srcDoFlipYDuringCopy' in cases)
+  - Valid 'flipY' config in 'GPUImageCopyExternalImage' (named 'srcFlipYInCopy' in cases)
   - Valid subrect copies.
 
   And the expected results are all passed.
@@ -437,7 +437,7 @@ g.test('copy_subrect_from_2D_Canvas')
     u
       .combine('orientation', ['none', 'flipY'] as const)
       .combine('colorSpaceConversion', ['none', 'default'] as const)
-      .combine('srcDoFlipYDuringCopy', [true, false])
+      .combine('srcFlipYInCopy', [true, false])
       .combine('dstPremultiplied', [true, false])
       .beginSubcases()
       .combine('copySubRectInfo', kCopySubrectInfo)
@@ -448,7 +448,7 @@ g.test('copy_subrect_from_2D_Canvas')
       orientation,
       colorSpaceConversion,
       dstPremultiplied,
-      srcDoFlipYDuringCopy,
+      srcFlipYInCopy,
     } = t.params;
 
     const { srcOrigin, dstOrigin, srcSize, dstSize, copyExtent } = copySubRectInfo;
@@ -524,7 +524,7 @@ g.test('copy_subrect_from_2D_Canvas')
       subRectSize: copyExtent,
       format: kColorFormat,
       flipSrcBeforeCopy,
-      srcDoFlipYDuringCopy,
+      srcDoFlipYDuringCopy: srcFlipYInCopy,
       conversion: {
         srcPremultiplied: false,
         dstPremultiplied,
@@ -532,7 +532,7 @@ g.test('copy_subrect_from_2D_Canvas')
     });
 
     t.doTestAndCheckResult(
-      { source: imageBitmap, origin: srcOrigin, flipY: srcDoFlipYDuringCopy },
+      { source: imageBitmap, origin: srcOrigin, flipY: srcFlipYInCopy },
       {
         texture: dst,
         origin: dstOrigin,

From cb86cd22795291ea23a5a9a0de18dafc32f1eca8 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Wed, 27 Sep 2023 15:58:22 -0700
Subject: [PATCH 106/166] Compat: make fragment_state test handle different
 limits

---
 .../render_pipeline/fragment_state.spec.ts    | 38 +++++++++++++++----
 1 file changed, 30 insertions(+), 8 deletions(-)

diff --git a/src/webgpu/api/validation/render_pipeline/fragment_state.spec.ts b/src/webgpu/api/validation/render_pipeline/fragment_state.spec.ts
index f1e59464abc9..9ae249546735 100644
--- a/src/webgpu/api/validation/render_pipeline/fragment_state.spec.ts
+++ b/src/webgpu/api/validation/render_pipeline/fragment_state.spec.ts
@@ -4,11 +4,16 @@ This test dedicatedly tests validation of GPUFragmentState of createRenderPipeli
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
 import { range } from '../../../../common/util/util.js';
-import { kBlendFactors, kBlendOperations, kMaxColorAttachments } from '../../../capability_info.js';
+import {
+  kBlendFactors,
+  kBlendOperations,
+  kMaxColorAttachmentsToTest,
+} from '../../../capability_info.js';
 import {
   kTextureFormats,
   kRenderableColorTextureFormats,
   kTextureFormatInfo,
+  computeBytesPerSampleFromFormats,
 } from '../../../format_info.js';
 import {
   getFragmentShaderCodeWithOutput,
@@ -66,9 +71,15 @@ g.test('limits,maxColorAttachments')
   .desc(
     `Tests that color state targets length must not be larger than device.limits.maxColorAttachments.`
   )
-  .params(u => u.combine('isAsync', [false, true]).combine('targetsLength', [8, 9]))
+  .params(u =>
+    u.combine('isAsync', [false, true]).combine('targetsLengthVariant', [
+      { mult: 1, add: 0 },
+      { mult: 1, add: 1 },
+    ])
+  )
   .fn(t => {
-    const { isAsync, targetsLength } = t.params;
+    const { isAsync, targetsLengthVariant } = t.params;
+    const targetsLength = t.makeLimitVariant('maxColorAttachments', targetsLengthVariant);
 
     const descriptor = t.getDescriptor({
       targets: range(targetsLength, i => {
@@ -103,7 +114,7 @@ g.test('limits,maxColorAttachmentBytesPerSample,aligned')
       .beginSubcases()
       .combine(
         'attachmentCount',
-        range(kMaxColorAttachments, i => i + 1)
+        range(kMaxColorAttachmentsToTest, i => i + 1)
       )
       .combine('isAsync', [false, true])
   )
@@ -114,6 +125,11 @@ g.test('limits,maxColorAttachmentBytesPerSample,aligned')
     const { format, attachmentCount, isAsync } = t.params;
     const info = kTextureFormatInfo[format];
 
+    t.skipIf(
+      attachmentCount > t.device.limits.maxColorAttachments,
+      `attachmentCount: ${attachmentCount} > maxColorAttachments: ${t.device.limits.maxColorAttachments}`
+    );
+
     const descriptor = t.getDescriptor({
       targets: range(attachmentCount, () => {
         return { format, writeMask: 0 };
@@ -149,7 +165,6 @@ g.test('limits,maxColorAttachmentBytesPerSample,unaligned')
             'rgba32float',
             'r8unorm',
           ] as GPUTextureFormat[],
-          _success: false,
         },
         {
           formats: [
@@ -159,14 +174,21 @@ g.test('limits,maxColorAttachmentBytesPerSample,unaligned')
             'r8unorm',
             'r8unorm',
           ] as GPUTextureFormat[],
-          _success: true,
         },
       ])
       .beginSubcases()
       .combine('isAsync', [false, true])
   )
   .fn(t => {
-    const { formats, _success, isAsync } = t.params;
+    const { formats, isAsync } = t.params;
+
+    t.skipIf(
+      formats.length > t.device.limits.maxColorAttachments,
+      `numColorAttachments: ${formats.length} > maxColorAttachments: ${t.device.limits.maxColorAttachments}`
+    );
+
+    const success =
+      computeBytesPerSampleFromFormats(formats) <= t.device.limits.maxColorAttachmentBytesPerSample;
 
     const descriptor = t.getDescriptor({
       targets: formats.map(f => {
@@ -174,7 +196,7 @@ g.test('limits,maxColorAttachmentBytesPerSample,unaligned')
       }),
     });
 
-    t.doCreateRenderPipelineTest(isAsync, _success, descriptor);
+    t.doCreateRenderPipelineTest(isAsync, success, descriptor);
   });
 
 g.test('targets_format_filterable')

From fc217e34b1792ab7600a42f0cf0aa5fa461efef3 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Wed, 27 Sep 2023 17:38:08 -0700
Subject: [PATCH 107/166] Compat: make perStageLimit tests handle different
 limits

---
 .../vertex_state/correctness.spec.ts          |  4 +--
 .../validation/createBindGroupLayout.spec.ts  | 11 +++++---
 .../validation/createPipelineLayout.spec.ts   | 26 +++++++++++------
 src/webgpu/capability_info.ts                 | 28 ++++++++++---------
 4 files changed, 41 insertions(+), 28 deletions(-)

diff --git a/src/webgpu/api/operation/vertex_state/correctness.spec.ts b/src/webgpu/api/operation/vertex_state/correctness.spec.ts
index aa06b7dca517..e394ae18c00e 100644
--- a/src/webgpu/api/operation/vertex_state/correctness.spec.ts
+++ b/src/webgpu/api/operation/vertex_state/correctness.spec.ts
@@ -97,9 +97,9 @@ class VertexStateTest extends GPUTest {
     // than maxVertexAttributes = 16.
     // However this might not work in the future for implementations that allow even more vertex
     // attributes so there will need to be larger changes when that happens.
-    const maxUniformBuffers = kPerStageBindingLimits['uniformBuf'].max;
+    const maxUniformBuffers = this.getDefaultLimit(kPerStageBindingLimits['uniformBuf'].maxLimit);
     assert(
-      maxUniformBuffers + kPerStageBindingLimits['storageBuf'].max >=
+      maxUniformBuffers + this.getDefaultLimit(kPerStageBindingLimits['storageBuf'].maxLimit) >=
         this.device.limits.maxVertexAttributes
     );
 
diff --git a/src/webgpu/api/validation/createBindGroupLayout.spec.ts b/src/webgpu/api/validation/createBindGroupLayout.spec.ts
index 521e560964cb..b265250f5b58 100644
--- a/src/webgpu/api/validation/createBindGroupLayout.spec.ts
+++ b/src/webgpu/api/validation/createBindGroupLayout.spec.ts
@@ -232,7 +232,10 @@ g.test('max_dynamic_buffers')
     const { type, extraDynamicBuffers, staticBuffers } = t.params;
     const info = bufferBindingTypeInfo({ type });
 
-    const dynamicBufferCount = info.perPipelineLimitClass.maxDynamic + extraDynamicBuffers;
+    const limitName = info.perPipelineLimitClass.maxDynamicLimit;
+    const bufferCount = limitName ? t.getDefaultLimit(limitName) : 0;
+    const dynamicBufferCount = bufferCount + extraDynamicBuffers;
+    const perStageLimit = t.getDefaultLimit(info.perStageLimitClass.maxLimit);
 
     const entries = [];
     for (let i = 0; i < dynamicBufferCount; i++) {
@@ -257,7 +260,7 @@ g.test('max_dynamic_buffers')
 
     t.expectValidationError(() => {
       t.device.createBindGroupLayout(descriptor);
-    }, extraDynamicBuffers > 0);
+    }, extraDynamicBuffers > 0 || entries.length > perStageLimit);
   });
 
 /**
@@ -311,7 +314,7 @@ g.test('max_resources_per_stage,in_bind_group_layout')
   .fn(t => {
     const { maxedEntry, extraEntry, maxedVisibility, extraVisibility } = t.params;
     const maxedTypeInfo = bindingTypeInfo(maxedEntry);
-    const maxedCount = maxedTypeInfo.perStageLimitClass.max;
+    const maxedCount = t.getDefaultLimit(maxedTypeInfo.perStageLimitClass.maxLimit);
     const extraTypeInfo = bindingTypeInfo(extraEntry);
 
     const maxResourceBindings: GPUBindGroupLayoutEntry[] = [];
@@ -362,7 +365,7 @@ g.test('max_resources_per_stage,in_pipeline_layout')
   .fn(t => {
     const { maxedEntry, extraEntry, maxedVisibility, extraVisibility } = t.params;
     const maxedTypeInfo = bindingTypeInfo(maxedEntry);
-    const maxedCount = maxedTypeInfo.perStageLimitClass.max;
+    const maxedCount = t.getDefaultLimit(maxedTypeInfo.perStageLimitClass.maxLimit);
     const extraTypeInfo = bindingTypeInfo(extraEntry);
 
     const maxResourceBindings: GPUBindGroupLayoutEntry[] = [];
diff --git a/src/webgpu/api/validation/createPipelineLayout.spec.ts b/src/webgpu/api/validation/createPipelineLayout.spec.ts
index 57d1ecd2da01..00e64cac749b 100644
--- a/src/webgpu/api/validation/createPipelineLayout.spec.ts
+++ b/src/webgpu/api/validation/createPipelineLayout.spec.ts
@@ -33,7 +33,13 @@ g.test('number_of_dynamic_buffers_exceeds_the_maximum_value')
   )
   .fn(t => {
     const { type, visibility } = t.params;
-    const { maxDynamic } = bufferBindingTypeInfo({ type }).perPipelineLimitClass;
+    const info = bufferBindingTypeInfo({ type });
+    const { maxDynamicLimit } = info.perPipelineLimitClass;
+    const perStageLimit = t.getDefaultLimit(info.perStageLimitClass.maxLimit);
+    const maxDynamic = Math.min(
+      maxDynamicLimit ? t.getDefaultLimit(maxDynamicLimit) : 0,
+      perStageLimit
+    );
 
     const maxDynamicBufferBindings: GPUBindGroupLayoutEntry[] = [];
     for (let binding = 0; binding < maxDynamic; binding++) {
@@ -52,15 +58,17 @@ g.test('number_of_dynamic_buffers_exceeds_the_maximum_value')
       entries: [{ binding: 0, visibility, buffer: { type, hasDynamicOffset: false } }],
     };
 
-    const goodPipelineLayoutDescriptor = {
-      bindGroupLayouts: [
-        maxDynamicBufferBindGroupLayout,
-        t.device.createBindGroupLayout(goodDescriptor),
-      ],
-    };
+    if (perStageLimit > maxDynamic) {
+      const goodPipelineLayoutDescriptor = {
+        bindGroupLayouts: [
+          maxDynamicBufferBindGroupLayout,
+          t.device.createBindGroupLayout(goodDescriptor),
+        ],
+      };
 
-    // Control case
-    t.device.createPipelineLayout(goodPipelineLayoutDescriptor);
+      // Control case
+      t.device.createPipelineLayout(goodPipelineLayoutDescriptor);
+    }
 
     // Check dynamic buffers exceed maximum in pipeline layout.
     const badDescriptor = clone(goodDescriptor);
diff --git a/src/webgpu/capability_info.ts b/src/webgpu/capability_info.ts
index fbffa67048d5..6b41ed08a5b0 100644
--- a/src/webgpu/capability_info.ts
+++ b/src/webgpu/capability_info.ts
@@ -360,15 +360,15 @@ export const kPerStageBindingLimits: {
     /** Which `PerShaderStage` binding limit class. */
     readonly class: k;
     /** Maximum number of allowed bindings in that class. */
-    readonly max: number;
+    readonly maxLimit: typeof kLimits[number];
     // Add fields as needed
   };
 } = /* prettier-ignore */ {
-  'uniformBuf': { class: 'uniformBuf', max: 12, },
-  'storageBuf': { class: 'storageBuf', max:  8, },
-  'sampler':    { class: 'sampler',    max: 16, },
-  'sampledTex': { class: 'sampledTex', max: 16, },
-  'storageTex': { class: 'storageTex', max:  4, },
+  'uniformBuf': { class: 'uniformBuf', maxLimit: 'maxUniformBuffersPerShaderStage', },
+  'storageBuf': { class: 'storageBuf', maxLimit: 'maxStorageBuffersPerShaderStage', },
+  'sampler':    { class: 'sampler',    maxLimit: 'maxSamplersPerShaderStage', },
+  'sampledTex': { class: 'sampledTex', maxLimit: 'maxSampledTexturesPerShaderStage', },
+  'storageTex': { class: 'storageTex', maxLimit: 'maxStorageTexturesPerShaderStage', },
 };
 
 /**
@@ -378,16 +378,18 @@ export const kPerPipelineBindingLimits: {
   readonly [k in PerPipelineBindingLimitClass]: {
     /** Which `PerPipelineLayout` binding limit class. */
     readonly class: k;
-    /** Maximum number of allowed bindings with `hasDynamicOffset: true` in that class. */
-    readonly maxDynamic: number;
+    /**
+     * The name of the limit for the maximum number of allowed bindings with `hasDynamicOffset: true` in that class.
+     */
+    readonly maxDynamicLimit: typeof kLimits[number] | '';
     // Add fields as needed
   };
 } = /* prettier-ignore */ {
-  'uniformBuf': { class: 'uniformBuf', maxDynamic: 8, },
-  'storageBuf': { class: 'storageBuf', maxDynamic: 4, },
-  'sampler':    { class: 'sampler',    maxDynamic: 0, },
-  'sampledTex': { class: 'sampledTex', maxDynamic: 0, },
-  'storageTex': { class: 'storageTex', maxDynamic: 0, },
+  'uniformBuf': { class: 'uniformBuf', maxDynamicLimit: 'maxDynamicUniformBuffersPerPipelineLayout', },
+  'storageBuf': { class: 'storageBuf', maxDynamicLimit: 'maxDynamicStorageBuffersPerPipelineLayout', },
+  'sampler':    { class: 'sampler',    maxDynamicLimit: '', },
+  'sampledTex': { class: 'sampledTex', maxDynamicLimit: '', },
+  'storageTex': { class: 'storageTex', maxDynamicLimit: '', },
 };
 
 interface BindingKindInfo {

From 2b55623e2d3d7beeb9c41d5a0bbd5e256cf9066b Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Mon, 25 Sep 2023 13:56:11 -0700
Subject: [PATCH 108/166] Compat: Make createTexture tests handle different
 limits

---
 .../api/validation/createTexture.spec.ts      | 464 ++++++++++++++----
 1 file changed, 355 insertions(+), 109 deletions(-)

diff --git a/src/webgpu/api/validation/createTexture.spec.ts b/src/webgpu/api/validation/createTexture.spec.ts
index cb61a12ac3a5..4cdcb8c5c39c 100644
--- a/src/webgpu/api/validation/createTexture.spec.ts
+++ b/src/webgpu/api/validation/createTexture.spec.ts
@@ -2,8 +2,8 @@ export const description = `createTexture validation tests.`;
 
 import { SkipTestCase } from '../../../common/framework/fixture.js';
 import { makeTestGroup } from '../../../common/framework/test_group.js';
-import { assert } from '../../../common/util/util.js';
-import { kTextureDimensions, kTextureUsages, kLimitInfo } from '../../capability_info.js';
+import { assert, makeValueTestVariant } from '../../../common/util/util.js';
+import { kTextureDimensions, kTextureUsages } from '../../capability_info.js';
 import { GPUConst } from '../../constants.js';
 import {
   kTextureFormats,
@@ -495,10 +495,10 @@ g.test('texture_size,1d_texture')
       // Compressed and depth-stencil textures are invalid for 1D.
       .combine('format', kRegularTextureFormats)
       .beginSubcases()
-      .combine('width', [
-        kLimitInfo.maxTextureDimension1D.default - 1,
-        kLimitInfo.maxTextureDimension1D.default,
-        kLimitInfo.maxTextureDimension1D.default + 1,
+      .combine('widthVariant', [
+        { mult: 1, add: -1 },
+        { mult: 1, add: 0 },
+        { mult: 1, add: 1 },
       ])
       .combine('height', [1, 2])
       .combine('depthOrArrayLayers', [1, 2])
@@ -510,7 +510,8 @@ g.test('texture_size,1d_texture')
     t.selectDeviceOrSkipTestCase(info.feature);
   })
   .fn(t => {
-    const { format, width, height, depthOrArrayLayers } = t.params;
+    const { format, widthVariant, height, depthOrArrayLayers } = t.params;
+    const width = t.makeLimitVariant('maxTextureDimension1D', widthVariant);
 
     const descriptor: GPUTextureDescriptor = {
       size: [width, height, depthOrArrayLayers],
@@ -520,7 +521,7 @@ g.test('texture_size,1d_texture')
     };
 
     const success =
-      width <= kLimitInfo.maxTextureDimension1D.default && height === 1 && depthOrArrayLayers === 1;
+      width <= t.device.limits.maxTextureDimension1D && height === 1 && depthOrArrayLayers === 1;
 
     t.expectValidationError(() => {
       t.device.createTexture(descriptor);
@@ -533,20 +534,23 @@ g.test('texture_size,2d_texture,uncompressed_format')
     u
       .combine('dimension', [undefined, '2d'] as const)
       .combine('format', kUncompressedTextureFormats)
-      .combine('size', [
-        // Test the bound of width
-        [kLimitInfo.maxTextureDimension2D.default - 1, 1, 1],
-        [kLimitInfo.maxTextureDimension2D.default, 1, 1],
-        [kLimitInfo.maxTextureDimension2D.default + 1, 1, 1],
-        // Test the bound of height
-        [1, kLimitInfo.maxTextureDimension2D.default - 1, 1],
-        [1, kLimitInfo.maxTextureDimension2D.default, 1],
-        [1, kLimitInfo.maxTextureDimension2D.default + 1, 1],
-        // Test the bound of array layers
-        [1, 1, kLimitInfo.maxTextureArrayLayers.default - 1],
-        [1, 1, kLimitInfo.maxTextureArrayLayers.default],
-        [1, 1, kLimitInfo.maxTextureArrayLayers.default + 1],
-      ])
+      .combine(
+        'sizeVariant',
+        /* prettier-ignore */ [
+          // Test the bound of width
+          [{ mult: 1, add: -1, }, { mult: 0, add: 1 }, { mult: 0, add: 1 }],
+          [{ mult: 1, add:  0, }, { mult: 0, add: 1 }, { mult: 0, add: 1 }],
+          [{ mult: 1, add:  1, }, { mult: 0, add: 1 }, { mult: 0, add: 1 }],
+          // Test the bound of height
+          [{ mult: 0, add:  1, }, { mult: 1, add: -1 }, { mult: 0, add: 1 }],
+          [{ mult: 0, add:  1, }, { mult: 1, add:  0 }, { mult: 0, add: 1 }],
+          [{ mult: 0, add:  1, }, { mult: 1, add:  1 }, { mult: 0, add: 1 }],
+          // Test the bound of array layers
+          [{ mult: 0, add:  1, }, { mult: 0, add: 1 }, { mult: 1, add: -1 }],
+          [{ mult: 0, add:  1, }, { mult: 0, add: 1 }, { mult: 1, add:  0 }],
+          [{ mult: 0, add:  1, }, { mult: 0, add: 1 }, { mult: 1, add:  1 }],
+        ]
+      )
   )
   .beforeAllSubcases(t => {
     const { format } = t.params;
@@ -555,7 +559,12 @@ g.test('texture_size,2d_texture,uncompressed_format')
     t.selectDeviceOrSkipTestCase(info.feature);
   })
   .fn(t => {
-    const { dimension, format, size } = t.params;
+    const { dimension, format, sizeVariant } = t.params;
+    const size = [
+      t.device.limits.maxTextureDimension2D,
+      t.device.limits.maxTextureDimension2D,
+      t.device.limits.maxTextureArrayLayers,
+    ].map((limit, ndx) => makeValueTestVariant(limit, sizeVariant[ndx]));
 
     const descriptor: GPUTextureDescriptor = {
       size,
@@ -565,9 +574,9 @@ g.test('texture_size,2d_texture,uncompressed_format')
     };
 
     const success =
-      size[0] <= kLimitInfo.maxTextureDimension2D.default &&
-      size[1] <= kLimitInfo.maxTextureDimension2D.default &&
-      size[2] <= kLimitInfo.maxTextureArrayLayers.default;
+      size[0] <= t.device.limits.maxTextureDimension2D &&
+      size[1] <= t.device.limits.maxTextureDimension2D &&
+      size[2] <= t.device.limits.maxTextureArrayLayers;
 
     t.expectValidationError(() => {
       t.device.createTexture(descriptor);
@@ -580,40 +589,152 @@ g.test('texture_size,2d_texture,compressed_format')
     u
       .combine('dimension', [undefined, '2d'] as const)
       .combine('format', kCompressedTextureFormats)
-      .expand('size', p => {
+      .expand('sizeVariant', p => {
         const { blockWidth, blockHeight } = kTextureFormatInfo[p.format];
         return [
           // Test the bound of width
-          [kLimitInfo.maxTextureDimension2D.default - 1, 1, 1],
-          [kLimitInfo.maxTextureDimension2D.default - blockWidth, 1, 1],
-          [kLimitInfo.maxTextureDimension2D.default - blockWidth, blockHeight, 1],
-          [kLimitInfo.maxTextureDimension2D.default, 1, 1],
-          [kLimitInfo.maxTextureDimension2D.default, blockHeight, 1],
-          [kLimitInfo.maxTextureDimension2D.default + 1, 1, 1],
-          [kLimitInfo.maxTextureDimension2D.default + blockWidth, 1, 1],
-          [kLimitInfo.maxTextureDimension2D.default + blockWidth, blockHeight, 1],
+          [
+            { mult: 1, add: -1 },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: -blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: -blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: 0 },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: 0 },
+            { mult: 0, add: blockHeight },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: 1 },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 0, add: 1 },
+          ],
           // Test the bound of height
-          [1, kLimitInfo.maxTextureDimension2D.default - 1, 1],
-          [1, kLimitInfo.maxTextureDimension2D.default - blockHeight, 1],
-          [blockWidth, kLimitInfo.maxTextureDimension2D.default - blockHeight, 1],
-          [1, kLimitInfo.maxTextureDimension2D.default, 1],
-          [blockWidth, kLimitInfo.maxTextureDimension2D.default, 1],
-          [1, kLimitInfo.maxTextureDimension2D.default + 1, 1],
-          [1, kLimitInfo.maxTextureDimension2D.default + blockWidth, 1],
-          [blockWidth, kLimitInfo.maxTextureDimension2D.default + blockHeight, 1],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: -1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: -blockHeight },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 1, add: -blockHeight },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: 0 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 1, add: 0 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: +1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: +blockWidth },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 1, add: +blockHeight },
+            { mult: 0, add: 1 },
+          ],
           // Test the bound of array layers
-          [1, 1, kLimitInfo.maxTextureArrayLayers.default - 1],
-          [blockWidth, 1, kLimitInfo.maxTextureArrayLayers.default - 1],
-          [1, blockHeight, kLimitInfo.maxTextureArrayLayers.default - 1],
-          [blockWidth, blockHeight, kLimitInfo.maxTextureArrayLayers.default - 1],
-          [1, 1, kLimitInfo.maxTextureArrayLayers.default],
-          [blockWidth, 1, kLimitInfo.maxTextureArrayLayers.default],
-          [1, blockHeight, kLimitInfo.maxTextureArrayLayers.default],
-          [blockWidth, blockHeight, kLimitInfo.maxTextureArrayLayers.default],
-          [1, 1, kLimitInfo.maxTextureArrayLayers.default + 1],
-          [blockWidth, 1, kLimitInfo.maxTextureArrayLayers.default + 1],
-          [1, blockHeight, kLimitInfo.maxTextureArrayLayers.default + 1],
-          [blockWidth, blockHeight, kLimitInfo.maxTextureArrayLayers.default + 1],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+            { mult: 1, add: -1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 1, add: -1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: -1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: -1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+            { mult: 1, add: 0 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 1, add: 0 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: 0 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: 0 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+            { mult: 1, add: +1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 1, add: +1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: +1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: +1 },
+          ],
         ];
       })
   )
@@ -623,8 +744,13 @@ g.test('texture_size,2d_texture,compressed_format')
     t.selectDeviceOrSkipTestCase(info.feature);
   })
   .fn(t => {
-    const { dimension, format, size } = t.params;
+    const { dimension, format, sizeVariant } = t.params;
     const info = kTextureFormatInfo[format];
+    const size = [
+      t.device.limits.maxTextureDimension2D,
+      t.device.limits.maxTextureDimension2D,
+      t.device.limits.maxTextureArrayLayers,
+    ].map((limit, ndx) => makeValueTestVariant(limit, sizeVariant[ndx]));
 
     const descriptor: GPUTextureDescriptor = {
       size,
@@ -636,9 +762,9 @@ g.test('texture_size,2d_texture,compressed_format')
     const success =
       size[0] % info.blockWidth === 0 &&
       size[1] % info.blockHeight === 0 &&
-      size[0] <= kLimitInfo.maxTextureDimension2D.default &&
-      size[1] <= kLimitInfo.maxTextureDimension2D.default &&
-      size[2] <= kLimitInfo.maxTextureArrayLayers.default;
+      size[0] <= t.device.limits.maxTextureDimension2D &&
+      size[1] <= t.device.limits.maxTextureDimension2D &&
+      size[2] <= t.device.limits.maxTextureArrayLayers;
 
     t.expectValidationError(() => {
       t.device.createTexture(descriptor);
@@ -653,20 +779,23 @@ g.test('texture_size,3d_texture,uncompressed_format')
     u //
       .combine('format', kRegularTextureFormats)
       .beginSubcases()
-      .combine('size', [
+      .combine(
+        'sizeVariant',
+        /* prettier-ignore */ [
         // Test the bound of width
-        [kLimitInfo.maxTextureDimension3D.default - 1, 1, 1],
-        [kLimitInfo.maxTextureDimension3D.default, 1, 1],
-        [kLimitInfo.maxTextureDimension3D.default + 1, 1, 1],
+        [{mult: 1, add: -1}, {mult: 0, add: 1}, {mult: 0, add: 1}],
+        [{mult: 1, add:  0}, {mult: 0, add: 1}, {mult: 0, add: 1}],
+        [{mult: 1, add: +1}, {mult: 0, add: 1}, {mult: 0, add: 1}],
         // Test the bound of height
-        [1, kLimitInfo.maxTextureDimension3D.default - 1, 1],
-        [1, kLimitInfo.maxTextureDimension3D.default, 1],
-        [1, kLimitInfo.maxTextureDimension3D.default + 1, 1],
+        [{mult: 0, add: 1}, {mult: 1, add: -1}, {mult: 0, add: 1}],
+        [{mult: 0, add: 1}, {mult: 1, add:  0}, {mult: 0, add: 1}],
+        [{mult: 0, add: 1}, {mult: 1, add: +1}, {mult: 0, add: 1}],
         // Test the bound of depth
-        [1, 1, kLimitInfo.maxTextureDimension3D.default - 1],
-        [1, 1, kLimitInfo.maxTextureDimension3D.default],
-        [1, 1, kLimitInfo.maxTextureDimension3D.default + 1],
-      ])
+        [{mult: 0, add: 1}, {mult: 0, add: 1}, {mult: 1, add: -1}],
+        [{mult: 0, add: 1}, {mult: 0, add: 1}, {mult: 1, add:  0}],
+        [{mult: 0, add: 1}, {mult: 0, add: 1}, {mult: 1, add: +1}],
+      ]
+      )
   )
   .beforeAllSubcases(t => {
     const { format } = t.params;
@@ -675,7 +804,9 @@ g.test('texture_size,3d_texture,uncompressed_format')
     t.selectDeviceOrSkipTestCase(info.feature);
   })
   .fn(t => {
-    const { format, size } = t.params;
+    const { format, sizeVariant } = t.params;
+    const maxTextureDimension3D = t.device.limits.maxTextureDimension3D;
+    const size = sizeVariant.map(variant => t.makeLimitVariant('maxTextureDimension3D', variant));
 
     const descriptor: GPUTextureDescriptor = {
       size,
@@ -685,9 +816,9 @@ g.test('texture_size,3d_texture,uncompressed_format')
     };
 
     const success =
-      size[0] <= kLimitInfo.maxTextureDimension3D.default &&
-      size[1] <= kLimitInfo.maxTextureDimension3D.default &&
-      size[2] <= kLimitInfo.maxTextureDimension3D.default;
+      size[0] <= maxTextureDimension3D &&
+      size[1] <= maxTextureDimension3D &&
+      size[2] <= maxTextureDimension3D;
 
     t.expectValidationError(() => {
       t.device.createTexture(descriptor);
@@ -700,40 +831,152 @@ g.test('texture_size,3d_texture,compressed_format')
     u //
       .combine('format', kCompressedTextureFormats)
       .beginSubcases()
-      .expand('size', p => {
+      .expand('sizeVariant', p => {
         const { blockWidth, blockHeight } = kTextureFormatInfo[p.format];
         return [
           // Test the bound of width
-          [kLimitInfo.maxTextureDimension3D.default - 1, 1, 1],
-          [kLimitInfo.maxTextureDimension3D.default - blockWidth, 1, 1],
-          [kLimitInfo.maxTextureDimension3D.default - blockWidth, blockHeight, 1],
-          [kLimitInfo.maxTextureDimension3D.default, 1, 1],
-          [kLimitInfo.maxTextureDimension3D.default, blockHeight, 1],
-          [kLimitInfo.maxTextureDimension3D.default + 1, 1, 1],
-          [kLimitInfo.maxTextureDimension3D.default + blockWidth, 1, 1],
-          [kLimitInfo.maxTextureDimension3D.default + blockWidth, blockHeight, 1],
+          [
+            { mult: 1, add: -1 },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: -blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: -blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: 0 },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: 0 },
+            { mult: 0, add: blockHeight },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: +1 },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: +blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 1, add: +blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 0, add: 1 },
+          ],
           // Test the bound of height
-          [1, kLimitInfo.maxTextureDimension3D.default - 1, 1],
-          [1, kLimitInfo.maxTextureDimension3D.default - blockHeight, 1],
-          [blockWidth, kLimitInfo.maxTextureDimension3D.default - blockHeight, 1],
-          [1, kLimitInfo.maxTextureDimension3D.default, 1],
-          [blockWidth, kLimitInfo.maxTextureDimension3D.default, 1],
-          [1, kLimitInfo.maxTextureDimension3D.default + 1, 1],
-          [1, kLimitInfo.maxTextureDimension3D.default + blockWidth, 1],
-          [blockWidth, kLimitInfo.maxTextureDimension3D.default + blockHeight, 1],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: -1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: -blockHeight },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 1, add: -blockHeight },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: 0 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 1, add: 0 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: +1 },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 1, add: +blockWidth },
+            { mult: 0, add: 1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 1, add: +blockHeight },
+            { mult: 0, add: 1 },
+          ],
           // Test the bound of depth
-          [1, 1, kLimitInfo.maxTextureDimension3D.default - 1],
-          [blockWidth, 1, kLimitInfo.maxTextureDimension3D.default - 1],
-          [1, blockHeight, kLimitInfo.maxTextureDimension3D.default - 1],
-          [blockWidth, blockHeight, kLimitInfo.maxTextureDimension3D.default - 1],
-          [1, 1, kLimitInfo.maxTextureDimension3D.default],
-          [blockWidth, 1, kLimitInfo.maxTextureDimension3D.default],
-          [1, blockHeight, kLimitInfo.maxTextureDimension3D.default],
-          [blockWidth, blockHeight, kLimitInfo.maxTextureDimension3D.default],
-          [1, 1, kLimitInfo.maxTextureDimension3D.default + 1],
-          [blockWidth, 1, kLimitInfo.maxTextureDimension3D.default + 1],
-          [1, blockHeight, kLimitInfo.maxTextureDimension3D.default + 1],
-          [blockWidth, blockHeight, kLimitInfo.maxTextureDimension3D.default + 1],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+            { mult: 1, add: -1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 1, add: -1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: -1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: -1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+            { mult: 1, add: 0 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 1, add: 0 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: 0 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: 0 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: 1 },
+            { mult: 1, add: +1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: 1 },
+            { mult: 1, add: +1 },
+          ],
+          [
+            { mult: 0, add: 1 },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: +1 },
+          ],
+          [
+            { mult: 0, add: blockWidth },
+            { mult: 0, add: blockHeight },
+            { mult: 1, add: +1 },
+          ],
         ];
       })
   )
@@ -746,12 +989,15 @@ g.test('texture_size,3d_texture,compressed_format')
     t.selectDeviceOrSkipTestCase(info.feature);
   })
   .fn(t => {
-    const { format, size } = t.params;
+    const { format, sizeVariant } = t.params;
     const info = kTextureFormatInfo[format];
 
+    const maxTextureDimension3D = t.device.limits.maxTextureDimension3D;
+    const size = sizeVariant.map(variant => t.makeLimitVariant('maxTextureDimension3D', variant));
+
     assert(
-      kLimitInfo.maxTextureDimension3D.default % info.blockWidth === 0 &&
-        kLimitInfo.maxTextureDimension3D.default % info.blockHeight === 0
+      maxTextureDimension3D % info.blockWidth === 0 &&
+        maxTextureDimension3D % info.blockHeight === 0
     );
 
     const descriptor: GPUTextureDescriptor = {
@@ -764,9 +1010,9 @@ g.test('texture_size,3d_texture,compressed_format')
     const success =
       size[0] % info.blockWidth === 0 &&
       size[1] % info.blockHeight === 0 &&
-      size[0] <= kLimitInfo.maxTextureDimension3D.default &&
-      size[1] <= kLimitInfo.maxTextureDimension3D.default &&
-      size[2] <= kLimitInfo.maxTextureDimension3D.default;
+      size[0] <= maxTextureDimension3D &&
+      size[1] <= maxTextureDimension3D &&
+      size[2] <= maxTextureDimension3D;
 
     t.expectValidationError(() => {
       t.device.createTexture(descriptor);

From 48b29a106fdc9d9be5331b21e187a7232a0e1104 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Thu, 28 Sep 2023 15:19:45 -0700
Subject: [PATCH 109/166] Fix Skip/Pass Issues

As it was, if several subcases were skipped but a few passed the
case would be marked as "skip".
---
 src/common/internal/test_group.ts |  3 ++-
 src/unittests/test_group.spec.ts  | 23 +++++++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/common/internal/test_group.ts b/src/common/internal/test_group.ts
index e446628bc0b0..f0853520624c 100644
--- a/src/common/internal/test_group.ts
+++ b/src/common/internal/test_group.ts
@@ -500,9 +500,10 @@ class RunCaseSpecific implements RunCase {
       // An error from init or test may have been a SkipTestCase.
       // An error from finalize may have been an eventualAsyncExpectation failure
       // or unexpected validation/OOM error from the GPUDevice.
-      rec.threw(ex);
       if (throwSkip && ex instanceof SkipTestCase) {
         throw ex;
+      } else {
+        rec.threw(ex);
       }
     } finally {
       try {
diff --git a/src/unittests/test_group.spec.ts b/src/unittests/test_group.spec.ts
index a098d07b71bc..8e1129411c74 100644
--- a/src/unittests/test_group.spec.ts
+++ b/src/unittests/test_group.spec.ts
@@ -262,6 +262,29 @@ g.test('subcases').fn(async t0 => {
   t0.expect(Array.from(result.values()).every(v => v.status === 'pass'));
 });
 
+g.test('subcases,skip')
+  .desc(
+    'If all tests are skipped then status is "skip". If at least one test passed, status is "pass"'
+  )
+  .params(u => u.combine('allSkip', [false, true]))
+  .fn(async t0 => {
+    const { allSkip } = t0.params;
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    g.test('a')
+      .params(u => u.beginSubcases().combine('do', ['pass', 'skip', 'pass']))
+      .fn(t => {
+        t.skipIf(allSkip || t.params.do === 'skip');
+      });
+    const result = await t0.run(g);
+    const values = Array.from(result.values());
+    t0.expect(values.length === 1);
+    const expectedStatus = allSkip ? 'skip' : 'pass';
+    t0.expect(
+      values[0].status === expectedStatus,
+      `expect: ${values[0].status} === ${expectedStatus}}, allSkip: ${allSkip}`
+    );
+  });
+
 g.test('exceptions')
   .params(u =>
     u

From 9f7135130f5f9d1aa2669f3c3a76c4e54867ac61 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Wed, 27 Sep 2023 15:40:17 -0700
Subject: [PATCH 110/166] Compat: make createRenderBundleEncoder test handle
 different limits

---
 .../createRenderBundleEncoder.spec.ts         | 31 ++++++++++++++-----
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/src/webgpu/api/validation/encoding/createRenderBundleEncoder.spec.ts b/src/webgpu/api/validation/encoding/createRenderBundleEncoder.spec.ts
index 8338cf948c69..2eaa9b43fd23 100644
--- a/src/webgpu/api/validation/encoding/createRenderBundleEncoder.spec.ts
+++ b/src/webgpu/api/validation/encoding/createRenderBundleEncoder.spec.ts
@@ -4,8 +4,9 @@ createRenderBundleEncoder validation tests.
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
 import { range } from '../../../../common/util/util.js';
-import { kMaxColorAttachments } from '../../../capability_info.js';
+import { kMaxColorAttachmentsToTest } from '../../../capability_info.js';
 import {
+  computeBytesPerSampleFromFormats,
   kAllTextureFormats,
   kDepthStencilFormats,
   kTextureFormatInfo,
@@ -20,11 +21,16 @@ g.test('attachment_state,limits,maxColorAttachments')
   .params(u =>
     u.beginSubcases().combine(
       'colorFormatCount',
-      range(kMaxColorAttachments + 1, i => i + 1) // 1-9
+      range(kMaxColorAttachmentsToTest, i => i + 1)
     )
   )
   .fn(t => {
     const { colorFormatCount } = t.params;
+    const maxColorAttachments = t.device.limits.maxColorAttachments;
+    t.skipIf(
+      colorFormatCount > maxColorAttachments,
+      `${colorFormatCount} > maxColorAttachments: ${maxColorAttachments}`
+    );
     t.expectValidationError(() => {
       t.device.createRenderBundleEncoder({
         colorFormats: Array(colorFormatCount).fill('r8unorm'),
@@ -46,7 +52,7 @@ g.test('attachment_state,limits,maxColorAttachmentBytesPerSample,aligned')
       .beginSubcases()
       .combine(
         'colorFormatCount',
-        range(kMaxColorAttachments, i => i + 1)
+        range(kMaxColorAttachmentsToTest, i => i + 1)
       )
   )
   .beforeAllSubcases(t => {
@@ -54,6 +60,11 @@ g.test('attachment_state,limits,maxColorAttachmentBytesPerSample,aligned')
   })
   .fn(t => {
     const { format, colorFormatCount } = t.params;
+    const maxColorAttachments = t.device.limits.maxColorAttachments;
+    t.skipIf(
+      colorFormatCount > maxColorAttachments,
+      `${colorFormatCount} > maxColorAttachments: ${maxColorAttachments}`
+    );
     const info = kTextureFormatInfo[format];
     const shouldError =
       !info.colorRender ||
@@ -89,7 +100,6 @@ g.test('attachment_state,limits,maxColorAttachmentBytesPerSample,unaligned')
           'rgba32float',
           'r8unorm',
         ] as GPUTextureFormat[],
-        _shouldError: true,
       },
       {
         formats: [
@@ -99,18 +109,25 @@ g.test('attachment_state,limits,maxColorAttachmentBytesPerSample,unaligned')
           'r8unorm',
           'r8unorm',
         ] as GPUTextureFormat[],
-        _shouldError: false,
       },
     ])
   )
   .fn(t => {
-    const { formats, _shouldError } = t.params;
+    const { formats } = t.params;
+
+    t.skipIf(
+      formats.length > t.device.limits.maxColorAttachments,
+      `numColorAttachments: ${formats.length} > maxColorAttachments: ${t.device.limits.maxColorAttachments}`
+    );
+
+    const shouldError =
+      computeBytesPerSampleFromFormats(formats) > t.device.limits.maxColorAttachmentBytesPerSample;
 
     t.expectValidationError(() => {
       t.device.createRenderBundleEncoder({
         colorFormats: formats,
       });
-    }, _shouldError);
+    }, shouldError);
   });
 
 g.test('attachment_state,empty_color_formats')

From 8f210ed7bd716bf6f0341d69d9aa43d9c80ef426 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Wed, 27 Sep 2023 16:32:08 -0700
Subject: [PATCH 111/166] Compat: make device_pool not refer to kLimitInfo

---
 src/webgpu/util/device_pool.ts | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/webgpu/util/device_pool.ts b/src/webgpu/util/device_pool.ts
index e2448412757e..e8584df19613 100644
--- a/src/webgpu/util/device_pool.ts
+++ b/src/webgpu/util/device_pool.ts
@@ -1,13 +1,13 @@
 import { SkipTestCase, TestCaseRecorder } from '../../common/framework/fixture.js';
 import { attemptGarbageCollection } from '../../common/util/collect_garbage.js';
-import { getGPU } from '../../common/util/navigator_gpu.js';
+import { getGPU, getDefaultRequestAdapterOptions } from '../../common/util/navigator_gpu.js';
 import {
   assert,
   raceWithRejectOnTimeout,
   assertReject,
   unreachable,
 } from '../../common/util/util.js';
-import { kLimitInfo, kLimits } from '../capability_info.js';
+import { getDefaultLimits, kLimits } from '../capability_info.js';
 
 export interface DeviceProvider {
   readonly device: GPUDevice;
@@ -229,10 +229,16 @@ function canonicalizeDescriptor(
   /** Canonicalized version of the requested limits: in canonical order, with only values which are
    * specified _and_ non-default. */
   const limitsCanonicalized: Record<string, number> = {};
+  // MAINTENANCE_TODO: Remove cast when @webgpu/types includes compatibilityMode
+  const adapterOptions = (getDefaultRequestAdapterOptions() as unknown) as {
+    compatibilityMode?: boolean;
+  };
+  const featureLevel = adapterOptions?.compatibilityMode ? 'compatibility' : 'core';
+  const defaultLimits = getDefaultLimits(featureLevel);
   if (desc.requiredLimits) {
     for (const limit of kLimits) {
       const requestedValue = desc.requiredLimits[limit];
-      const defaultValue = kLimitInfo[limit].default;
+      const defaultValue = defaultLimits[limit].default;
       // Skip adding a limit to limitsCanonicalized if it is the same as the default.
       if (requestedValue !== undefined && requestedValue !== defaultValue) {
         limitsCanonicalized[limit] = requestedValue;

From f2b59e03621238d0d0fd6305be2c406ce3e45ac2 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Thu, 28 Sep 2023 17:20:34 -0700
Subject: [PATCH 112/166] Remove limit constants

All the other tests have stopped referencing these
hard coded constants so it should be safe to remove
them
---
 .../capability_checks/limits/limit_utils.ts       |  7 +------
 src/webgpu/capability_info.ts                     | 15 ---------------
 2 files changed, 1 insertion(+), 21 deletions(-)

diff --git a/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts b/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
index c91e1637a950..f6b0f96aa805 100644
--- a/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
@@ -2,7 +2,7 @@ import { kUnitCaseParamsBuilder } from '../../../../../common/framework/params_b
 import { makeTestGroup } from '../../../../../common/framework/test_group.js';
 import { getGPU } from '../../../../../common/util/navigator_gpu.js';
 import { assert, range, reorder, ReorderOrder } from '../../../../../common/util/util.js';
-import { kLimitInfo, getDefaultLimitsForAdapter } from '../../../../capability_info.js';
+import { getDefaultLimitsForAdapter } from '../../../../capability_info.js';
 import { GPUTestBase } from '../../../../gpu_test.js';
 
 type GPUSupportedLimit = keyof GPUSupportedLimits;
@@ -262,11 +262,6 @@ export function getDefaultLimitForAdapter(adapter: GPUAdapter, limit: GPUSupport
   return limitInfo[limit as keyof typeof limitInfo].default;
 }
 
-// MAINTENANCE_TODO: remove as soon as compat refactor is done and this is no longer used.
-export function getDefaultLimit(limit: GPUSupportedLimit): number {
-  return (kLimitInfo as Record<string, { default: number }>)[limit].default;
-}
-
 export type DeviceAndLimits = {
   device: GPUDevice;
   defaultLimit: number;
diff --git a/src/webgpu/capability_info.ts b/src/webgpu/capability_info.ts
index 6b41ed08a5b0..1c37d55f33db 100644
--- a/src/webgpu/capability_info.ts
+++ b/src/webgpu/capability_info.ts
@@ -353,7 +353,6 @@ assertTypeTrue<TypeEqual<BindableResource, typeof kBindableResources[number]>>()
 /** Dynamic buffer offsets require offset to be divisible by 256, by spec. */
 export const kMinDynamicBufferOffsetAlignment = 256;
 
-// MAINTENANCE_TODO: remove these as tests need to use different limits for compatibility mode
 /** Default `PerShaderStage` binding limits, by spec. */
 export const kPerStageBindingLimits: {
   readonly [k in PerStageBindingLimitClass]: {
@@ -723,9 +722,6 @@ const kLimitInfoCompatibility = makeTableRenameAndFilter(
   kLimitInfoData
 );
 
-// MAINTENANCE_TODO: remove this as tests need to use different limits for compatibility mode
-export const kLimitInfo = kLimitInfoCore;
-
 const kLimitInfos = {
   core: kLimitInfoCore,
   compatibility: kLimitInfoCompatibility,
@@ -751,17 +747,6 @@ export function getDefaultLimitsForAdapter(adapter: GPUAdapter) {
 /** List of all entries of GPUSupportedLimits. */
 export const kLimits = keysOf(kLimitInfoCore);
 
-// MAINTENANCE_TODO: remove these as tests need to use different limits for compatibility mode
-// Pipeline limits
-
-/** Maximum number of color attachments to a render pass, by spec. */
-export const kMaxColorAttachments = kLimitInfo.maxColorAttachments.default;
-/** `maxVertexBuffers` per GPURenderPipeline, by spec. */
-export const kMaxVertexBuffers = kLimitInfo.maxVertexBuffers.default;
-/** `maxVertexAttributes` per GPURenderPipeline, by spec. */
-export const kMaxVertexAttributes = kLimitInfo.maxVertexAttributes.default;
-/** `maxVertexBufferArrayStride` in a vertex buffer in a GPURenderPipeline, by spec. */
-export const kMaxVertexBufferArrayStride = kLimitInfo.maxVertexBufferArrayStride.default;
 /**
  * The number of color attachments to test.
  * The CTS needs to generate a consistent list of tests.

From 1889b53634c3debd17c4a8363e1dc40e48d86663 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Beaufort?= <beaufort.francois@gmail.com>
Date: Mon, 2 Oct 2023 12:22:06 +0200
Subject: [PATCH 113/166] Add unorm10-10-10-2 vertex format (#2941)

* Add unorm10-10-10-2 vertex format

* Rename rgb10a2 to unorm10-10-10-2

* Update webgpu/types to 0.1.37
---
 package-lock.json                             | 19 +++--
 package.json                                  |  2 +-
 .../vertex_state/correctness.spec.ts          | 55 ++++++++++++---
 .../encoding/cmds/render/draw.spec.ts         |  4 +-
 .../render_pipeline/vertex_state.spec.ts      | 11 ++-
 src/webgpu/capability_info.ts                 | 70 ++++++++++---------
 6 files changed, 99 insertions(+), 62 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index d0b850245006..4ed46ad4344f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -23,7 +23,7 @@
         "@types/pngjs": "^6.0.1",
         "@types/serve-index": "^1.9.1",
         "@typescript-eslint/parser": "^4.33.0",
-        "@webgpu/types": "gpuweb/types#d1d74def71a13a2318828139994afd1b9c3f987c",
+        "@webgpu/types": "^0.1.37",
         "ansi-colors": "4.1.1",
         "babel-plugin-add-header-comment": "^1.0.3",
         "babel-plugin-const-enum": "^1.2.0",
@@ -1262,11 +1262,10 @@
       }
     },
     "node_modules/@webgpu/types": {
-      "version": "0.1.35",
-      "resolved": "git+ssh://git@github.com/gpuweb/types.git#d1d74def71a13a2318828139994afd1b9c3f987c",
-      "integrity": "sha512-6mh8zm/DDdtY6c+DXRmYc/7wJ1RQitFFmQiviwV8BK1XB75lXigN8AC8netNUO4XWTm7zEZevWgdMzXgThwOtA==",
-      "dev": true,
-      "license": "BSD-3-Clause"
+      "version": "0.1.37",
+      "resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.37.tgz",
+      "integrity": "sha512-hfndFDYk5AlZUE/qZ1kSuZHLobxzsbn7/jdJEJfmn4kg3rTM0+A+5TC/+z7lg3L74tSNEtZUVk7ojXw31wzeFw==",
+      "dev": true
     },
     "node_modules/abbrev": {
       "version": "1.1.1",
@@ -9884,10 +9883,10 @@
       }
     },
     "@webgpu/types": {
-      "version": "git+ssh://git@github.com/gpuweb/types.git#d1d74def71a13a2318828139994afd1b9c3f987c",
-      "integrity": "sha512-6mh8zm/DDdtY6c+DXRmYc/7wJ1RQitFFmQiviwV8BK1XB75lXigN8AC8netNUO4XWTm7zEZevWgdMzXgThwOtA==",
-      "dev": true,
-      "from": "@webgpu/types@gpuweb/types#d1d74def71a13a2318828139994afd1b9c3f987c"
+      "version": "0.1.37",
+      "resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.37.tgz",
+      "integrity": "sha512-hfndFDYk5AlZUE/qZ1kSuZHLobxzsbn7/jdJEJfmn4kg3rTM0+A+5TC/+z7lg3L74tSNEtZUVk7ojXw31wzeFw==",
+      "dev": true
     },
     "abbrev": {
       "version": "1.1.1",
diff --git a/package.json b/package.json
index 2e3cc0d8ca7f..95b154261260 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,7 @@
     "@types/pngjs": "^6.0.1",
     "@types/serve-index": "^1.9.1",
     "@typescript-eslint/parser": "^4.33.0",
-    "@webgpu/types": "gpuweb/types#d1d74def71a13a2318828139994afd1b9c3f987c",
+    "@webgpu/types": "^0.1.37",
     "ansi-colors": "4.1.1",
     "babel-plugin-add-header-comment": "^1.0.3",
     "babel-plugin-const-enum": "^1.2.0",
diff --git a/src/webgpu/api/operation/vertex_state/correctness.spec.ts b/src/webgpu/api/operation/vertex_state/correctness.spec.ts
index e394ae18c00e..4f49ff2ff71d 100644
--- a/src/webgpu/api/operation/vertex_state/correctness.spec.ts
+++ b/src/webgpu/api/operation/vertex_state/correctness.spec.ts
@@ -61,6 +61,20 @@ function mapStateAttribs<V, A1, A2>(
   return buffers.map(b => mapBufferAttribs(b, f));
 }
 
+function makeRgb10a2(rgba: Array<number>): number {
+  const [r, g, b, a] = rgba;
+  assert((r & 0x3ff) === r);
+  assert((g & 0x3ff) === g);
+  assert((b & 0x3ff) === b);
+  assert((a & 0x3) === a);
+  return r | (g << 10) | (b << 20) | (a << 30);
+}
+
+function normalizeRgb10a2(rgba: number, index: number): number {
+  const normalizationFactor = index % 4 === 3 ? 3 : 1023;
+  return rgba / normalizationFactor;
+}
+
 type TestData = {
   shaderBaseType: string;
   floatTolerance?: number;
@@ -308,7 +322,8 @@ struct VSOutputs {
   // test value in a test is still meaningful.
   generateTestData(format: GPUVertexFormat): TestData {
     const formatInfo = kVertexFormatInfo[format];
-    const bitSize = formatInfo.bytesPerComponent * 8;
+    const bitSize =
+      formatInfo.bytesPerComponent === 'packed' ? 0 : formatInfo.bytesPerComponent * 8;
 
     switch (formatInfo.type) {
       case 'float': {
@@ -411,6 +426,28 @@ struct VSOutputs {
       }
 
       case 'unorm': {
+        if (formatInfo.bytesPerComponent === 'packed') {
+          assert(format === 'unorm10-10-10-2'); // This is the only packed format for now.
+          assert(bitSize === 0);
+
+          /* prettier-ignore */
+          const data = [
+            [0, 0, 0, 0],
+            [1023, 1023, 1023, 3],
+            [243, 567, 765, 2],
+          ];
+          const vertexData = new Uint32Array(data.map(makeRgb10a2)).buffer;
+          const expectedData = new Float32Array(data.flat().map(normalizeRgb10a2)).buffer;
+
+          return {
+            shaderBaseType: 'f32',
+            testComponentCount: data.flat().length,
+            expectedData,
+            vertexData,
+            floatTolerance: 0.1 / 1023,
+          };
+        }
+
         /* prettier-ignore */
         const data = [
           42,
@@ -561,7 +598,7 @@ struct VSOutputs {
         this.interleaveVertexDataInto(vertexData, attrib.vertexData, {
           targetStride: buffer.arrayStride,
           offset: (buffer.vbOffset ?? 0) + attrib.offset,
-          size: formatInfo.componentCount * formatInfo.bytesPerComponent,
+          size: formatInfo.byteSize,
         });
       }
 
@@ -653,7 +690,7 @@ g.test('setVertexBuffer_offset_and_attribute_offset')
       .combine('arrayStride', [128])
       .expand('offset', p => {
         const formatInfo = kVertexFormatInfo[p.format];
-        const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+        const formatSize = formatInfo.byteSize;
         return new Set([
           0,
           4,
@@ -701,7 +738,7 @@ g.test('non_zero_array_stride_and_attribute_offset')
       .beginSubcases()
       .expand('arrayStrideVariant', p => {
         const formatInfo = kVertexFormatInfo[p.format];
-        const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+        const formatSize = formatInfo.byteSize;
 
         return [
           { mult: 0, add: align(formatSize, 4) },
@@ -711,7 +748,7 @@ g.test('non_zero_array_stride_and_attribute_offset')
       })
       .expand('offsetVariant', p => {
         const formatInfo = kVertexFormatInfo[p.format];
-        const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+        const formatSize = formatInfo.byteSize;
         return [
           { mult: 0, add: 0 },
           { mult: 0, add: formatSize },
@@ -727,7 +764,7 @@ g.test('non_zero_array_stride_and_attribute_offset')
     const { format, arrayStrideVariant, offsetVariant } = t.params;
     const arrayStride = t.makeLimitVariant('maxVertexBufferArrayStride', arrayStrideVariant);
     const formatInfo = kVertexFormatInfo[format];
-    const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+    const formatSize = formatInfo.byteSize;
     const offset = clamp(makeValueTestVariant(arrayStride, offsetVariant), {
       min: 0,
       max: arrayStride - formatSize,
@@ -803,7 +840,7 @@ g.test('vertex_buffer_used_multiple_times_overlapped')
     const kVertexCount = 20;
     const kInstanceCount = 1;
     const formatInfo = kVertexFormatInfo[format];
-    const formatByteSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+    const formatByteSize = formatInfo.byteSize;
     // We need to align so the offset for non-0 setVertexBuffer don't fail validation.
     const alignedFormatByteSize = align(formatByteSize, 4);
 
@@ -907,7 +944,7 @@ g.test('vertex_buffer_used_multiple_times_interleaved')
     const kVertexCount = 20;
     const kInstanceCount = 1;
     const formatInfo = kVertexFormatInfo[format];
-    const formatByteSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+    const formatByteSize = formatInfo.byteSize;
     // We need to align so the offset for non-0 setVertexBuffer don't fail validation.
     const alignedFormatByteSize = align(formatByteSize, 4);
 
@@ -1014,7 +1051,7 @@ g.test('array_stride_zero')
       .combine('stepMode', ['vertex', 'instance'] as const)
       .expand('offsetVariant', p => {
         const formatInfo = kVertexFormatInfo[p.format];
-        const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+        const formatSize = formatInfo.byteSize;
         return filterUniqueValueTestVariants([
           { mult: 0, add: 0 },
           { mult: 0, add: 4 },
diff --git a/src/webgpu/api/validation/encoding/cmds/render/draw.spec.ts b/src/webgpu/api/validation/encoding/cmds/render/draw.spec.ts
index c91771c25710..1efd16483430 100644
--- a/src/webgpu/api/validation/encoding/cmds/render/draw.spec.ts
+++ b/src/webgpu/api/validation/encoding/cmds/render/draw.spec.ts
@@ -445,7 +445,7 @@ success/error as expected. Such set of buffer parameters should include cases li
     } = t.params;
 
     const attributeFormatInfo = kVertexFormatInfo[attributeFormat];
-    const formatSize = attributeFormatInfo.bytesPerComponent * attributeFormatInfo.componentCount;
+    const formatSize = attributeFormatInfo.byteSize;
     const attributeOffset = attributeOffsetFactor * Math.min(4, formatSize);
     const lastStride = attributeOffset + formatSize;
     let arrayStride = 0;
@@ -609,7 +609,7 @@ buffer slot and index buffer will cause no validation error, with completely/par
     // Compute the array stride for vertex step mode and instance step mode attribute
     const attributeFormat = 'float32x4';
     const attributeFormatInfo = kVertexFormatInfo[attributeFormat];
-    const formatSize = attributeFormatInfo.bytesPerComponent * attributeFormatInfo.componentCount;
+    const formatSize = attributeFormatInfo.byteSize;
     const attributeOffset = 0;
     const lastStride = attributeOffset + formatSize;
     let arrayStride = 0;
diff --git a/src/webgpu/api/validation/render_pipeline/vertex_state.spec.ts b/src/webgpu/api/validation/render_pipeline/vertex_state.spec.ts
index c500a9f930f5..0a64494c8989 100644
--- a/src/webgpu/api/validation/render_pipeline/vertex_state.spec.ts
+++ b/src/webgpu/api/validation/render_pipeline/vertex_state.spec.ts
@@ -605,8 +605,7 @@ g.test('vertex_attribute_offset_alignment')
         { mult: 1, add: 0 },
       ])
       .expand('offsetVariant', p => {
-        const { bytesPerComponent, componentCount } = kVertexFormatInfo[p.format];
-        const formatSize = bytesPerComponent * componentCount;
+        const formatSize = kVertexFormatInfo[p.format].byteSize;
         return filterUniqueValueTestVariants([
           { mult: 0, add: 0 },
           { mult: 0, add: Math.floor(formatSize / 2) },
@@ -661,7 +660,7 @@ g.test('vertex_attribute_offset_alignment')
     vertexBuffers[vertexBufferIndex] = { arrayStride, attributes };
 
     const formatInfo = kVertexFormatInfo[format];
-    const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+    const formatSize = formatInfo.byteSize;
     const success = offset % Math.min(4, formatSize) === 0;
 
     t.testVertexState(success, vertexBuffers);
@@ -688,8 +687,7 @@ g.test('vertex_attribute_contained_in_stride')
       ])
       .expand('offsetVariant', function* (p) {
         // Compute a bunch of test offsets to test.
-        const { bytesPerComponent, componentCount } = kVertexFormatInfo[p.format];
-        const formatSize = bytesPerComponent * componentCount;
+        const formatSize = kVertexFormatInfo[p.format].byteSize;
         yield { mult: 0, add: 0 };
         yield { mult: 0, add: 4 };
         yield { mult: 1, add: -formatSize };
@@ -746,8 +744,7 @@ g.test('vertex_attribute_contained_in_stride')
     const vertexBuffers = [];
     vertexBuffers[vertexBufferIndex] = { arrayStride, attributes };
 
-    const formatInfo = kVertexFormatInfo[format];
-    const formatSize = formatInfo.bytesPerComponent * formatInfo.componentCount;
+    const formatSize = kVertexFormatInfo[format].byteSize;
     const limit = arrayStride === 0 ? t.device.limits.maxVertexBufferArrayStride : arrayStride;
 
     const success = offset + formatSize <= limit;
diff --git a/src/webgpu/capability_info.ts b/src/webgpu/capability_info.ts
index 1c37d55f33db..3626877544af 100644
--- a/src/webgpu/capability_info.ts
+++ b/src/webgpu/capability_info.ts
@@ -235,11 +235,13 @@ export const kTextureViewDimensions = keysOf(kTextureViewDimensionInfo);
 // Exists just for documentation. Otherwise could be inferred by `makeTable`.
 export type VertexFormatInfo = {
   /** Number of bytes in each component. */
-  readonly bytesPerComponent: 1 | 2 | 4;
+  readonly bytesPerComponent: 1 | 2 | 4 | 'packed';
   /** The data encoding (float, normalized, or integer) for each component. */
   readonly type: 'float' | 'unorm' | 'snorm' | 'uint' | 'sint';
   /** Number of components. */
   readonly componentCount: 1 | 2 | 3 | 4;
+  /** Size in bytes. */
+  readonly byteSize: 2 | 4 | 8 | 12 | 16;
   /** The completely matching WGSL type for vertex format */
   readonly wgslType:
     | 'f32'
@@ -260,41 +262,43 @@ export type VertexFormatInfo = {
 export const kVertexFormatInfo: {
   readonly [k in GPUVertexFormat]: VertexFormatInfo;
 } = /* prettier-ignore */ makeTable(
-               ['bytesPerComponent',  'type', 'componentCount',  'wgslType'] as const,
-               [                   ,        ,                 ,            ] as const, {
+                     ['bytesPerComponent',   'type', 'componentCount', 'byteSize',  'wgslType'] as const,
+                     [                   ,         ,                 ,           ,            ] as const, {
   // 8 bit components
-  'uint8x2':   [                  1,  'uint',                2, 'vec2<u32>'],
-  'uint8x4':   [                  1,  'uint',                4, 'vec4<u32>'],
-  'sint8x2':   [                  1,  'sint',                2, 'vec2<i32>'],
-  'sint8x4':   [                  1,  'sint',                4, 'vec4<i32>'],
-  'unorm8x2':  [                  1, 'unorm',                2, 'vec2<f32>'],
-  'unorm8x4':  [                  1, 'unorm',                4, 'vec4<f32>'],
-  'snorm8x2':  [                  1, 'snorm',                2, 'vec2<f32>'],
-  'snorm8x4':  [                  1, 'snorm',                4, 'vec4<f32>'],
+  'uint8x2':         [                  1,   'uint',                2,          2, 'vec2<u32>'],
+  'uint8x4':         [                  1,   'uint',                4,          4, 'vec4<u32>'],
+  'sint8x2':         [                  1,   'sint',                2,          2, 'vec2<i32>'],
+  'sint8x4':         [                  1,   'sint',                4,          4, 'vec4<i32>'],
+  'unorm8x2':        [                  1,  'unorm',                2,          2, 'vec2<f32>'],
+  'unorm8x4':        [                  1,  'unorm',                4,          4, 'vec4<f32>'],
+  'snorm8x2':        [                  1,  'snorm',                2,          2, 'vec2<f32>'],
+  'snorm8x4':        [                  1,  'snorm',                4,          4, 'vec4<f32>'],
   // 16 bit components
-  'uint16x2':  [                  2,  'uint',                2, 'vec2<u32>'],
-  'uint16x4':  [                  2,  'uint',                4, 'vec4<u32>'],
-  'sint16x2':  [                  2,  'sint',                2, 'vec2<i32>'],
-  'sint16x4':  [                  2,  'sint',                4, 'vec4<i32>'],
-  'unorm16x2': [                  2, 'unorm',                2, 'vec2<f32>'],
-  'unorm16x4': [                  2, 'unorm',                4, 'vec4<f32>'],
-  'snorm16x2': [                  2, 'snorm',                2, 'vec2<f32>'],
-  'snorm16x4': [                  2, 'snorm',                4, 'vec4<f32>'],
-  'float16x2': [                  2, 'float',                2, 'vec2<f32>'],
-  'float16x4': [                  2, 'float',                4, 'vec4<f32>'],
+  'uint16x2':        [                  2,   'uint',                2,          4, 'vec2<u32>'],
+  'uint16x4':        [                  2,   'uint',                4,          8, 'vec4<u32>'],
+  'sint16x2':        [                  2,   'sint',                2,          4, 'vec2<i32>'],
+  'sint16x4':        [                  2,   'sint',                4,          8, 'vec4<i32>'],
+  'unorm16x2':       [                  2,  'unorm',                2,          4, 'vec2<f32>'],
+  'unorm16x4':       [                  2,  'unorm',                4,          8, 'vec4<f32>'],
+  'snorm16x2':       [                  2,  'snorm',                2,          4, 'vec2<f32>'],
+  'snorm16x4':       [                  2,  'snorm',                4,          8, 'vec4<f32>'],
+  'float16x2':       [                  2,  'float',                2,          4, 'vec2<f32>'],
+  'float16x4':       [                  2,  'float',                4,          8, 'vec4<f32>'],
   // 32 bit components
-  'float32':   [                  4, 'float',                1,       'f32'],
-  'float32x2': [                  4, 'float',                2, 'vec2<f32>'],
-  'float32x3': [                  4, 'float',                3, 'vec3<f32>'],
-  'float32x4': [                  4, 'float',                4, 'vec4<f32>'],
-  'uint32':    [                  4,  'uint',                1,       'u32'],
-  'uint32x2':  [                  4,  'uint',                2, 'vec2<u32>'],
-  'uint32x3':  [                  4,  'uint',                3, 'vec3<u32>'],
-  'uint32x4':  [                  4,  'uint',                4, 'vec4<u32>'],
-  'sint32':    [                  4,  'sint',                1,       'i32'],
-  'sint32x2':  [                  4,  'sint',                2, 'vec2<i32>'],
-  'sint32x3':  [                  4,  'sint',                3, 'vec3<i32>'],
-  'sint32x4':  [                  4,  'sint',                4, 'vec4<i32>']
+  'float32':         [                  4,  'float',                1,          4,       'f32'],
+  'float32x2':       [                  4,  'float',                2,          8, 'vec2<f32>'],
+  'float32x3':       [                  4,  'float',                3,         12, 'vec3<f32>'],
+  'float32x4':       [                  4,  'float',                4,         16, 'vec4<f32>'],
+  'uint32':          [                  4,   'uint',                1,          4,       'u32'],
+  'uint32x2':        [                  4,   'uint',                2,          8, 'vec2<u32>'],
+  'uint32x3':        [                  4,   'uint',                3,         12, 'vec3<u32>'],
+  'uint32x4':        [                  4,   'uint',                4,         16, 'vec4<u32>'],
+  'sint32':          [                  4,   'sint',                1,          4,       'i32'],
+  'sint32x2':        [                  4,   'sint',                2,          8, 'vec2<i32>'],
+  'sint32x3':        [                  4,   'sint',                3,         12, 'vec3<i32>'],
+  'sint32x4':        [                  4,   'sint',                4,         16, 'vec4<i32>'],
+  // 32 bit packed
+  'unorm10-10-10-2': [           'packed',  'unorm',                4,          4, 'vec4<f32>']
 } as const);
 /** List of all GPUVertexFormat values. */
 export const kVertexFormats = keysOf(kVertexFormatInfo);

From 03df5bf6a897f5152a441a9dca19152af5cb9269 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Mon, 2 Oct 2023 23:45:50 +0800
Subject: [PATCH 114/166] wgsl: Add f16 validation tests for bistcast from bad
 const (#3034)

This PR add validation test for bad constant bitcast to vec2/vec4
of f16. This PR also add validation that f16/f32 testcases without
bad constants should pass the compilation.

Issue: #1609
---
 src/webgpu/listing_meta.json                  |   1 +
 .../expression/call/builtin/bitcast.spec.ts   | 109 +++++++++++++++++-
 2 files changed, 106 insertions(+), 4 deletions(-)

diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 2a2cdadc75b7..55a52d685325 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1677,6 +1677,7 @@
   "webgpu:shader,validation,expression,call,builtin,atanh:integer_argument:*": { "subcaseMS": 0.912 },
   "webgpu:shader,validation,expression,call,builtin,atanh:values:*": { "subcaseMS": 0.231 },
   "webgpu:shader,validation,expression,call,builtin,atomics:stage:*": { "subcaseMS": 1.346 },
+  "webgpu:shader,validation,expression,call,builtin,bitcast:bad_const_to_f16:*": { "subcaseMS": 0.753 },
   "webgpu:shader,validation,expression,call,builtin,bitcast:bad_const_to_f32:*": { "subcaseMS": 0.844 },
   "webgpu:shader,validation,expression,call,builtin,bitcast:bad_to_f16:*": { "subcaseMS": 8.518 },
   "webgpu:shader,validation,expression,call,builtin,bitcast:bad_to_vec3h:*": { "subcaseMS": 17.641 },
diff --git a/src/webgpu/shader/validation/expression/call/builtin/bitcast.spec.ts b/src/webgpu/shader/validation/expression/call/builtin/bitcast.spec.ts
index 6acd261552d0..20c2c40664d7 100644
--- a/src/webgpu/shader/validation/expression/call/builtin/bitcast.spec.ts
+++ b/src/webgpu/shader/validation/expression/call/builtin/bitcast.spec.ts
@@ -4,6 +4,7 @@ Validation negative tests for bitcast builtins.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { keysOf } from '../../../../../../common/util/data_tables.js';
+import { assert } from '../../../../../../common/util/util.js';
 import { kBit } from '../../../../../util/constants.js';
 import { linearRange } from '../../../../../util/math.js';
 import { ShaderValidationTest } from '../../../shader_validation_test.js';
@@ -54,7 +55,11 @@ It is a shader-creation error if any const-expression of floating-point type eva
       .combine('fromScalarType', ['i32', 'u32'] as const)
       .combine('vectorize', keysOf(kVectorCases))
       .beginSubcases()
-      .combine('bitBadValue', [...f32InfAndNaNInU32] as const)
+      // Also validate that testcases without using bad bit can pass the exam
+      .combine('useBadValue', [true, false])
+      .expand('bitBadValue', p =>
+        p.useBadValue ? ([...f32InfAndNaNInU32] as const) : [0 as const]
+      )
   )
   .fn(t => {
     // For scalar cases, generate code like:
@@ -73,12 +78,96 @@ It is a shader-creation error if any const-expression of floating-point type eva
       .map(i => (i === badIndex ? badScalar : '0'))
       .join(',');
     const code = `const f = bitcast<${destType}>(${srcType}(${components}));`;
-    t.expectCompileResult(false, code);
+    t.expectCompileResult(!t.params.useBadValue, code);
+  });
+
+const f16InfAndNaNInU16: number[] = [
+  // Cover NaNs evenly in integer space.
+  // The positive NaN with the lowest integer representation is the integer
+  // for infinity, plus one.
+  // The positive NaN with the highest integer representation is i16.max = 32767
+  ...linearRange(kBit.f16.positive.infinity + 1, 32767, numNaNs),
+  // The negative NaN with the lowest integer representation is the integer
+  // for negative infinity, plus one.
+  // The negative NaN with the highest integer representation is u16.max = 65535
+  ...linearRange(kBit.f16.negative.infinity + 1, 65535, numNaNs),
+  kBit.f16.positive.infinity,
+  kBit.f16.negative.infinity,
+];
+
+/**
+ * @returns an u32 whose lower and higher 16bits are the two elements of the
+ * given array of two u16 respectively, in little-endian.
+ */
+function u16x2ToU32(u16x2: number[]): number {
+  assert(u16x2.length === 2);
+  // Create a DataView with 4 bytes buffer.
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  // Enforce little-endian.
+  view.setUint16(0, u16x2[0], true);
+  view.setUint16(2, u16x2[1], true);
+  return view.getUint32(0, true);
+}
+
+g.test('bad_const_to_f16')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+It is a shader-creation error if any const-expression of floating-point type evaluates to NaN or infinity.
+`
+  )
+  .params(u =>
+    u
+      .combine('fromScalarType', ['i32', 'u32'] as const)
+      .combine('vectorize', keysOf(kVectorCases))
+      // Only test valid bitcast to vec2<f16> or vec4<f16>
+      .filter(p => kVectorCases[p.vectorize].width % 2 === 0)
+      .beginSubcases()
+      // Also validate that testcases without using bad bit can pass the exam
+      .combine('useBadValue', [true, false])
+      .expand('bitBadValue', p =>
+        p.useBadValue ? ([...f16InfAndNaNInU16] as const) : [0 as const]
+      )
+  )
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(t => {
+    // For width = 2 generate code like:
+    //  const f = bitcast<vec2<f16>>(i32(u32(0x7f800000)));
+    // And for width = 4:
+    //  const f = bitcast<vec4<f16>>(vec2<i32>(0,i32(u32(0x7f800000))));
+    const vectorize = kVectorCases[t.params.vectorize];
+    const width = vectorize.width;
+    const badIndex = vectorize.badIndex;
+
+    // Only bistcast to vec2<f16> or vec4<f16> is valid.
+    assert(width === 2 || width === 4);
+
+    // Put the bad f16 bits into lower 16 bits of source element if bad index is 0 or 2, else higher 16 bits.
+    const badSrcElemBitsInU32 = u16x2ToU32(
+      badIndex % 2 === 0 ? [t.params.bitBadValue, 0] : [0, t.params.bitBadValue]
+    );
+    const badScalar = `${t.params.fromScalarType}(u32(${badSrcElemBitsInU32}))`;
+
+    const destType = `vec${width}<f16>`;
+    const srcType = width === 2 ? t.params.fromScalarType : `vec2<${t.params.fromScalarType}>`;
+    const components = [...Array(width / 2).keys()]
+      .map(i => (i === badIndex >> 1 ? badScalar : '0'))
+      .join(',');
+    const code = `
+    enable f16;
+    const f = bitcast<${destType}>(${srcType}(${components}));`;
+    t.expectCompileResult(!t.params.useBadValue, code);
   });
 
 const f32_matrix_types = [2, 3, 4]
   .map(i => [2, 3, 4].map(j => `mat${i}x${j}f`))
   .reduce((a, c) => a.concat(c), []);
+const f16_matrix_types = [2, 3, 4]
+  .map(i => [2, 3, 4].map(j => `mat${i}x${j}<f16>`))
+  .reduce((a, c) => a.concat(c), []);
 const bool_types = ['bool', ...[2, 3, 4].map(i => `vec${i}<bool>`)];
 
 g.test('bad_type_constructible')
@@ -91,16 +180,28 @@ Test constructible types.
   )
   .params(u =>
     u
-      .combine('type', [...f32_matrix_types, ...bool_types, 'array<i32,2>', 'S'])
+      .combine('type', [
+        ...f32_matrix_types,
+        ...f16_matrix_types,
+        ...bool_types,
+        'array<i32,2>',
+        'S',
+      ])
       .combine('direction', ['to', 'from'])
   )
+  .beforeAllSubcases(t => {
+    if (t.params.type.includes('f16')) {
+      t.selectDeviceOrSkipTestCase('shader-f16');
+    }
+  })
   .fn(t => {
     const T = t.params.type;
+    const enable_directives = t.params.type.includes('f16') ? 'enable f16;\n' : '';
     const preamble = T === 'S' ? 'struct S { a:i32 } ' : '';
     // Create a value of type T using zero-construction: T().
     const srcVal = t.params.direction === 'to' ? '0' : `${T}()`;
     const destType = t.params.direction === 'to' ? T : 'i32';
-    const code = preamble + `const x = bitcast<${destType}>(${srcVal});`;
+    const code = enable_directives + preamble + `const x = bitcast<${destType}>(${srcVal});`;
     t.expectCompileResult(false, code);
   });
 

From 609645eb5b272668cbfb120d1aa9549eee86e02d Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Mon, 2 Oct 2023 23:46:14 +0800
Subject: [PATCH 115/166] unittest: Fix/add f16 cases for data cache
 serialization unittest (#3033)

This PR fix and add some f16 cases for data cache serialization unittest.
---
 src/unittests/serialization.spec.ts | 58 +++++++++++++++++++++++------
 1 file changed, 46 insertions(+), 12 deletions(-)

diff --git a/src/unittests/serialization.spec.ts b/src/unittests/serialization.spec.ts
index 1879b1e75ac7..25aa44561fab 100644
--- a/src/unittests/serialization.spec.ts
+++ b/src/unittests/serialization.spec.ts
@@ -117,14 +117,14 @@ g.test('value').fn(t => {
     f16(-1),
     f16(0.5),
     f16(-0.5),
-    f16(kValue.f32.positive.max),
-    f16(kValue.f32.positive.min),
-    f16(kValue.f32.positive.subnormal.max),
-    f16(kValue.f32.positive.subnormal.min),
-    f16(kValue.f32.negative.subnormal.max),
-    f16(kValue.f32.negative.subnormal.min),
-    f16(kValue.f32.positive.infinity),
-    f16(kValue.f32.negative.infinity),
+    f16(kValue.f16.positive.max),
+    f16(kValue.f16.positive.min),
+    f16(kValue.f16.positive.subnormal.max),
+    f16(kValue.f16.positive.subnormal.min),
+    f16(kValue.f16.negative.subnormal.max),
+    f16(kValue.f16.negative.subnormal.min),
+    f16(kValue.f16.positive.infinity),
+    f16(kValue.f16.negative.infinity),
 
     bool(true),
     bool(false),
@@ -145,7 +145,7 @@ g.test('value').fn(t => {
         [0.0, 1.0, 2.0],
         [3.0, 4.0, 5.0],
       ],
-      f32
+      f16
     ),
     toMatrix(
       [
@@ -160,7 +160,7 @@ g.test('value').fn(t => {
         [2.0, 3.0],
         [4.0, 5.0],
       ],
-      f32
+      f16
     ),
     toMatrix(
       [
@@ -176,7 +176,7 @@ g.test('value').fn(t => {
         [4.0, 5.0, 6.0, 7.0],
         [8.0, 9.0, 10.0, 11.0],
       ],
-      f32
+      f16
     ),
     toMatrix(
       [
@@ -194,7 +194,7 @@ g.test('value').fn(t => {
         [6.0, 7.0, 8.0],
         [9.0, 10.0, 11.0],
       ],
-      f32
+      f16
     ),
     toMatrix(
       [
@@ -249,6 +249,40 @@ g.test('fpinterval_f32').fn(t => {
   }
 });
 
+g.test('fpinterval_f16').fn(t => {
+  for (const interval of [
+    FP.f16.toInterval(0),
+    FP.f16.toInterval(-0),
+    FP.f16.toInterval(1),
+    FP.f16.toInterval(-1),
+    FP.f16.toInterval(0.5),
+    FP.f16.toInterval(-0.5),
+    FP.f16.toInterval(kValue.f16.positive.max),
+    FP.f16.toInterval(kValue.f16.positive.min),
+    FP.f16.toInterval(kValue.f16.positive.subnormal.max),
+    FP.f16.toInterval(kValue.f16.positive.subnormal.min),
+    FP.f16.toInterval(kValue.f16.negative.subnormal.max),
+    FP.f16.toInterval(kValue.f16.negative.subnormal.min),
+    FP.f16.toInterval(kValue.f16.positive.infinity),
+    FP.f16.toInterval(kValue.f16.negative.infinity),
+
+    FP.f16.toInterval([-0, 0]),
+    FP.f16.toInterval([-1, 1]),
+    FP.f16.toInterval([-0.5, 0.5]),
+    FP.f16.toInterval([kValue.f16.positive.min, kValue.f16.positive.max]),
+    FP.f16.toInterval([kValue.f16.positive.subnormal.min, kValue.f16.positive.subnormal.max]),
+    FP.f16.toInterval([kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max]),
+    FP.f16.toInterval([kValue.f16.negative.infinity, kValue.f16.positive.infinity]),
+  ]) {
+    const serialized = serializeFPInterval(interval);
+    const deserialized = deserializeFPInterval(serialized);
+    t.expect(
+      objectEquals(interval, deserialized),
+      `interval ${interval} -> serialize -> deserialize -> ${deserialized}`
+    );
+  }
+});
+
 g.test('fpinterval_abstract').fn(t => {
   for (const interval of [
     FP.abstract.toInterval(0),

From d253683c9379d5a02b0cbcb04f6c0e9b26f15b0c Mon Sep 17 00:00:00 2001
From: David Neto <dneto@google.com>
Date: Mon, 2 Oct 2023 17:18:23 -0400
Subject: [PATCH 116/166] shader/execution/memory_model: test f16 adjacent
 writes (#3038)

* shader/execution/memory_model: test f16 adjacent writes

Check that writes from different invocations to adjacent
f16 values in an array do not interfere with each other.

Fixes: #2779

* Fix pattern descriptions
---
 src/webgpu/listing_meta.json                  |   1 +
 .../execution/memory_model/adjacent.spec.ts   | 272 ++++++++++++++++++
 2 files changed, 273 insertions(+)
 create mode 100644 src/webgpu/shader/execution/memory_model/adjacent.spec.ts

diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 55a52d685325..48ebd1a6d25a 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1579,6 +1579,7 @@
   "webgpu:shader,execution,flow_control,while:while_continue:*": { "subcaseMS": 5.650 },
   "webgpu:shader,execution,flow_control,while:while_nested_break:*": { "subcaseMS": 12.701 },
   "webgpu:shader,execution,flow_control,while:while_nested_continue:*": { "subcaseMS": 5.450 },
+  "webgpu:shader,execution,memory_model,adjacent:f16:*": { "subcaseMS": 23.625 },
   "webgpu:shader,execution,memory_model,atomicity:atomicity:*": { "subcaseMS": 77.201 },
   "webgpu:shader,execution,memory_model,barrier:workgroup_barrier_load_store:*": { "subcaseMS": 65.850 },
   "webgpu:shader,execution,memory_model,barrier:workgroup_barrier_store_load:*": { "subcaseMS": 78.800 },
diff --git a/src/webgpu/shader/execution/memory_model/adjacent.spec.ts b/src/webgpu/shader/execution/memory_model/adjacent.spec.ts
new file mode 100644
index 000000000000..332cca293161
--- /dev/null
+++ b/src/webgpu/shader/execution/memory_model/adjacent.spec.ts
@@ -0,0 +1,272 @@
+export const description = `
+Tests writes from different invocations to adjacent scalars do not interfere.
+This is especially interesting when the scalar type is narrower than 32-bits.
+`;
+
+import { makeTestGroup } from '../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../gpu_test.js';
+import { PRNG } from '../../../util/prng.js';
+
+export const g = makeTestGroup(GPUTest);
+
+// Algorithm: with N invocations, N is even:
+//     srcBuffer: An array of random scalar values.  Avoids unsupported values like infinity and NaN.
+//     resultBuffer: A result array
+//     pattern: 0|1|2|3
+//       Pattern 0: Identity: invocation i: dst[i] = src[i]
+//       Pattern 1: Try to prevent write coalescing.
+//          Even elements stay in place.
+//          Reverse order of odd elements.
+//          invocation 2k:   dst[2k] = src[2k]
+//          invocation 2k+1: dst[2k+1] = src[N - (2k+1)]
+//          Example: with N=6
+//             dst[0] = src[0]
+//             dst[1] = src[5]
+//             dst[2] = src[2]
+//             dst[3] = src[3]
+//             dst[4] = src[4]
+//             dst[5] = src[1]
+//       Pattern 2: Try to prevent write coalescing.
+//          Reverse order of even elements.
+//          Odd elements stay in place.
+//          invocation 2k:   dst[2k] = src[N - 2 - 2k]
+//          invocation 2k+1: dst[2k+1] = src[2k+1]
+//          Example: with N=6
+//             dst[0] = src[4]
+//             dst[1] = src[1]
+//             dst[2] = src[2]
+//             dst[3] = src[3]
+//             dst[4] = src[0]
+//             dst[5] = src[5]
+//       Pattern 3: Reverse elements: dst[i] = src[N-1-i]
+//     addressSpace: workgroup|storage
+//          Where dst is allocated.
+
+type AddressSpace = 'workgroup' | 'storage';
+type Pattern = 0 | 1 | 2 | 3;
+const kAddressSpaces = ['workgroup', 'storage'] as const;
+const kPatterns = [0, 1, 2, 3] as const;
+
+interface AdjacentWritesTest extends GPUTest {
+  params: {
+    pattern: Pattern;
+    addressSpace: AddressSpace;
+  };
+}
+
+// For simplicity, make the entire source (and destination) array fit
+// in workgroup memory.
+// We can count on up to 16384 bytes in workgroup memory.
+const kNumValues = 4096; // Assumed even
+const kWorkgroupSize = 128; // Use 1-dimensional workgroups.
+
+/**
+ * @returns an integer for the bit pattern of a random finite f16 value.
+ * Consumes values from `prng`.
+ *
+ * @param prng - a pseudo-random number generator.
+ */
+function randomFiniteF16(prng: PRNG): number {
+  const exponent_bits = 0x7c00;
+  // With any reasonable random number stream, the average number
+  // of trips around this loop is < 1 + 1/32 because there are 5
+  // exponent bits.
+  let candidate: number;
+  do {
+    candidate = prng.randomU32() & 0xffff;
+    // Non-finite f16 values have all 1 bits in the exponent.
+  } while ((candidate & exponent_bits) === exponent_bits);
+  return candidate;
+}
+
+/**
+ * Fills array `arr` with random finite f16 values.
+ * Consumes values from `prng`.
+ *
+ * @param prng - a pseudo-random number generator.
+ * @param arr - the array to fill. Assume it is already correctly sized.
+ */
+function fillWithRandomFiniteF16(prng: PRNG, arr: Uint16Array) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = randomFiniteF16(prng);
+  }
+}
+
+/**
+ * @returns the expression for the destination index, based on `pattern`.
+ *
+ * @param i the WGSL string for the source index
+ * @param pattern the indexing pattern
+ */
+function getDstIndexExpression(i: string, pattern: Pattern): string {
+  switch (pattern) {
+    case 0:
+      return `${i}`;
+    case 1:
+      // Even elements map to themselves.
+      // Odd elements map to the reversed order of odd elements.
+      return `select(${kNumValues} - ${i}, ${i}, (${i} & 1) == 0)`;
+    case 2:
+      // Even elements map to the reversed order of odd elements.
+      // Since N is even, element 0 should get index N-2. (!)
+      // Odd elements map to themselves.
+      return `select(${i}, ${kNumValues} - 2 - ${i}, (${i} & 1) == 0)`;
+    case 3:
+      return `${kNumValues} - 1 -${i}`;
+  }
+}
+
+/**
+ * Computes the reference (correct) result for the given source array and indexing pattern.
+ *
+ * @param pattern the indexing pattern
+ * @param src the source array
+ * @param dst the array to fill with values transferred from `src`
+ */
+function computeReference(pattern: Pattern, src: Uint16Array, dst: Uint16Array) {
+  for (let i = 0; i < src.length; i++) {
+    const isEven = (i & 1) === 0;
+    switch (pattern) {
+      case 0:
+        dst[i] = src[i];
+        break;
+      case 1:
+        if (isEven) {
+          dst[i] = src[i];
+        } else {
+          dst[src.length - i] = src[i];
+        }
+        break;
+      case 2:
+        if (isEven) {
+          dst[kNumValues - 2 - i] = src[i];
+        } else {
+          dst[i] = src[i];
+        }
+        break;
+      case 3:
+        dst[src.length - 1 - i] = src[i];
+        break;
+    }
+  }
+}
+
+/**
+ * @returns the source text for a shader that copies elements from a source
+ * buffer to a destination buffer, while remapping indices according to the
+ * specified pattern.
+ *
+ * @param p contains the address space and pattern
+ */
+function makeShaderText(p: { addressSpace: AddressSpace; pattern: Pattern }): string {
+  // When the destination buffer is in 'storage', then write directly to it.
+  // Otherwise, destination is in workgroup memory, and we need to name the
+  // output buffer differently.
+  const dstBuf = p.addressSpace === 'storage' ? 'dst' : 'dstBuf';
+
+  const parts: string[] = [];
+
+  parts.push(`
+    enable f16;
+    @group(0) @binding(0) var<storage> src: array<f16>;
+    @group(0) @binding(1) var<storage,read_write> ${dstBuf}: array<f16>;
+    `);
+
+  if (p.addressSpace === 'workgroup') {
+    parts.push(`var<workgroup> dst: array<f16,${kNumValues}>;`);
+  }
+
+  parts.push(`
+    @compute @workgroup_size(${kWorkgroupSize})
+    fn adjacent_writes(@builtin(global_invocation_id) gid: vec3u) {
+        let srcIndex = gid.x;
+        let dstIndex = ${getDstIndexExpression('srcIndex', p.pattern)};
+        dst[dstIndex] = src[srcIndex];
+    `);
+
+  if (p.addressSpace === 'workgroup') {
+    // Copy to the output buffer.
+    // The barrier is not necessary here, but it should prevent
+    // the compiler from being clever and optimizing away the
+    // intermediate write to workgroup memory.
+    parts.push(`        workgroupBarrier();`);
+    parts.push(`        ${dstBuf}[dstIndex] = dst[dstIndex];`);
+  }
+  parts.push('}');
+
+  return parts.join('\n');
+}
+
+/**
+ * Runs the test on the GPU, generating random source data and
+ * checking the results against the expected permutation of that data.
+ *
+ * @param t the AdjacentWritesTest specification.
+ */
+function runTest(t: AdjacentWritesTest) {
+  const seed = ((t.params.pattern as number) + 1) * (t.params.addressSpace as string).length;
+  const prng = new PRNG(seed);
+
+  const expected = new Uint16Array(kNumValues);
+
+  const bytesPerScalar = 2; // f16 is 2 bytes wide.
+  const bufByteSize = kNumValues * bytesPerScalar;
+  const hostSrcBuf = t.device.createBuffer({
+    size: bufByteSize,
+    usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
+    mappedAtCreation: true,
+  });
+  {
+    const hostSrcUint16 = new Uint16Array(hostSrcBuf.getMappedRange());
+    fillWithRandomFiniteF16(prng, hostSrcUint16);
+    computeReference(t.params.pattern, hostSrcUint16, expected);
+    hostSrcBuf.unmap();
+  }
+
+  const srcBuf = t.device.createBuffer({
+    size: bufByteSize,
+    usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE,
+  });
+  const dstBuf = t.device.createBuffer({
+    size: bufByteSize,
+    usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
+  });
+
+  const shaderText = makeShaderText(t.params);
+  const shader = t.device.createShaderModule({ code: shaderText });
+  const pipeline = t.device.createComputePipeline({
+    layout: 'auto',
+    compute: { module: shader, entryPoint: 'adjacent_writes' },
+  });
+  const bindGroup = t.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: srcBuf } },
+      { binding: 1, resource: { buffer: dstBuf } },
+    ],
+  });
+
+  const encoder = t.device.createCommandEncoder();
+  encoder.copyBufferToBuffer(hostSrcBuf, 0, srcBuf, 0, bufByteSize);
+
+  const computeEncoder = encoder.beginComputePass();
+  computeEncoder.setPipeline(pipeline);
+  computeEncoder.setBindGroup(0, bindGroup);
+  computeEncoder.dispatchWorkgroups(kNumValues / kWorkgroupSize);
+  computeEncoder.end();
+
+  const commands = encoder.finish();
+  t.device.queue.submit([commands]);
+
+  t.expectGPUBufferValuesEqual(dstBuf, expected);
+}
+
+g.test('f16')
+  .desc(
+    `Check that writes by different invocations to adjacent f16 values in an array do not interfere with each other.`
+  )
+  .params(u => u.combine('addressSpace', kAddressSpaces).combine('pattern', kPatterns))
+  .beforeAllSubcases(t => {
+    t.selectDeviceOrSkipTestCase('shader-f16');
+  })
+  .fn(t => runTest(t));

From 46e0a48df6347ffb70586ac770d2cbd47751e9ac Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Tue, 3 Oct 2023 14:07:19 -0700
Subject: [PATCH 117/166] Compat: Skip unsupported texture operations

---
 .../encoding/cmds/copyTextureToTexture.spec.ts         |  6 ++++--
 src/webgpu/gpu_test.ts                                 | 10 ++++++++++
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts b/src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts
index 3e6ee2ddf93c..19d0f308fac6 100644
--- a/src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts
+++ b/src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts
@@ -363,10 +363,12 @@ Test the formats of textures in copyTextureToTexture must be copy-compatible.
   })
   .fn(t => {
     const { srcFormat, dstFormat } = t.params;
-    const srcFormatInfo = kTextureFormatInfo[srcFormat];
-    const dstFormatInfo = kTextureFormatInfo[dstFormat];
 
     t.skipIfTextureFormatNotSupported(srcFormat, dstFormat);
+    t.skipIfCopyTextureToTextureNotSupportedForFormat(srcFormat, dstFormat);
+
+    const srcFormatInfo = kTextureFormatInfo[srcFormat];
+    const dstFormatInfo = kTextureFormatInfo[dstFormat];
 
     const textureSize = {
       width: lcm(srcFormatInfo.blockWidth, dstFormatInfo.blockWidth),
diff --git a/src/webgpu/gpu_test.ts b/src/webgpu/gpu_test.ts
index aa0189c9e5ea..f6aa87254ccd 100644
--- a/src/webgpu/gpu_test.ts
+++ b/src/webgpu/gpu_test.ts
@@ -410,6 +410,16 @@ export class GPUTestBase extends Fixture<GPUTestSubcaseBatchState> {
     }
   }
 
+  skipIfCopyTextureToTextureNotSupportedForFormat(...formats: (GPUTextureFormat | undefined)[]) {
+    if (this.isCompatibility) {
+      for (const format of formats) {
+        if (format && isCompressedTextureFormat(format)) {
+          this.skip(`copyTextureToTexture with ${format} is not supported`);
+        }
+      }
+    }
+  }
+
   /**
    * Expect a GPUBuffer's contents to pass the provided check.
    *

From e2763fb820416e783f6d6bc18cebb182c98e45bd Mon Sep 17 00:00:00 2001
From: Antonio Maiorano <amaiorano@google.com>
Date: Wed, 4 Oct 2023 12:15:48 -0400
Subject: [PATCH 118/166] Fix atan and tan validation tests (#3041)

The atan validation code was copied from tan, and did not apply. It should always succeed.
For tan, was failing for f16 values because the value was not first being quantized to f16 before its cosine was computed.

Fixes https://crbug.com/tint/2035
---
 .../shader/validation/expression/call/builtin/atan.spec.ts  | 4 +---
 .../shader/validation/expression/call/builtin/tan.spec.ts   | 6 ++++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/webgpu/shader/validation/expression/call/builtin/atan.spec.ts b/src/webgpu/shader/validation/expression/call/builtin/atan.spec.ts
index df65e658290e..3080f4e971cf 100644
--- a/src/webgpu/shader/validation/expression/call/builtin/atan.spec.ts
+++ b/src/webgpu/shader/validation/expression/call/builtin/atan.spec.ts
@@ -12,7 +12,6 @@ import {
   kAllFloatScalarsAndVectors,
   kAllIntegerScalarsAndVectors,
 } from '../../../../../util/conversion.js';
-import { fpTraitsFor } from '../../../../../util/floating_point.js';
 import { ShaderValidationTest } from '../../../shader_validation_test.js';
 
 import {
@@ -49,8 +48,7 @@ Validates that constant evaluation and override evaluation of ${builtin}() rejec
   })
   .fn(t => {
     const type = kValuesTypes[t.params.type];
-    const smallestPositive = fpTraitsFor(elementType(type)).constants().positive.min;
-    const expectedResult = Math.abs(Math.cos(t.params.value)) > smallestPositive;
+    const expectedResult = true;
     validateConstOrOverrideBuiltinEval(
       t,
       builtin,
diff --git a/src/webgpu/shader/validation/expression/call/builtin/tan.spec.ts b/src/webgpu/shader/validation/expression/call/builtin/tan.spec.ts
index a7e2c612a716..b9744643f62d 100644
--- a/src/webgpu/shader/validation/expression/call/builtin/tan.spec.ts
+++ b/src/webgpu/shader/validation/expression/call/builtin/tan.spec.ts
@@ -49,8 +49,10 @@ Validates that constant evaluation and override evaluation of ${builtin}() rejec
   })
   .fn(t => {
     const type = kValuesTypes[t.params.type];
-    const smallestPositive = fpTraitsFor(elementType(type)).constants().positive.min;
-    const expectedResult = Math.abs(Math.cos(t.params.value)) > smallestPositive;
+    const fp = fpTraitsFor(elementType(type));
+    const smallestPositive = fp.constants().positive.min;
+    const v = fp.quantize(t.params.value);
+    const expectedResult = Math.abs(Math.cos(v)) > smallestPositive;
     validateConstOrOverrideBuiltinEval(
       t,
       builtin,

From 17c90bca804385a5a959196e10c5229571434d16 Mon Sep 17 00:00:00 2001
From: Antonio Maiorano <amaiorano@google.com>
Date: Wed, 4 Oct 2023 14:55:25 -0400
Subject: [PATCH 119/166] Revert "Fix Skip/Pass Issues" (#3043)

This reverts commit 48b29a106fdc9d9be5331b21e187a7232a0e1104.
---
 src/common/internal/test_group.ts |  3 +--
 src/unittests/test_group.spec.ts  | 23 -----------------------
 2 files changed, 1 insertion(+), 25 deletions(-)

diff --git a/src/common/internal/test_group.ts b/src/common/internal/test_group.ts
index f0853520624c..e446628bc0b0 100644
--- a/src/common/internal/test_group.ts
+++ b/src/common/internal/test_group.ts
@@ -500,10 +500,9 @@ class RunCaseSpecific implements RunCase {
       // An error from init or test may have been a SkipTestCase.
       // An error from finalize may have been an eventualAsyncExpectation failure
       // or unexpected validation/OOM error from the GPUDevice.
+      rec.threw(ex);
       if (throwSkip && ex instanceof SkipTestCase) {
         throw ex;
-      } else {
-        rec.threw(ex);
       }
     } finally {
       try {
diff --git a/src/unittests/test_group.spec.ts b/src/unittests/test_group.spec.ts
index 8e1129411c74..a098d07b71bc 100644
--- a/src/unittests/test_group.spec.ts
+++ b/src/unittests/test_group.spec.ts
@@ -262,29 +262,6 @@ g.test('subcases').fn(async t0 => {
   t0.expect(Array.from(result.values()).every(v => v.status === 'pass'));
 });
 
-g.test('subcases,skip')
-  .desc(
-    'If all tests are skipped then status is "skip". If at least one test passed, status is "pass"'
-  )
-  .params(u => u.combine('allSkip', [false, true]))
-  .fn(async t0 => {
-    const { allSkip } = t0.params;
-    const g = makeTestGroupForUnitTesting(UnitTest);
-    g.test('a')
-      .params(u => u.beginSubcases().combine('do', ['pass', 'skip', 'pass']))
-      .fn(t => {
-        t.skipIf(allSkip || t.params.do === 'skip');
-      });
-    const result = await t0.run(g);
-    const values = Array.from(result.values());
-    t0.expect(values.length === 1);
-    const expectedStatus = allSkip ? 'skip' : 'pass';
-    t0.expect(
-      values[0].status === expectedStatus,
-      `expect: ${values[0].status} === ${expectedStatus}}, allSkip: ${allSkip}`
-    );
-  });
-
 g.test('exceptions')
   .params(u =>
     u

From 4619a2b1936f2ae34f7de4a028324bc60ed31670 Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Thu, 5 Oct 2023 14:19:00 +0100
Subject: [PATCH 120/166] gen_cache: Add --nth flag

Can be used for parallizing the generation by an outer tool
---
 src/common/tools/gen_cache.ts | 91 ++++++++++++++++++++++++-----------
 1 file changed, 63 insertions(+), 28 deletions(-)

diff --git a/src/common/tools/gen_cache.ts b/src/common/tools/gen_cache.ts
index c712f2ede48e..4d1a9da726da 100644
--- a/src/common/tools/gen_cache.ts
+++ b/src/common/tools/gen_cache.ts
@@ -14,6 +14,7 @@ DataCache will load this instead of building the expensive data at CTS runtime.
 Options:
   --help          Print this message and exit.
   --list          Print the list of output files without writing them.
+  --nth i/n       Only process every file where (file_index % n == i)
   --validate      Check that cache should build (Tests for collisions).
   --verbose       Print each action taken.
 `);
@@ -21,30 +22,60 @@ Options:
 }
 
 let mode: 'emit' | 'list' | 'validate' = 'emit';
+let nth = { i: 0, n: 1 };
 let verbose = false;
 
 const nonFlagsArgs: string[] = [];
-for (const a of process.argv) {
-  if (a.startsWith('-')) {
-    switch (a) {
-      case '--list':
+
+for (let i = 0; i < process.argv.length; i++) {
+  const arg = process.argv[i];
+  if (arg.startsWith('-')) {
+    switch (arg) {
+      case '--list': {
         mode = 'list';
         break;
-      case '--help':
+      }
+      case '--help': {
         usage(0);
         break;
-      case '--verbose':
+      }
+      case '--verbose': {
         verbose = true;
         break;
-      case '--validate':
+      }
+      case '--validate': {
         mode = 'validate';
         break;
-      default:
-        console.log('unrecognized flag: ', a);
+      }
+      case '--nth': {
+        const err = () => {
+          console.error(
+            `--nth requires a value of the form 'i/n', where i and n are positive integers and i < n`
+          );
+          process.exit(1);
+        };
+        i++;
+        if (i >= process.argv.length) {
+          err();
+        }
+        const value = process.argv[i];
+        const parts = value.split('/');
+        if (parts.length !== 2) {
+          err();
+        }
+        nth = { i: parseInt(parts[0]), n: parseInt(parts[1]) };
+        if (nth.i < 0 || nth.n < 1 || nth.i > nth.n) {
+          err();
+        }
+        break;
+      }
+      default: {
+        console.log('unrecognized flag: ', arg);
         usage(1);
+      }
     }
   } else {
-    nonFlagsArgs.push(a);
+    nonFlagsArgs.push(arg);
   }
 }
 
@@ -109,34 +140,38 @@ async function build(suiteDir: string) {
   }
 
   // Crawl files and convert paths to be POSIX-style, relative to suiteDir.
-  const filesToEnumerate = (await crawlFilesRecursively(suiteDir)).sort();
+  let filesToEnumerate = (await crawlFilesRecursively(suiteDir)).sort();
+
+  // Filter out non-spec files
+  filesToEnumerate = filesToEnumerate.filter(f => f.endsWith(specFileSuffix));
 
   const cacheablePathToTS = new Map<string, string>();
 
+  let fileIndex = 0;
   for (const file of filesToEnumerate) {
-    if (file.endsWith(specFileSuffix)) {
-      const pathWithoutExtension = file.substring(0, file.length - specFileSuffix.length);
-      const mod = await import(`../../../${pathWithoutExtension}.spec.js`);
-      if (mod.d?.serialize !== undefined) {
-        const cacheable = mod.d as Cacheable<unknown>;
-
-        {
-          // Check for collisions
-          const existing = cacheablePathToTS.get(cacheable.path);
-          if (existing !== undefined) {
-            console.error(
-              `error: Cacheable '${cacheable.path}' is emitted by both:
+    const pathWithoutExtension = file.substring(0, file.length - specFileSuffix.length);
+    const mod = await import(`../../../${pathWithoutExtension}.spec.js`);
+    if (mod.d?.serialize !== undefined) {
+      const cacheable = mod.d as Cacheable<unknown>;
+
+      {
+        // Check for collisions
+        const existing = cacheablePathToTS.get(cacheable.path);
+        if (existing !== undefined) {
+          console.error(
+            `error: Cacheable '${cacheable.path}' is emitted by both:
     '${existing}'
 and
     '${file}'`
-            );
-            process.exit(1);
-          }
-          cacheablePathToTS.set(cacheable.path, file);
+          );
+          process.exit(1);
         }
+        cacheablePathToTS.set(cacheable.path, file);
+      }
 
-        const outPath = `${outRootDir}/data/${cacheable.path}`;
+      const outPath = `${outRootDir}/data/${cacheable.path}`;
 
+      if (fileIndex++ % nth.n === nth.i) {
         switch (mode) {
           case 'emit': {
             if (verbose) {

From b0ea37d9c8155fe3a94de252b0ec91a99b55c1df Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 5 Oct 2023 15:07:10 -0400
Subject: [PATCH 121/166] wgsl: Optimize memory allocations when quantizing
 data (#3052)

This improves my local gen_cache run time from 1148.2532s to 240.2233s

Fixes #3051
---
 src/webgpu/util/math.ts | 44 ++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 23 deletions(-)

diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 3055b6d9aa96..dfdc0a879642 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -6,15 +6,7 @@ import {
 } from '../../external/petamoriken/float16/float16.js';
 
 import { kBit, kValue } from './constants.js';
-import {
-  f32,
-  f16,
-  floatBitsToNumber,
-  i32,
-  kFloat16Format,
-  kFloat32Format,
-  u32,
-} from './conversion.js';
+import { floatBitsToNumber, i32, kFloat16Format, kFloat32Format, u32 } from './conversion.js';
 
 /**
  * A multiple of 8 guaranteed to be way too large to allocate (just under 8 pebibytes).
@@ -529,21 +521,20 @@ export function correctlyRoundedF32(n: number): number[] {
 
   // f32 finite
   if (n <= kValue.f32.positive.max && n >= kValue.f32.negative.min) {
-    const n_32 = new Float32Array([n])[0];
-    const converted: number = n_32;
-    if (n === converted) {
+    const n_32 = quantizeToF32(n);
+    if (n === n_32) {
       // n is precisely expressible as a f32, so should not be rounded
       return [n];
     }
 
-    if (converted > n) {
+    if (n_32 > n) {
       // n_32 rounded towards +inf, so is after n
       const other = nextAfterF32(n_32, 'negative', 'no-flush');
-      return [other, converted];
+      return [other, n_32];
     } else {
       // n_32 rounded towards -inf, so is before n
       const other = nextAfterF32(n_32, 'positive', 'no-flush');
-      return [converted, other];
+      return [n_32, other];
     }
   }
 
@@ -598,21 +589,20 @@ export function correctlyRoundedF16(n: number): number[] {
 
   // f16 finite
   if (n <= kValue.f16.positive.max && n >= kValue.f16.negative.min) {
-    const n_16 = new Float16Array([n])[0];
-    const converted: number = n_16;
-    if (n === converted) {
+    const n_16 = quantizeToF16(n);
+    if (n === n_16) {
       // n is precisely expressible as a f16, so should not be rounded
       return [n];
     }
 
-    if (converted > n) {
+    if (n_16 > n) {
       // n_16 rounded towards +inf, so is after n
       const other = nextAfterF16(n_16, 'negative', 'no-flush');
-      return [other, converted];
+      return [other, n_16];
     } else {
       // n_16 rounded towards -inf, so is before n
       const other = nextAfterF16(n_16, 'positive', 'no-flush');
-      return [converted, other];
+      return [n_16, other];
     }
   }
 
@@ -2004,14 +1994,22 @@ export interface QuantizeFunc {
   (num: number): number;
 }
 
+/** Statically allocate working data, so it doesn't need per-call creation */
+const quantizeToF32Data = new Float32Array(new ArrayBuffer(4));
+
 /** @returns the closest 32-bit floating point value to the input */
 export function quantizeToF32(num: number): number {
-  return f32(num).value as number;
+  quantizeToF32Data[0] = num;
+  return quantizeToF32Data[0];
 }
 
+/** Statically allocate working data, so it doesn't need per-call creation */
+const quantizeToF16Data = new Float16Array(new ArrayBuffer(2));
+
 /** @returns the closest 16-bit floating point value to the input */
 export function quantizeToF16(num: number): number {
-  return f16(num).value as number;
+  quantizeToF16Data[0] = num;
+  return quantizeToF16Data[0];
 }
 
 /** @returns the closest 32-bit signed integer value to the input */

From 202bddec09f9db661360e5826ec6127e0e0580cc Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Wed, 4 Oct 2023 15:09:43 -0700
Subject: [PATCH 122/166] Compat: make zero_init tests handle different limits

---
 src/webgpu/shader/execution/zero_init.spec.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/webgpu/shader/execution/zero_init.spec.ts b/src/webgpu/shader/execution/zero_init.spec.ts
index b30fc46fd2ab..ad7b095b8995 100644
--- a/src/webgpu/shader/execution/zero_init.spec.ts
+++ b/src/webgpu/shader/execution/zero_init.spec.ts
@@ -228,6 +228,14 @@ g.test('compute,zero_init')
   )
   .batch(15)
   .fn(t => {
+    const { workgroupSize } = t.params;
+    const { maxComputeInvocationsPerWorkgroup } = t.device.limits;
+    const numWorkgroupInvocations = workgroupSize.reduce((a, b) => a * b);
+    t.skipIf(
+      numWorkgroupInvocations > maxComputeInvocationsPerWorkgroup,
+      `workgroupSize: ${workgroupSize} > maxComputeInvocationsPerWorkgroup: ${maxComputeInvocationsPerWorkgroup}`
+    );
+
     let moduleScope = `
       struct Output {
         failed : atomic<u32>

From 812ebafafba78be88c56c646e80c198d656f786d Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Wed, 4 Oct 2023 14:33:35 -0700
Subject: [PATCH 123/166] Compat: Fix attachment_compatibility color_count
 tests for limits

---
 .../attachment_compatibility.spec.ts          | 26 +++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/webgpu/api/validation/render_pass/attachment_compatibility.spec.ts b/src/webgpu/api/validation/render_pass/attachment_compatibility.spec.ts
index 2170224ed931..c0ab23b91c8e 100644
--- a/src/webgpu/api/validation/render_pass/attachment_compatibility.spec.ts
+++ b/src/webgpu/api/validation/render_pass/attachment_compatibility.spec.ts
@@ -206,6 +206,17 @@ g.test('render_pass_and_bundle,color_count')
   )
   .fn(t => {
     const { passCount, bundleCount } = t.params;
+
+    const { maxColorAttachments } = t.device.limits;
+    t.skipIf(
+      passCount > maxColorAttachments,
+      `passCount: ${passCount} > maxColorAttachments for device: ${maxColorAttachments}`
+    );
+    t.skipIf(
+      bundleCount > maxColorAttachments,
+      `bundleCount: ${bundleCount} > maxColorAttachments for device: ${maxColorAttachments}`
+    );
+
     const bundleEncoder = t.device.createRenderBundleEncoder({
       colorFormats: range(bundleCount, () => 'rgba8uint'),
     });
@@ -242,7 +253,7 @@ g.test('render_pass_and_bundle,color_sparse')
   .fn(t => {
     const { passAttachments, bundleAttachments } = t.params;
 
-    const maxColorAttachments = t.device.limits.maxColorAttachments;
+    const { maxColorAttachments } = t.device.limits;
     t.skipIf(
       passAttachments.length > maxColorAttachments,
       `num passAttachments: ${passAttachments.length} > maxColorAttachments for device: ${maxColorAttachments}`
@@ -402,6 +413,17 @@ count.
   )
   .fn(t => {
     const { encoderType, encoderCount, pipelineCount } = t.params;
+
+    const { maxColorAttachments } = t.device.limits;
+    t.skipIf(
+      pipelineCount > maxColorAttachments,
+      `pipelineCount: ${pipelineCount} > maxColorAttachments for device: ${maxColorAttachments}`
+    );
+    t.skipIf(
+      encoderCount > maxColorAttachments,
+      `encoderCount: ${encoderCount} > maxColorAttachments for device: ${maxColorAttachments}`
+    );
+
     const pipeline = t.createRenderPipeline(
       range(pipelineCount, () => ({ format: 'rgba8uint', writeMask: 0 }))
     );
@@ -435,7 +457,7 @@ Test that each of color attachments in render passes or bundles match that of th
   )
   .fn(t => {
     const { encoderType, encoderAttachments, pipelineAttachments } = t.params;
-    const maxColorAttachments = t.device.limits.maxColorAttachments;
+    const { maxColorAttachments } = t.device.limits;
     t.skipIf(
       encoderAttachments.length > maxColorAttachments,
       `num encoderAttachments: ${encoderAttachments.length} > maxColorAttachments for device: ${maxColorAttachments}`

From db80cf2ef0c390cb95a4bdf8981097a0b56dc336 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Wed, 4 Oct 2023 14:16:27 -0700
Subject: [PATCH 124/166] Compat: skip unsupported formats in filter mode tests

---
 src/webgpu/api/operation/sampling/filter_mode.spec.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/webgpu/api/operation/sampling/filter_mode.spec.ts b/src/webgpu/api/operation/sampling/filter_mode.spec.ts
index 63f4409ca158..6f48f606cec7 100644
--- a/src/webgpu/api/operation/sampling/filter_mode.spec.ts
+++ b/src/webgpu/api/operation/sampling/filter_mode.spec.ts
@@ -480,6 +480,7 @@ g.test('magFilter,nearest')
       .combine('addressModeV', kAddressModes)
   )
   .beforeAllSubcases(t => {
+    t.skipIfTextureFormatNotSupported(t.params.format);
     if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
       t.selectDeviceOrSkipTestCase('float32-filterable');
     }
@@ -602,6 +603,7 @@ g.test('magFilter,linear')
       .combine('addressModeV', kAddressModes)
   )
   .beforeAllSubcases(t => {
+    t.skipIfTextureFormatNotSupported(t.params.format);
     if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
       t.selectDeviceOrSkipTestCase('float32-filterable');
     }
@@ -736,6 +738,7 @@ g.test('minFilter,nearest')
       .combine('addressModeV', kAddressModes)
   )
   .beforeAllSubcases(t => {
+    t.skipIfTextureFormatNotSupported(t.params.format);
     if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
       t.selectDeviceOrSkipTestCase('float32-filterable');
     }
@@ -868,6 +871,7 @@ g.test('minFilter,linear')
       .combine('addressModeV', kAddressModes)
   )
   .beforeAllSubcases(t => {
+    t.skipIfTextureFormatNotSupported(t.params.format);
     if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
       t.selectDeviceOrSkipTestCase('float32-filterable');
     }
@@ -963,6 +967,7 @@ g.test('mipmapFilter')
       .combine('filterMode', kMipmapFilterModes)
   )
   .beforeAllSubcases(t => {
+    t.skipIfTextureFormatNotSupported(t.params.format);
     if (kTextureFormatInfo[t.params.format].color.type === 'unfilterable-float') {
       t.selectDeviceOrSkipTestCase('float32-filterable');
     }

From 8bb48275486acc5ce8ec25dcd3eabaeba80ed832 Mon Sep 17 00:00:00 2001
From: Greggman <github@greggman.com>
Date: Fri, 6 Oct 2023 10:45:30 -0700
Subject: [PATCH 125/166] Make Pass > Skip (#3054)

As it is, the test recorder only keeps the "highest" status. It
was Pass = 0, Skip = 1, that means if 1000 subcases passes but just
one was skipped the entire case was marked as skip.

Making Pass > Skip means that as long as one subcase runs
the test will be marked as Pass unless there is a higher status
subcase
---
 src/common/internal/logging/result.ts         |  2 +-
 .../internal/logging/test_case_recorder.ts    | 62 ++++++++++++-------
 src/common/internal/test_group.ts             |  1 +
 src/unittests/logger.spec.ts                  | 28 ++++++++-
 src/unittests/test_group.spec.ts              | 23 +++++++
 5 files changed, 91 insertions(+), 25 deletions(-)

diff --git a/src/common/internal/logging/result.ts b/src/common/internal/logging/result.ts
index 0de661b50ce9..3318e8c937d5 100644
--- a/src/common/internal/logging/result.ts
+++ b/src/common/internal/logging/result.ts
@@ -3,7 +3,7 @@ import { LogMessageWithStack } from './log_message.js';
 // MAINTENANCE_TODO: Add warn expectations
 export type Expectation = 'pass' | 'skip' | 'fail';
 
-export type Status = 'running' | 'warn' | Expectation;
+export type Status = 'notrun' | 'running' | 'warn' | Expectation;
 
 export interface TestCaseResult {
   status: Status;
diff --git a/src/common/internal/logging/test_case_recorder.ts b/src/common/internal/logging/test_case_recorder.ts
index ca37ba4b0287..f5c3252b5c7d 100644
--- a/src/common/internal/logging/test_case_recorder.ts
+++ b/src/common/internal/logging/test_case_recorder.ts
@@ -3,27 +3,43 @@ import { globalTestConfig } from '../../framework/test_config.js';
 import { now, assert } from '../../util/util.js';
 
 import { LogMessageWithStack } from './log_message.js';
-import { Expectation, LiveTestCaseResult } from './result.js';
+import { Expectation, LiveTestCaseResult, Status } from './result.js';
 
 enum LogSeverity {
-  Pass = 0,
+  NotRun = 0,
   Skip = 1,
-  Warn = 2,
-  ExpectFailed = 3,
-  ValidationFailed = 4,
-  ThrewException = 5,
+  Pass = 2,
+  Warn = 3,
+  ExpectFailed = 4,
+  ValidationFailed = 5,
+  ThrewException = 6,
 }
 
 const kMaxLogStacks = 2;
 const kMinSeverityForStack = LogSeverity.Warn;
 
+function logSeverityToString(status: LogSeverity): Status {
+  switch (status) {
+    case LogSeverity.NotRun:
+      return 'notrun';
+    case LogSeverity.Pass:
+      return 'pass';
+    case LogSeverity.Skip:
+      return 'skip';
+    case LogSeverity.Warn:
+      return 'warn';
+    default:
+      return 'fail'; // Everything else is an error
+  }
+}
+
 /** Holds onto a LiveTestCaseResult owned by the Logger, and writes the results into it. */
 export class TestCaseRecorder {
   readonly result: LiveTestCaseResult;
   public nonskippedSubcaseCount: number = 0;
   private inSubCase: boolean = false;
-  private subCaseStatus = LogSeverity.Pass;
-  private finalCaseStatus = LogSeverity.Pass;
+  private subCaseStatus = LogSeverity.NotRun;
+  private finalCaseStatus = LogSeverity.NotRun;
   private hideStacksBelowSeverity = kMinSeverityForStack;
   private startTime = -1;
   private logs: LogMessageWithStack[] = [];
@@ -56,20 +72,13 @@ export class TestCaseRecorder {
     }
 
     // Convert numeric enum back to string (but expose 'exception' as 'fail')
-    this.result.status =
-      this.finalCaseStatus === LogSeverity.Pass
-        ? 'pass'
-        : this.finalCaseStatus === LogSeverity.Skip
-        ? 'skip'
-        : this.finalCaseStatus === LogSeverity.Warn
-        ? 'warn'
-        : 'fail'; // Everything else is an error
+    this.result.status = logSeverityToString(this.finalCaseStatus);
 
     this.result.logs = this.logs;
   }
 
   beginSubCase() {
-    this.subCaseStatus = LogSeverity.Pass;
+    this.subCaseStatus = LogSeverity.NotRun;
     this.inSubCase = true;
   }
 
@@ -87,9 +96,7 @@ export class TestCaseRecorder {
       }
     } finally {
       this.inSubCase = false;
-      if (this.subCaseStatus > this.finalCaseStatus) {
-        this.finalCaseStatus = this.subCaseStatus;
-      }
+      this.finalCaseStatus = Math.max(this.finalCaseStatus, this.subCaseStatus);
     }
   }
 
@@ -103,7 +110,8 @@ export class TestCaseRecorder {
   }
 
   info(ex: Error): void {
-    this.logImpl(LogSeverity.Pass, 'INFO', ex);
+    // We need this to use the lowest LogSeverity so it doesn't override the current severity for this test case.
+    this.logImpl(LogSeverity.NotRun, 'INFO', ex);
   }
 
   skipped(ex: SkipTestCase): void {
@@ -122,6 +130,14 @@ export class TestCaseRecorder {
     this.logImpl(LogSeverity.ValidationFailed, 'VALIDATION FAILED', ex);
   }
 
+  passed(): void {
+    if (this.inSubCase) {
+      this.subCaseStatus = Math.max(this.subCaseStatus, LogSeverity.Pass);
+    } else {
+      this.finalCaseStatus = Math.max(this.finalCaseStatus, LogSeverity.Pass);
+    }
+  }
+
   threw(ex: unknown): void {
     if (ex instanceof SkipTestCase) {
       this.skipped(ex);
@@ -137,9 +153,9 @@ export class TestCaseRecorder {
 
     // Final case status should be the "worst" of all log entries.
     if (this.inSubCase) {
-      if (level > this.subCaseStatus) this.subCaseStatus = level;
+      this.subCaseStatus = Math.max(this.subCaseStatus, level);
     } else {
-      if (level > this.finalCaseStatus) this.finalCaseStatus = level;
+      this.finalCaseStatus = Math.max(this.finalCaseStatus, level);
     }
 
     // setFirstLineOnly for all logs except `kMaxLogStacks` stacks at the highest severity
diff --git a/src/common/internal/test_group.ts b/src/common/internal/test_group.ts
index e446628bc0b0..c7dc38d06bbc 100644
--- a/src/common/internal/test_group.ts
+++ b/src/common/internal/test_group.ts
@@ -491,6 +491,7 @@ class RunCaseSpecific implements RunCase {
       try {
         await inst.init();
         await this.fn(inst as Fixture & { params: {} });
+        rec.passed();
       } finally {
         // Runs as long as constructor succeeded, even if initialization or the test failed.
         await inst.finalize();
diff --git a/src/unittests/logger.spec.ts b/src/unittests/logger.spec.ts
index 18aa0a02fe92..abc27e28767a 100644
--- a/src/unittests/logger.spec.ts
+++ b/src/unittests/logger.spec.ts
@@ -36,6 +36,18 @@ g.test('empty').fn(t => {
   t.expect(res.status === 'running');
   rec.finish();
 
+  t.expect(res.status === 'notrun');
+  t.expect(res.timems >= 0);
+});
+
+g.test('passed').fn(t => {
+  const mylog = new Logger({ overrideDebugMode: true });
+  const [rec, res] = mylog.record('one');
+
+  rec.start();
+  rec.passed();
+  rec.finish();
+
   t.expect(res.status === 'pass');
   t.expect(res.timems >= 0);
 });
@@ -59,13 +71,27 @@ g.test('skip').fn(t => {
 
   rec.start();
   rec.skipped(new SkipTestCase());
-  rec.debug(new Error('hello'));
   rec.finish();
 
   t.expect(res.status === 'skip');
   t.expect(res.timems >= 0);
 });
 
+// Tests if there's some skips and at least one pass it's pass.
+g.test('skip_pass').fn(t => {
+  const mylog = new Logger({ overrideDebugMode: true });
+  const [rec, res] = mylog.record('one');
+
+  rec.start();
+  rec.skipped(new SkipTestCase());
+  rec.debug(new Error('hello'));
+  rec.skipped(new SkipTestCase());
+  rec.finish();
+
+  t.expect(res.status === 'pass');
+  t.expect(res.timems >= 0);
+});
+
 g.test('warn').fn(t => {
   const mylog = new Logger({ overrideDebugMode: true });
   const [rec, res] = mylog.record('one');
diff --git a/src/unittests/test_group.spec.ts b/src/unittests/test_group.spec.ts
index a098d07b71bc..8e1129411c74 100644
--- a/src/unittests/test_group.spec.ts
+++ b/src/unittests/test_group.spec.ts
@@ -262,6 +262,29 @@ g.test('subcases').fn(async t0 => {
   t0.expect(Array.from(result.values()).every(v => v.status === 'pass'));
 });
 
+g.test('subcases,skip')
+  .desc(
+    'If all tests are skipped then status is "skip". If at least one test passed, status is "pass"'
+  )
+  .params(u => u.combine('allSkip', [false, true]))
+  .fn(async t0 => {
+    const { allSkip } = t0.params;
+    const g = makeTestGroupForUnitTesting(UnitTest);
+    g.test('a')
+      .params(u => u.beginSubcases().combine('do', ['pass', 'skip', 'pass']))
+      .fn(t => {
+        t.skipIf(allSkip || t.params.do === 'skip');
+      });
+    const result = await t0.run(g);
+    const values = Array.from(result.values());
+    t0.expect(values.length === 1);
+    const expectedStatus = allSkip ? 'skip' : 'pass';
+    t0.expect(
+      values[0].status === expectedStatus,
+      `expect: ${values[0].status} === ${expectedStatus}}, allSkip: ${allSkip}`
+    );
+  });
+
 g.test('exceptions')
   .params(u =>
     u

From 08a4f176de99034a3089ce1a6ff48797fa4213ff Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 10 Oct 2023 23:43:33 +0800
Subject: [PATCH 126/166] [Reland] util: Add negative zero in full F16/F32/F64
 range (#3060)

* util: Add negative zero in full F16/F32/F64 range

This PR add negative zero in fullF16Range, fullF32Range, and fullF64Range.

* Update unittests

* Distinguish +/-0.0 in test cases query

Distinguish +/-0.0 in test cases query by making objectEquals able to
opted to distinguish them.
---
 src/common/internal/query/compare.ts |  3 +-
 src/common/util/util.ts              | 16 +++++++--
 src/unittests/maths.spec.ts          | 52 ++++++++++++++--------------
 src/unittests/query_compare.spec.ts  | 11 ++++++
 src/webgpu/util/math.ts              | 12 +++++++
 5 files changed, 64 insertions(+), 30 deletions(-)

diff --git a/src/common/internal/query/compare.ts b/src/common/internal/query/compare.ts
index e9f4b0150336..a9419b87c196 100644
--- a/src/common/internal/query/compare.ts
+++ b/src/common/internal/query/compare.ts
@@ -80,7 +80,8 @@ export function comparePublicParamsPaths(a: TestParams, b: TestParams): Ordering
   const commonKeys = new Set(aKeys.filter(k => k in b));
 
   for (const k of commonKeys) {
-    if (!objectEquals(a[k], b[k])) {
+    // Treat +/-0.0 as different query by distinguishing them in objectEquals
+    if (!objectEquals(a[k], b[k], true)) {
       return Ordering.Unordered;
     }
   }
diff --git a/src/common/util/util.ts b/src/common/util/util.ts
index ebee7d59b85a..876851f100c3 100644
--- a/src/common/util/util.ts
+++ b/src/common/util/util.ts
@@ -182,14 +182,24 @@ export function sortObjectByKey(v: { [k: string]: unknown }): { [k: string]: unk
 
 /**
  * Determines whether two JS values are equal, recursing into objects and arrays.
- * NaN is treated specially, such that `objectEquals(NaN, NaN)`.
+ * NaN is treated specially, such that `objectEquals(NaN, NaN)`. +/-0.0 are treated as equal
+ * by default, but can be opted to be distinguished.
+ * @param x the first JS values that get compared
+ * @param y the second JS values that get compared
+ * @param distinguishSignedZero if set to true, treat 0.0 and -0.0 as unequal. Default to false.
  */
-export function objectEquals(x: unknown, y: unknown): boolean {
+export function objectEquals(
+  x: unknown,
+  y: unknown,
+  distinguishSignedZero: boolean = false
+): boolean {
   if (typeof x !== 'object' || typeof y !== 'object') {
     if (typeof x === 'number' && typeof y === 'number' && Number.isNaN(x) && Number.isNaN(y)) {
       return true;
     }
-    return x === y;
+    // Object.is(0.0, -0.0) is false while (0.0 === -0.0) is true. Other than +/-0.0 and NaN cases,
+    // Object.is works in the same way as ===.
+    return distinguishSignedZero ? Object.is(x, y) : x === y;
   }
   if (x === null || y === null) return x === y;
   if (x.constructor !== y.constructor) return false;
diff --git a/src/unittests/maths.spec.ts b/src/unittests/maths.spec.ts
index 00ea2be54d5e..126a0d371e03 100644
--- a/src/unittests/maths.spec.ts
+++ b/src/unittests/maths.spec.ts
@@ -1535,19 +1535,19 @@ g.test('fullF32Range')
   .paramsSimple<fullF32RangeCase>(
     // prettier-ignore
     [
-      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
-      { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, 0.0] },
-      { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, 0.0 ] },
-      { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -1.9999998807907104, kValue.f32.negative.max, 0.0 ] },
-      { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.subnormal.min, 0.0 ] },
-      { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max, 0.0 ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f32.positive.subnormal.min ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f32.positive.subnormal.min, kValue.f32.positive.subnormal.max ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f32.positive.min ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f32.positive.min, kValue.f32.positive.max ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f32.positive.min, 1.9999998807907104, kValue.f32.positive.max ] },
-      { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f32.negative.min, kValue.f32.negative.subnormal.min, 0.0, kValue.f32.positive.subnormal.min, kValue.f32.positive.min ] },
-      { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max, 0.0, kValue.f32.positive.subnormal.min, kValue.f32.positive.subnormal.max, kValue.f32.positive.min, kValue.f32.positive.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ -0.0, 0.0 ] },
+      { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -0.0, 0.0] },
+      { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, -0.0, 0.0 ] },
+      { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.min, -1.9999998807907104, kValue.f32.negative.max, -0.0, 0.0 ] },
+      { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.subnormal.min, -0.0, 0.0 ] },
+      { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max, -0.0, 0.0 ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f32.positive.subnormal.min ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f32.positive.subnormal.min, kValue.f32.positive.subnormal.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ -0.0, 0.0, kValue.f32.positive.min ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ -0.0, 0.0, kValue.f32.positive.min, kValue.f32.positive.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ -0.0, 0.0, kValue.f32.positive.min, 1.9999998807907104, kValue.f32.positive.max ] },
+      { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f32.negative.min, kValue.f32.negative.subnormal.min, -0.0, 0.0, kValue.f32.positive.subnormal.min, kValue.f32.positive.min ] },
+      { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f32.negative.min, kValue.f32.negative.max, kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max, -0.0, 0.0, kValue.f32.positive.subnormal.min, kValue.f32.positive.subnormal.max, kValue.f32.positive.min, kValue.f32.positive.max ] },
     ]
   )
   .fn(test => {
@@ -1576,19 +1576,19 @@ g.test('fullF16Range')
   .paramsSimple<fullF16RangeCase>(
     // prettier-ignore
     [
-      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ 0.0 ] },
-      { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, 0.0] },
-      { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, 0.0 ] },
-      { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -1.9990234375, kValue.f16.negative.max, 0.0 ] },
-      { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.subnormal.min, 0.0 ] },
-      { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max, 0.0 ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ 0.0, kValue.f16.positive.subnormal.min ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ 0.0, kValue.f16.positive.subnormal.min, kValue.f16.positive.subnormal.max ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ 0.0, kValue.f16.positive.min ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ 0.0, kValue.f16.positive.min, kValue.f16.positive.max ] },
-      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ 0.0, kValue.f16.positive.min, 1.9990234375, kValue.f16.positive.max ] },
-      { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f16.negative.min, kValue.f16.negative.subnormal.min, 0.0, kValue.f16.positive.subnormal.min, kValue.f16.positive.min ] },
-      { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max, 0.0, kValue.f16.positive.subnormal.min, kValue.f16.positive.subnormal.max, kValue.f16.positive.min, kValue.f16.positive.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ -0.0, 0.0 ] },
+      { neg_norm: 1, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -0.0, 0.0] },
+      { neg_norm: 2, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, -0.0, 0.0 ] },
+      { neg_norm: 3, neg_sub: 0, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.min, -1.9990234375, kValue.f16.negative.max, -0.0, 0.0 ] },
+      { neg_norm: 0, neg_sub: 1, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.subnormal.min, -0.0, 0.0 ] },
+      { neg_norm: 0, neg_sub: 2, pos_sub: 0, pos_norm: 0, expect: [ kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max, -0.0, 0.0 ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 1, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f16.positive.subnormal.min ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 2, pos_norm: 0, expect: [ -0.0, 0.0, kValue.f16.positive.subnormal.min, kValue.f16.positive.subnormal.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 1, expect: [ -0.0, 0.0, kValue.f16.positive.min ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 2, expect: [ -0.0, 0.0, kValue.f16.positive.min, kValue.f16.positive.max ] },
+      { neg_norm: 0, neg_sub: 0, pos_sub: 0, pos_norm: 3, expect: [ -0.0, 0.0, kValue.f16.positive.min, 1.9990234375, kValue.f16.positive.max ] },
+      { neg_norm: 1, neg_sub: 1, pos_sub: 1, pos_norm: 1, expect: [ kValue.f16.negative.min, kValue.f16.negative.subnormal.min, -0.0, 0.0, kValue.f16.positive.subnormal.min, kValue.f16.positive.min ] },
+      { neg_norm: 2, neg_sub: 2, pos_sub: 2, pos_norm: 2, expect: [ kValue.f16.negative.min, kValue.f16.negative.max, kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max, -0.0, 0.0, kValue.f16.positive.subnormal.min, kValue.f16.positive.subnormal.max, kValue.f16.positive.min, kValue.f16.positive.max ] },
     ]
   )
   .fn(test => {
diff --git a/src/unittests/query_compare.spec.ts b/src/unittests/query_compare.spec.ts
index 520af9e663c5..b53b76a4dffb 100644
--- a/src/unittests/query_compare.spec.ts
+++ b/src/unittests/query_compare.spec.ts
@@ -130,4 +130,15 @@ g.test('unordered').fn(t => {
     new TestQuerySingleCase('suite1', ['bar', 'buzz', 'buzz'], ['zap'], {}),
     new TestQueryMultiTest('suite1', ['bar'], [])
   );
+  // Expect that 0.0 and -0.0 are treated as different queries
+  t.expectUnordered(
+    new TestQueryMultiCase('suite', ['a', 'b'], ['c', 'd'], { x: 0.0 }),
+    new TestQueryMultiCase('suite', ['a', 'b'], ['c', 'd'], { x: -0.0 })
+  );
+  t.expectUnordered(
+    new TestQuerySingleCase('suite', ['a', 'b'], ['c', 'd'], { x: 0.0, y: 0.0 }),
+    new TestQuerySingleCase('suite', ['a', 'b'], ['c', 'd'], { x: 0.0, y: -0.0 }),
+    new TestQuerySingleCase('suite', ['a', 'b'], ['c', 'd'], { x: -0.0, y: 0.0 }),
+    new TestQuerySingleCase('suite', ['a', 'b'], ['c', 'd'], { x: -0.0, y: -0.0 })
+  );
 });
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index dfdc0a879642..cc7b5e44a99f 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -910,6 +910,9 @@ export function fullF32Range(
       kBit.f32.negative.subnormal.max,
       counts.neg_sub
     ),
+    // -0.0
+    0x80000000,
+    // +0.0
     0,
     ...linearRange(
       kBit.f32.positive.subnormal.min,
@@ -974,6 +977,9 @@ export function fullF16Range(
       kBit.f16.negative.subnormal.max,
       counts.neg_sub
     ),
+    // -0.0
+    0x8000,
+    // +0.0
     0,
     ...linearRange(
       kBit.f16.positive.subnormal.min,
@@ -1022,6 +1028,9 @@ export function fullF64Range(
       kBit.f64.negative.subnormal.max,
       counts.neg_sub
     ),
+    // -0.0
+    0x8000_0000_0000_0000n,
+    // +0.0
     0n,
     ...linearRangeBigInt(
       kBit.f64.positive.subnormal.min,
@@ -1078,6 +1087,9 @@ export function filteredF64Range(
       kBit.f64.negative.subnormal.max,
       counts.neg_sub
     ),
+    // -0.0
+    0x8000_0000_0000_0000n,
+    // +0.0
     0n,
     ...linearRangeBigInt(
       kBit.f64.positive.subnormal.min,

From 4e91a54a0767cf596a407e9bc0933e4bbc66e8d3 Mon Sep 17 00:00:00 2001
From: David Neto <dneto@google.com>
Date: Tue, 10 Oct 2023 15:32:09 -0400
Subject: [PATCH 127/166] memory_model: Add f16 to barrier tests (#3055)

* memory_model: Add f16 to barrier tests

memory_model_setup.ts: Generalize access value type

- Describe the test_locations and results buffers in more detail
- Use new type alias AccessValueType as the element type in
  test_locations.  It is set up to be switched easily between f16 and u32.
- In the results shader, use the Memory type for test_locations instead
  of AtomicMemory.
- In test shaders, use 1 and 2 instead of 1u and 2u.  Take advantage of
  the flexibility of AbstractInt literals.

barrier.spec.ts: Add f16 to barrier test

- Rework parameterization of the barrier tests.

Fixes: #3053

* Fix method comment for comment extractor
---
 .../execution/memory_model/barrier.spec.ts    | 163 +++++++++++-------
 .../memory_model/memory_model_setup.ts        |  89 ++++++++--
 2 files changed, 180 insertions(+), 72 deletions(-)

diff --git a/src/webgpu/shader/execution/memory_model/barrier.spec.ts b/src/webgpu/shader/execution/memory_model/barrier.spec.ts
index 6cda6c3e1920..478ae28a7ac9 100644
--- a/src/webgpu/shader/execution/memory_model/barrier.spec.ts
+++ b/src/webgpu/shader/execution/memory_model/barrier.spec.ts
@@ -7,6 +7,7 @@ import { GPUTest } from '../../../gpu_test.js';
 import {
   MemoryModelTestParams,
   MemoryModelTester,
+  kAccessValueTypes,
   buildTestShader,
   MemoryType,
   TestType,
@@ -42,20 +43,74 @@ const memoryModelTestParams: MemoryModelTestParams = {
   numBehaviors: 2,
 };
 
+// The two kinds of non-atomic accesses tested.
+//  rw: read -> barrier -> write
+//  wr: write -> barrier -> read
+//  ww: write -> barrier -> write
+type AccessPair = 'rw' | 'wr' | 'ww';
+
+// Test the non-atomic memory types.
+const kMemTypes = [MemoryType.NonAtomicStorageClass, MemoryType.NonAtomicWorkgroupClass] as const;
+
 const storageMemoryBarrierStoreLoadTestCode = `
-  test_locations.value[x_0] = 1u;
+  test_locations.value[x_0] = 1;
   workgroupBarrier();
-  let r0 = test_locations.value[x_1];
+  let r0 = u32(test_locations.value[x_1]);
   atomicStore(&results.value[shuffled_workgroup * workgroupXSize + id_1].r0, r0);
 `;
 
 const workgroupMemoryBarrierStoreLoadTestCode = `
-  wg_test_locations[x_0] = 1u;
+  wg_test_locations[x_0] = 1;
   workgroupBarrier();
-  let r0 = wg_test_locations[x_1];
+  let r0 = u32(wg_test_locations[x_1]);
   atomicStore(&results.value[shuffled_workgroup * workgroupXSize + id_1].r0, r0);
 `;
 
+const storageMemoryBarrierLoadStoreTestCode = `
+  let r0 = u32(test_locations.value[x_0]);
+  workgroupBarrier();
+  test_locations.value[x_1] = 1;
+  atomicStore(&results.value[shuffled_workgroup * workgroupXSize + id_0].r0, r0);
+`;
+
+const workgroupMemoryBarrierLoadStoreTestCode = `
+  let r0 = u32(wg_test_locations[x_0]);
+  workgroupBarrier();
+  wg_test_locations[x_1] = 1;
+  atomicStore(&results.value[shuffled_workgroup * workgroupXSize + id_0].r0, r0);
+`;
+
+const storageMemoryBarrierStoreStoreTestCode = `
+  test_locations.value[x_0] = 1;
+  storageBarrier();
+  test_locations.value[x_1] = 2;
+`;
+
+const workgroupMemoryBarrierStoreStoreTestCode = `
+  wg_test_locations[x_0] = 1;
+  workgroupBarrier();
+  wg_test_locations[x_1] = 2;
+  workgroupBarrier();
+  test_locations.value[shuffled_workgroup * workgroupXSize * stress_params.mem_stride * 2u + x_1] = wg_test_locations[x_1];
+`;
+
+function getTestCode(p: { memType: MemoryType; accessPair: AccessPair }): string {
+  switch (p.accessPair) {
+    case 'rw':
+      return p.memType === MemoryType.NonAtomicStorageClass
+        ? storageMemoryBarrierLoadStoreTestCode
+        : workgroupMemoryBarrierLoadStoreTestCode;
+    case 'wr':
+      return p.memType === MemoryType.NonAtomicStorageClass
+        ? storageMemoryBarrierStoreLoadTestCode
+        : workgroupMemoryBarrierStoreLoadTestCode;
+    case 'ww':
+      return p.memType === MemoryType.NonAtomicStorageClass
+        ? storageMemoryBarrierStoreStoreTestCode
+        : workgroupMemoryBarrierStoreStoreTestCode;
+  }
+}
+
 g.test('workgroup_barrier_store_load')
   .desc(
     `Checks whether the workgroup barrier properly synchronizes a non-atomic write and read on
@@ -63,13 +118,17 @@ g.test('workgroup_barrier_store_load')
     after the barrier to read a write from an invocation before the barrier.
     `
   )
-  .paramsSimple([
-    { memType: MemoryType.NonAtomicStorageClass, _testCode: storageMemoryBarrierStoreLoadTestCode },
-    {
-      memType: MemoryType.NonAtomicWorkgroupClass,
-      _testCode: workgroupMemoryBarrierStoreLoadTestCode,
-    },
-  ])
+  .params(u =>
+    u
+      .combine('accessValueType', kAccessValueTypes)
+      .combine('memType', kMemTypes)
+      .combine('accessPair', ['wr'] as const)
+  )
+  .beforeAllSubcases(t => {
+    if (t.params.accessValueType === 'f16') {
+      t.selectDeviceOrSkipTestCase('shader-f16');
+    }
+  })
   .fn(async t => {
     const resultCode = `
       if (r0 == 1u) {
@@ -79,7 +138,7 @@ g.test('workgroup_barrier_store_load')
       }
     `;
     const testShader = buildTestShader(
-      t.params._testCode,
+      getTestCode(t.params),
       t.params.memType,
       TestType.IntraWorkgroup
     );
@@ -92,25 +151,12 @@ g.test('workgroup_barrier_store_load')
       t,
       memoryModelTestParams,
       testShader,
-      resultShader
+      resultShader,
+      t.params.accessValueType
     );
     await memModelTester.run(15, 1);
   });
 
-const storageMemoryBarrierLoadStoreTestCode = `
-  let r0 = test_locations.value[x_0];
-  workgroupBarrier();
-  test_locations.value[x_1] = 1u;
-  atomicStore(&results.value[shuffled_workgroup * workgroupXSize + id_0].r0, r0);
-`;
-
-const workgroupMemoryBarrierLoadStoreTestCode = `
-  let r0 = wg_test_locations[x_0];
-  workgroupBarrier();
-  wg_test_locations[x_1] = 1u;
-  atomicStore(&results.value[shuffled_workgroup * workgroupXSize + id_0].r0, r0);
-`;
-
 g.test('workgroup_barrier_load_store')
   .desc(
     `Checks whether the workgroup barrier properly synchronizes a non-atomic write and read on
@@ -118,13 +164,17 @@ g.test('workgroup_barrier_load_store')
     before the barrier to not read the write from an invocation after the barrier.
     `
   )
-  .paramsSimple([
-    { memType: MemoryType.NonAtomicStorageClass, _testCode: storageMemoryBarrierLoadStoreTestCode },
-    {
-      memType: MemoryType.NonAtomicWorkgroupClass,
-      _testCode: workgroupMemoryBarrierLoadStoreTestCode,
-    },
-  ])
+  .params(u =>
+    u
+      .combine('accessValueType', kAccessValueTypes)
+      .combine('memType', kMemTypes)
+      .combine('accessPair', ['rw'] as const)
+  )
+  .beforeAllSubcases(t => {
+    if (t.params.accessValueType === 'f16') {
+      t.selectDeviceOrSkipTestCase('shader-f16');
+    }
+  })
   .fn(async t => {
     const resultCode = `
       if (r0 == 0u) {
@@ -134,7 +184,7 @@ g.test('workgroup_barrier_load_store')
       }
     `;
     const testShader = buildTestShader(
-      t.params._testCode,
+      getTestCode(t.params),
       t.params.memType,
       TestType.IntraWorkgroup
     );
@@ -147,25 +197,12 @@ g.test('workgroup_barrier_load_store')
       t,
       memoryModelTestParams,
       testShader,
-      resultShader
+      resultShader,
+      t.params.accessValueType
     );
     await memModelTester.run(12, 1);
   });
 
-const storageMemoryBarrierStoreStoreTestCode = `
-  test_locations.value[x_0] = 1u;
-  storageBarrier();
-  test_locations.value[x_1] = 2u;
-`;
-
-const workgroupMemoryBarrierStoreStoreTestCode = `
-  wg_test_locations[x_0] = 1u;
-  workgroupBarrier();
-  wg_test_locations[x_1] = 2u;
-  workgroupBarrier();
-  test_locations.value[shuffled_workgroup * workgroupXSize * stress_params.mem_stride * 2u + x_1] = wg_test_locations[x_1];
-`;
-
 g.test('workgroup_barrier_store_store')
   .desc(
     `Checks whether the workgroup barrier properly synchronizes non-atomic writes on
@@ -173,16 +210,17 @@ g.test('workgroup_barrier_store_store')
     to be the result of the write after the barrier, not the write before.
     `
   )
-  .paramsSimple([
-    {
-      memType: MemoryType.NonAtomicStorageClass,
-      _testCode: storageMemoryBarrierStoreStoreTestCode,
-    },
-    {
-      memType: MemoryType.NonAtomicWorkgroupClass,
-      _testCode: workgroupMemoryBarrierStoreStoreTestCode,
-    },
-  ])
+  .params(u =>
+    u
+      .combine('accessValueType', kAccessValueTypes)
+      .combine('memType', kMemTypes)
+      .combine('accessPair', ['ww'] as const)
+  )
+  .beforeAllSubcases(t => {
+    if (t.params.accessValueType === 'f16') {
+      t.selectDeviceOrSkipTestCase('shader-f16');
+    }
+  })
   .fn(async t => {
     const resultCode = `
       if (mem_x_0 == 2u) {
@@ -192,7 +230,7 @@ g.test('workgroup_barrier_store_store')
       }
     `;
     const testShader = buildTestShader(
-      t.params._testCode,
+      getTestCode(t.params),
       t.params.memType,
       TestType.IntraWorkgroup
     );
@@ -205,7 +243,8 @@ g.test('workgroup_barrier_store_store')
       t,
       memoryModelTestParams,
       testShader,
-      resultShader
+      resultShader,
+      t.params.accessValueType
     );
     await memModelTester.run(10, 1);
   });
diff --git a/src/webgpu/shader/execution/memory_model/memory_model_setup.ts b/src/webgpu/shader/execution/memory_model/memory_model_setup.ts
index c26f8fde29c9..d2dab32ecbb1 100644
--- a/src/webgpu/shader/execution/memory_model/memory_model_setup.ts
+++ b/src/webgpu/shader/execution/memory_model/memory_model_setup.ts
@@ -3,6 +3,18 @@ import { checkElementsPassPredicate } from '../../../util/check_contents.js';
 
 /* All buffer sizes are counted in units of 4-byte words. */
 
+/**
+ * The value type loaded and stored from memory.
+ * This is what the WGSL spec calls 'store type' for the locations being accessed.
+ * The GPU buffers are sized assuming this type is at most 4 bytes.
+ *
+ * 'u32' is the default case; it can be atomically loaded and stored.
+ * 'f16' is interesting because it is not 32-bits, and can't be the store type
+ * for atomic accesses.
+ */
+export type AccessValueType = 'f16' | 'u32';
+export const kAccessValueTypes = ['f16', 'u32'] as const;
+
 /* Parameter values are set heuristically, typically by a time-intensive search. */
 export type MemoryModelTestParams = {
   /* Number of invocations per workgroup. The workgroups are 1-dimensional. */
@@ -111,14 +123,53 @@ const memLocationOffsetIndex = 11;
  */
 const bytesPerWord = 4;
 
+/**
+ * Returns the shader preamble based on the access value type:
+ *  - enable directives, if necessary
+ *  - the type alias for AccessValueType
+ */
+function shaderPreamble(accessValueType: AccessValueType): string {
+  if (accessValueType === 'f16') {
+    return 'enable f16;\nalias AccessValueTy = f16;\n';
+  }
+  return `alias AccessValueTy = ${accessValueType};\n`;
+}
+
 /**
  * Implements setup code necessary to run a memory model test. A test consists of two parts:
  *  1.) A test shader that runs a specified memory model litmus test and attempts to reveal a weak (disallowed) behavior.
  *      At a high level, a test shader consists of a set of testing workgroups where every invocation executes the litmus test
  *      on a set of test locations, and a set of stressing workgroups where every invocation accesses a specified memory location
  *      in a random pattern.
+ *
+ *      The main buffer variables are:
+ *
+ *        `test_locations`: invocations access entries in this array, trying to
+ *          evoke weak behaviours.
+ *
+ *          This is array<AccessValueTy> or array<atomic<u32>>.
+ *          AccessValueTy is either f16 or u32.
+ *          Note that atomic<u32> is only used when AccessValueTy is u32.
+ *
+ *        `results`: holds the observed values, which is where we can see
+ *          whether a weak behaviour was observed.
+ *
+ *          This is an array<atomic<u32>>.
+ *
+ *      The others are used to parameterize and stress the main activity.
+ *
  *  2.) A result shader that takes the output of the test shader, which consists of the memory locations accessed during the test
  *      and the results of any reads made during the test, and aggregate the results based on the possible behaviors of the test.
+ *
+ *      The first two buffer variables are the same buffers as for the test shader:
+ *
+ *        `test_locations` is the same as `test_locations` from the test shader,
+ *        but is mapped as array<AccessValueTy>.
+ *
+ *        `read_results` is the same buffer as `results` from the test shader.
+ *
+ *      The other variables are used to accumulate a summary that counts the weak behaviours stimulated and recorded by the
+ *      test shader.
  */
 export class MemoryModelTester {
   protected test: GPUTest;
@@ -130,10 +181,19 @@ export class MemoryModelTester {
   protected resultBindGroup: GPUBindGroup;
 
   /** Sets up a memory model test by initializing buffers and pipeline layouts. */
-  constructor(t: GPUTest, params: MemoryModelTestParams, testShader: string, resultShader: string) {
+  constructor(
+    t: GPUTest,
+    params: MemoryModelTestParams,
+    testShader: string,
+    resultShader: string,
+    accessValueType: AccessValueType = 'u32'
+  ) {
     this.test = t;
     this.params = params;
 
+    testShader = shaderPreamble(accessValueType) + testShader;
+    resultShader = shaderPreamble(accessValueType) + resultShader;
+
     // set up buffers
     const testingThreads = this.params.workgroupSize * this.params.testingWorkgroups;
     const testLocationsSize =
@@ -558,13 +618,17 @@ export class MemoryModelTester {
 /** Defines common data structures used in memory model test shaders. */
 const shaderMemStructures = `
   struct Memory {
-    value: array<u32>
+    value: array<AccessValueTy>
   };
 
   struct AtomicMemory {
     value: array<atomic<u32>>
   };
 
+  struct IndexMemory {
+    value: array<u32>
+  };
+
   struct ReadResult {
     r0: atomic<u32>,
     r1: atomic<u32>,
@@ -622,10 +686,10 @@ const twoBehaviorTestResultStructure = `
 /** Common bindings used in the test shader phase of a test. */
 const commonTestShaderBindings = `
   @group(0) @binding(1) var<storage, read_write> results : ReadResults;
-  @group(0) @binding(2) var<storage, read> shuffled_workgroups : Memory;
+  @group(0) @binding(2) var<storage, read> shuffled_workgroups : IndexMemory;
   @group(0) @binding(3) var<storage, read_write> barrier : AtomicMemory;
-  @group(0) @binding(4) var<storage, read_write> scratchpad : Memory;
-  @group(0) @binding(5) var<storage, read_write> scratch_locations : Memory;
+  @group(0) @binding(4) var<storage, read_write> scratchpad : IndexMemory;
+  @group(0) @binding(5) var<storage, read_write> scratch_locations : IndexMemory;
   @group(0) @binding(6) var<uniform> stress_params : StressParamsMemory;
 `;
 
@@ -647,7 +711,7 @@ const nonAtomicTestShaderBindings = [
 
 /** Bindings used in the result aggregation phase of the test. */
 const resultShaderBindings = `
-  @group(0) @binding(0) var<storage, read_write> test_locations : AtomicMemory;
+  @group(0) @binding(0) var<storage, read_write> test_locations : Memory;
   @group(0) @binding(1) var<storage, read_write> read_results : ReadResults;
   @group(0) @binding(2) var<storage, read_write> test_results : TestResults;
   @group(0) @binding(3) var<uniform> stress_params : StressParamsMemory;
@@ -668,7 +732,7 @@ const atomicWorkgroupMemory = `
  * is large enough to accommodate the maximum memory size needed per workgroup for testing.
  */
 const nonAtomicWorkgroupMemory = `
-  var<workgroup> wg_test_locations: array<u32, 3584>;
+  var<workgroup> wg_test_locations: array<AccessValueTy, 3584>;
 `;
 
 /**
@@ -857,11 +921,16 @@ const testShaderCommonFooter = `
 /**
  * All result shaders must calculate memory locations used in the test. Not all these locations are
  * used in every result shader, but no result shader uses more than these locations.
+ *
+ * Each value read from test_locations is converted from AccessValueTy to u32
+ * before storing it in the read result.  This assumes u32(AccessValueTy)
+ * is either an identity function u32(u32) or a value-converting overload such
+ * as u32(f16).
  */
 const resultShaderCommonCalculations = `
   let id_0 = workgroup_id[0] * workgroupXSize + local_invocation_id[0];
   let x_0 = id_0 * stress_params.mem_stride * 2u;
-  let mem_x_0 = atomicLoad(&test_locations.value[x_0]);
+  let mem_x_0 = u32(test_locations.value[x_0]);
   let r0 = atomicLoad(&read_results.value[id_0].r0);
   let r1 = atomicLoad(&read_results.value[id_0].r1);
 `;
@@ -872,7 +941,7 @@ const interWorkgroupResultShaderCode = [
   `
   let total_ids = workgroupXSize * stress_params.testing_workgroups;
   let y_0 = permute_id(id_0, stress_params.permute_second, total_ids) * stress_params.mem_stride * 2u + stress_params.location_offset;
-  let mem_y_0 = atomicLoad(&test_locations.value[y_0]);
+  let mem_y_0 = u32(test_locations.value[y_0]);
 `,
 ].join('\n');
 
@@ -882,7 +951,7 @@ const intraWorkgroupResultShaderCode = [
   `
   let total_ids = workgroupXSize;
   let y_0 = (workgroup_id[0] * workgroupXSize + permute_id(local_invocation_id[0], stress_params.permute_second, total_ids)) * stress_params.mem_stride * 2u + stress_params.location_offset;
-  let mem_y_0 = atomicLoad(&test_locations.value[y_0]);
+  let mem_y_0 = u32(test_locations.value[y_0]);
 `,
 ].join('\n');
 

From 56e1a2e473ce150fe22e29a5b8788a8be3938cca Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Fri, 13 Oct 2023 16:14:56 +0800
Subject: [PATCH 128/166] wgsl: show output values in flow_control exec tests
 error messages (#3067)

This PR make error messages in WGSL flow_control execution tests contains
full output values, in order to help seeing the whole execution trace.

Issue: #2312
---
 .../shader/execution/flow_control/harness.ts  | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/webgpu/shader/execution/flow_control/harness.ts b/src/webgpu/shader/execution/flow_control/harness.ts
index 56f3b3ddc7a8..90eab383fb35 100644
--- a/src/webgpu/shader/execution/flow_control/harness.ts
+++ b/src/webgpu/shader/execution/flow_control/harness.ts
@@ -217,6 +217,13 @@ ${main_wgsl.extra}
         // returns an Error with the given message and WGSL source
         const fail = (err: string) => Error(`${err}\nWGSL:\n${Colors.dim(Colors.blue(wgsl))}`);
 
+        // returns a string that shows the outputted values to help understand the whole trace.
+        const print_output_value = () => {
+          return `Output values (length: ${outputCount}): ${outputs.data
+            .slice(1, outputCount + 1)
+            .join(', ')}`;
+        };
+
         // returns a colorized string of the expect_order() call, highlighting
         // the event number that caused an error.
         const expect_order_err = (expectation: ExpectedEvents, err_idx: number) => {
@@ -243,27 +250,35 @@ ${main_wgsl.extra}
           const expectationIndex = outputs.data[1 + event]; // 0 is count
           if (expectationIndex >= expectations.length) {
             return fail(
-              `outputs.data[${event}] value (${expectationIndex}) exceeds number of expectations (${expectations.length})`
+              `outputs.data[${event}] value (${expectationIndex}) exceeds number of expectations (${
+                expectations.length
+              })\n${print_output_value()}`
             );
           }
           const expectation = expectations[expectationIndex];
           switch (expectation.kind) {
             case 'not-reached':
-              return fail(`expect_not_reached() reached at event ${event}\n${expectation.stack}`);
+              return fail(
+                `expect_not_reached() reached at event ${event}\n${print_output_value()}\n${
+                  expectation.stack
+                }`
+              );
             case 'events':
               if (expectation.counter >= expectation.values.length) {
                 return fail(
                   `${expect_order_err(
                     expectation,
                     expectation.counter
-                  )}) unexpectedly reached at event ${Colors.red(`${event}`)}\n${expectation.stack}`
+                  )}) unexpectedly reached at event ${Colors.red(
+                    `${event}`
+                  )}\n${print_output_value()}\n${expectation.stack}`
                 );
               }
               if (event !== expectation.values[expectation.counter]) {
                 return fail(
                   `${expect_order_err(expectation, expectation.counter)} expected event ${
                     expectation.values[expectation.counter]
-                  }, got ${event}\n${expectation.stack}`
+                  }, got ${event}\n${print_output_value()}\n${expectation.stack}`
                 );
               }
 
@@ -278,7 +293,7 @@ ${main_wgsl.extra}
             return fail(
               `${expect_order_err(expectation, expectation.counter)} event ${
                 expectation.values[expectation.counter]
-              } was not reached\n${expectation.stack}`
+              } was not reached\n${expectation.stack}\n${print_output_value()}`
             );
           }
         }

From 0a01f3897740aa83a132631f6b0523d77d882654 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 16 Oct 2023 13:45:20 -0400
Subject: [PATCH 129/166] wgsl: Correctly invoke multiplicationInterval instead
 impl directly (#3046)

This corrects issues with missing possible FTZ

Fixes #3044
---
 src/unittests/floating_point.spec.ts | 282 +++++++++++++++------------
 src/webgpu/util/floating_point.ts    |   2 +-
 2 files changed, 160 insertions(+), 124 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index d5a0a0ddcc75..62f77ecbb07e 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -7574,135 +7574,171 @@ interface MatrixScalarToMatrixCase {
   expected: (number | IntervalBounds)[][];
 }
 
+const kMultiplicationMatrixScalarIntervalCases = {
+  f32: [
+    // From https://github.com/gpuweb/cts/issues/3044
+    {
+      matrix: [
+        [kValue.f32.negative.min, 0],
+        [0, 0],
+      ],
+      scalar: kValue.f32.negative.subnormal.min,
+      expected: [
+        [[0, reinterpretU32AsF32(0x407ffffe)], 0], // [[0, 3.9999995...], 0],
+        [0, 0],
+      ],
+    },
+  ] as MatrixScalarToMatrixCase[],
+  f16: [
+    // From https://github.com/gpuweb/cts/issues/3044
+    {
+      matrix: [
+        [kValue.f16.negative.min, 0],
+        [0, 0],
+      ],
+      scalar: kValue.f16.negative.subnormal.min,
+      expected: [
+        [[0, reinterpretU16AsF16(0x43fe)], 0], // [[0, 3.99609375], 0]
+        [0, 0],
+      ],
+    },
+  ] as MatrixScalarToMatrixCase[],
+} as const;
+
 g.test('multiplicationMatrixScalarInterval')
   .params(u =>
     u
       .combine('trait', ['f32', 'f16'] as const)
       .beginSubcases()
-      .combineWithParams<MatrixScalarToMatrixCase>([
-        // Only testing that different shapes of matrices are handled correctly
-        // here, to reduce test duplication.
-        // multiplicationMatrixScalarInterval uses MultiplicationIntervalOp for calculating intervals,
-        // so the testing for multiplcationInterval covers the actual interval
+      .expandWithParams<MatrixScalarToMatrixCase>(p => {
+        // Primarily testing that different shapes of matrices are handled correctly
+        // here, to reduce test duplication. Additional testing for edge case
+        // discovered in https://github.com/gpuweb/cts/issues/3044.
+        //
+        // multiplicationMatrixScalarInterval uses for calculating intervals,
+        // so the testing for multiplicationInterval covers the actual interval
         // calculations.
-        {
-          matrix: [
-            [1, 2],
-            [3, 4],
-          ],
-          scalar: 10,
-          expected: [
-            [10, 20],
-            [30, 40],
-          ],
-        },
-        {
-          matrix: [
-            [1, 2],
-            [3, 4],
-            [5, 6],
-          ],
-          scalar: 10,
-          expected: [
-            [10, 20],
-            [30, 40],
-            [50, 60],
-          ],
-        },
-        {
-          matrix: [
-            [1, 2],
-            [3, 4],
-            [5, 6],
-            [7, 8],
-          ],
-          scalar: 10,
-          expected: [
-            [10, 20],
-            [30, 40],
-            [50, 60],
-            [70, 80],
-          ],
-        },
-        {
-          matrix: [
-            [1, 2, 3],
-            [4, 5, 6],
-          ],
-          scalar: 10,
-          expected: [
-            [10, 20, 30],
-            [40, 50, 60],
-          ],
-        },
-        {
-          matrix: [
-            [1, 2, 3],
-            [4, 5, 6],
-            [7, 8, 9],
-          ],
-          scalar: 10,
-          expected: [
-            [10, 20, 30],
-            [40, 50, 60],
-            [70, 80, 90],
-          ],
-        },
-        {
-          matrix: [
-            [1, 2, 3],
-            [4, 5, 6],
-            [7, 8, 9],
-            [10, 11, 12],
-          ],
-          scalar: 10,
-          expected: [
-            [10, 20, 30],
-            [40, 50, 60],
-            [70, 80, 90],
-            [100, 110, 120],
-          ],
-        },
-        {
-          matrix: [
-            [1, 2, 3, 4],
-            [5, 6, 7, 8],
-          ],
-          scalar: 10,
-          expected: [
-            [10, 20, 30, 40],
-            [50, 60, 70, 80],
-          ],
-        },
-        {
-          matrix: [
-            [1, 2, 3, 4],
-            [5, 6, 7, 8],
-            [9, 10, 11, 12],
-          ],
-          scalar: 10,
-          expected: [
-            [10, 20, 30, 40],
-            [50, 60, 70, 80],
-            [90, 100, 110, 120],
-          ],
-        },
-        {
-          matrix: [
-            [1, 2, 3, 4],
-            [5, 6, 7, 8],
-            [9, 10, 11, 12],
-            [13, 14, 15, 16],
-          ],
-          scalar: 10,
-          expected: [
-            [10, 20, 30, 40],
-            [50, 60, 70, 80],
-            [90, 100, 110, 120],
-            [130, 140, 150, 160],
-          ],
-        },
-      ])
+        return [
+          {
+            matrix: [
+              [1, 2],
+              [3, 4],
+            ],
+            scalar: 10,
+            expected: [
+              [10, 20],
+              [30, 40],
+            ],
+          },
+          {
+            matrix: [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+            ],
+            scalar: 10,
+            expected: [
+              [10, 20],
+              [30, 40],
+              [50, 60],
+            ],
+          },
+          {
+            matrix: [
+              [1, 2],
+              [3, 4],
+              [5, 6],
+              [7, 8],
+            ],
+            scalar: 10,
+            expected: [
+              [10, 20],
+              [30, 40],
+              [50, 60],
+              [70, 80],
+            ],
+          },
+          {
+            matrix: [
+              [1, 2, 3],
+              [4, 5, 6],
+            ],
+            scalar: 10,
+            expected: [
+              [10, 20, 30],
+              [40, 50, 60],
+            ],
+          },
+          {
+            matrix: [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+            ],
+            scalar: 10,
+            expected: [
+              [10, 20, 30],
+              [40, 50, 60],
+              [70, 80, 90],
+            ],
+          },
+          {
+            matrix: [
+              [1, 2, 3],
+              [4, 5, 6],
+              [7, 8, 9],
+              [10, 11, 12],
+            ],
+            scalar: 10,
+            expected: [
+              [10, 20, 30],
+              [40, 50, 60],
+              [70, 80, 90],
+              [100, 110, 120],
+            ],
+          },
+          {
+            matrix: [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+            ],
+            scalar: 10,
+            expected: [
+              [10, 20, 30, 40],
+              [50, 60, 70, 80],
+            ],
+          },
+          {
+            matrix: [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+            ],
+            scalar: 10,
+            expected: [
+              [10, 20, 30, 40],
+              [50, 60, 70, 80],
+              [90, 100, 110, 120],
+            ],
+          },
+          {
+            matrix: [
+              [1, 2, 3, 4],
+              [5, 6, 7, 8],
+              [9, 10, 11, 12],
+              [13, 14, 15, 16],
+            ],
+            scalar: 10,
+            expected: [
+              [10, 20, 30, 40],
+              [50, 60, 70, 80],
+              [90, 100, 110, 120],
+              [130, 140, 150, 160],
+            ],
+          },
+          ...kMultiplicationMatrixScalarIntervalCases[p.trait],
+        ];
+      })
   )
   .fn(t => {
     const matrix = t.params.matrix;
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 461810b9e540..ec3808589056 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -3748,7 +3748,7 @@ export abstract class FPTraits {
     const rows = mat[0].length;
     return this.toMatrix(
       unflatten2DArray(
-        flatten2DArray(mat).map(e => this.MultiplicationIntervalOp.impl(e, scalar)),
+        flatten2DArray(mat).map(e => this.multiplicationInterval(e, scalar)),
         cols,
         rows
       )

From cbd7ed8cc2eab96cc28d12ffb19a14f483b60376 Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Mon, 16 Oct 2023 11:03:51 -0700
Subject: [PATCH 130/166] Move listing_meta docs to docs/, clarify a few things
 (#3064)

Followup to https://github.com/gpuweb/cts/pull/2942 and
https://github.com/gpuweb/cts/pull/2936#issuecomment-1756601807
---
 docs/adding_timing_metadata.md          | 97 +++++++++++++++++++------
 src/common/tools/merge_listing_times.ts |  2 +-
 src/webgpu/listing_meta.json            |  2 +-
 tools/merge_listing_times               | 37 +---------
 4 files changed, 81 insertions(+), 57 deletions(-)

diff --git a/docs/adding_timing_metadata.md b/docs/adding_timing_metadata.md
index 056d0fb06271..fe32cead2039 100644
--- a/docs/adding_timing_metadata.md
+++ b/docs/adding_timing_metadata.md
@@ -1,7 +1,32 @@
+# Adding Timing Metadata
+
+## listing_meta.json files
+
+`listing_meta.json` files are SEMI AUTO-GENERATED.
+
+The raw data may be edited manually, to add entries or change timing values.
+
+The **list** of tests must stay up to date, so it can be used by external
+tools. This is verified by presubmit checks.
+
+The `subcaseMS` values are estimates. They can be set to 0 if for some reason
+you can't estimate the time (or there's an existing test with a long name and
+slow subcases that would result in query strings that are too long), but this
+will produce a non-fatal warning. Avoid creating new warnings whenever
+possible. Any existing failures should be fixed (eventually).
+
+### Performance
+
+Note this data is typically captured by developers using higher-end
+computers, so typical test machines might execute more slowly. For this
+reason, the WPT chunking should be configured to generate chunks much shorter
+than 5 seconds (a typical default time limit in WPT test executors) so they
+should still execute in under 5 seconds on lower-end computers.
+
 ## Problem
 
 When adding new tests to the CTS you may occasionally see an error like this
-when running `npm test` or `npm run standalone`
+when running `npm test` or `npm run standalone`:
 
 ```
 ERROR: Tests missing from listing_meta.json. Please add the new tests (set subcaseMS to 0 if you cannot estimate it):
@@ -10,7 +35,7 @@ ERROR: Tests missing from listing_meta.json. Please add the new tests (set subca
 /home/runner/work/cts/cts/src/common/util/util.ts:38
     throw new Error(msg && (typeof msg === 'string' ? msg : msg()));
           ^
-Error: 
+Error:
     at assert (/home/runner/work/cts/cts/src/common/util/util.ts:38:11)
     at crawl (/home/runner/work/cts/cts/src/common/tools/crawl.ts:155:11)
 Warning: non-zero exit code 1
@@ -25,9 +50,10 @@ What this error message is trying to tell us, is that there is no entry for
 
 These entries are estimates for the amount of time that subcases take to run,
 and are used as inputs into the WPT tooling to attempt to portion out tests into
-approximately same sized chunks.
+approximately same-sized chunks.
+
+If a value has been defaulted to 0 by someone, you will see warnings like this:
 
-If a value has been defaulted to 0 by someone, you will see warnings like this
 ```
 ...
 WARNING: subcaseMS≤0 found in listing_meta.json (allowed, but try to avoid):
@@ -38,71 +64,98 @@ WARNING: subcaseMS≤0 found in listing_meta.json (allowed, but try to avoid):
 These messages should be resolved by adding appropriate entries to the JSON
 file.
 
-## Solution
+## Solution 1 (manual, best for simple tests)
+
+If you're developing new tests and need to update this file, it is sometimes
+easiest to do so manually. Run your tests under your usual development workflow
+and see how long they take. In the standalone web runner `npm start`, the total
+time for a test case is reported on the right-hand side when the case logs are
+expanded.
+
+Record the average time per *subcase* across all cases of the test (you may need
+to compute this) into the `listing_meta.json` file.
+
+## Solution 2 (semi-automated)
 
 There exists tooling in the CTS repo for generating appropriate estimates for
 these values, though they do require some manual intervention. The rest of this
 doc will be a walkthrough of running these tools.
 
-### Default Value
+Timing data can be captured in bulk and "merged" into this file using
+the `merge_listing_times` tool. This is useful when a large number of tests
+change or otherwise a lot of tests need to be updated, but it also automates the
+manual steps above.
+
+The tool can also be used without any inputs to reformat `listing_meta.json`.
+Please read the help message of `merge_listing_times` for more information.
 
-The first step is to add a default value for entry to 
-`src/webgpu/listing_meta.json`, since there is a chicken-and-egg problem for 
-updating these values.
+### Placeholder Value
+
+If your development workflow requires a clean build, the first step is to add a
+placeholder value for entry to `src/webgpu/listing_meta.json`, since there is a
+chicken-and-egg problem for updating these values.
 
 ```
   "webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*": { "subcaseMS": 0 },
 ```
 
 (It should have a value of 0, since later tooling updates the value if the newer
-value is higher)
+value is higher.)
 
 ### Websocket Logger
 
-The first tool that needs to be run is `websocket-logger`, which uses a side
-channel from WPT to report timing data when CTS is run via a websocket. This
+The first tool that needs to be run is `websocket-logger`, which receives data
+on a WebSocket channel to capture timing data when CTS is run. This
 should be run in a separate process/terminal, since it needs to stay running
 throughout the following steps.
 
-At `tools/websocket-logger/`
+In the `tools/websocket-logger/` directory:
+
 ```
 npm ci
 npm start
 ```
 
 The output from this command will indicate where the results are being logged,
-which will be needed later
+which will be needed later. For example:
+
 ```
 ...
-Writing to wslog-2023-09-11T18-57-34.txt
+Writing to wslog-2023-09-12T18-57-34.txt
 ...
 ```
 
 ### Running CTS
 
-Now we need to run the specific cases in CTS, which requires serving the CTS 
-locally.
+Now we need to run the specific cases in CTS that we need to time.
+This should be possible under any development workflow (as long as its runtime environment, like Node, supports WebSockets), but the most well-tested way is using the standalone web runner.
+
+This requires serving the CTS locally. In the project root:
 
-At project root
 ```
 npm run standalone
 npm start
 ```
 
 Once this is started you can then direct a WebGPU enabled browser to the
-specific CTS entry and run the tests, for example
+specific CTS entry and run the tests, for example:
+
 ```
-http://127.0.0.1:8080/standalone/q?webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*
+http://localhost:8080/standalone/?q=webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*
 ```
 
+If the tests have a high variance in runtime, you can run them multiple times.
+The longest recorded time will be used.
+
 ### Merging metadata
 
 The final step is to merge the new data that has been captured into the JSON
 file.
 
-This can be done using the following command
+This can be done using the following command:
+
 ```
-tools/merge_listing_times webgpu -- tools/websocket-logger/wslog-2023-09-11T18-57-34.txt
+tools/merge_listing_times webgpu -- tools/websocket-logger/wslog-2023-09-12T18-57-34.txt
 ```
 
 where the text file is the result file from websocket-logger.
diff --git a/src/common/tools/merge_listing_times.ts b/src/common/tools/merge_listing_times.ts
index 0a32b3c520be..fb33ae20fb38 100644
--- a/src/common/tools/merge_listing_times.ts
+++ b/src/common/tools/merge_listing_times.ts
@@ -50,7 +50,7 @@ How to generate TIMING_LOG_FILES files:
 }
 
 const kHeader = `{
-  "_comment": "SEMI AUTO-GENERATED: Please read tools/merge_listing_times.",
+  "_comment": "SEMI AUTO-GENERATED: Please read docs/adding_timing_metadata.md.",
 `;
 const kFooter = `\
   "_end": ""
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 48ebd1a6d25a..9c61a3976c2e 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1,5 +1,5 @@
 {
-  "_comment": "SEMI AUTO-GENERATED: Please read tools/merge_listing_times.",
+  "_comment": "SEMI AUTO-GENERATED: Please read docs/adding_timing_metadata.md.",
   "webgpu:api,operation,adapter,requestAdapter:requestAdapter:*": { "subcaseMS": 152.083 },
   "webgpu:api,operation,adapter,requestAdapter:requestAdapter_no_parameters:*": { "subcaseMS": 384.601 },
   "webgpu:api,operation,adapter,requestAdapterInfo:adapter_info:*": { "subcaseMS": 136.601 },
diff --git a/tools/merge_listing_times b/tools/merge_listing_times
index f84bc9736310..a9bcd2e71ae8 100755
--- a/tools/merge_listing_times
+++ b/tools/merge_listing_times
@@ -1,38 +1,9 @@
 #!/usr/bin/env node
 
+// See `docs/adding_timing_metadata.md` for an explanation of listing times, and
+// a walkthrough on adding entries for new tests.
+
 require('../src/common/tools/setup-ts-in-node.js');
 
-// See help message in this file for info on how to use the tool.
+// See the help message in this file for info on how to use the tool.
 require('../src/common/tools/merge_listing_times.ts');
-
-// See docs/adding_timing_metadata.md for a basic walkthrough on adding entries
-// for new tests
-//
-// ## listing_meta.json File Maintenance ##
-//
-// listing_meta.json files are SEMI AUTO-GENERATED.
-//
-// The raw data may be edited manually, to add entries or change timing values.
-// This is a complete listing of tests in the CTS, which can be used for other
-// scripting purposes too. Presubmit checks will fail when it gets out of sync.
-//
-// The subcaseMS values are estimates. They can be set to 0 if for some reason
-// you can't estimate the time (or there's an existing test with a long name and
-// slow subcases that would result in query strings that are too long).
-//
-// If you're developing new tests and need to update this file, it may be
-// easiest to do so manually. Run your tests in your development environment and
-// see how long they take. Record the average time per *subcase* into the
-// listing_meta.json file.
-//
-// Timing data can also be captured in bulk and "merged" into this file using
-// the 'merge_listing_times' tool. This is useful when a large number of tests
-// change or otherwise a lot of tests need to be updated. It can also be used
-// without any inputs to reformat the listing_meta.json file. Please read the
-// documentation of the tool (see above) for more information.
-//
-// Finally, note this data is typically captured by developers using higher-end
-// computers, so typical test machines might execute more slowly. For this
-// reason, the WPT chunking should be configured to generate chunks much shorter
-// than 5 seconds (a typical default time limit in WPT test executors) so they
-// should still execute in under 5 seconds on lower-end computers.

From 42f3da8f186e7b680047018043afd83687f8a1a2 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 16 Oct 2023 16:50:04 -0400
Subject: [PATCH 131/166] wgsl: Use sparse version of kMinus3PiTo3Pi for atan2
 validation tests (#3072)

Reduces run time for these tests to ~1/3 of original

Fixes #3071
---
 .../expression/call/builtin/atan2.spec.ts     |  6 +++---
 .../call/builtin/const_override_validation.ts | 19 +++++++++++++++++++
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/webgpu/shader/validation/expression/call/builtin/atan2.spec.ts b/src/webgpu/shader/validation/expression/call/builtin/atan2.spec.ts
index 5de3236c3ddf..33f197069763 100644
--- a/src/webgpu/shader/validation/expression/call/builtin/atan2.spec.ts
+++ b/src/webgpu/shader/validation/expression/call/builtin/atan2.spec.ts
@@ -20,7 +20,7 @@ import { ShaderValidationTest } from '../../../shader_validation_test.js';
 import {
   fullRangeForType,
   kConstantAndOverrideStages,
-  kMinus3PiTo3Pi,
+  kSparseMinus3PiTo3Pi,
   stageSupportsType,
   unique,
   validateConstOrOverrideBuiltinEval,
@@ -42,8 +42,8 @@ Validates that constant evaluation and override evaluation of ${builtin}() rejec
       .combine('type', keysOf(kValuesTypes))
       .filter(u => stageSupportsType(u.stage, kValuesTypes[u.type]))
       .beginSubcases()
-      .expand('y', u => unique(kMinus3PiTo3Pi, fullRangeForType(kValuesTypes[u.type], 4)))
-      .expand('x', u => unique(kMinus3PiTo3Pi, fullRangeForType(kValuesTypes[u.type], 4)))
+      .expand('y', u => unique(kSparseMinus3PiTo3Pi, fullRangeForType(kValuesTypes[u.type], 4)))
+      .expand('x', u => unique(kSparseMinus3PiTo3Pi, fullRangeForType(kValuesTypes[u.type], 4)))
   )
   .beforeAllSubcases(t => {
     if (elementType(kValuesTypes[t.params.type]) === TypeF16) {
diff --git a/src/webgpu/shader/validation/expression/call/builtin/const_override_validation.ts b/src/webgpu/shader/validation/expression/call/builtin/const_override_validation.ts
index eaaec7cc129d..3c68b192a21d 100644
--- a/src/webgpu/shader/validation/expression/call/builtin/const_override_validation.ts
+++ b/src/webgpu/shader/validation/expression/call/builtin/const_override_validation.ts
@@ -67,6 +67,25 @@ export const kMinus3PiTo3Pi = [
   3 * Math.PI,
 ] as const;
 
+/// A minimal array of values ranging from -3π to 3π, with a focus on multiples
+/// of π. Used when multiple parameters are being passed in, so the number of
+/// cases becomes the square or more of this list.
+export const kSparseMinus3PiTo3Pi = [
+  -3 * Math.PI,
+  -2.5 * Math.PI,
+  -2.0 * Math.PI,
+  -1.5 * Math.PI,
+  -1.0 * Math.PI,
+  -0.5 * Math.PI,
+  0,
+  0.5 * Math.PI,
+  Math.PI,
+  1.5 * Math.PI,
+  2.0 * Math.PI,
+  2.5 * Math.PI,
+  3 * Math.PI,
+] as const;
+
 /// The evaluation stages to test
 export const kConstantAndOverrideStages = ['constant', 'override'] as const;
 

From b3cefa6ed08baa3c8167045fed11ebe1d03749bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Beaufort?= <beaufort.francois@gmail.com>
Date: Tue, 17 Oct 2023 03:48:15 +0200
Subject: [PATCH 132/166] Require depthWriteEnabled and depthCompare only for
 formats with depth (#3066)

* Require depthWriteEnabled and depthCompare only for formats with depth

* Addressed feedback

* Added timing metadata

* Address @Kangz feedback

* Add subcases
---
 package-lock.json                             | 14 +++---
 package.json                                  |  2 +-
 .../depth_stencil_state.spec.ts               | 48 +++++++++++++++++++
 src/webgpu/listing_meta.json                  |  2 +
 4 files changed, 58 insertions(+), 8 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 4ed46ad4344f..c4761e5f9aae 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -23,7 +23,7 @@
         "@types/pngjs": "^6.0.1",
         "@types/serve-index": "^1.9.1",
         "@typescript-eslint/parser": "^4.33.0",
-        "@webgpu/types": "^0.1.37",
+        "@webgpu/types": "^0.1.38",
         "ansi-colors": "4.1.1",
         "babel-plugin-add-header-comment": "^1.0.3",
         "babel-plugin-const-enum": "^1.2.0",
@@ -1262,9 +1262,9 @@
       }
     },
     "node_modules/@webgpu/types": {
-      "version": "0.1.37",
-      "resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.37.tgz",
-      "integrity": "sha512-hfndFDYk5AlZUE/qZ1kSuZHLobxzsbn7/jdJEJfmn4kg3rTM0+A+5TC/+z7lg3L74tSNEtZUVk7ojXw31wzeFw==",
+      "version": "0.1.38",
+      "resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.38.tgz",
+      "integrity": "sha512-7LrhVKz2PRh+DD7+S+PVaFd5HxaWQvoMqBbsV9fNJO1pjUs1P8bM2vQVNfk+3URTqbuTI7gkXi0rfsN0IadoBA==",
       "dev": true
     },
     "node_modules/abbrev": {
@@ -9883,9 +9883,9 @@
       }
     },
     "@webgpu/types": {
-      "version": "0.1.37",
-      "resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.37.tgz",
-      "integrity": "sha512-hfndFDYk5AlZUE/qZ1kSuZHLobxzsbn7/jdJEJfmn4kg3rTM0+A+5TC/+z7lg3L74tSNEtZUVk7ojXw31wzeFw==",
+      "version": "0.1.38",
+      "resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.38.tgz",
+      "integrity": "sha512-7LrhVKz2PRh+DD7+S+PVaFd5HxaWQvoMqBbsV9fNJO1pjUs1P8bM2vQVNfk+3URTqbuTI7gkXi0rfsN0IadoBA==",
       "dev": true
     },
     "abbrev": {
diff --git a/package.json b/package.json
index 95b154261260..32c73858ef81 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,7 @@
     "@types/pngjs": "^6.0.1",
     "@types/serve-index": "^1.9.1",
     "@typescript-eslint/parser": "^4.33.0",
-    "@webgpu/types": "^0.1.37",
+    "@webgpu/types": "^0.1.38",
     "ansi-colors": "4.1.1",
     "babel-plugin-add-header-comment": "^1.0.3",
     "babel-plugin-const-enum": "^1.2.0",
diff --git a/src/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.ts b/src/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.ts
index 3f59f7f3630d..c8c42146456f 100644
--- a/src/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.ts
+++ b/src/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.ts
@@ -32,6 +32,54 @@ g.test('format')
     t.doCreateRenderPipelineTest(isAsync, !!info.depth || !!info.stencil, descriptor);
   });
 
+g.test('depthCompare_optional')
+  .desc(
+    `The depthCompare in depthStencilState is optional for stencil-only formats but required for formats with a depth.`
+  )
+  .params(u =>
+    u
+      .combine('isAsync', [false, true])
+      .combine('format', kDepthStencilFormats)
+      .beginSubcases()
+      .combine('depthCompare', ['always', undefined] as const)
+  )
+  .beforeAllSubcases(t => {
+    const { format } = t.params;
+    const info = kTextureFormatInfo[format];
+    t.skipIfTextureFormatNotSupported(format);
+    t.selectDeviceOrSkipTestCase(info.feature);
+  })
+  .fn(t => {
+    const { isAsync, format, depthCompare } = t.params;
+    const info = kTextureFormatInfo[format];
+    const descriptor = t.getDescriptor({
+      depthStencil: { format, depthCompare, depthWriteEnabled: false },
+    });
+
+    t.doCreateRenderPipelineTest(isAsync, !(info.depth && depthCompare === undefined), descriptor);
+  });
+
+g.test('depthWriteEnabled_optional')
+  .desc(
+    `The depthWriteEnabled in depthStencilState is optional for stencil-only formats but required for formats with a depth.`
+  )
+  .params(u => u.combine('isAsync', [false, true]).combine('format', kDepthStencilFormats))
+  .beforeAllSubcases(t => {
+    const { format } = t.params;
+    const info = kTextureFormatInfo[format];
+    t.skipIfTextureFormatNotSupported(format);
+    t.selectDeviceOrSkipTestCase(info.feature);
+  })
+  .fn(t => {
+    const { isAsync, format } = t.params;
+    const info = kTextureFormatInfo[format];
+    const descriptor = t.getDescriptor({
+      depthStencil: { format, depthCompare: 'always', depthWriteEnabled: undefined },
+    });
+
+    t.doCreateRenderPipelineTest(isAsync, !info.depth, descriptor);
+  });
+
 g.test('depth_test')
   .desc(
     `Depth aspect must be contained in the format if depth test is enabled in depthStencilState.`
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 9c61a3976c2e..3e6856ef9693 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -676,6 +676,8 @@
   "webgpu:api,validation,render_pass,render_pass_descriptor:timestampWrite,query_index:*": { "subcaseMS": 0.200 },
   "webgpu:api,validation,render_pass,render_pass_descriptor:timestampWrites,query_set_type:*": { "subcaseMS": 0.501 },
   "webgpu:api,validation,render_pass,resolve:resolve_attachment:*": { "subcaseMS": 6.205 },
+  "webgpu:api,validation,render_pipeline,depth_stencil_state:depthCompare_optional:*": { "subcaseMS": 21.401 },
+  "webgpu:api,validation,render_pipeline,depth_stencil_state:depthWriteEnabled_optional:*": { "subcaseMS": 16.950 },
   "webgpu:api,validation,render_pipeline,depth_stencil_state:depth_test:*": { "subcaseMS": 3.407 },
   "webgpu:api,validation,render_pipeline,depth_stencil_state:depth_write,frag_depth:*": { "subcaseMS": 6.465 },
   "webgpu:api,validation,render_pipeline,depth_stencil_state:depth_write:*": { "subcaseMS": 4.113 },

From 6696b0e2df59ae2bb5a29a7b1dbb50e4109b6b55 Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Tue, 17 Oct 2023 11:19:42 +0800
Subject: [PATCH 133/166] wgsl: make expectation id strat from 1 in
 flow_control exec tests (#3068)

This PR make expectation id start from 1 instead of 0 to be distinguishable
from initializaed 0 value. And also improve the generated WGSL shader's
readability by adding expectation details in comments next to push_output.

Issue: #2312
---
 .../shader/execution/flow_control/harness.ts      | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/webgpu/shader/execution/flow_control/harness.ts b/src/webgpu/shader/execution/flow_control/harness.ts
index 90eab383fb35..8de19fda8e8a 100644
--- a/src/webgpu/shader/execution/flow_control/harness.ts
+++ b/src/webgpu/shader/execution/flow_control/harness.ts
@@ -119,14 +119,16 @@ export function runFlowControlTest(
         values: expected,
         counter: 0,
       });
-      return `push_output(${expectations.length - 1});`;
+      // Expectation id starts from 1 to distinguish from initialization 0.
+      return `push_output(${expectations.length}); // expect_order(${expected.join(', ')})`;
     },
     expect_not_reached: () => {
       expectations.push({
         kind: 'not-reached',
         stack: Error().stack,
       });
-      return `push_output(${expectations.length - 1});`;
+      // Expectation id starts from 1 to distinguish from initialization 0.
+      return `push_output(${expectations.length}); // expect_not_reached()`;
     },
   });
 
@@ -247,7 +249,14 @@ ${main_wgsl.extra}
         // Each of the outputted values represents an event
         // Check that each event is as expected
         for (let event = 0; event < outputCount; event++) {
-          const expectationIndex = outputs.data[1 + event]; // 0 is count
+          const eventValue = outputs.data[1 + event]; // outputs.data[0] is count
+          // Expectation id starts from 1, and 0 is invalid value.
+          if (eventValue === 0) {
+            return fail(
+              `outputs.data[${event}] is initial value 0, doesn't refer to any valid expectations)\n${print_output_value()}`
+            );
+          }
+          const expectationIndex = eventValue - 1;
           if (expectationIndex >= expectations.length) {
             return fail(
               `outputs.data[${event}] value (${expectationIndex}) exceeds number of expectations (${

From c78f0a43e79c2b0fa86dbd7775dfaed04d79b9f1 Mon Sep 17 00:00:00 2001
From: Gregg Tavares <github@greggman.com>
Date: Wed, 18 Oct 2023 10:00:47 -0700
Subject: [PATCH 134/166] Add compat moode support to cmdline.ts and server.ts

---
 src/common/runtime/cmdline.ts | 10 +++++++++-
 src/common/runtime/server.ts  | 10 +++++++++-
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/src/common/runtime/cmdline.ts b/src/common/runtime/cmdline.ts
index 463546c06d32..1fb39b68ce8c 100644
--- a/src/common/runtime/cmdline.ts
+++ b/src/common/runtime/cmdline.ts
@@ -11,7 +11,7 @@ import { LiveTestCaseResult } from '../internal/logging/result.js';
 import { parseQuery } from '../internal/query/parseQuery.js';
 import { parseExpectationsForTestQuery } from '../internal/query/query.js';
 import { Colors } from '../util/colors.js';
-import { setGPUProvider } from '../util/navigator_gpu.js';
+import { setDefaultRequestAdapterOptions, setGPUProvider } from '../util/navigator_gpu.js';
 import { assert, unreachable } from '../util/util.js';
 
 import sys from './helper/sys.js';
@@ -22,6 +22,7 @@ function usage(rc: number): never {
   tools/run_${sys.type} 'unittests:*' 'webgpu:buffers,*'
 Options:
   --colors                  Enable ANSI colors in output.
+  --compat                  Runs tests in compatibility mode.
   --coverage                Emit coverage data.
   --verbose                 Print result/log of every test as it runs.
   --list                    Print all testcase names that match the given query and exit.
@@ -99,6 +100,8 @@ for (let i = 0; i < sys.args.length; ++i) {
       quiet = true;
     } else if (a === '--unroll-const-eval-loops') {
       globalTestConfig.unrollConstEvalLoops = true;
+    } else if (a === '--compat') {
+      globalTestConfig.compatibility = true;
     } else {
       console.log('unrecognized flag: ', a);
       usage(1);
@@ -110,6 +113,11 @@ for (let i = 0; i < sys.args.length; ++i) {
 
 let codeCoverage: CodeCoverageProvider | undefined = undefined;
 
+if (globalTestConfig.compatibility) {
+  // MAINTENANCE_TODO: remove the cast once compatibilityMode is officially added
+  setDefaultRequestAdapterOptions({ compatibilityMode: true } as GPURequestAdapterOptions);
+}
+
 if (gpuProviderModule) {
   setGPUProvider(() => gpuProviderModule!.create(gpuProviderFlags));
   if (emitCoverage) {
diff --git a/src/common/runtime/server.ts b/src/common/runtime/server.ts
index d8caf001c022..8903d5a53293 100644
--- a/src/common/runtime/server.ts
+++ b/src/common/runtime/server.ts
@@ -14,7 +14,7 @@ import { parseQuery } from '../internal/query/parseQuery.js';
 import { TestQueryWithExpectation } from '../internal/query/query.js';
 import { TestTreeLeaf } from '../internal/tree.js';
 import { Colors } from '../util/colors.js';
-import { setGPUProvider } from '../util/navigator_gpu.js';
+import { setDefaultRequestAdapterOptions, setGPUProvider } from '../util/navigator_gpu.js';
 
 import sys from './helper/sys.js';
 
@@ -23,6 +23,7 @@ function usage(rc: number): never {
   tools/run_${sys.type} [OPTIONS...]
 Options:
   --colors                  Enable ANSI colors in output.
+  --compat                  Run tests in compatibility mode.
   --coverage                Add coverage data to each result.
   --data                    Path to the data cache directory.
   --verbose                 Print result/log of every test as it runs.
@@ -84,6 +85,8 @@ for (let i = 0; i < sys.args.length; ++i) {
   if (a.startsWith('-')) {
     if (a === '--colors') {
       Colors.enabled = true;
+    } else if (a === '--compat') {
+      globalTestConfig.compatibility = true;
     } else if (a === '--coverage') {
       emitCoverage = true;
     } else if (a === '--data') {
@@ -107,6 +110,11 @@ for (let i = 0; i < sys.args.length; ++i) {
 
 let codeCoverage: CodeCoverageProvider | undefined = undefined;
 
+if (globalTestConfig.compatibility) {
+  // MAINTENANCE_TODO: remove the cast once compatibilityMode is officially added
+  setDefaultRequestAdapterOptions({ compatibilityMode: true } as GPURequestAdapterOptions);
+}
+
 if (gpuProviderModule) {
   setGPUProvider(() => gpuProviderModule!.create(gpuProviderFlags));
 

From e5e7ee1d2103cd2fd592c805f42a7036df731fed Mon Sep 17 00:00:00 2001
From: jzm-intel <zhaoming.jiang@intel.com>
Date: Fri, 20 Oct 2023 15:22:21 +0800
Subject: [PATCH 135/166] wgsl: Implement validation test for parsing f16
 literal (#3059)

This PR add missing validation test for parsing f16 literal.

Issue: #1192
---
 src/webgpu/shader/validation/parse/literal.spec.ts | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/webgpu/shader/validation/parse/literal.spec.ts b/src/webgpu/shader/validation/parse/literal.spec.ts
index 25aaf71fddc8..576d646a7b09 100644
--- a/src/webgpu/shader/validation/parse/literal.spec.ts
+++ b/src/webgpu/shader/validation/parse/literal.spec.ts
@@ -287,10 +287,16 @@ const kAbstractFloat = new Set([
     .desc(
       `
 Test that valid half floats are accepted, and invalid half floats are rejected
-
-TODO: Need to inject the 'enable fp16' into the shader to enable the parsing.
 `
     )
     .params(u => u.combine('val', new Set([...kValidF16, ...kInvalidF16])).beginSubcases())
-    .unimplemented();
+    .beforeAllSubcases(t => {
+      t.selectDeviceOrSkipTestCase('shader-f16');
+    })
+    .fn(t => {
+      const { val } = t.params;
+      const code = `var test: f16 = ${val};`;
+      const extensionList = ['f16'];
+      t.expectCompileResult(kValidF16.has(val), t.wrapInEntryPoint(code, extensionList));
+    });
 }

From c2d5b057361cecba6bed8df79d819e56dc17dab3 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 23 Oct 2023 12:45:56 -0400
Subject: [PATCH 136/166] wgsl: Add AF Division execution tests (#3074)

Adds in forwarding of ULP and division interval calls to f32 for
abstract

Issue #1626
---
 src/unittests/floating_point.spec.ts          |  48 ++++--
 src/webgpu/listing_meta.json                  |   4 +
 .../expression/binary/af_division.spec.ts     | 154 ++++++++++++++++++
 src/webgpu/util/floating_point.ts             |  47 ++++--
 src/webgpu/util/math.ts                       |  16 ++
 5 files changed, 241 insertions(+), 28 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/binary/af_division.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 62f77ecbb07e..2bb30dbab7ee 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -20,6 +20,16 @@ import { UnitTest } from './unit_test.js';
 
 export const g = makeTestGroup(UnitTest);
 
+/**
+ * For ULP purposes, abstract float behaves like f32, so need to swizzle it in
+ * for expectations.
+ */
+const kFPTraitForULP = {
+  abstract: 'f32',
+  f32: 'f32',
+  f16: 'f16',
+} as const;
+
 /** Bounds indicating an expectation of unbounded error */
 const kUnboundedBounds: IntervalBounds = [Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY];
 
@@ -2079,15 +2089,16 @@ const kULPErrorValue = {
 g.test('ulpInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['abstract', 'f32', 'f16'] as const)
       .beginSubcases()
       .expandWithParams<ULPCase>(p => {
-        const constants = FP[p.trait].constants();
-        const ULPValue = kULPErrorValue[p.trait];
-        const plusOneULP = kPlusOneULPFunctions[p.trait];
-        const plusNULP = kPlusNULPFunctions[p.trait];
-        const minusOneULP = kMinusOneULPFunctions[p.trait];
-        const minusNULP = kMinusNULPFunctions[p.trait];
+        const trait = kFPTraitForULP[p.trait];
+        const constants = FP[trait].constants();
+        const ULPValue = kULPErrorValue[trait];
+        const plusOneULP = kPlusOneULPFunctions[trait];
+        const plusNULP = kPlusNULPFunctions[trait];
+        const minusOneULP = kMinusOneULPFunctions[trait];
+        const minusNULP = kMinusNULPFunctions[trait];
         // prettier-ignore
         return [
           // Edge Cases
@@ -4364,11 +4375,14 @@ const kDivisionInterval64BitsNormalCases = {
 g.test('divisionInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['abstract', 'f32', 'f16'] as const)
       .beginSubcases()
       .expandWithParams<ScalarPairToIntervalCase>(p => {
-        const trait = FP[p.trait];
-        const constants = trait.constants();
+        // This is a ULP based interval, so abstract should behave like f32, so
+        // swizzling the trait as needed.
+        const trait = p.trait === 'abstract' ? 'f32' : p.trait;
+        const fp = FP[trait];
+        const constants = fp.constants();
         // prettier-ignore
         return [
           // Representable normals
@@ -4384,7 +4398,7 @@ g.test('divisionInterval')
           { input: [-4, -2], expected: 2 },
 
           // 64-bit normals that can not be exactly represented
-          ...kDivisionInterval64BitsNormalCases[p.trait],
+          ...kDivisionInterval64BitsNormalCases[trait],
 
           // Denominator out of range
           { input: [1, constants.positive.infinity], expected: kUnboundedBounds },
@@ -4400,17 +4414,21 @@ g.test('divisionInterval')
       })
   )
   .fn(t => {
-    const trait = FP[t.params.trait];
+    // This is a ULP based interval, so abstract should behave like f32, so
+    // swizzling the trait as needed for calculating the expected result.
+    const trait = t.params.trait === 'abstract' ? 'f32' : t.params.trait;
+    const fp = FP[trait];
 
     const error = (n: number): number => {
-      return 2.5 * trait.oneULP(n);
+      return 2.5 * fp.oneULP(n);
     };
 
     const [x, y] = t.params.input;
     t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
 
-    const got = trait.divisionInterval(x, y);
+    // Do not swizzle here, so the correct implementation under test is called.
+    const expected = FP[t.params.trait].toInterval(t.params.expected);
+    const got = FP[t.params.trait].divisionInterval(x, y);
     t.expect(
       objectEquals(expected, got),
       `${t.params.trait}.divisionInterval(${x}, ${y}) returned ${got}. Expected ${expected}`
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 3e6856ef9693..486f22cf9b47 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -863,6 +863,10 @@
   "webgpu:shader,execution,expression,binary,af_comparison:less_equals:*": { "subcaseMS": 19.651 },
   "webgpu:shader,execution,expression,binary,af_comparison:less_than:*": { "subcaseMS": 19.975 },
   "webgpu:shader,execution,expression,binary,af_comparison:not_equals:*": { "subcaseMS": 19.651 },
+  "webgpu:shader,execution,expression,binary,af_division:scalar:*": { "subcaseMS": 563.200 },
+  "webgpu:shader,execution,expression,binary,af_division:scalar_vector:*": { "subcaseMS": 567.101 },
+  "webgpu:shader,execution,expression,binary,af_division:vector:*": { "subcaseMS": 237.134 },
+  "webgpu:shader,execution,expression,binary,af_division:vector_scalar:*": { "subcaseMS": 580.000 },
   "webgpu:shader,execution,expression,binary,af_matrix_addition:matrix:*": { "subcaseMS": 11169.534 },
   "webgpu:shader,execution,expression,binary,af_matrix_subtraction:matrix:*": { "subcaseMS": 14060.956 },
   "webgpu:shader,execution,expression,binary,af_multiplication:scalar:*": { "subcaseMS": 777.901 },
diff --git a/src/webgpu/shader/execution/expression/binary/af_division.spec.ts b/src/webgpu/shader/execution/expression/binary/af_division.spec.ts
new file mode 100644
index 000000000000..e473acb20d8f
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/af_division.spec.ts
@@ -0,0 +1,154 @@
+export const description = `
+Execution Tests for non-matrix AbstractFloat division expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractFloat, TypeVec } from '../../../../util/conversion.js';
+import { FP, FPVector } from '../../../../util/floating_point.js';
+import { sparseF64Range, sparseVectorF64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { abstractBinary } from './binary.js';
+
+const divisionVectorScalarInterval = (v: number[], s: number): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.divisionInterval(e, s)));
+};
+
+const divisionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.divisionInterval(s, e)));
+};
+
+export const g = makeTestGroup(GPUTest);
+
+const scalar_cases = {
+  ['scalar']: () => {
+    return FP.abstract.generateScalarPairToIntervalCases(
+      sparseF64Range(),
+      sparseF64Range(),
+      'finite',
+      FP.abstract.divisionInterval
+    );
+  },
+};
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`vec${dim}_scalar`]: () => {
+      return FP.abstract.generateVectorScalarToVectorCases(
+        sparseVectorF64Range(dim),
+        sparseF64Range(),
+        'finite',
+        divisionVectorScalarInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`scalar_vec${dim}`]: () => {
+      return FP.abstract.generateScalarVectorToVectorCases(
+        sparseF64Range(),
+        sparseVectorF64Range(dim),
+        'finite',
+        divisionScalarVectorInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/af_division', {
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
+});
+
+g.test('scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x / y, where x and y are scalars
+Accuracy: 2.5 ULP for |y| in the range [2^-126, 2^126]
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('scalar');
+    await run(
+      t,
+      abstractBinary('/'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x / y, where x and y are vectors
+Accuracy: 2.5 ULP for |y| in the range [2^-126, 2^126]
+`
+  )
+  .params(u =>
+    u.combine('inputSource', onlyConstInputSource).combine('vectorize', [2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cases = await d.get('scalar'); // Using vectorize to generate vector cases based on scalar cases
+    await run(
+      t,
+      abstractBinary('/'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector_scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x / y, where x is a vector and y is a scalar
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`vec${dim}_scalar`);
+    await run(
+      t,
+      abstractBinary('/'),
+      [TypeVec(dim, TypeAbstractFloat), TypeAbstractFloat],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('scalar_vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x / y, where x is a scalar and y is a vector
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`scalar_vec${dim}`);
+    await run(
+      t,
+      abstractBinary('/'),
+      [TypeAbstractFloat, TypeVec(dim, TypeAbstractFloat)],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index ec3808589056..efe4119fc4ba 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -40,10 +40,10 @@ import {
   map2DArray,
   oneULPF16,
   oneULPF32,
-  oneULPF64,
   quantizeToF32,
   quantizeToF16,
   unflatten2DArray,
+  every2DArray,
 } from './math.js';
 
 /** Indicate the kind of WGSL floating point numbers being operated on */
@@ -631,12 +631,19 @@ export abstract class FPTraits {
   public abstract constants(): FPConstants;
 
   // Utilities - Implemented
+
   /** @returns an interval containing the point or the original interval */
   public toInterval(n: number | IntervalBounds | FPInterval): FPInterval {
     if (n instanceof FPInterval) {
       if (n.kind === this.kind) {
         return n;
       }
+
+      // Preserve if the original interval was unbounded or bounded
+      if (!n.isFinite()) {
+        return this.constants().unboundedInterval;
+      }
+
       return new FPInterval(this.kind, ...n.bounds());
     }
 
@@ -700,7 +707,7 @@ export abstract class FPTraits {
 
   /** @returns an FPVector representation of an array of values if possible */
   public toVector(v: (number | IntervalBounds | FPInterval)[]): FPVector {
-    if (this.isVector(v)) {
+    if (this.isVector(v) && v.every(e => e.kind === this.kind)) {
       return v;
     }
 
@@ -764,7 +771,12 @@ export abstract class FPTraits {
 
   /** @returns an FPMatrix representation of an array of an array of values if possible */
   public toMatrix(m: Array2D<number | IntervalBounds | FPInterval> | FPVector[]): FPMatrix {
-    if (this.isMatrix(m)) {
+    if (
+      this.isMatrix(m) &&
+      every2DArray(m, (e: FPInterval) => {
+        return e.kind === this.kind;
+      })
+    ) {
       return m;
     }
 
@@ -3228,11 +3240,10 @@ export abstract class FPTraits {
 
   // This op is implemented differently for f32 and f16.
   private DivisionIntervalOpBuilder(): ScalarPairToIntervalOp {
-    assert(this.kind === 'f32' || this.kind === 'f16');
     const constants = this.constants();
     const domain_x = [this.toInterval([constants.negative.min, constants.positive.max])];
     const domain_y =
-      this.kind === 'f32'
+      this.kind === 'f32' || this.kind === 'abstract'
         ? [this.toInterval([-(2 ** 126), -(2 ** -126)]), this.toInterval([2 ** -126, 2 ** 126])]
         : [this.toInterval([-(2 ** 14), -(2 ** -14)]), this.toInterval([2 ** -14, 2 ** 14])];
     return {
@@ -3259,7 +3270,6 @@ export abstract class FPTraits {
   }
 
   protected divisionIntervalImpl(x: number | FPInterval, y: number | FPInterval): FPInterval {
-    assert(this.kind === 'f32' || this.kind === 'f16');
     return this.runScalarPairToIntervalOp(
       this.toInterval(x),
       this.toInterval(y),
@@ -4727,6 +4737,10 @@ class F32Traits extends FPTraits {
   public readonly quantizeToF16Interval = this.quantizeToF16IntervalImpl.bind(this);
 }
 
+// Need to separately allocate f32 traits, so they can be referenced by
+// FPAbstractTraits for forwarding.
+const kF32Traits = new F32Traits();
+
 // Pre-defined values that get used multiple times in _constants' initializers. Cannot use FPTraits members, since this
 // executes before they are defined.
 const kAbstractUnboundedInterval = new FPInterval(
@@ -4930,14 +4944,18 @@ class FPAbstractTraits extends FPTraits {
   public readonly isFinite = Number.isFinite;
   public readonly isSubnormal = isSubnormalNumberF64;
   public readonly flushSubnormal = flushSubnormalNumberF64;
-  public readonly oneULP = oneULPF64;
+  public readonly oneULP = (_target: number, _mode: FlushMode = 'flush'): number => {
+    unreachable(`'FPAbstractTraits.oneULP should never be called`);
+  };
   public readonly scalarBuilder = abstractFloat;
 
   // Framework - Fundamental Error Intervals - Overrides
   public readonly absoluteErrorInterval = this.unboundedAbsoluteErrorInterval.bind(this);
   public readonly correctlyRoundedInterval = this.correctlyRoundedIntervalImpl.bind(this);
   public readonly correctlyRoundedMatrix = this.correctlyRoundedMatrixImpl.bind(this);
-  public readonly ulpInterval = this.unboundedUlpInterval.bind(this);
+  public readonly ulpInterval = (n: number, numULP: number): FPInterval => {
+    return this.toInterval(kF32Traits.ulpInterval(n, numULP));
+  };
 
   // Framework - API - Overrides
   public readonly absInterval = this.absIntervalImpl.bind(this);
@@ -4974,10 +4992,13 @@ class FPAbstractTraits extends FPTraits {
     'determinantInterval'
   );
   public readonly distanceInterval = this.unimplementedDistance.bind(this);
-  public readonly divisionInterval = this.unimplementedScalarPairToInterval.bind(
-    this,
-    'divisionInterval'
-  );
+  public readonly divisionInterval = (
+    x: number | FPInterval,
+    y: number | FPInterval
+  ): FPInterval => {
+    return this.toInterval(kF32Traits.divisionInterval(x, y));
+  };
+
   public readonly dotInterval = this.unimplementedVectorPairToInterval.bind(this, 'dotInterval');
   public readonly expInterval = this.unimplementedScalarToInterval.bind(this, 'expInterval');
   public readonly exp2Interval = this.unimplementedScalarToInterval.bind(this, 'exp2Interval');
@@ -5364,7 +5385,7 @@ class F16Traits extends FPTraits {
 }
 
 export const FP = {
-  f32: new F32Traits(),
+  f32: kF32Traits,
   f16: new F16Traits(),
   abstract: new FPAbstractTraits(),
 };
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index cc7b5e44a99f..1fb1d1a7ff69 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -2241,3 +2241,19 @@ export function map2DArray<T, S>(m: T[][], op: (input: T) => S): S[][] {
   }
   return result;
 }
+
+/**
+ * Performs a .every over a matrix and return the result
+ *
+ * @param m input matrix of type T
+ * @param op operation that performs a test on an element
+ * @returns a boolean indicating if the test passed for every element
+ */
+export function every2DArray<T>(m: T[][], op: (input: T) => boolean): boolean {
+  const r = m[0].length;
+  assert(
+    m.every(c => c.length === r),
+    `Unexpectedly received jagged array to map`
+  );
+  return m.every(col => col.every(el => op(el)));
+}

From 2757809159f4f5c482a5b700858d6f425d930e7e Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 23 Oct 2023 14:02:50 -0400
Subject: [PATCH 137/166] wgsl: Add AF remainder (%) execution tests (#3075)

Issue #1626
---
 src/unittests/floating_point.spec.ts          |  11 +-
 src/webgpu/listing_meta.json                  |   4 +
 .../expression/binary/af_remainder.spec.ts    | 154 ++++++++++++++++++
 src/webgpu/util/floating_point.ts             |   8 +-
 4 files changed, 167 insertions(+), 10 deletions(-)
 create mode 100644 src/webgpu/shader/execution/expression/binary/af_remainder.spec.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 2bb30dbab7ee..4c32e11459af 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -4853,14 +4853,15 @@ const kRemainderCases = {
 g.test('remainderInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['abstract', 'f32', 'f16'] as const)
       .beginSubcases()
       .expandWithParams<ScalarPairToIntervalCase>(p => {
-        const trait = FP[p.trait];
-        const constants = trait.constants();
+        const trait = kFPTraitForULP[p.trait];
+        const constants = FP[trait].constants();
+
         // prettier-ignore
         return [
-          ...kRemainderCases[p.trait],
+          ...kRemainderCases[trait],
           // Normals
           { input: [0, 1], expected: 0 },
           { input: [0, -1], expected: 0 },
@@ -4901,7 +4902,7 @@ g.test('remainderInterval')
     const got = trait.remainderInterval(x, y);
     t.expect(
       objectEquals(expected, got),
-      `FP.${t.params.trait}.remainderInterval(${x}, ${y}) returned ${got}. Expected ${expected}`
+      `${t.params.trait}.remainderInterval(${x}, ${y}) returned ${got}. Expected ${expected}`
     );
   });
 
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 486f22cf9b47..867e33f82d8a 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -873,6 +873,10 @@
   "webgpu:shader,execution,expression,binary,af_multiplication:scalar_vector:*": { "subcaseMS": 2025.534 },
   "webgpu:shader,execution,expression,binary,af_multiplication:vector:*": { "subcaseMS": 710.667 },
   "webgpu:shader,execution,expression,binary,af_multiplication:vector_scalar:*": { "subcaseMS": 2085.300 },
+  "webgpu:shader,execution,expression,binary,af_remainder:scalar:*": { "subcaseMS": 1103.701 },
+  "webgpu:shader,execution,expression,binary,af_remainder:scalar_vector:*": { "subcaseMS": 756.800 },
+  "webgpu:shader,execution,expression,binary,af_remainder:vector:*": { "subcaseMS": 299.701 },
+  "webgpu:shader,execution,expression,binary,af_remainder:vector_scalar:*": { "subcaseMS": 777.701 },
   "webgpu:shader,execution,expression,binary,af_subtraction:scalar:*": { "subcaseMS": 854.100 },
   "webgpu:shader,execution,expression,binary,af_subtraction:scalar_vector:*": { "subcaseMS": 2336.534 },
   "webgpu:shader,execution,expression,binary,af_subtraction:vector:*": { "subcaseMS": 764.201 },
diff --git a/src/webgpu/shader/execution/expression/binary/af_remainder.spec.ts b/src/webgpu/shader/execution/expression/binary/af_remainder.spec.ts
new file mode 100644
index 000000000000..f6f343a57621
--- /dev/null
+++ b/src/webgpu/shader/execution/expression/binary/af_remainder.spec.ts
@@ -0,0 +1,154 @@
+export const description = `
+Execution Tests for non-matrix abstract float remainder expression
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractFloat, TypeVec } from '../../../../util/conversion.js';
+import { FP, FPVector } from '../../../../util/floating_point.js';
+import { sparseF64Range, sparseVectorF64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { abstractBinary } from './binary.js';
+
+const remainderVectorScalarInterval = (v: number[], s: number): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.remainderInterval(e, s)));
+};
+
+const remainderScalarVectorInterval = (s: number, v: number[]): FPVector => {
+  return FP.abstract.toVector(v.map(e => FP.abstract.remainderInterval(s, e)));
+};
+
+export const g = makeTestGroup(GPUTest);
+
+const scalar_cases = {
+  ['scalar']: () => {
+    return FP.abstract.generateScalarPairToIntervalCases(
+      sparseF64Range(),
+      sparseF64Range(),
+      'finite',
+      FP.abstract.remainderInterval
+    );
+  },
+};
+
+const vector_scalar_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`vec${dim}_scalar`]: () => {
+      return FP.abstract.generateVectorScalarToVectorCases(
+        sparseVectorF64Range(dim),
+        sparseF64Range(),
+        'finite',
+        remainderVectorScalarInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+const scalar_vector_cases = ([2, 3, 4] as const)
+  .map(dim => ({
+    [`scalar_vec${dim}`]: () => {
+      return FP.abstract.generateScalarVectorToVectorCases(
+        sparseF64Range(),
+        sparseVectorF64Range(dim),
+        'finite',
+        remainderScalarVectorInterval
+      );
+    },
+  }))
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('binary/af_remainder', {
+  ...scalar_cases,
+  ...vector_scalar_cases,
+  ...scalar_vector_cases,
+});
+
+g.test('scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x % y, where x and y are scalars
+Accuracy: Derived from x - y * trunc(x/y)
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource))
+  .fn(async t => {
+    const cases = await d.get('scalar');
+    await run(
+      t,
+      abstractBinary('%'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x % y, where x and y are vectors
+Accuracy: Derived from x - y * trunc(x/y)
+`
+  )
+  .params(u =>
+    u.combine('inputSource', onlyConstInputSource).combine('vectorize', [2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cases = await d.get('scalar'); // Using vectorize to generate vector cases based on scalar cases
+    await run(
+      t,
+      abstractBinary('%'),
+      [TypeAbstractFloat, TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases
+    );
+  });
+
+g.test('vector_scalar')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x % y, where x is a vector and y is a scalar
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`vec${dim}_scalar`);
+    await run(
+      t,
+      abstractBinary('%'),
+      [TypeVec(dim, TypeAbstractFloat), TypeAbstractFloat],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
+
+g.test('scalar_vector')
+  .specURL('https://www.w3.org/TR/WGSL/#floating-point-evaluation')
+  .desc(
+    `
+Expression: x % y, where x is a scalar and y is a vector
+Accuracy: Correctly rounded
+`
+  )
+  .params(u => u.combine('inputSource', onlyConstInputSource).combine('dim', [2, 3, 4] as const))
+  .fn(async t => {
+    const dim = t.params.dim;
+    const cases = await d.get(`scalar_vec${dim}`);
+    await run(
+      t,
+      abstractBinary('%'),
+      [TypeAbstractFloat, TypeVec(dim, TypeAbstractFloat)],
+      TypeVec(dim, TypeAbstractFloat),
+      t.params,
+      cases
+    );
+  });
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index efe4119fc4ba..e9f6271c323b 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4998,7 +4998,6 @@ class FPAbstractTraits extends FPTraits {
   ): FPInterval => {
     return this.toInterval(kF32Traits.divisionInterval(x, y));
   };
-
   public readonly dotInterval = this.unimplementedVectorPairToInterval.bind(this, 'dotInterval');
   public readonly expInterval = this.unimplementedScalarToInterval.bind(this, 'expInterval');
   public readonly exp2Interval = this.unimplementedScalarToInterval.bind(this, 'exp2Interval');
@@ -5066,10 +5065,9 @@ class FPAbstractTraits extends FPTraits {
     'reflectInterval'
   );
   public readonly refractInterval = this.unimplementedRefract.bind(this);
-  public readonly remainderInterval = this.unimplementedScalarPairToInterval.bind(
-    this,
-    'remainderInterval'
-  );
+  public readonly remainderInterval = (x: number, y: number): FPInterval => {
+    return this.toInterval(kF32Traits.remainderInterval(x, y));
+  };
   public readonly roundInterval = this.unimplementedScalarToInterval.bind(this, 'roundInterval');
   public readonly saturateInterval = this.saturateIntervalImpl.bind(this);
   public readonly signInterval = this.unimplementedScalarToInterval.bind(this, 'signInterval');

From 3148e15b94109e2dc683260ba3f72441cfe45368 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 23 Oct 2023 14:32:47 -0400
Subject: [PATCH 138/166] wgsl: Add AF `select` execution tests (#3077)

Fixes #3076
---
 .../expression/call/builtin/select.spec.ts    | 20 +++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/src/webgpu/shader/execution/expression/call/builtin/select.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/select.spec.ts
index d49a714e417b..c64f989f4218 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/select.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/select.spec.ts
@@ -30,10 +30,12 @@ import {
   vec2,
   vec3,
   vec4,
+  abstractFloat,
+  TypeAbstractFloat,
 } from '../../../../../util/conversion.js';
 import { run, CaseList, allInputSources } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -41,13 +43,17 @@ function makeBool(n: number) {
   return bool((n & 1) === 1);
 }
 
-type scalarKind = 'b' | 'f' | 'h' | 'i' | 'u';
+type scalarKind = 'b' | 'af' | 'f' | 'h' | 'i' | 'u';
 
 const dataType = {
   b: {
     type: TypeBool,
     constructor: makeBool,
   },
+  af: {
+    type: TypeAbstractFloat,
+    constructor: abstractFloat,
+  },
   f: {
     type: TypeF32,
     constructor: f32,
@@ -72,13 +78,14 @@ g.test('scalar')
   .params(u =>
     u
       .combine('inputSource', allInputSources)
-      .combine('component', ['b', 'f', 'h', 'i', 'u'] as const)
+      .combine('component', ['b', 'af', 'f', 'h', 'i', 'u'] as const)
       .combine('overload', ['scalar', 'vec2', 'vec3', 'vec4'] as const)
   )
   .beforeAllSubcases(t => {
     if (t.params.component === 'h') {
       t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
     }
+    t.skipIf(t.params.component === 'af' && t.params.inputSource !== 'const');
   })
   .fn(async t => {
     const componentType = dataType[t.params.component as scalarKind].type;
@@ -133,7 +140,7 @@ g.test('scalar')
 
     await run(
       t,
-      builtin('select'),
+      t.params.component === 'af' ? abstractBuiltin('select') : builtin('select'),
       [overload.type, overload.type, TypeBool],
       overload.type,
       t.params,
@@ -147,13 +154,14 @@ g.test('vector')
   .params(u =>
     u
       .combine('inputSource', allInputSources)
-      .combine('component', ['b', 'f', 'h', 'i', 'u'] as const)
+      .combine('component', ['b', 'af', 'f', 'h', 'i', 'u'] as const)
       .combine('overload', ['vec2', 'vec3', 'vec4'] as const)
   )
   .beforeAllSubcases(t => {
     if (t.params.component === 'h') {
       t.selectDeviceOrSkipTestCase({ requiredFeatures: ['shader-f16'] });
     }
+    t.skipIf(t.params.component === 'af' && t.params.inputSource !== 'const');
   })
   .fn(async t => {
     const componentType = dataType[t.params.component as scalarKind].type;
@@ -236,7 +244,7 @@ g.test('vector')
 
     await run(
       t,
-      builtin('select'),
+      t.params.component === 'af' ? abstractBuiltin('select') : builtin('select'),
       [tests.dataType, tests.dataType, tests.boolType],
       tests.dataType,
       t.params,

From 2499ea9a40816d152d52dc8e08a227f1d11d14be Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Mon, 23 Oct 2023 16:33:42 -0400
Subject: [PATCH 139/166] wgsl: Add AbstractFloat `sign` execution tests
 (#3081)

Fixes #2582
---
 src/unittests/floating_point.spec.ts          |  2 +-
 src/webgpu/listing_meta.json                  |  2 +-
 .../expression/call/builtin/sign.spec.ts      | 37 +++++++++++++++----
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 4c32e11459af..052ee84bc6d4 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3647,7 +3647,7 @@ g.test('saturateInterval')
 g.test('signInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarToIntervalCase>(p => {
         const constants = FP[p.trait].constants();
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index 867e33f82d8a..fa57ff978139 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -1356,7 +1356,7 @@
   "webgpu:shader,execution,expression,call,builtin,saturate:f32:*": { "subcaseMS": 116.275 },
   "webgpu:shader,execution,expression,call,builtin,select:scalar:*": { "subcaseMS": 6.882 },
   "webgpu:shader,execution,expression,call,builtin,select:vector:*": { "subcaseMS": 7.096 },
-  "webgpu:shader,execution,expression,call,builtin,sign:abstract_float:*": { "subcaseMS": 31.708 },
+  "webgpu:shader,execution,expression,call,builtin,sign:abstract_float:*": { "subcaseMS": 412.925 },
   "webgpu:shader,execution,expression,call,builtin,sign:abstract_int:*": { "subcaseMS": 25.806 },
   "webgpu:shader,execution,expression,call,builtin,sign:f16:*": { "subcaseMS": 25.103 },
   "webgpu:shader,execution,expression,call,builtin,sign:f32:*": { "subcaseMS": 8.188 },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/sign.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/sign.spec.ts
index 454ff48e6edc..a147acf6fb24 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/sign.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/sign.spec.ts
@@ -9,13 +9,24 @@ Returns the sign of e. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { i32, TypeF32, TypeF16, TypeI32 } from '../../../../../util/conversion.js';
+import {
+  i32,
+  TypeF32,
+  TypeF16,
+  TypeI32,
+  TypeAbstractFloat,
+} from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, fullF16Range, fullI32Range } from '../../../../../util/math.js';
+import {
+  fullF32Range,
+  fullF16Range,
+  fullI32Range,
+  fullF64Range,
+} from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -26,6 +37,13 @@ export const d = makeCaseCache('sign', {
   f16: () => {
     return FP.f16.generateScalarToIntervalCases(fullF16Range(), 'unfiltered', FP.f16.signInterval);
   },
+  abstract_float: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      fullF64Range(),
+      'unfiltered',
+      FP.abstract.signInterval
+    );
+  },
   i32: () =>
     fullI32Range().map(i => {
       const signFunc = (i: number): number => (i < 0 ? -1 : i > 0 ? 1 : 0);
@@ -37,13 +55,18 @@ g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#sign-builtin')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract_float');
+    await run(t, abstractBuiltin('sign'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases);
+  });
 
 g.test('abstract_int')
   .specURL('https://www.w3.org/TR/WGSL/#sign-builtin')
-  .desc(`abstract float tests`)
+  .desc(`abstract int tests`)
   .params(u =>
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index e9f6271c323b..4d2f9a324cb5 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5070,7 +5070,7 @@ class FPAbstractTraits extends FPTraits {
   };
   public readonly roundInterval = this.unimplementedScalarToInterval.bind(this, 'roundInterval');
   public readonly saturateInterval = this.saturateIntervalImpl.bind(this);
-  public readonly signInterval = this.unimplementedScalarToInterval.bind(this, 'signInterval');
+  public readonly signInterval = this.signIntervalImpl.bind(this);
   public readonly sinInterval = this.unimplementedScalarToInterval.bind(this, 'sinInterval');
   public readonly sinhInterval = this.unimplementedScalarToInterval.bind(this, 'sinhInterval');
   public readonly smoothStepInterval = this.unimplementedScalarTripleToInterval.bind(

From b3c2508028464ecbc0396a6a543fb328a55520ad Mon Sep 17 00:00:00 2001
From: Brandon Jones <tojiro@gmail.com>
Date: Mon, 23 Oct 2023 14:43:37 -0700
Subject: [PATCH 140/166] Fix a bad slice operation in image_copy stencil tests

---
 .../operation/command_buffer/image_copy.spec.ts | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/webgpu/api/operation/command_buffer/image_copy.spec.ts b/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
index f5b11534305f..9f08ffd5e46c 100644
--- a/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
+++ b/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
@@ -1088,16 +1088,19 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
 
       // Check the valid data in outputStagingBuffer once per row.
       for (let y = 0; y < copyFromOutputTextureLayout.mipSize[1]; ++y) {
+        const rowOffset = expectedStencilTextureDataBytesPerRow * y;
+        const dataStart = expectedStencilTextureDataOffset +
+                          expectedStencilTextureDataBytesPerRow *
+                            expectedStencilTextureDataRowsPerImage *
+                            stencilTextureLayer +
+                          rowOffset;
         this.expectGPUBufferValuesEqual(
           outputStagingBuffer,
           expectedStencilTextureData.slice(
-            expectedStencilTextureDataOffset +
-              expectedStencilTextureDataBytesPerRow *
-                expectedStencilTextureDataRowsPerImage *
-                stencilTextureLayer +
-              expectedStencilTextureDataBytesPerRow * y,
-            copyFromOutputTextureLayout.mipSize[0]
-          )
+            dataStart,
+            dataStart + copyFromOutputTextureLayout.mipSize[0]
+          ),
+          rowOffset
         );
       }
     }

From 3fe36f2d484d86d25af05beae0706938db30b42b Mon Sep 17 00:00:00 2001
From: Brandon Jones <tojiro@gmail.com>
Date: Mon, 23 Oct 2023 15:49:26 -0700
Subject: [PATCH 141/166] Run grunt fix

---
 .../api/operation/command_buffer/image_copy.spec.ts   | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/webgpu/api/operation/command_buffer/image_copy.spec.ts b/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
index 9f08ffd5e46c..3dc889799bb2 100644
--- a/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
+++ b/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
@@ -1089,11 +1089,12 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
       // Check the valid data in outputStagingBuffer once per row.
       for (let y = 0; y < copyFromOutputTextureLayout.mipSize[1]; ++y) {
         const rowOffset = expectedStencilTextureDataBytesPerRow * y;
-        const dataStart = expectedStencilTextureDataOffset +
-                          expectedStencilTextureDataBytesPerRow *
-                            expectedStencilTextureDataRowsPerImage *
-                            stencilTextureLayer +
-                          rowOffset;
+        const dataStart =
+          expectedStencilTextureDataOffset +
+          expectedStencilTextureDataBytesPerRow *
+            expectedStencilTextureDataRowsPerImage *
+            stencilTextureLayer +
+          rowOffset;
         this.expectGPUBufferValuesEqual(
           outputStagingBuffer,
           expectedStencilTextureData.slice(

From d4914999a0cb5cb9877f5037aa051582dd74a78e Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 24 Oct 2023 11:03:58 -0400
Subject: [PATCH 142/166] wgsl: Add AbstractFloat `floor` execution tests
 (#3084)

Issue #1297
---
 src/unittests/floating_point.spec.ts          | 12 +++-
 .../expression/call/builtin/floor.spec.ts     | 60 +++++++++----------
 .../expression/call/builtin/round.spec.ts     | 27 +++++++--
 src/webgpu/util/floating_point.ts             |  2 +-
 4 files changed, 60 insertions(+), 41 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 052ee84bc6d4..3d73d4254577 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3026,12 +3026,20 @@ const kFloorIntervalCases = {
     { input: -(2 ** 14), expected: -(2 ** 14) },
     { input: 0x8000, expected: 0x8000 }, // https://github.com/gpuweb/cts/issues/2766
   ],
+  abstract: [
+    { input: 2 ** 62, expected: 2 ** 62 },
+    { input: -(2 ** 62), expected: -(2 ** 62) },
+    {
+      input: 0x8000_0000_0000_0000,
+      expected: 0x8000_0000_0000_0000,
+    }, // https://github.com/gpuweb/cts/issues/2766
+  ],
 } as const;
 
 g.test('floorInterval')
   .params(u =>
     u
-      .combine('trait', ['f32', 'f16'] as const)
+      .combine('trait', ['f32', 'f16', 'abstract'] as const)
       .beginSubcases()
       .expandWithParams<ScalarToIntervalCase>(p => {
         const constants = FP[p.trait].constants();
@@ -3058,7 +3066,7 @@ g.test('floorInterval')
           { input: constants.negative.max, expected: -1 },
           ...kFloorIntervalCases[p.trait],
 
-          // 32-bit subnormals
+          // Subnormals
           { input: constants.positive.subnormal.max, expected: 0 },
           { input: constants.positive.subnormal.min, expected: 0 },
           { input: constants.negative.subnormal.min, expected: [-1, 0] },
diff --git a/src/webgpu/shader/execution/expression/call/builtin/floor.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/floor.spec.ts
index 9dd7f3f9a8cf..873a6772c360 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/floor.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/floor.spec.ts
@@ -9,34 +9,25 @@ Returns the floor of e. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16, TypeAbstractFloat } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range, fullF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
+const kSmallMagnitudeTestValues = [0.1, 0.9, 1.0, 1.1, 1.9, -0.1, -0.9, -1.0, -1.1, -1.9];
+
 export const d = makeCaseCache('floor', {
   f32: () => {
     return FP.f32.generateScalarToIntervalCases(
       [
-        // Small positive numbers
-        0.1,
-        0.9,
-        1.0,
-        1.1,
-        1.9,
-        // Small negative numbers
-        -0.1,
-        -0.9,
-        -1.0,
-        -1.1,
-        -1.9,
-        0x80000000, // https://github.com/gpuweb/cts/issues/2766
+        ...kSmallMagnitudeTestValues,
         ...fullF32Range(),
+        0x8000_0000, // https://github.com/gpuweb/cts/issues/2766
       ],
       'unfiltered',
       FP.f32.floorInterval
@@ -45,34 +36,39 @@ export const d = makeCaseCache('floor', {
   f16: () => {
     return FP.f16.generateScalarToIntervalCases(
       [
-        // Small positive numbers
-        0.1,
-        0.9,
-        1.0,
-        1.1,
-        1.9,
-        // Small negative numbers
-        -0.1,
-        -0.9,
-        -1.0,
-        -1.1,
-        -1.9,
-        0x8000, // https://github.com/gpuweb/cts/issues/2766
+        ...kSmallMagnitudeTestValues,
         ...fullF16Range(),
+        0x8000, // https://github.com/gpuweb/cts/issues/2766
       ],
       'unfiltered',
       FP.f16.floorInterval
     );
   },
+  abstract: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      [
+        ...kSmallMagnitudeTestValues,
+        ...fullF64Range(),
+        0x8000_0000_0000_0000, // https://github.com/gpuweb/cts/issues/2766
+      ],
+      'unfiltered',
+      FP.abstract.floorInterval
+    );
+  },
 });
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(t, abstractBuiltin('floor'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases);
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/shader/execution/expression/call/builtin/round.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/round.spec.ts
index bd40ed4b2a3e..fe81af632660 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/round.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/round.spec.ts
@@ -12,13 +12,13 @@ Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16, TypeAbstractFloat } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range, fullF64Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, run } from '../../expression.js';
+import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
 
-import { builtin } from './builtin.js';
+import { abstractBuiltin, builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -43,15 +43,30 @@ export const d = makeCaseCache('round', {
       FP.f16.roundInterval
     );
   },
+  abstract: () => {
+    return FP.abstract.generateScalarToIntervalCases(
+      [
+        0x8000_0000_0000_0000, // https://github.com/gpuweb/cts/issues/2766
+        ...fullF64Range(),
+      ],
+      'unfiltered',
+      FP.abstract.roundInterval
+    );
+  },
 });
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .unimplemented();
+  .fn(async t => {
+    const cases = await d.get('abstract');
+    await run(t, abstractBuiltin('round'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases);
+  });
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 4d2f9a324cb5..20f74483df31 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5002,7 +5002,7 @@ class FPAbstractTraits extends FPTraits {
   public readonly expInterval = this.unimplementedScalarToInterval.bind(this, 'expInterval');
   public readonly exp2Interval = this.unimplementedScalarToInterval.bind(this, 'exp2Interval');
   public readonly faceForwardIntervals = this.unimplementedFaceForward.bind(this);
-  public readonly floorInterval = this.unimplementedScalarToInterval.bind(this, 'floorInterval');
+  public readonly floorInterval = this.floorIntervalImpl.bind(this);
   public readonly fmaInterval = this.fmaIntervalImpl.bind(this);
   public readonly fractInterval = this.unimplementedScalarToInterval.bind(this, 'fractInterval');
   public readonly inverseSqrtInterval = this.unimplementedScalarToInterval.bind(

From 73bcf42aac5de60bb62e7c7b0ee2f6365612d672 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Beaufort?= <beaufort.francois@gmail.com>
Date: Tue, 24 Oct 2023 19:25:27 +0200
Subject: [PATCH 143/166] depthCompare is not required for depth attachments if
 not used (#3069)

* depthCompare is not required for depth attachments if not used

* Refactor for success

* Refactor success definition
---
 .../depth_stencil_state.spec.ts               | 42 +++++++++++++++++--
 1 file changed, 38 insertions(+), 4 deletions(-)

diff --git a/src/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.ts b/src/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.ts
index c8c42146456f..eaaf78af66f9 100644
--- a/src/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.ts
+++ b/src/webgpu/api/validation/render_pipeline/depth_stencil_state.spec.ts
@@ -34,7 +34,8 @@ g.test('format')
 
 g.test('depthCompare_optional')
   .desc(
-    `The depthCompare in depthStencilState is optional for stencil-only formats but required for formats with a depth.`
+    `The depthCompare in depthStencilState is optional for stencil-only formats but
+    required for formats with a depth if depthCompare is not used for anything.`
   )
   .params(u =>
     u
@@ -42,6 +43,9 @@ g.test('depthCompare_optional')
       .combine('format', kDepthStencilFormats)
       .beginSubcases()
       .combine('depthCompare', ['always', undefined] as const)
+      .combine('depthWriteEnabled', [false, true, undefined] as const)
+      .combine('stencilFrontDepthFailOp', ['keep', 'zero'] as const)
+      .combine('stencilBackDepthFailOp', ['keep', 'zero'] as const)
   )
   .beforeAllSubcases(t => {
     const { format } = t.params;
@@ -50,13 +54,43 @@ g.test('depthCompare_optional')
     t.selectDeviceOrSkipTestCase(info.feature);
   })
   .fn(t => {
-    const { isAsync, format, depthCompare } = t.params;
+    const {
+      isAsync,
+      format,
+      depthCompare,
+      depthWriteEnabled,
+      stencilFrontDepthFailOp,
+      stencilBackDepthFailOp,
+    } = t.params;
     const info = kTextureFormatInfo[format];
     const descriptor = t.getDescriptor({
-      depthStencil: { format, depthCompare, depthWriteEnabled: false },
+      depthStencil: {
+        format,
+        depthCompare,
+        depthWriteEnabled,
+        stencilFront: { depthFailOp: stencilFrontDepthFailOp },
+        stencilBack: { depthFailOp: stencilBackDepthFailOp },
+      },
     });
 
-    t.doCreateRenderPipelineTest(isAsync, !(info.depth && depthCompare === undefined), descriptor);
+    const depthFailOpsAreKeep =
+      stencilFrontDepthFailOp === 'keep' && stencilBackDepthFailOp === 'keep';
+    const stencilStateIsDefault = depthFailOpsAreKeep;
+    let success = true;
+    if (depthWriteEnabled || (depthCompare && depthCompare !== 'always')) {
+      if (!info.depth) success = false;
+    }
+    if (!stencilStateIsDefault) {
+      if (!info.stencil) success = false;
+    }
+    if (info.depth) {
+      if (depthWriteEnabled === undefined) success = false;
+      if (depthWriteEnabled || !depthFailOpsAreKeep) {
+        if (depthCompare === undefined) success = false;
+      }
+    }
+
+    t.doCreateRenderPipelineTest(isAsync, success, descriptor);
   });
 
 g.test('depthWriteEnabled_optional')

From 7991cc76d6443bc94b0bed8a596f4ac2bf3d1c2d Mon Sep 17 00:00:00 2001
From: Brandon Jones <tojiro@gmail.com>
Date: Tue, 24 Oct 2023 11:08:07 -0700
Subject: [PATCH 144/166] Fix a minor issue introduced in previous stencil test
 fix (#3086)

---
 src/webgpu/api/operation/command_buffer/image_copy.spec.ts | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/webgpu/api/operation/command_buffer/image_copy.spec.ts b/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
index 3dc889799bb2..ee6f5182950c 100644
--- a/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
+++ b/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
@@ -1088,20 +1088,19 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
 
       // Check the valid data in outputStagingBuffer once per row.
       for (let y = 0; y < copyFromOutputTextureLayout.mipSize[1]; ++y) {
-        const rowOffset = expectedStencilTextureDataBytesPerRow * y;
         const dataStart =
           expectedStencilTextureDataOffset +
           expectedStencilTextureDataBytesPerRow *
             expectedStencilTextureDataRowsPerImage *
             stencilTextureLayer +
-          rowOffset;
+          expectedStencilTextureDataBytesPerRow * y;
         this.expectGPUBufferValuesEqual(
           outputStagingBuffer,
           expectedStencilTextureData.slice(
             dataStart,
             dataStart + copyFromOutputTextureLayout.mipSize[0]
           ),
-          rowOffset
+          copyFromOutputTextureLayout.bytesPerRow * y
         );
       }
     }

From 8e7a9958e740c3278eb143e49317633dcaeea669 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Beaufort?= <beaufort.francois@gmail.com>
Date: Tue, 24 Oct 2023 20:12:23 +0200
Subject: [PATCH 145/166] Remove pipeline statistics query feature (#3085)

---
 .../queries/pipeline_statistics.spec.ts       | 38 ---------------
 .../command_buffer/queries/README.txt         |  4 +-
 .../features/query_types.spec.ts              |  2 +-
 .../encoding/queries/begin_end.spec.ts        | 47 +------------------
 .../encoding/queries/general.spec.ts          | 11 ++---
 .../queries/pipeline_statistics.spec.ts       | 14 ------
 6 files changed, 6 insertions(+), 110 deletions(-)
 delete mode 100644 src/stress/queries/pipeline_statistics.spec.ts
 delete mode 100644 src/webgpu/api/validation/encoding/queries/pipeline_statistics.spec.ts

diff --git a/src/stress/queries/pipeline_statistics.spec.ts b/src/stress/queries/pipeline_statistics.spec.ts
deleted file mode 100644
index ce8a16f4625a..000000000000
--- a/src/stress/queries/pipeline_statistics.spec.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-export const description = `
-Stress tests for pipeline statistics queries.
-
-TODO: pipeline statistics queries are removed from core; consider moving tests to another suite.
-`;
-
-import { makeTestGroup } from '../../common/framework/test_group.js';
-import { GPUTest } from '../../webgpu/gpu_test.js';
-
-export const g = makeTestGroup(GPUTest);
-
-g.test('render_pass_one_query_set')
-  .desc(
-    `Tests a huge number of pipeline statistics queries over a single query set in a
-single render pass.`
-  )
-  .unimplemented();
-
-g.test('render_pass_many_query_sets')
-  .desc(
-    `Tests a huge number of pipeline statistics queries over a huge number of query
-sets in a single render pass.`
-  )
-  .unimplemented();
-
-g.test('compute_pass_one_query_set')
-  .desc(
-    `Tests a huge number of pipeline statistics queries over a single query set in a
-single compute pass.`
-  )
-  .unimplemented();
-
-g.test('compute_pass_many_query_sets')
-  .desc(
-    `Tests a huge number of pipeline statistics queries over a huge number of query
-sets in a single compute pass.`
-  )
-  .unimplemented();
diff --git a/src/webgpu/api/operation/command_buffer/queries/README.txt b/src/webgpu/api/operation/command_buffer/queries/README.txt
index 68badafa20fd..8e7c22c315f1 100644
--- a/src/webgpu/api/operation/command_buffer/queries/README.txt
+++ b/src/webgpu/api/operation/command_buffer/queries/README.txt
@@ -1,7 +1,5 @@
 TODO: test the behavior of creating/using/resolving queries.
-- pipeline statistics
-  TODO: pipeline statistics queries are removed from core; consider moving tests to another suite.
 - timestamp
-- nested (e.g. timestamp or PS query inside occlusion query), if any such cases are valid. Try
+- nested (e.g. timestamp inside occlusion query), if any such cases are valid. Try
   writing to the same query set (at same or different indices), if valid. Check results make sense.
 - start a query (all types) with no draw calls
diff --git a/src/webgpu/api/validation/capability_checks/features/query_types.spec.ts b/src/webgpu/api/validation/capability_checks/features/query_types.spec.ts
index 3a0b53ef4bac..8016252b1ede 100644
--- a/src/webgpu/api/validation/capability_checks/features/query_types.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/features/query_types.spec.ts
@@ -14,7 +14,7 @@ g.test('createQuerySet')
   'timestamp-query'.
     - createQuerySet
       - type {occlusion, timestamp}
-      - x= {pipeline statistics, timestamp} query {enable, disable}
+      - x= timestamp query {enable, disable}
   `
   )
   .params(u =>
diff --git a/src/webgpu/api/validation/encoding/queries/begin_end.spec.ts b/src/webgpu/api/validation/encoding/queries/begin_end.spec.ts
index 5ce014ede57f..e1329023d7d7 100644
--- a/src/webgpu/api/validation/encoding/queries/begin_end.spec.ts
+++ b/src/webgpu/api/validation/encoding/queries/begin_end.spec.ts
@@ -1,18 +1,5 @@
 export const description = `
 Validation for encoding begin/endable queries.
-
-TODO: pipeline statistics queries are removed from core; consider moving tests to another suite.
-TODO: tests for pipeline statistics queries:
-- balance: {
-    - begin 0, end 1
-    - begin 1, end 0
-    - begin 1, end 1
-    - begin 2, end 2
-    - }
-    - x= {
-        - render pass + pipeline statistics
-        - compute pass + pipeline statistics
-        - }
 `;
 
 import { makeTestGroup } from '../../../../../common/framework/test_group.js';
@@ -119,44 +106,12 @@ g.test('nesting')
   .desc(
     `
 Tests that whether it's allowed to nest various types of queries:
-- call {occlusion, pipeline-statistics, timestamp} query in same type or other type.
+- call {occlusion, timestamp} query in same type or other type.
   `
   )
   .paramsSubcasesOnly([
     { begin: 'occlusion', nest: 'timestamp', end: 'occlusion', _valid: true },
     { begin: 'occlusion', nest: 'occlusion', end: 'occlusion', _valid: false },
-    { begin: 'occlusion', nest: 'pipeline-statistics', end: 'occlusion', _valid: true },
-    {
-      begin: 'occlusion',
-      nest: 'pipeline-statistics',
-      end: 'pipeline-statistics',
-      _valid: true,
-    },
-    {
-      begin: 'pipeline-statistics',
-      nest: 'timestamp',
-      end: 'pipeline-statistics',
-      _valid: true,
-    },
-    {
-      begin: 'pipeline-statistics',
-      nest: 'pipeline-statistics',
-      end: 'pipeline-statistics',
-      _valid: false,
-    },
-    {
-      begin: 'pipeline-statistics',
-      nest: 'occlusion',
-      end: 'pipeline-statistics',
-      _valid: true,
-    },
-    { begin: 'pipeline-statistics', nest: 'occlusion', end: 'occlusion', _valid: true },
     { begin: 'timestamp', nest: 'occlusion', end: 'occlusion', _valid: true },
-    {
-      begin: 'timestamp',
-      nest: 'pipeline-statistics',
-      end: 'pipeline-statistics',
-      _valid: true,
-    },
   ] as const)
   .unimplemented();
diff --git a/src/webgpu/api/validation/encoding/queries/general.spec.ts b/src/webgpu/api/validation/encoding/queries/general.spec.ts
index 06990400bae0..0ed2352bfd1a 100644
--- a/src/webgpu/api/validation/encoding/queries/general.spec.ts
+++ b/src/webgpu/api/validation/encoding/queries/general.spec.ts
@@ -1,10 +1,5 @@
 export const description = `
-TODO: pipeline statistics queries are removed from core; consider moving tests to another suite.
-TODO:
-- Start a pipeline statistics query in all possible encoders:
-    - queryIndex {in, out of} range for GPUQuerySet
-    - GPUQuerySet {valid, invalid, device mismatched}
-    - x ={render pass, compute pass} encoder
+Validation for encoding queries.
 `;
 
 import { makeTestGroup } from '../../../../../common/framework/test_group.js';
@@ -19,7 +14,7 @@ g.test('occlusion_query,query_type')
   .desc(
     `
 Tests that set occlusion query set with all types in render pass descriptor:
-- type {occlusion (control case), pipeline statistics, timestamp}
+- type {occlusion (control case), timestamp}
 - {undefined} for occlusion query set in render pass descriptor
   `
   )
@@ -77,7 +72,7 @@ g.test('timestamp_query,query_type_and_index')
   .desc(
     `
 Tests that write timestamp to all types of query set on all possible encoders:
-- type {occlusion, pipeline statistics, timestamp}
+- type {occlusion, timestamp}
 - queryIndex {in, out of} range for GPUQuerySet
 - x= {non-pass} encoder
   `
diff --git a/src/webgpu/api/validation/encoding/queries/pipeline_statistics.spec.ts b/src/webgpu/api/validation/encoding/queries/pipeline_statistics.spec.ts
deleted file mode 100644
index 5827f460581f..000000000000
--- a/src/webgpu/api/validation/encoding/queries/pipeline_statistics.spec.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-export const description = `
-Validation for encoding pipeline statistics queries.
-Excludes query begin/end balance and nesting (begin_end.spec.ts)
-and querySet/queryIndex (general.spec.ts).
-
-TODO: pipeline statistics queries are removed from core; consider moving tests to another suite.
-TODO:
-- Test pipelineStatistics with {undefined, empty, duplicated, full (control case)} values
-`;
-
-import { makeTestGroup } from '../../../../../common/framework/test_group.js';
-import { ValidationTest } from '../../validation_test.js';
-
-export const g = makeTestGroup(ValidationTest);

From b929ebb9bc13ee2cb1c0f7261c5c86ba512c87a4 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 24 Oct 2023 17:56:58 -0400
Subject: [PATCH 146/166] wgsl: Revert changes to `round` execution tests
 (#3090)

These were landed on the wrong branch, and are causing tests to fail
to build, because some of the code that they depend on is implemented
in a PR that hasn't landed yet.
---
 .../expression/call/builtin/round.spec.ts     | 27 +++++--------------
 1 file changed, 6 insertions(+), 21 deletions(-)

diff --git a/src/webgpu/shader/execution/expression/call/builtin/round.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/round.spec.ts
index fe81af632660..bd40ed4b2a3e 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/round.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/round.spec.ts
@@ -12,13 +12,13 @@ Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { TypeF32, TypeF16, TypeAbstractFloat } from '../../../../../util/conversion.js';
+import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
-import { fullF32Range, fullF16Range, fullF64Range } from '../../../../../util/math.js';
+import { fullF32Range, fullF16Range } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
-import { allInputSources, onlyConstInputSource, run } from '../../expression.js';
+import { allInputSources, run } from '../../expression.js';
 
-import { abstractBuiltin, builtin } from './builtin.js';
+import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -43,30 +43,15 @@ export const d = makeCaseCache('round', {
       FP.f16.roundInterval
     );
   },
-  abstract: () => {
-    return FP.abstract.generateScalarToIntervalCases(
-      [
-        0x8000_0000_0000_0000, // https://github.com/gpuweb/cts/issues/2766
-        ...fullF64Range(),
-      ],
-      'unfiltered',
-      FP.abstract.roundInterval
-    );
-  },
 });
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
   .desc(`abstract float tests`)
   .params(u =>
-    u
-      .combine('inputSource', onlyConstInputSource)
-      .combine('vectorize', [undefined, 2, 3, 4] as const)
+    u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
-  .fn(async t => {
-    const cases = await d.get('abstract');
-    await run(t, abstractBuiltin('round'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases);
-  });
+  .unimplemented();
 
 g.test('f32')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')

From 24055936ff66119932e4802b823e9283c244bdd4 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 25 Oct 2023 10:05:00 -0400
Subject: [PATCH 147/166] wgsl: Filter `atan2` tests based on if const-eval or
 not (#3089)

Rewrites how test cases are generated for atan2, so that if running in
const-eval unbounded results will not be generated, since those will
cause compilation errors.

Fixes #3088
---
 .../expression/call/builtin/atan2.spec.ts     | 58 ++++++++-----------
 1 file changed, 25 insertions(+), 33 deletions(-)

diff --git a/src/webgpu/shader/execution/expression/call/builtin/atan2.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/atan2.spec.ts
index 3ccdcae67ecc..fbace73dd204 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/atan2.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/atan2.spec.ts
@@ -9,7 +9,6 @@ Returns the arc tangent of e1 over e2. Component-wise when T is a vector.
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
 import { GPUTest } from '../../../../../gpu_test.js';
-import { kValue } from '../../../../../util/constants.js';
 import { TypeF32, TypeF16 } from '../../../../../util/conversion.js';
 import { FP } from '../../../../../util/floating_point.js';
 import { linearRange, sparseF32Range, sparseF16Range } from '../../../../../util/math.js';
@@ -20,36 +19,29 @@ import { builtin } from './builtin.js';
 
 export const g = makeTestGroup(GPUTest);
 
-export const d = makeCaseCache('atan2', {
-  f32: () => {
-    // Using sparse range since there are N^2 cases being generated, and also including extra values
-    // around 0, where there is a discontinuity that implementations may behave badly at.
-    const numeric_range = [
-      ...sparseF32Range(),
-      ...linearRange(kValue.f32.negative.max, kValue.f32.positive.min, 10),
-    ];
-    return FP.f32.generateScalarPairToIntervalCases(
-      numeric_range,
-      numeric_range,
-      'unfiltered',
-      FP.f32.atan2Interval
-    );
-  },
-  f16: () => {
-    // Using sparse range since there are N^2 cases being generated, and also including extra values
-    // around 0, where there is a discontinuity that implementations may behave badly at.
-    const numeric_range = [
-      ...sparseF16Range(),
-      ...linearRange(kValue.f16.negative.max, kValue.f16.positive.min, 10),
-    ];
-    return FP.f16.generateScalarPairToIntervalCases(
-      numeric_range,
-      numeric_range,
-      'unfiltered',
-      FP.f16.atan2Interval
-    );
-  },
-});
+const cases = (['f32', 'f16'] as const)
+  .flatMap(kind =>
+    ([true, false] as const).map(nonConst => ({
+      [`${kind}_${nonConst ? 'non_const' : 'const'}`]: () => {
+        const fp = FP[kind];
+        // Using sparse range since there are N^2 cases being generated, and also including extra values
+        // around 0, where there is a discontinuity that implementations may behave badly at.
+        const numeric_range = [
+          ...(kind === 'f32' ? sparseF32Range() : sparseF16Range()),
+          ...linearRange(fp.constants().negative.max, fp.constants().positive.min, 10),
+        ];
+        return fp.generateScalarPairToIntervalCases(
+          numeric_range,
+          numeric_range,
+          nonConst ? 'unfiltered' : 'finite',
+          fp.atan2Interval
+        );
+      },
+    }))
+  )
+  .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('atan2', cases);
 
 g.test('abstract_float')
   .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
@@ -72,7 +64,7 @@ TODO(#792): Decide what the ground-truth is for these tests. [1]
     u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
   )
   .fn(async t => {
-    const cases = await d.get('f32');
+    const cases = await d.get(`f32_${t.params.inputSource === 'const' ? 'const' : 'non_const'}`);
     await run(t, builtin('atan2'), [TypeF32, TypeF32], TypeF32, t.params, cases);
   });
 
@@ -86,6 +78,6 @@ g.test('f16')
     t.selectDeviceOrSkipTestCase('shader-f16');
   })
   .fn(async t => {
-    const cases = await d.get('f16');
+    const cases = await d.get(`f16_${t.params.inputSource === 'const' ? 'const' : 'non_const'}`);
     await run(t, builtin('atan2'), [TypeF16, TypeF16], TypeF16, t.params, cases);
   });

From 199c8f19b37d12192105ef8b67a5dc8e75fa8a15 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 25 Oct 2023 10:33:02 -0400
Subject: [PATCH 148/166] wgsl: Cleanup cruft related to quantizeToF16 (#3082)

This is only defined for f32, so doesn't really need to be defined in
the common super class. This allows for removing the various stub
references to it, that will never be implemented.
---
 src/unittests/floating_point.spec.ts |  2 +-
 src/webgpu/util/floating_point.ts    | 41 ++++++++++------------------
 2 files changed, 16 insertions(+), 27 deletions(-)

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index 3d73d4254577..da9110bc2d70 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -3431,7 +3431,7 @@ g.test('negationInterval')
     );
   });
 
-g.test('quantizeToF16Interval_f32')
+g.test('quantizeToF16Interval')
   .paramsSubcasesOnly<ScalarToIntervalCase>(
     // prettier-ignore
     [
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 20f74483df31..fc76f85260fa 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -4608,6 +4608,21 @@ class F32Traits extends FPTraits {
 
   // Framework - API
 
+  private readonly QuantizeToF16IntervalOp: ScalarToIntervalOp = {
+    impl: (n: number): FPInterval => {
+      const rounded = correctlyRoundedF16(n);
+      const flushed = addFlushedIfNeededF16(rounded);
+      return this.spanIntervals(...flushed.map(f => this.toInterval(f)));
+    },
+  };
+
+  protected quantizeToF16IntervalImpl(n: number): FPInterval {
+    return this.runScalarToIntervalOp(this.toInterval(n), this.QuantizeToF16IntervalOp);
+  }
+
+  /** Calculate an acceptance interval of quantizeToF16(x) */
+  public readonly quantizeToF16Interval = this.quantizeToF16IntervalImpl.bind(this);
+
   /**
    * Once-allocated ArrayBuffer/views to avoid overhead of allocation when
    * converting between numeric formats
@@ -4720,21 +4735,6 @@ class F32Traits extends FPTraits {
 
   /** Calculate an acceptance interval vector for unpack4x8unorm(x) */
   public readonly unpack4x8unormInterval = this.unpack4x8unormIntervalImpl.bind(this);
-
-  private readonly QuantizeToF16IntervalOp: ScalarToIntervalOp = {
-    impl: (n: number): FPInterval => {
-      const rounded = correctlyRoundedF16(n);
-      const flushed = addFlushedIfNeededF16(rounded);
-      return this.spanIntervals(...flushed.map(f => this.toInterval(f)));
-    },
-  };
-
-  protected quantizeToF16IntervalImpl(n: number): FPInterval {
-    return this.runScalarToIntervalOp(this.toInterval(n), this.QuantizeToF16IntervalOp);
-  }
-
-  /** Calculate an acceptance interval of quantizeToF16(x) */
-  public readonly quantizeToF16Interval = this.quantizeToF16IntervalImpl.bind(this);
 }
 
 // Need to separately allocate f32 traits, so they can be referenced by
@@ -5055,10 +5055,6 @@ class FPAbstractTraits extends FPTraits {
     'normalizeInterval'
   );
   public readonly powInterval = this.unimplementedScalarPairToInterval.bind(this, 'powInterval');
-  public readonly quantizeToF16Interval = this.unimplementedScalarToInterval.bind(
-    this,
-    'quantizeToF16Interval'
-  );
   public readonly radiansInterval = this.radiansIntervalImpl.bind(this);
   public readonly reflectInterval = this.unimplementedVectorPairToVector.bind(
     this,
@@ -5353,7 +5349,6 @@ class F16Traits extends FPTraits {
   public readonly negationInterval = this.negationIntervalImpl.bind(this);
   public readonly normalizeInterval = this.normalizeIntervalImpl.bind(this);
   public readonly powInterval = this.powIntervalImpl.bind(this);
-  public readonly quantizeToF16Interval = this.quantizeToF16IntervalNotAvailable.bind(this);
   public readonly radiansInterval = this.radiansIntervalImpl.bind(this);
   public readonly reflectInterval = this.reflectIntervalImpl.bind(this);
   public readonly refractInterval = this.refractIntervalImpl.bind(this);
@@ -5374,12 +5369,6 @@ class F16Traits extends FPTraits {
   public readonly tanhInterval = this.tanhIntervalImpl.bind(this);
   public readonly transposeInterval = this.transposeIntervalImpl.bind(this);
   public readonly truncInterval = this.truncIntervalImpl.bind(this);
-
-  /** quantizeToF16 has no f16 overload. */
-  private quantizeToF16IntervalNotAvailable(n: number): FPInterval {
-    unreachable("quantizeToF16 don't have f16 overload.");
-    return kF16UnboundedInterval;
-  }
 }
 
 export const FP = {

From 1281ee140066822ddf48d074c52eae54bdc84786 Mon Sep 17 00:00:00 2001
From: Antonio Maiorano <amaiorano@google.com>
Date: Wed, 25 Oct 2023 12:04:34 -0400
Subject: [PATCH 149/166] Add back generate-cache grunt command (#3091)

This was accidentally removed in
https://github.com/gpuweb/cts/commit/30c129e2ed4a61149eeb697d8abd6cb155b3e70f
---
 Gruntfile.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Gruntfile.js b/Gruntfile.js
index 51b4971a06bf..9bb14e2f14c2 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -38,6 +38,10 @@ module.exports = function (grunt) {
         cmd: 'node',
         args: ['tools/gen_wpt_cts_html', 'tools/gen_wpt_cfg_chunked2sec.json'],
       },
+      'generate-cache': {
+        cmd: 'node',
+        args: ['tools/gen_cache', 'out', 'src/webgpu'],
+      },
       unittest: {
         cmd: 'node',
         args: ['tools/run_node', 'unittests:*'],

From 42e6b6d54587a786e0618d717c51d04427a03222 Mon Sep 17 00:00:00 2001
From: Austin Eng <enga@chromium.org>
Date: Wed, 25 Oct 2023 12:14:00 -0700
Subject: [PATCH 150/166] Slim down on typed array allocations in conversion.ts
 (#3092)

* Slim down on typed array allocations in conversion.ts

* Add comments explaining requirements of aliased working data
---
 src/webgpu/util/conversion.ts | 344 +++++++++++++++++-----------------
 1 file changed, 169 insertions(+), 175 deletions(-)

diff --git a/src/webgpu/util/conversion.ts b/src/webgpu/util/conversion.ts
index e1aa31566e38..5ee3e30c36ac 100644
--- a/src/webgpu/util/conversion.ts
+++ b/src/webgpu/util/conversion.ts
@@ -66,6 +66,24 @@ export function numbersApproximatelyEqual(a: number, b: number, maxDiff: number
   );
 }
 
+/**
+ * Once-allocated ArrayBuffer/views to avoid overhead of allocation when converting between numeric formats
+ *
+ * workingData* is shared between multiple functions in this file, so to avoid re-entrancy problems, make sure in
+ * functions that use it that they don't call themselves or other functions that use workingData*.
+ */
+const workingData = new ArrayBuffer(8);
+const workingDataU32 = new Uint32Array(workingData);
+const workingDataU16 = new Uint16Array(workingData);
+const workingDataU8 = new Uint8Array(workingData);
+const workingDataF32 = new Float32Array(workingData);
+const workingDataF16 = new Float16Array(workingData);
+const workingDataI16 = new Int16Array(workingData);
+const workingDataI32 = new Int32Array(workingData);
+const workingDataI8 = new Int8Array(workingData);
+const workingDataF64 = new Float64Array(workingData);
+const workingDataView = new DataView(workingData);
+
 /**
  * Encodes a JS `number` into an IEEE754 floating point number with the specified number of
  * sign, exponent, mantissa bits, and exponent bias.
@@ -91,9 +109,8 @@ export function float32ToFloatBits(
     return (((1 << exponentBits) - 1) << mantissaBits) | ((1 << mantissaBits) - 1);
   }
 
-  const buf = new DataView(new ArrayBuffer(Float32Array.BYTES_PER_ELEMENT));
-  buf.setFloat32(0, n, true);
-  const bits = buf.getUint32(0, true);
+  workingDataView.setFloat32(0, n, true);
+  const bits = workingDataView.getUint32(0, true);
   // bits (32): seeeeeeeefffffffffffffffffffffff
 
   // 0 or 1
@@ -165,21 +182,6 @@ export const kFloat16Format = { signed: 1, exponentBits: 5, mantissaBits: 10, bi
 /** FloatFormat for 9 bit mantissa, 5 bit exponent unsigned float */
 export const kUFloat9e5Format = { signed: 0, exponentBits: 5, mantissaBits: 9, bias: 15 } as const;
 
-/**
- * Once-allocated ArrayBuffer/views to avoid overhead of allocation when converting between numeric formats
- *
- * workingData* is shared between multiple functions in this file, so to avoid re-entrancy problems, make sure in
- * functions that use it that they don't call themselves or other functions that use workingData*.
- */
-const workingData = new ArrayBuffer(4);
-const workingDataU32 = new Uint32Array(workingData);
-const workingDataU16 = new Uint16Array(workingData);
-const workingDataU8 = new Uint8Array(workingData);
-const workingDataF32 = new Float32Array(workingData);
-const workingDataF16 = new Float16Array(workingData);
-const workingDataI16 = new Int16Array(workingData);
-const workingDataI8 = new Int8Array(workingData);
-
 /** Bitcast u32 (represented as integer Number) to f32 (represented as floating-point Number). */
 export function float32BitsToNumber(bits: number): number {
   workingDataU32[0] = bits;
@@ -531,58 +533,44 @@ export function gammaDecompress(n: number): number {
 
 /** Converts a 32-bit float value to a 32-bit unsigned integer value */
 export function float32ToUint32(f32: number): number {
-  const f32Arr = new Float32Array(1);
-  f32Arr[0] = f32;
-  const u32Arr = new Uint32Array(f32Arr.buffer);
-  return u32Arr[0];
+  workingDataF32[0] = f32;
+  return workingDataU32[0];
 }
 
 /** Converts a 32-bit unsigned integer value to a 32-bit float value */
 export function uint32ToFloat32(u32: number): number {
-  const u32Arr = new Uint32Array(1);
-  u32Arr[0] = u32;
-  const f32Arr = new Float32Array(u32Arr.buffer);
-  return f32Arr[0];
+  workingDataU32[0] = u32;
+  return workingDataF32[0];
 }
 
 /** Converts a 32-bit float value to a 32-bit signed integer value */
 export function float32ToInt32(f32: number): number {
-  const f32Arr = new Float32Array(1);
-  f32Arr[0] = f32;
-  const i32Arr = new Int32Array(f32Arr.buffer);
-  return i32Arr[0];
+  workingDataF32[0] = f32;
+  return workingDataI32[0];
 }
 
 /** Converts a 32-bit unsigned integer value to a 32-bit signed integer value */
 export function uint32ToInt32(u32: number): number {
-  const u32Arr = new Uint32Array(1);
-  u32Arr[0] = u32;
-  const i32Arr = new Int32Array(u32Arr.buffer);
-  return i32Arr[0];
+  workingDataU32[0] = u32;
+  return workingDataI32[0];
 }
 
 /** Converts a 16-bit float value to a 16-bit unsigned integer value */
 export function float16ToUint16(f16: number): number {
-  const f16Arr = new Float16Array(1);
-  f16Arr[0] = f16;
-  const u16Arr = new Uint16Array(f16Arr.buffer);
-  return u16Arr[0];
+  workingDataF16[0] = f16;
+  return workingDataU16[0];
 }
 
 /** Converts a 16-bit unsigned integer value to a 16-bit float value */
 export function uint16ToFloat16(u16: number): number {
-  const u16Arr = new Uint16Array(1);
-  u16Arr[0] = u16;
-  const f16Arr = new Float16Array(u16Arr.buffer);
-  return f16Arr[0];
+  workingDataU16[0] = u16;
+  return workingDataF16[0];
 }
 
 /** Converts a 16-bit float value to a 16-bit signed integer value */
 export function float16ToInt16(f16: number): number {
-  const f16Arr = new Float16Array(1);
-  f16Arr[0] = f16;
-  const i16Arr = new Int16Array(f16Arr.buffer);
-  return i16Arr[0];
+  workingDataF16[0] = f16;
+  return workingDataI16[0];
 }
 
 /** A type of number representable by Scalar. */
@@ -764,40 +752,48 @@ export function TypeMat(cols: number, rows: number, elementType: ScalarType): Ma
 /** Type is a ScalarType, VectorType, or MatrixType. */
 export type Type = ScalarType | VectorType | MatrixType;
 
+/** Copy bytes from `buf` at `offset` into the working data, then read it out using `workingDataOut` */
+function valueFromBytes(workingDataOut: TypedArrayBufferView, buf: Uint8Array, offset: number) {
+  for (let i = 0; i < workingDataOut.BYTES_PER_ELEMENT; ++i) {
+    workingDataU8[i] = buf[offset + i];
+  }
+  return workingDataOut[0];
+}
+
 export const TypeI32 = new ScalarType('i32', 4, (buf: Uint8Array, offset: number) =>
-  i32(new Int32Array(buf.buffer, offset)[0])
+  i32(valueFromBytes(workingDataI32, buf, offset))
 );
 export const TypeU32 = new ScalarType('u32', 4, (buf: Uint8Array, offset: number) =>
-  u32(new Uint32Array(buf.buffer, offset)[0])
+  u32(valueFromBytes(workingDataU32, buf, offset))
 );
 export const TypeAbstractFloat = new ScalarType(
   'abstract-float',
   8,
-  (buf: Uint8Array, offset: number) => abstractFloat(new Float64Array(buf.buffer, offset)[0])
+  (buf: Uint8Array, offset: number) => abstractFloat(valueFromBytes(workingDataF64, buf, offset))
 );
 export const TypeF64 = new ScalarType('f64', 8, (buf: Uint8Array, offset: number) =>
-  f64(new Float64Array(buf.buffer, offset)[0])
+  f64(valueFromBytes(workingDataF64, buf, offset))
 );
 export const TypeF32 = new ScalarType('f32', 4, (buf: Uint8Array, offset: number) =>
-  f32(new Float32Array(buf.buffer, offset)[0])
+  f32(valueFromBytes(workingDataF32, buf, offset))
 );
 export const TypeI16 = new ScalarType('i16', 2, (buf: Uint8Array, offset: number) =>
-  i16(new Int16Array(buf.buffer, offset)[0])
+  i16(valueFromBytes(workingDataI16, buf, offset))
 );
 export const TypeU16 = new ScalarType('u16', 2, (buf: Uint8Array, offset: number) =>
-  u16(new Uint16Array(buf.buffer, offset)[0])
+  u16(valueFromBytes(workingDataU16, buf, offset))
 );
 export const TypeF16 = new ScalarType('f16', 2, (buf: Uint8Array, offset: number) =>
-  f16Bits(new Uint16Array(buf.buffer, offset)[0])
+  f16Bits(valueFromBytes(workingDataU16, buf, offset))
 );
 export const TypeI8 = new ScalarType('i8', 1, (buf: Uint8Array, offset: number) =>
-  i8(new Int8Array(buf.buffer, offset)[0])
+  i8(valueFromBytes(workingDataI8, buf, offset))
 );
 export const TypeU8 = new ScalarType('u8', 1, (buf: Uint8Array, offset: number) =>
-  u8(new Uint8Array(buf.buffer, offset)[0])
+  u8(valueFromBytes(workingDataU8, buf, offset))
 );
 export const TypeBool = new ScalarType('bool', 4, (buf: Uint8Array, offset: number) =>
-  bool(new Uint32Array(buf.buffer, offset)[0] !== 0)
+  bool(valueFromBytes(workingDataU32, buf, offset) !== 0)
 );
 
 /** @returns the ScalarType from the ScalarKind */
@@ -877,12 +873,17 @@ type ScalarValue = boolean | number;
 export class Scalar {
   readonly value: ScalarValue; // The scalar value
   readonly type: ScalarType; // The type of the scalar
-  readonly bits: Uint8Array; // The scalar value packed in a Uint8Array
 
-  public constructor(type: ScalarType, value: ScalarValue, bits: TypedArrayBufferView) {
+  // The scalar value, packed in one or two 32-bit unsigned integers.
+  // Whether or not the bits1 is used depends on `this.type.size`.
+  readonly bits1: number;
+  readonly bits0: number;
+
+  public constructor(type: ScalarType, value: ScalarValue, bits1: number, bits0: number) {
     this.value = value;
     this.type = type;
-    this.bits = new Uint8Array(bits.buffer);
+    this.bits1 = bits1;
+    this.bits0 = bits0;
   }
 
   /**
@@ -892,8 +893,10 @@ export class Scalar {
    */
   public copyTo(buffer: Uint8Array, offset: number) {
     assert(this.type.kind !== 'f64', `Copying f64 values to/from buffers is not defined`);
-    for (let i = 0; i < this.bits.length; i++) {
-      buffer[offset + i] = this.bits[i];
+    workingDataU32[1] = this.bits1;
+    workingDataU32[0] = this.bits0;
+    for (let i = 0; i < this.type.size; i++) {
+      buffer[offset + i] = workingDataU8[i];
     }
   }
 
@@ -937,11 +940,12 @@ export class Scalar {
       case -Infinity:
         return Colors.bold(this.value.toString());
       default: {
-        // Uint8Array.map returns a Uint8Array, so cannot use .map directly
-        const hex = Array.from(this.bits)
-          .reverse()
-          .map(x => x.toString(16).padStart(2, '0'))
-          .join('');
+        workingDataU32[1] = this.bits1;
+        workingDataU32[0] = this.bits0;
+        let hex = '';
+        for (let i = 0; i < this.type.size; ++i) {
+          hex = workingDataU8[i].toString(16).padStart(2, '0') + hex;
+        }
         const n = this.value as Number;
         if (n !== null && isFloatValue(this)) {
           let str = this.value.toString();
@@ -979,108 +983,109 @@ export interface ScalarBuilder {
   (value: number): Scalar;
 }
 
-/** Create an AbstractFloat from a numeric value, a JS `number`. */
-export function abstractFloat(value: number): Scalar {
-  const arr = new Float64Array([value]);
-  return new Scalar(TypeAbstractFloat, arr[0], arr);
+/** Create a Scalar of `type` by storing `value` as an element of `workingDataArray` and retrieving it.
+ * The working data array *must* be an alias of `workingData`.
+ */
+function scalarFromValue(
+  type: ScalarType,
+  workingDataArray: TypedArrayBufferView,
+  value: number
+): Scalar {
+  // Clear all bits of the working data since `value` may be smaller; the upper bits should be 0.
+  workingDataU32[1] = 0;
+  workingDataU32[0] = 0;
+  workingDataArray[0] = value;
+  return new Scalar(type, workingDataArray[0], workingDataU32[1], workingDataU32[0]);
+}
+
+/** Create a Scalar of `type` by storing `value` as an element of `workingDataStoreArray` and
+ * reinterpreting it as an element of `workingDataLoadArray`.
+ * Both working data arrays *must* be aliases of `workingData`.
+ */
+function scalarFromBits(
+  type: ScalarType,
+  workingDataStoreArray: TypedArrayBufferView,
+  workingDataLoadArray: TypedArrayBufferView,
+  bits: number
+): Scalar {
+  // Clear all bits of the working data since `value` may be smaller; the upper bits should be 0.
+  workingDataU32[1] = 0;
+  workingDataU32[0] = 0;
+  workingDataStoreArray[0] = bits;
+  return new Scalar(type, workingDataLoadArray[0], workingDataU32[1], workingDataU32[0]);
 }
+
+/** Create an AbstractFloat from a numeric value, a JS `number`. */
+export const abstractFloat = (value: number): Scalar =>
+  scalarFromValue(TypeAbstractFloat, workingDataF64, value);
+
 /** Create an f64 from a numeric value, a JS `number`. */
-export function f64(value: number): Scalar {
-  const arr = new Float64Array([value]);
-  return new Scalar(TypeF64, arr[0], arr);
-}
+export const f64 = (value: number): Scalar => scalarFromValue(TypeF64, workingDataF64, value);
+
 /** Create an f32 from a numeric value, a JS `number`. */
-export function f32(value: number): Scalar {
-  const arr = new Float32Array([value]);
-  return new Scalar(TypeF32, arr[0], arr);
-}
+export const f32 = (value: number): Scalar => scalarFromValue(TypeF32, workingDataF32, value);
+
 /** Create an f16 from a numeric value, a JS `number`. */
-export function f16(value: number): Scalar {
-  const arr = new Float16Array([value]);
-  return new Scalar(TypeF16, arr[0], arr);
-}
+export const f16 = (value: number): Scalar => scalarFromValue(TypeF16, workingDataF16, value);
+
 /** Create an f32 from a bit representation, a uint32 represented as a JS `number`. */
-export function f32Bits(bits: number): Scalar {
-  const arr = new Uint32Array([bits]);
-  return new Scalar(TypeF32, new Float32Array(arr.buffer)[0], arr);
-}
+export const f32Bits = (bits: number): Scalar =>
+  scalarFromBits(TypeF32, workingDataU32, workingDataF32, bits);
+
 /** Create an f16 from a bit representation, a uint16 represented as a JS `number`. */
-export function f16Bits(bits: number): Scalar {
-  const arr = new Uint16Array([bits]);
-  return new Scalar(TypeF16, new Float16Array(arr.buffer)[0], arr);
-}
+export const f16Bits = (bits: number): Scalar =>
+  scalarFromBits(TypeF16, workingDataU16, workingDataF16, bits);
 
 /** Create an i32 from a numeric value, a JS `number`. */
-export function i32(value: number): Scalar {
-  const arr = new Int32Array([value]);
-  return new Scalar(TypeI32, arr[0], arr);
-}
+export const i32 = (value: number): Scalar => scalarFromValue(TypeI32, workingDataI32, value);
+
 /** Create an i16 from a numeric value, a JS `number`. */
-export function i16(value: number): Scalar {
-  const arr = new Int16Array([value]);
-  return new Scalar(TypeI16, arr[0], arr);
-}
+export const i16 = (value: number): Scalar => scalarFromValue(TypeI16, workingDataI16, value);
+
 /** Create an i8 from a numeric value, a JS `number`. */
-export function i8(value: number): Scalar {
-  const arr = new Int8Array([value]);
-  return new Scalar(TypeI8, arr[0], arr);
-}
+export const i8 = (value: number): Scalar => scalarFromValue(TypeI8, workingDataI8, value);
 
 /** Create an i32 from a bit representation, a uint32 represented as a JS `number`. */
-export function i32Bits(bits: number): Scalar {
-  const arr = new Uint32Array([bits]);
-  return new Scalar(TypeI32, new Int32Array(arr.buffer)[0], arr);
-}
+export const i32Bits = (bits: number): Scalar =>
+  scalarFromBits(TypeI32, workingDataU32, workingDataI32, bits);
+
 /** Create an i16 from a bit representation, a uint16 represented as a JS `number`. */
-export function i16Bits(bits: number): Scalar {
-  const arr = new Uint16Array([bits]);
-  return new Scalar(TypeI16, new Int16Array(arr.buffer)[0], arr);
-}
+export const i16Bits = (bits: number): Scalar =>
+  scalarFromBits(TypeI16, workingDataU16, workingDataI16, bits);
+
 /** Create an i8 from a bit representation, a uint8 represented as a JS `number`. */
-export function i8Bits(bits: number): Scalar {
-  const arr = new Uint8Array([bits]);
-  return new Scalar(TypeI8, new Int8Array(arr.buffer)[0], arr);
-}
+export const i8Bits = (bits: number): Scalar =>
+  scalarFromBits(TypeI8, workingDataU8, workingDataI8, bits);
 
 /** Create a u32 from a numeric value, a JS `number`. */
-export function u32(value: number): Scalar {
-  const arr = new Uint32Array([value]);
-  return new Scalar(TypeU32, arr[0], arr);
-}
+export const u32 = (value: number): Scalar => scalarFromValue(TypeU32, workingDataU32, value);
+
 /** Create a u16 from a numeric value, a JS `number`. */
-export function u16(value: number): Scalar {
-  const arr = new Uint16Array([value]);
-  return new Scalar(TypeU16, arr[0], arr);
-}
+export const u16 = (value: number): Scalar => scalarFromValue(TypeU16, workingDataU16, value);
+
 /** Create a u8 from a numeric value, a JS `number`. */
-export function u8(value: number): Scalar {
-  const arr = new Uint8Array([value]);
-  return new Scalar(TypeU8, arr[0], arr);
-}
+export const u8 = (value: number): Scalar => scalarFromValue(TypeU8, workingDataU8, value);
 
 /** Create an u32 from a bit representation, a uint32 represented as a JS `number`. */
-export function u32Bits(bits: number): Scalar {
-  const arr = new Uint32Array([bits]);
-  return new Scalar(TypeU32, bits, arr);
-}
+export const u32Bits = (bits: number): Scalar =>
+  scalarFromBits(TypeU32, workingDataU32, workingDataU32, bits);
+
 /** Create an u16 from a bit representation, a uint16 represented as a JS `number`. */
-export function u16Bits(bits: number): Scalar {
-  const arr = new Uint16Array([bits]);
-  return new Scalar(TypeU16, bits, arr);
-}
+export const u16Bits = (bits: number): Scalar =>
+  scalarFromBits(TypeU16, workingDataU16, workingDataU16, bits);
+
 /** Create an u8 from a bit representation, a uint8 represented as a JS `number`. */
-export function u8Bits(bits: number): Scalar {
-  const arr = new Uint8Array([bits]);
-  return new Scalar(TypeU8, bits, arr);
-}
+export const u8Bits = (bits: number): Scalar =>
+  scalarFromBits(TypeU8, workingDataU8, workingDataU8, bits);
 
 /** Create a boolean value. */
 export function bool(value: boolean): Scalar {
   // WGSL does not support using 'bool' types directly in storage / uniform
   // buffers, so instead we pack booleans in a u32, where 'false' is zero and
   // 'true' is any non-zero value.
-  const arr = new Uint32Array([value ? 1 : 0]);
-  return new Scalar(TypeBool, value, arr);
+  workingDataU32[0] = value ? 1 : 0;
+  workingDataU32[1] = 0;
+  return new Scalar(TypeBool, value, workingDataU32[1], workingDataU32[0]);
 }
 
 /** A 'true' literal value */
@@ -1091,18 +1096,15 @@ export const False = bool(false);
 
 // Encoding to u32s, instead of BigInt, for serialization
 export function reinterpretF64AsU32s(f64: number): [number, number] {
-  const array = new Float64Array(1);
-  array[0] = f64;
-  const u32s = new Uint32Array(array.buffer);
-  return [u32s[0], u32s[1]];
+  workingDataF64[0] = f64;
+  return [workingDataU32[0], workingDataU32[1]];
 }
 
 // De-encoding from u32s, instead of BigInt, for serialization
 export function reinterpretU32sAsF64(u32s: [number, number]): number {
-  const array = new Uint32Array(2);
-  array[0] = u32s[0];
-  array[1] = u32s[1];
-  return new Float64Array(array.buffer)[0];
+  workingDataU32[0] = u32s[0];
+  workingDataU32[1] = u32s[1];
+  return workingDataF64[0];
 }
 
 /**
@@ -1110,9 +1112,8 @@ export function reinterpretU32sAsF64(u32s: [number, number]): number {
  * of the bits of a number assumed to be an f32 value.
  */
 export function reinterpretF32AsU32(f32: number): number {
-  const array = new Float32Array(1);
-  array[0] = f32;
-  return new Uint32Array(array.buffer)[0];
+  workingDataF32[0] = f32;
+  return workingDataU32[0];
 }
 
 /**
@@ -1120,9 +1121,8 @@ export function reinterpretF32AsU32(f32: number): number {
  * of the bits of a number assumed to be an f32 value.
  */
 export function reinterpretF32AsI32(f32: number): number {
-  const array = new Float32Array(1);
-  array[0] = f32;
-  return new Int32Array(array.buffer)[0];
+  workingDataF32[0] = f32;
+  return workingDataI32[0];
 }
 
 /**
@@ -1130,9 +1130,8 @@ export function reinterpretF32AsI32(f32: number): number {
  * of the bits of a number assumed to be an u32 value.
  */
 export function reinterpretU32AsF32(u32: number): number {
-  const array = new Uint32Array(1);
-  array[0] = u32;
-  return new Float32Array(array.buffer)[0];
+  workingDataU32[0] = u32;
+  return workingDataF32[0];
 }
 
 /**
@@ -1140,9 +1139,8 @@ export function reinterpretU32AsF32(u32: number): number {
  * of the bits of a number assumed to be an u32 value.
  */
 export function reinterpretU32AsI32(u32: number): number {
-  const array = new Uint32Array(1);
-  array[0] = u32;
-  return new Int32Array(array.buffer)[0];
+  workingDataU32[0] = u32;
+  return workingDataI32[0];
 }
 
 /**
@@ -1150,9 +1148,8 @@ export function reinterpretU32AsI32(u32: number): number {
  * of the bits of a number assumed to be an i32 value.
  */
 export function reinterpretI32AsU32(i32: number): number {
-  const array = new Int32Array(1);
-  array[0] = i32;
-  return new Uint32Array(array.buffer)[0];
+  workingDataI32[0] = i32;
+  return workingDataU32[0];
 }
 
 /**
@@ -1160,9 +1157,8 @@ export function reinterpretI32AsU32(i32: number): number {
  * of the bits of a number assumed to be an i32 value.
  */
 export function reinterpretI32AsF32(i32: number): number {
-  const array = new Int32Array(1);
-  array[0] = i32;
-  return new Float32Array(array.buffer)[0];
+  workingDataI32[0] = i32;
+  return workingDataF32[0];
 }
 
 /**
@@ -1170,9 +1166,8 @@ export function reinterpretI32AsF32(i32: number): number {
  * of the bits of a number assumed to be an f16 value.
  */
 export function reinterpretF16AsU16(f16: number): number {
-  const array = new Float16Array(1);
-  array[0] = f16;
-  return new Uint16Array(array.buffer)[0];
+  workingDataF16[0] = f16;
+  return workingDataU16[0];
 }
 
 /**
@@ -1180,9 +1175,8 @@ export function reinterpretF16AsU16(f16: number): number {
  * of the bits of a number assumed to be an u16 value.
  */
 export function reinterpretU16AsF16(u16: number): number {
-  const array = new Uint16Array(1);
-  array[0] = u16;
-  return new Float16Array(array.buffer)[0];
+  workingDataU16[0] = u16;
+  return workingDataF16[0];
 }
 
 /**
@@ -1397,9 +1391,9 @@ export function serializeValue(v: Value): SerializedValue {
   const value = (kind: ScalarKind, s: Scalar) => {
     switch (kind) {
       case 'f32':
-        return new Uint32Array(s.bits.buffer)[0];
+        return s.bits0;
       case 'f16':
-        return new Uint16Array(s.bits.buffer)[0];
+        return s.bits0;
       default:
         return s.value;
     }

From 2be0e90f782b2693f964e59d38044f0a1dd65ccb Mon Sep 17 00:00:00 2001
From: Austin Eng <enga@chromium.org>
Date: Wed, 25 Oct 2023 13:06:10 -0700
Subject: [PATCH 151/166] Remove duplicate definitions of reinterpret* (#3095)

---
 src/unittests/floating_point.spec.ts          |   7 +-
 src/unittests/maths.spec.ts                   |   8 +-
 .../expression/call/builtin/bitcast.spec.ts   |  18 +--
 .../expression/unary/af_assignment.spec.ts    |   8 +-
 .../expression/unary/i32_conversion.spec.ts   |   2 +-
 .../expression/unary/u32_conversion.spec.ts   |   2 +-
 src/webgpu/util/constants.ts                  |  50 +-------
 src/webgpu/util/conversion.ts                 |  85 -------------
 src/webgpu/util/floating_point.ts             |  14 ++-
 src/webgpu/util/math.ts                       |  40 ++----
 src/webgpu/util/reinterpret.ts                | 118 ++++++++++++++++++
 11 files changed, 160 insertions(+), 192 deletions(-)
 create mode 100644 src/webgpu/util/reinterpret.ts

diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index da9110bc2d70..d016980a13f1 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -6,15 +6,12 @@ import { makeTestGroup } from '../common/framework/test_group.js';
 import { objectEquals, unreachable } from '../common/util/util.js';
 import { kValue } from '../webgpu/util/constants.js';
 import { FP, FPInterval, FPIntervalParam, IntervalBounds } from '../webgpu/util/floating_point.js';
+import { map2DArray, oneULPF32, oneULPF16, oneULPF64 } from '../webgpu/util/math.js';
 import {
   reinterpretU16AsF16,
   reinterpretU32AsF32,
   reinterpretU64AsF64,
-  map2DArray,
-  oneULPF32,
-  oneULPF16,
-  oneULPF64,
-} from '../webgpu/util/math.js';
+} from '../webgpu/util/reinterpret.js';
 
 import { UnitTest } from './unit_test.js';
 
diff --git a/src/unittests/maths.spec.ts b/src/unittests/maths.spec.ts
index 126a0d371e03..1c37e436fbd5 100644
--- a/src/unittests/maths.spec.ts
+++ b/src/unittests/maths.spec.ts
@@ -25,9 +25,6 @@ import {
   fullF16Range,
   fullF32Range,
   fullI32Range,
-  reinterpretU16AsF16,
-  reinterpretU32AsF32,
-  reinterpretU64AsF64,
   lerp,
   linearRange,
   nextAfterF16,
@@ -40,6 +37,11 @@ import {
   lerpBigInt,
   linearRangeBigInt,
 } from '../webgpu/util/math.js';
+import {
+  reinterpretU16AsF16,
+  reinterpretU32AsF32,
+  reinterpretU64AsF64,
+} from '../webgpu/util/reinterpret.js';
 
 import { UnitTest } from './unit_test.js';
 
diff --git a/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
index 9f0938f430c6..7f84f016683b 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
@@ -25,14 +25,6 @@ import { GPUTest } from '../../../../../gpu_test.js';
 import { Comparator, alwaysPass, anyOf } from '../../../../../util/compare.js';
 import { kBit, kValue } from '../../../../../util/constants.js';
 import {
-  reinterpretI32AsF32,
-  reinterpretI32AsU32,
-  reinterpretF32AsI32,
-  reinterpretF32AsU32,
-  reinterpretU32AsF32,
-  reinterpretU32AsI32,
-  reinterpretU16AsF16,
-  reinterpretF16AsU16,
   f32,
   i32,
   u32,
@@ -59,6 +51,16 @@ import {
   isFiniteF32,
   isFiniteF16,
 } from '../../../../../util/math.js';
+import {
+  reinterpretI32AsF32,
+  reinterpretI32AsU32,
+  reinterpretF32AsI32,
+  reinterpretF32AsU32,
+  reinterpretU32AsF32,
+  reinterpretU32AsI32,
+  reinterpretU16AsF16,
+  reinterpretF16AsU16,
+} from '../../../../../util/reinterpret.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, run, ShaderBuilder } from '../../expression.js';
 
diff --git a/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts b/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
index 372051c949a3..141d87d0f2d9 100644
--- a/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/af_assignment.spec.ts
@@ -7,12 +7,8 @@ import { GPUTest } from '../../../../gpu_test.js';
 import { kValue } from '../../../../util/constants.js';
 import { abstractFloat, TypeAbstractFloat, TypeF16, TypeF32 } from '../../../../util/conversion.js';
 import { FP } from '../../../../util/floating_point.js';
-import {
-  filteredF64Range,
-  fullF64Range,
-  isSubnormalNumberF64,
-  reinterpretU64AsF64,
-} from '../../../../util/math.js';
+import { filteredF64Range, fullF64Range, isSubnormalNumberF64 } from '../../../../util/math.js';
+import { reinterpretU64AsF64 } from '../../../../util/reinterpret.js';
 import { makeCaseCache } from '../case_cache.js';
 import {
   abstractFloatShaderBuilder,
diff --git a/src/webgpu/shader/execution/expression/unary/i32_conversion.spec.ts b/src/webgpu/shader/execution/expression/unary/i32_conversion.spec.ts
index 4d326f87f776..a77aa0e4d345 100644
--- a/src/webgpu/shader/execution/expression/unary/i32_conversion.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/i32_conversion.spec.ts
@@ -10,7 +10,6 @@ import {
   f32,
   f16,
   i32,
-  reinterpretU32AsI32,
   TypeBool,
   TypeF32,
   TypeF16,
@@ -26,6 +25,7 @@ import {
   quantizeToF32,
   quantizeToF16,
 } from '../../../../util/math.js';
+import { reinterpretU32AsI32 } from '../../../../util/reinterpret.js';
 import { makeCaseCache } from '../case_cache.js';
 import { allInputSources, run, ShaderBuilder } from '../expression.js';
 
diff --git a/src/webgpu/shader/execution/expression/unary/u32_conversion.spec.ts b/src/webgpu/shader/execution/expression/unary/u32_conversion.spec.ts
index 255662c6e402..87dc6e7a5df8 100644
--- a/src/webgpu/shader/execution/expression/unary/u32_conversion.spec.ts
+++ b/src/webgpu/shader/execution/expression/unary/u32_conversion.spec.ts
@@ -10,7 +10,6 @@ import {
   f32,
   f16,
   i32,
-  reinterpretI32AsU32,
   TypeBool,
   TypeF32,
   TypeF16,
@@ -26,6 +25,7 @@ import {
   quantizeToF32,
   quantizeToF16,
 } from '../../../../util/math.js';
+import { reinterpretI32AsU32 } from '../../../../util/reinterpret.js';
 import { makeCaseCache } from '../case_cache.js';
 import { allInputSources, run, ShaderBuilder } from '../expression.js';
 
diff --git a/src/webgpu/util/constants.ts b/src/webgpu/util/constants.ts
index 0dec73f187c1..5ee819c64e4f 100644
--- a/src/webgpu/util/constants.ts
+++ b/src/webgpu/util/constants.ts
@@ -1,4 +1,9 @@
-import { Float16Array } from '../../external/petamoriken/float16/float16.js';
+import {
+  reinterpretU64AsF64,
+  reinterpretF64AsU64,
+  reinterpretU32AsF32,
+  reinterpretU16AsF16,
+} from './reinterpret.js';
 
 export const kBit = {
   // Limits of int32
@@ -236,49 +241,6 @@ export const kBit = {
   },
 } as const;
 
-/**
- * @returns a 64-bit float value via interpreting the input as the bit
- * representation as a 64-bit integer
- *
- * Using a locally defined function here to avoid compile time dependency
- * issues.
- */
-function reinterpretU64AsF64(input: bigint): number {
-  return new Float64Array(new BigUint64Array([input]).buffer)[0];
-}
-
-/**
- * @returns the 64-bit integer bit representation of 64-bit float value
- *
- * Using a locally defined function here to avoid compile time dependency
- * issues.
- */
-function reinterpretF64AsU64(input: number): bigint {
-  return new BigUint64Array(new Float64Array([input]).buffer)[0];
-}
-
-/**
- * @returns a 32-bit float value via interpreting the input as the bit
- * representation as a 32-bit integer
- *
- * Using a locally defined function here to avoid compile time dependency
- * issues.
- */
-function reinterpretU32AsF32(input: number): number {
-  return new Float32Array(new Uint32Array([input]).buffer)[0];
-}
-
-/**
- * @returns a 16-bit float value via interpreting the input as the bit
- * representation as a 64-bit integer
- *
- * Using a locally defined function here to avoid compile time dependency
- * issues.
- */
-function reinterpretU16AsF16(input: number): number {
-  return new Float16Array(new Uint16Array([input]).buffer)[0];
-}
-
 export const kValue = {
   // Limits of i32
   i32: {
diff --git a/src/webgpu/util/conversion.ts b/src/webgpu/util/conversion.ts
index 5ee3e30c36ac..f94c2b918806 100644
--- a/src/webgpu/util/conversion.ts
+++ b/src/webgpu/util/conversion.ts
@@ -1094,91 +1094,6 @@ export const True = bool(true);
 /** A 'false' literal value */
 export const False = bool(false);
 
-// Encoding to u32s, instead of BigInt, for serialization
-export function reinterpretF64AsU32s(f64: number): [number, number] {
-  workingDataF64[0] = f64;
-  return [workingDataU32[0], workingDataU32[1]];
-}
-
-// De-encoding from u32s, instead of BigInt, for serialization
-export function reinterpretU32sAsF64(u32s: [number, number]): number {
-  workingDataU32[0] = u32s[0];
-  workingDataU32[1] = u32s[1];
-  return workingDataF64[0];
-}
-
-/**
- * @returns a number representing the u32 interpretation
- * of the bits of a number assumed to be an f32 value.
- */
-export function reinterpretF32AsU32(f32: number): number {
-  workingDataF32[0] = f32;
-  return workingDataU32[0];
-}
-
-/**
- * @returns a number representing the i32 interpretation
- * of the bits of a number assumed to be an f32 value.
- */
-export function reinterpretF32AsI32(f32: number): number {
-  workingDataF32[0] = f32;
-  return workingDataI32[0];
-}
-
-/**
- * @returns a number representing the f32 interpretation
- * of the bits of a number assumed to be an u32 value.
- */
-export function reinterpretU32AsF32(u32: number): number {
-  workingDataU32[0] = u32;
-  return workingDataF32[0];
-}
-
-/**
- * @returns a number representing the i32 interpretation
- * of the bits of a number assumed to be an u32 value.
- */
-export function reinterpretU32AsI32(u32: number): number {
-  workingDataU32[0] = u32;
-  return workingDataI32[0];
-}
-
-/**
- * @returns a number representing the u32 interpretation
- * of the bits of a number assumed to be an i32 value.
- */
-export function reinterpretI32AsU32(i32: number): number {
-  workingDataI32[0] = i32;
-  return workingDataU32[0];
-}
-
-/**
- * @returns a number representing the f32 interpretation
- * of the bits of a number assumed to be an i32 value.
- */
-export function reinterpretI32AsF32(i32: number): number {
-  workingDataI32[0] = i32;
-  return workingDataF32[0];
-}
-
-/**
- * @returns a number representing the u16 interpretation
- * of the bits of a number assumed to be an f16 value.
- */
-export function reinterpretF16AsU16(f16: number): number {
-  workingDataF16[0] = f16;
-  return workingDataU16[0];
-}
-
-/**
- * @returns a number representing the f16 interpretation
- * of the bits of a number assumed to be an u16 value.
- */
-export function reinterpretU16AsF16(u16: number): number {
-  workingDataU16[0] = u16;
-  return workingDataF16[0];
-}
-
 /**
  * Class that encapsulates a vector value.
  */
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index fc76f85260fa..70109f5cab9e 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -9,12 +9,6 @@ import {
   f16,
   f32,
   isFloatType,
-  reinterpretF16AsU16,
-  reinterpretF32AsU32,
-  reinterpretF64AsU32s,
-  reinterpretU16AsF16,
-  reinterpretU32AsF32,
-  reinterpretU32sAsF64,
   Scalar,
   ScalarType,
   toMatrix,
@@ -45,6 +39,14 @@ import {
   unflatten2DArray,
   every2DArray,
 } from './math.js';
+import {
+  reinterpretF16AsU16,
+  reinterpretF32AsU32,
+  reinterpretF64AsU32s,
+  reinterpretU16AsF16,
+  reinterpretU32AsF32,
+  reinterpretU32sAsF64,
+} from './reinterpret.js';
 
 /** Indicate the kind of WGSL floating point numbers being operated on */
 export type FPKind = 'f32' | 'f16' | 'abstract';
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 1fb1d1a7ff69..c22b4f395024 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -6,7 +6,13 @@ import {
 } from '../../external/petamoriken/float16/float16.js';
 
 import { kBit, kValue } from './constants.js';
-import { floatBitsToNumber, i32, kFloat16Format, kFloat32Format, u32 } from './conversion.js';
+import { i32, u32 } from './conversion.js';
+import {
+  reinterpretF64AsU64,
+  reinterpretU64AsF64,
+  reinterpretU32AsF32,
+  reinterpretU16AsF16,
+} from './reinterpret.js';
 
 /**
  * A multiple of 8 guaranteed to be way too large to allocate (just under 8 pebibytes).
@@ -2061,38 +2067,6 @@ export function lcm(a: number, b: number): number {
   return (a * b) / gcd(a, b);
 }
 
-/**
- * @returns the bit representation as a 64-integer, via interpreting the input
- * as a 64-bit float value
- */
-export function reinterpretF64AsU64(input: number): bigint {
-  return new BigUint64Array(new Float64Array([input]).buffer)[0];
-}
-
-/**
- * @returns a 64-bit float value via interpreting the input as the bit
- * representation as a 64-bit integer
- */
-export function reinterpretU64AsF64(input: bigint): number {
-  return new Float64Array(new BigUint64Array([input]).buffer)[0];
-}
-
-/**
- * @returns a 32-bit float value via interpreting the input as the bit
- * representation as a 32-bit integer
- */
-export function reinterpretU32AsF32(input: number): number {
-  return floatBitsToNumber(input, kFloat32Format);
-}
-
-/**
- * @returns a 16-bit float value via interpreting the input as the bit
- * representation as a 16-bit integer
- */
-export function reinterpretU16AsF16(hex: number): number {
-  return floatBitsToNumber(hex, kFloat16Format);
-}
-
 /** @returns the cross of an array with the intermediate result of cartesianProduct
  *
  * @param elements array of values to cross with the intermediate result of
diff --git a/src/webgpu/util/reinterpret.ts b/src/webgpu/util/reinterpret.ts
new file mode 100644
index 000000000000..2ffb24b231f0
--- /dev/null
+++ b/src/webgpu/util/reinterpret.ts
@@ -0,0 +1,118 @@
+import { Float16Array } from '../../external/petamoriken/float16/float16.js';
+
+/**
+ * Once-allocated ArrayBuffer/views to avoid overhead of allocation when converting between numeric formats
+ *
+ * workingData* is shared between multiple functions in this file, so to avoid re-entrancy problems, make sure in
+ * functions that use it that they don't call themselves or other functions that use workingData*.
+ */
+const workingData = new ArrayBuffer(8);
+const workingDataU32 = new Uint32Array(workingData);
+const workingDataU16 = new Uint16Array(workingData);
+const workingDataF32 = new Float32Array(workingData);
+const workingDataF16 = new Float16Array(workingData);
+const workingDataI32 = new Int32Array(workingData);
+const workingDataF64 = new Float64Array(workingData);
+const workingDataU64 = new BigUint64Array(workingData);
+
+/**
+ * @returns a 64-bit float value via interpreting the input as the bit
+ * representation as a 64-bit integer
+ */
+export function reinterpretU64AsF64(input: bigint): number {
+  workingDataU64[0] = input;
+  return workingDataF64[0];
+}
+
+/**
+ * @returns the 64-bit integer bit representation of 64-bit float value
+ */
+export function reinterpretF64AsU64(input: number): bigint {
+  workingDataF64[0] = input;
+  return workingDataU64[0];
+}
+
+// Encoding to u32s, instead of BigInt, for serialization
+export function reinterpretF64AsU32s(f64: number): [number, number] {
+  workingDataF64[0] = f64;
+  return [workingDataU32[0], workingDataU32[1]];
+}
+
+// De-encoding from u32s, instead of BigInt, for serialization
+export function reinterpretU32sAsF64(u32s: [number, number]): number {
+  workingDataU32[0] = u32s[0];
+  workingDataU32[1] = u32s[1];
+  return workingDataF64[0];
+}
+
+/**
+ * @returns a number representing the u32 interpretation
+ * of the bits of a number assumed to be an f32 value.
+ */
+export function reinterpretF32AsU32(f32: number): number {
+  workingDataF32[0] = f32;
+  return workingDataU32[0];
+}
+
+/**
+ * @returns a number representing the i32 interpretation
+ * of the bits of a number assumed to be an f32 value.
+ */
+export function reinterpretF32AsI32(f32: number): number {
+  workingDataF32[0] = f32;
+  return workingDataI32[0];
+}
+
+/**
+ * @returns a number representing the f32 interpretation
+ * of the bits of a number assumed to be an u32 value.
+ */
+export function reinterpretU32AsF32(u32: number): number {
+  workingDataU32[0] = u32;
+  return workingDataF32[0];
+}
+
+/**
+ * @returns a number representing the i32 interpretation
+ * of the bits of a number assumed to be an u32 value.
+ */
+export function reinterpretU32AsI32(u32: number): number {
+  workingDataU32[0] = u32;
+  return workingDataI32[0];
+}
+
+/**
+ * @returns a number representing the u32 interpretation
+ * of the bits of a number assumed to be an i32 value.
+ */
+export function reinterpretI32AsU32(i32: number): number {
+  workingDataI32[0] = i32;
+  return workingDataU32[0];
+}
+
+/**
+ * @returns a number representing the f32 interpretation
+ * of the bits of a number assumed to be an i32 value.
+ */
+export function reinterpretI32AsF32(i32: number): number {
+  workingDataI32[0] = i32;
+  return workingDataF32[0];
+}
+
+/**
+ * @returns a number representing the u16 interpretation
+ * of the bits of a number assumed to be an f16 value.
+ */
+export function reinterpretF16AsU16(f16: number): number {
+  workingDataF16[0] = f16;
+  return workingDataU16[0];
+}
+
+/**
+ * @returns a number representing the f16 interpretation
+ * of the bits of a number assumed to be an u16 value.
+ */
+export function reinterpretU16AsF16(u16: number): number {
+  workingDataU16[0] = u16;
+  return workingDataF16[0];
+}

From e5f120ee5cfc477b1eeeb4b57a402a831767ef00 Mon Sep 17 00:00:00 2001
From: Lokbondo Kung <lokokung@google.com>
Date: Wed, 25 Oct 2023 15:24:13 -0700
Subject: [PATCH 152/166] Fixes flaky test because parameters were changed when
 the test was ran. (#3096)

---
 src/webgpu/api/validation/compute_pipeline.spec.ts | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/webgpu/api/validation/compute_pipeline.spec.ts b/src/webgpu/api/validation/compute_pipeline.spec.ts
index c552fed50af8..3a0a51b363c6 100644
--- a/src/webgpu/api/validation/compute_pipeline.spec.ts
+++ b/src/webgpu/api/validation/compute_pipeline.spec.ts
@@ -233,7 +233,7 @@ Tests calling createComputePipeline(Async) validation for compute workgroup_size
         [1, 1, 63],
         [1, 1, 64],
         [1, 1, 65],
-      ])
+      ] as const)
   )
   .fn(t => {
     const { isAsync, size } = t.params;
@@ -251,13 +251,14 @@ Tests calling createComputePipeline(Async) validation for compute workgroup_size
       },
     };
 
-    size[1] = size[1] ?? 1;
-    size[2] = size[2] ?? 1;
+    const workgroupX = size[0];
+    const workgroupY = size[1] ?? 1;
+    const workgroupZ = size[2] ?? 1;
 
     const _success =
-      size[0] <= t.device.limits.maxComputeWorkgroupSizeX &&
-      size[1] <= t.device.limits.maxComputeWorkgroupSizeY &&
-      size[2] <= t.device.limits.maxComputeWorkgroupSizeZ;
+      workgroupX <= t.device.limits.maxComputeWorkgroupSizeX &&
+      workgroupY <= t.device.limits.maxComputeWorkgroupSizeY &&
+      workgroupZ <= t.device.limits.maxComputeWorkgroupSizeZ;
     t.doCreateComputePipelineTest(isAsync, _success, descriptor);
   });
 

From f3196f886db26476d3a185ef705da5d321570761 Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Wed, 25 Oct 2023 22:08:07 -0700
Subject: [PATCH 153/166] Make test params readonly so they can't be
 accidentally permanently modified (#3097)

This should hopefully categorically prevent bugs like the one fixed in
https://github.com/gpuweb/cts/pull/3096
---
 src/common/framework/params_builder.ts        |  16 +-
 src/common/internal/test_group.ts             |   7 +-
 src/common/util/types.ts                      |  39 ++
 src/common/util/util.ts                       |   4 +-
 src/unittests/floating_point.spec.ts          |  30 +-
 src/unittests/maths.spec.ts                   |   4 +-
 .../render_pipeline/inter_stage.spec.ts       |   4 +-
 src/webgpu/format_info.ts                     |   2 +-
 .../expression/binary/af_addition.spec.ts     |   4 +-
 .../expression/binary/af_division.spec.ts     |   4 +-
 .../binary/af_multiplication.spec.ts          |   4 +-
 .../expression/binary/af_remainder.spec.ts    |   4 +-
 .../expression/binary/af_subtraction.spec.ts  |   4 +-
 .../expression/binary/f16_addition.spec.ts    |   4 +-
 .../expression/binary/f16_division.spec.ts    |   4 +-
 .../binary/f16_multiplication.spec.ts         |   4 +-
 .../expression/binary/f16_remainder.spec.ts   |   4 +-
 .../expression/binary/f16_subtraction.spec.ts |   4 +-
 .../expression/binary/f32_addition.spec.ts    |   4 +-
 .../expression/binary/f32_division.spec.ts    |   4 +-
 .../binary/f32_multiplication.spec.ts         |   4 +-
 .../expression/binary/f32_remainder.spec.ts   |   4 +-
 .../expression/binary/f32_subtraction.spec.ts |   4 +-
 .../expression/call/builtin/bitcast.spec.ts   |   4 +-
 .../expression/call/builtin/clamp.spec.ts     |   2 +-
 .../call/builtin/faceForward.spec.ts          |  13 +-
 .../expression/call/builtin/frexp.spec.ts     |  28 +-
 .../expression/call/builtin/modf.spec.ts      |   4 +-
 .../expression/call/builtin/refract.spec.ts   |  11 +-
 .../shader/execution/expression/expression.ts |  62 ++-
 src/webgpu/shader/execution/zero_init.spec.ts |   2 +-
 src/webgpu/util/conversion.ts                 |  17 +-
 src/webgpu/util/floating_point.ts             | 415 ++++++++++--------
 src/webgpu/util/math.ts                       |  76 ++--
 34 files changed, 449 insertions(+), 351 deletions(-)

diff --git a/src/common/framework/params_builder.ts b/src/common/framework/params_builder.ts
index 4947245a3251..845d1cd2e92a 100644
--- a/src/common/framework/params_builder.ts
+++ b/src/common/framework/params_builder.ts
@@ -1,6 +1,7 @@
 import { Merged, mergeParams, mergeParamsChecked } from '../internal/params_utils.js';
 import { comparePublicParamsPaths, Ordering } from '../internal/query/compare.js';
 import { stringifyPublicParams } from '../internal/query/stringify_params.js';
+import { DeepReadonly } from '../util/types.js';
 import { assert, mapLazy, objectEquals } from '../util/util.js';
 
 import { TestParams } from './fixture.js';
@@ -98,7 +99,7 @@ export type ParamTypeOf<
  * - `[case params, undefined]` if not.
  */
 export type CaseSubcaseIterable<CaseP, SubcaseP> = Iterable<
-  readonly [CaseP, Iterable<SubcaseP> | undefined]
+  readonly [DeepReadonly<CaseP>, Iterable<DeepReadonly<SubcaseP>> | undefined]
 >;
 
 /**
@@ -143,7 +144,7 @@ export function builderIterateCasesWithSubcases(
  */
 export class CaseParamsBuilder<CaseP extends {}>
   extends ParamsBuilderBase<CaseP, {}>
-  implements Iterable<CaseP>, ParamsBuilder {
+  implements Iterable<DeepReadonly<CaseP>>, ParamsBuilder {
   *iterateCasesWithSubcases(caseFilter: TestParams | null): CaseSubcaseIterable<CaseP, {}> {
     for (const caseP of this.cases(caseFilter)) {
       if (caseFilter) {
@@ -155,12 +156,12 @@ export class CaseParamsBuilder<CaseP extends {}>
         }
       }
 
-      yield [caseP, undefined];
+      yield [caseP as DeepReadonly<typeof caseP>, undefined];
     }
   }
 
-  [Symbol.iterator](): Iterator<CaseP> {
-    return this.cases(null);
+  [Symbol.iterator](): Iterator<DeepReadonly<CaseP>> {
+    return this.cases(null) as Iterator<DeepReadonly<CaseP>>;
   }
 
   /** @inheritDoc */
@@ -302,7 +303,10 @@ export class SubcaseParamsBuilder<CaseP extends {}, SubcaseP extends {}>
 
       const subcases = Array.from(this.subcases(caseP));
       if (subcases.length) {
-        yield [caseP, subcases];
+        yield [
+          caseP as DeepReadonly<typeof caseP>,
+          subcases as DeepReadonly<typeof subcases[number]>[],
+        ];
       }
     }
   }
diff --git a/src/common/internal/test_group.ts b/src/common/internal/test_group.ts
index c7dc38d06bbc..6e13fbf47458 100644
--- a/src/common/internal/test_group.ts
+++ b/src/common/internal/test_group.ts
@@ -26,6 +26,7 @@ import {
   stringifyPublicParamsUniquely,
 } from '../internal/query/stringify_params.js';
 import { validQueryPart } from '../internal/query/validQueryPart.js';
+import { DeepReadonly } from '../util/types.js';
 import { assert, unreachable } from '../util/util.js';
 
 import { logToWebsocket } from './websocket_logger.js';
@@ -82,9 +83,11 @@ export function makeTestGroupForUnitTesting<F extends Fixture>(
 /** Parameter name for batch number (see also TestBuilder.batch). */
 const kBatchParamName = 'batch__';
 
-type TestFn<F extends Fixture, P extends {}> = (t: F & { params: P }) => Promise<void> | void;
+type TestFn<F extends Fixture, P extends {}> = (
+  t: F & { params: DeepReadonly<P> }
+) => Promise<void> | void;
 type BeforeAllSubcasesFn<S extends SubcaseBatchState, P extends {}> = (
-  s: S & { params: P }
+  s: S & { params: DeepReadonly<P> }
 ) => Promise<void> | void;
 
 export class TestGroup<F extends Fixture> implements TestGroupBuilder<F> {
diff --git a/src/common/util/types.ts b/src/common/util/types.ts
index dfd5e4b5eab5..e677cbb6c78a 100644
--- a/src/common/util/types.ts
+++ b/src/common/util/types.ts
@@ -13,6 +13,45 @@ export type TypeEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T
 /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
 export function assertTypeTrue<T extends true>() {}
 
+/** `ReadonlyArray` of `ReadonlyArray`s. */
+export type ROArrayArray<T> = ReadonlyArray<ReadonlyArray<T>>;
+/** `ReadonlyArray` of `ReadonlyArray`s of `ReadonlyArray`s. */
+export type ROArrayArrayArray<T> = ReadonlyArray<ReadonlyArray<ReadonlyArray<T>>>;
+
+/**
+ * Deep version of the Readonly<> type, with support for tuples (up to length 7).
+ * <https://gist.github.com/masterkidan/7322752f569b1bba53e0426266768623>
+ */
+export type DeepReadonly<T> = T extends [infer A]
+  ? DeepReadonlyObject<[A]>
+  : T extends [infer A, infer B]
+  ? DeepReadonlyObject<[A, B]>
+  : T extends [infer A, infer B, infer C]
+  ? DeepReadonlyObject<[A, B, C]>
+  : T extends [infer A, infer B, infer C, infer D]
+  ? DeepReadonlyObject<[A, B, C, D]>
+  : T extends [infer A, infer B, infer C, infer D, infer E]
+  ? DeepReadonlyObject<[A, B, C, D, E]>
+  : T extends [infer A, infer B, infer C, infer D, infer E, infer F]
+  ? DeepReadonlyObject<[A, B, C, D, E, F]>
+  : T extends [infer A, infer B, infer C, infer D, infer E, infer F, infer G]
+  ? DeepReadonlyObject<[A, B, C, D, E, F, G]>
+  : T extends Map<infer U, infer V>
+  ? ReadonlyMap<DeepReadonlyObject<U>, DeepReadonlyObject<V>>
+  : T extends Set<infer U>
+  ? ReadonlySet<DeepReadonlyObject<U>>
+  : T extends Promise<infer U>
+  ? Promise<DeepReadonlyObject<U>>
+  : T extends Primitive
+  ? T
+  : T extends (infer A)[]
+  ? DeepReadonlyArray<A>
+  : DeepReadonlyObject<T>;
+
+type Primitive = string | number | boolean | undefined | null | Function | symbol;
+type DeepReadonlyArray<T> = ReadonlyArray<DeepReadonly<T>>;
+type DeepReadonlyObject<T> = { readonly [P in keyof T]: DeepReadonly<T[P]> };
+
 /**
  * Computes the intersection of a set of types, given the union of those types.
  *
diff --git a/src/common/util/util.ts b/src/common/util/util.ts
index 876851f100c3..be109fc9d422 100644
--- a/src/common/util/util.ts
+++ b/src/common/util/util.ts
@@ -346,7 +346,7 @@ interface TypedArrayMap {
 
 type TypedArrayParam<K extends keyof TypedArrayMap> = {
   type: K;
-  data: number[];
+  data: readonly number[];
 };
 
 /**
@@ -387,7 +387,7 @@ export function typedArrayParam<K extends keyof TypedArrayMap>(
 
 export function createTypedArray<K extends keyof TypedArrayMap>(
   type: K,
-  data: number[]
+  data: readonly number[]
 ): TypedArrayMap[K] {
   return new kTypedArrayBufferViews[type](data) as TypedArrayMap[K];
 }
diff --git a/src/unittests/floating_point.spec.ts b/src/unittests/floating_point.spec.ts
index d016980a13f1..7eae72447624 100644
--- a/src/unittests/floating_point.spec.ts
+++ b/src/unittests/floating_point.spec.ts
@@ -2582,8 +2582,7 @@ g.test('atanInterval')
       return ulp_error * trait.oneULP(n);
     };
 
-    t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
+    const expected = trait.toInterval(applyError(t.params.expected, error));
 
     const got = trait.atanInterval(t.params.input);
     t.expect(
@@ -2760,8 +2759,7 @@ g.test('cosInterval')
       return t.params.trait === 'f32' ? 2 ** -11 : 2 ** -7;
     };
 
-    t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
+    const expected = trait.toInterval(applyError(t.params.expected, error));
 
     const got = trait.cosInterval(t.params.input);
     t.expect(
@@ -2941,8 +2939,7 @@ g.test('expInterval')
       return ulp_error * trait.oneULP(x);
     };
 
-    t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
+    const expected = trait.toInterval(applyError(t.params.expected, error));
     const got = trait.expInterval(t.params.input);
 
     t.expect(
@@ -3001,8 +2998,7 @@ g.test('exp2Interval')
       return ulp_error * trait.oneULP(x);
     };
 
-    t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
+    const expected = trait.toInterval(applyError(t.params.expected, error));
 
     const got = trait.exp2Interval(t.params.input);
     t.expect(
@@ -3197,8 +3193,7 @@ g.test('inverseSqrtInterval')
       return 2 * trait.oneULP(n);
     };
 
-    t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
+    const expected = trait.toInterval(applyError(t.params.expected, error));
 
     const got = trait.inverseSqrtInterval(t.params.input);
     t.expect(
@@ -3322,8 +3317,7 @@ g.test('logInterval')
       return 3 * trait.oneULP(n);
     };
 
-    t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
+    const expected = trait.toInterval(applyError(t.params.expected, error));
 
     const got = trait.logInterval(t.params.input);
     t.expect(
@@ -3373,8 +3367,7 @@ g.test('log2Interval')
       return 3 * trait.oneULP(n);
     };
 
-    t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
+    const expected = trait.toInterval(applyError(t.params.expected, error));
 
     const got = trait.log2Interval(t.params.input);
     t.expect(
@@ -3720,8 +3713,7 @@ g.test('sinInterval')
       return t.params.trait === 'f32' ? 2 ** -11 : 2 ** -7;
     };
 
-    t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
+    const expected = trait.toInterval(applyError(t.params.expected, error));
 
     const got = trait.sinInterval(t.params.input);
     t.expect(
@@ -3855,8 +3847,7 @@ g.test('sqrtInterval')
       return 2.5 * trait.oneULP(n);
     };
 
-    t.params.expected = applyError(t.params.expected, error);
-    const expected = trait.toInterval(t.params.expected);
+    const expected = trait.toInterval(applyError(t.params.expected, error));
 
     const got = trait.sqrtInterval(t.params.input);
     t.expect(
@@ -4429,10 +4420,9 @@ g.test('divisionInterval')
     };
 
     const [x, y] = t.params.input;
-    t.params.expected = applyError(t.params.expected, error);
 
     // Do not swizzle here, so the correct implementation under test is called.
-    const expected = FP[t.params.trait].toInterval(t.params.expected);
+    const expected = FP[t.params.trait].toInterval(applyError(t.params.expected, error));
     const got = FP[t.params.trait].divisionInterval(x, y);
     t.expect(
       objectEquals(expected, got),
diff --git a/src/unittests/maths.spec.ts b/src/unittests/maths.spec.ts
index 1c37e436fbd5..357c574281f3 100644
--- a/src/unittests/maths.spec.ts
+++ b/src/unittests/maths.spec.ts
@@ -72,8 +72,8 @@ function withinOneULPF32(got: number, expected: number, mode: FlushMode): boolea
  *              FTZ occur during comparison
  **/
 function compareArrayOfNumbersF32(
-  got: Array<number>,
-  expect: Array<number>,
+  got: readonly number[],
+  expect: readonly number[],
   mode: FlushMode = 'flush'
 ): boolean {
   return (
diff --git a/src/webgpu/api/validation/render_pipeline/inter_stage.spec.ts b/src/webgpu/api/validation/render_pipeline/inter_stage.spec.ts
index afcb5ace1309..91aabb0ab8c9 100644
--- a/src/webgpu/api/validation/render_pipeline/inter_stage.spec.ts
+++ b/src/webgpu/api/validation/render_pipeline/inter_stage.spec.ts
@@ -12,7 +12,7 @@ function getVarName(i: number) {
 }
 
 class InterStageMatchingValidationTest extends CreateRenderPipelineValidationTest {
-  getVertexStateWithOutputs(outputs: string[]): GPUVertexState {
+  getVertexStateWithOutputs(outputs: readonly string[]): GPUVertexState {
     return {
       module: this.device.createShaderModule({
         code: `
@@ -32,7 +32,7 @@ class InterStageMatchingValidationTest extends CreateRenderPipelineValidationTes
   }
 
   getFragmentStateWithInputs(
-    inputs: string[],
+    inputs: readonly string[],
     hasBuiltinPosition: boolean = false
   ): GPUFragmentState {
     return {
diff --git a/src/webgpu/format_info.ts b/src/webgpu/format_info.ts
index 242549a8b6c9..9333afed1352 100644
--- a/src/webgpu/format_info.ts
+++ b/src/webgpu/format_info.ts
@@ -1255,7 +1255,7 @@ export const kFeaturesForFormats = getFeaturesForFormats(kTextureFormats);
 /**
  * Given an array of texture formats return the number of bytes per sample.
  */
-export function computeBytesPerSampleFromFormats(formats: GPUTextureFormat[]) {
+export function computeBytesPerSampleFromFormats(formats: readonly GPUTextureFormat[]) {
   let bytesPerSample = 0;
   for (const format of formats) {
     const info = kTextureFormatInfo[format];
diff --git a/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
index 1765ce3d95cb..0f703f088970 100644
--- a/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_addition.spec.ts
@@ -12,11 +12,11 @@ import { onlyConstInputSource, run } from '../expression.js';
 
 import { abstractBinary } from './binary.js';
 
-const additionVectorScalarInterval = (v: number[], s: number): FPVector => {
+const additionVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.additionInterval(e, s)));
 };
 
-const additionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const additionScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.additionInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/af_division.spec.ts b/src/webgpu/shader/execution/expression/binary/af_division.spec.ts
index e473acb20d8f..4c1765d20337 100644
--- a/src/webgpu/shader/execution/expression/binary/af_division.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_division.spec.ts
@@ -12,11 +12,11 @@ import { onlyConstInputSource, run } from '../expression.js';
 
 import { abstractBinary } from './binary.js';
 
-const divisionVectorScalarInterval = (v: number[], s: number): FPVector => {
+const divisionVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.divisionInterval(e, s)));
 };
 
-const divisionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const divisionScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.divisionInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
index 83d60aaa9a23..6b1581270346 100644
--- a/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_multiplication.spec.ts
@@ -12,11 +12,11 @@ import { onlyConstInputSource, run } from '../expression.js';
 
 import { abstractBinary } from './binary.js';
 
-const multiplicationVectorScalarInterval = (v: number[], s: number): FPVector => {
+const multiplicationVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.multiplicationInterval(e, s)));
 };
 
-const multiplicationScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const multiplicationScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.multiplicationInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/af_remainder.spec.ts b/src/webgpu/shader/execution/expression/binary/af_remainder.spec.ts
index f6f343a57621..b4ce930bdb25 100644
--- a/src/webgpu/shader/execution/expression/binary/af_remainder.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_remainder.spec.ts
@@ -12,11 +12,11 @@ import { onlyConstInputSource, run } from '../expression.js';
 
 import { abstractBinary } from './binary.js';
 
-const remainderVectorScalarInterval = (v: number[], s: number): FPVector => {
+const remainderVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.remainderInterval(e, s)));
 };
 
-const remainderScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const remainderScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.remainderInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
index c2d4cd90941c..00dc66feb951 100644
--- a/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/af_subtraction.spec.ts
@@ -12,11 +12,11 @@ import { onlyConstInputSource, run } from '../expression.js';
 
 import { abstractBinary } from './binary.js';
 
-const subtractionVectorScalarInterval = (v: number[], s: number): FPVector => {
+const subtractionVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.subtractionInterval(e, s)));
 };
 
-const subtractionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const subtractionScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.abstract.toVector(v.map(e => FP.abstract.subtractionInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts
index e285277b5cf4..8948f9049963 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_addition.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const additionVectorScalarInterval = (v: number[], s: number): FPVector => {
+const additionVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.additionInterval(e, s)));
 };
 
-const additionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const additionScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.additionInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts
index 346c38499df2..c3b8fc04dbb7 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_division.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const divisionVectorScalarInterval = (v: number[], s: number): FPVector => {
+const divisionVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.divisionInterval(e, s)));
 };
 
-const divisionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const divisionScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.divisionInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts
index a2985ec0303f..10041fbc173f 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_multiplication.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const multiplicationVectorScalarInterval = (v: number[], s: number): FPVector => {
+const multiplicationVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.multiplicationInterval(e, s)));
 };
 
-const multiplicationScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const multiplicationScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.multiplicationInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts
index 5a9de5d84e1c..801b84904b84 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_remainder.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const remainderVectorScalarInterval = (v: number[], s: number): FPVector => {
+const remainderVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.remainderInterval(e, s)));
 };
 
-const remainderScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const remainderScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.remainderInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts
index 81c0d94845c6..a64d5568375f 100644
--- a/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f16_subtraction.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const subtractionVectorScalarInterval = (v: number[], s: number): FPVector => {
+const subtractionVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.subtractionInterval(e, s)));
 };
 
-const subtractionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const subtractionScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f16.toVector(v.map(e => FP.f16.subtractionInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
index 53051b29e364..65739f67ca6c 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_addition.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const additionVectorScalarInterval = (v: number[], s: number): FPVector => {
+const additionVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.additionInterval(e, s)));
 };
 
-const additionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const additionScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.additionInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts
index f2d5b6a1c70a..bd3793bf8a66 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_division.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const divisionVectorScalarInterval = (v: number[], s: number): FPVector => {
+const divisionVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.divisionInterval(e, s)));
 };
 
-const divisionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const divisionScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.divisionInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts
index 406642fcb553..38da08fd3e77 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_multiplication.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const multiplicationVectorScalarInterval = (v: number[], s: number): FPVector => {
+const multiplicationVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.multiplicationInterval(e, s)));
 };
 
-const multiplicationScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const multiplicationScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.multiplicationInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts
index 44058939b83a..390a7f34266c 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_remainder.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const remainderVectorScalarInterval = (v: number[], s: number): FPVector => {
+const remainderVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.remainderInterval(e, s)));
 };
 
-const remainderScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const remainderScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.remainderInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts b/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts
index 0fbb2e8d7107..91e06b7de8c1 100644
--- a/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts
+++ b/src/webgpu/shader/execution/expression/binary/f32_subtraction.spec.ts
@@ -12,11 +12,11 @@ import { allInputSources, run } from '../expression.js';
 
 import { binary, compoundBinary } from './binary.js';
 
-const subtractionVectorScalarInterval = (v: number[], s: number): FPVector => {
+const subtractionVectorScalarInterval = (v: readonly number[], s: number): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.subtractionInterval(e, s)));
 };
 
-const subtractionScalarVectorInterval = (s: number, v: number[]): FPVector => {
+const subtractionScalarVectorInterval = (s: number, v: readonly number[]): FPVector => {
   return FP.f32.toVector(v.map(e => FP.f32.subtractionInterval(s, e)));
 };
 
diff --git a/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
index 7f84f016683b..390129f2c73a 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/bitcast.spec.ts
@@ -123,7 +123,7 @@ const f16ZerosInterval: FPInterval = new FPInterval('f16', -0.0, 0.0);
  * @returns an u32 whose lower and higher 16bits are the two elements of the
  * given array of two u16 respectively, in little-endian.
  */
-function u16x2ToU32(u16x2: number[]): number {
+function u16x2ToU32(u16x2: readonly number[]): number {
   assert(u16x2.length === 2);
   // Create a DataView with 4 bytes buffer.
   const buffer = new ArrayBuffer(4);
@@ -531,7 +531,7 @@ function possible32BitScalarIntervalsFromF16x2(
   }
   const possibleU16Bits = f16x2InU16x2.map(possibleBitsInU16FromFiniteF16InU16);
   const possibleExpectations = cartesianProduct(...possibleU16Bits).flatMap<Scalar | FPInterval>(
-    (possibleBitsU16x2: number[]) => {
+    (possibleBitsU16x2: readonly number[]) => {
       assert(possibleBitsU16x2.length === 2);
       return expectationsForValue(reinterpretFromU32(u16x2ToU32(possibleBitsU16x2)));
     }
diff --git a/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts
index 47aa4604498f..0113fd656f8d 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/clamp.spec.ts
@@ -97,7 +97,7 @@ function generateIntegerTestCases(
 }
 
 function generateFloatTestCases(
-  test_values: Array<number>,
+  test_values: readonly number[],
   trait: 'f32' | 'f16' | 'abstract',
   stage: 'const' | 'non-const'
 ): Array<Case> {
diff --git a/src/webgpu/shader/execution/expression/call/builtin/faceForward.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/faceForward.spec.ts
index f2a6b9584e96..6b6794fb9ff0 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/faceForward.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/faceForward.spec.ts
@@ -7,6 +7,7 @@ Returns e1 if dot(e2,e3) is negative, and -e1 otherwise.
 `;
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
+import { ROArrayArray } from '../../../../../../common/util/types.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { anyOf } from '../../../../../util/compare.js';
 import { toVector, TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
@@ -41,9 +42,9 @@ export const g = makeTestGroup(GPUTest);
  * */
 function makeCase(
   kind: FPKind,
-  x: number[],
-  y: number[],
-  z: number[],
+  x: readonly number[],
+  y: readonly number[],
+  z: readonly number[],
   check: IntervalFilter
 ): Case | undefined {
   const fp = FP[kind];
@@ -81,9 +82,9 @@ function makeCase(
  */
 function generateCases(
   kind: FPKind,
-  xs: number[][],
-  ys: number[][],
-  zs: number[][],
+  xs: ROArrayArray<number>,
+  ys: ROArrayArray<number>,
+  zs: ROArrayArray<number>,
   check: IntervalFilter
 ): Case[] {
   // Cannot use `cartesianProduct` here due to heterogeneous param types
diff --git a/src/webgpu/shader/execution/expression/call/builtin/frexp.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/frexp.spec.ts
index 3d74fc354799..ffe672b08cf9 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/frexp.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/frexp.spec.ts
@@ -56,19 +56,19 @@ function expBuilder(): ShaderBuilder {
 }
 
 /* @returns a fract Case for a given scalar or vector input */
-function makeVectorCaseFract(v: number | number[], trait: 'f32' | 'f16'): Case {
+function makeVectorCaseFract(v: number | readonly number[], trait: 'f32' | 'f16'): Case {
   const fp = FP[trait];
-  let toInput: (n: number[]) => Scalar | Vector;
-  let toOutput: (n: number[]) => Scalar | Vector;
+  let toInput: (n: readonly number[]) => Scalar | Vector;
+  let toOutput: (n: readonly number[]) => Scalar | Vector;
   if (v instanceof Array) {
     // Input is vector
-    toInput = (n: number[]) => toVector(n, fp.scalarBuilder);
-    toOutput = (n: number[]) => toVector(n, fp.scalarBuilder);
+    toInput = (n: readonly number[]) => toVector(n, fp.scalarBuilder);
+    toOutput = (n: readonly number[]) => toVector(n, fp.scalarBuilder);
   } else {
     // Input is scalar, also wrap it in an array.
     v = [v];
-    toInput = (n: number[]) => fp.scalarBuilder(n[0]);
-    toOutput = (n: number[]) => fp.scalarBuilder(n[0]);
+    toInput = (n: readonly number[]) => fp.scalarBuilder(n[0]);
+    toOutput = (n: readonly number[]) => fp.scalarBuilder(n[0]);
   }
 
   v = v.map(fp.quantize);
@@ -84,19 +84,19 @@ function makeVectorCaseFract(v: number | number[], trait: 'f32' | 'f16'): Case {
 }
 
 /* @returns an exp Case for a given scalar or vector input */
-function makeVectorCaseExp(v: number | number[], trait: 'f32' | 'f16'): Case {
+function makeVectorCaseExp(v: number | readonly number[], trait: 'f32' | 'f16'): Case {
   const fp = FP[trait];
-  let toInput: (n: number[]) => Scalar | Vector;
-  let toOutput: (n: number[]) => Scalar | Vector;
+  let toInput: (n: readonly number[]) => Scalar | Vector;
+  let toOutput: (n: readonly number[]) => Scalar | Vector;
   if (v instanceof Array) {
     // Input is vector
-    toInput = (n: number[]) => toVector(n, fp.scalarBuilder);
-    toOutput = (n: number[]) => toVector(n, i32);
+    toInput = (n: readonly number[]) => toVector(n, fp.scalarBuilder);
+    toOutput = (n: readonly number[]) => toVector(n, i32);
   } else {
     // Input is scalar, also wrap it in an array.
     v = [v];
-    toInput = (n: number[]) => fp.scalarBuilder(n[0]);
-    toOutput = (n: number[]) => i32(n[0]);
+    toInput = (n: readonly number[]) => fp.scalarBuilder(n[0]);
+    toOutput = (n: readonly number[]) => i32(n[0]);
   }
 
   v = v.map(fp.quantize);
diff --git a/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts
index 5bc4a54ab7d0..1a3d8a285091 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/modf.spec.ts
@@ -86,7 +86,7 @@ function makeScalarCaseWhole(kind: FPKind, n: number): Case {
 }
 
 /** @returns a fract Case for a given vector input */
-function makeVectorCaseFract(kind: FPKind, v: number[]): Case {
+function makeVectorCaseFract(kind: FPKind, v: readonly number[]): Case {
   const fp = FP[kind];
   v = v.map(fp.quantize);
   const fs = v.map(e => {
@@ -97,7 +97,7 @@ function makeVectorCaseFract(kind: FPKind, v: number[]): Case {
 }
 
 /** @returns a whole Case for a given vector input */
-function makeVectorCaseWhole(kind: FPKind, v: number[]): Case {
+function makeVectorCaseWhole(kind: FPKind, v: readonly number[]): Case {
   const fp = FP[kind];
   v = v.map(fp.quantize);
   const ws = v.map(e => {
diff --git a/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
index 9cc726276b42..be1a76b4372f 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/refract.spec.ts
@@ -11,6 +11,7 @@ vector e3*e1- (e3* dot(e2,e1) + sqrt(k)) *e2.
 `;
 
 import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
+import { ROArrayArray } from '../../../../../../common/util/types.js';
 import { GPUTest } from '../../../../../gpu_test.js';
 import { toVector, TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
 import { FP, FPKind } from '../../../../../util/floating_point.js';
@@ -41,8 +42,8 @@ export const g = makeTestGroup(GPUTest);
  * */
 function makeCase(
   kind: FPKind,
-  i: number[],
-  s: number[],
+  i: readonly number[],
+  s: readonly number[],
   r: number,
   check: IntervalFilter
 ): Case | undefined {
@@ -72,9 +73,9 @@ function makeCase(
  */
 function generateCases(
   kind: FPKind,
-  param_is: number[][],
-  param_ss: number[][],
-  param_rs: number[],
+  param_is: ROArrayArray<number>,
+  param_ss: ROArrayArray<number>,
+  param_rs: readonly number[],
   check: IntervalFilter
 ): Case[] {
   // Cannot use `cartesianProduct` here due to heterogeneous param types
diff --git a/src/webgpu/shader/execution/expression/expression.ts b/src/webgpu/shader/execution/expression/expression.ts
index e78081e70eab..8765476831d4 100644
--- a/src/webgpu/shader/execution/expression/expression.ts
+++ b/src/webgpu/shader/execution/expression/expression.ts
@@ -1,4 +1,5 @@
 import { globalTestConfig } from '../../../../common/framework/test_config.js';
+import { ROArrayArray } from '../../../../common/util/types.js';
 import { assert, objectEquals, unreachable } from '../../../../common/util/util.js';
 import { GPUTest } from '../../../gpu_test.js';
 import { compare, Comparator, ComparatorImpl } from '../../../util/compare.js';
@@ -27,7 +28,12 @@ import {
   quantizeToU32,
 } from '../../../util/math.js';
 
-export type Expectation = Value | FPInterval | FPInterval[] | FPInterval[][] | Comparator;
+export type Expectation =
+  | Value
+  | FPInterval
+  | readonly FPInterval[]
+  | ROArrayArray<FPInterval>
+  | Comparator;
 
 /** @returns if this Expectation actually a Comparator */
 export function isComparator(e: Expectation): e is Comparator {
@@ -52,7 +58,7 @@ export function toComparator(input: Expectation): Comparator {
 /** Case is a single expression test case. */
 export type Case = {
   // The input value(s)
-  input: Value | Array<Value>;
+  input: Value | ReadonlyArray<Value>;
   // The expected result, or function to check the result
   expected: Expectation;
 };
@@ -466,7 +472,7 @@ function submitBatch(
  * transformed with @p fn.
  * If @p v is not an array, then @p fn is called with (v, 0).
  */
-function map<T, U>(v: T | T[], fn: (value: T, index?: number) => U): U[] {
+function map<T, U>(v: T | readonly T[], fn: (value: T, index?: number) => U): U[] {
   if (v instanceof Array) {
     return v.map(fn);
   }
@@ -588,7 +594,7 @@ function wgslHeader(parameterTypes: Array<Type>, resultType: Type) {
  * ExpressionBuilder returns the WGSL used to evaluate an expression with the
  * given input values.
  */
-export type ExpressionBuilder = (values: Array<string>) => string;
+export type ExpressionBuilder = (values: ReadonlyArray<string>) => string;
 
 /**
  * Returns a ShaderBuilder that builds a basic expression test shader.
@@ -1212,8 +1218,8 @@ export interface BinaryOp {
  * @param scalarize function to convert numbers to Scalars
  */
 function generateScalarBinaryToScalarCases(
-  param0s: number[],
-  param1s: number[],
+  param0s: readonly number[],
+  param1s: readonly number[],
   op: BinaryOp,
   quantize: QuantizeFunc,
   scalarize: ScalarBuilder
@@ -1235,7 +1241,11 @@ function generateScalarBinaryToScalarCases(
  * @param param1s array of inputs to try for the second param
  * @param op callback called on each pair of inputs to produce each case
  */
-export function generateBinaryToI32Cases(param0s: number[], param1s: number[], op: BinaryOp) {
+export function generateBinaryToI32Cases(
+  param0s: readonly number[],
+  param1s: readonly number[],
+  op: BinaryOp
+) {
   return generateScalarBinaryToScalarCases(param0s, param1s, op, quantizeToI32, i32);
 }
 
@@ -1245,7 +1255,11 @@ export function generateBinaryToI32Cases(param0s: number[], param1s: number[], o
  * @param param1s array of inputs to try for the second param
  * @param op callback called on each pair of inputs to produce each case
  */
-export function generateBinaryToU32Cases(param0s: number[], param1s: number[], op: BinaryOp) {
+export function generateBinaryToU32Cases(
+  param0s: readonly number[],
+  param1s: readonly number[],
+  op: BinaryOp
+) {
   return generateScalarBinaryToScalarCases(param0s, param1s, op, quantizeToU32, u32);
 }
 
@@ -1259,7 +1273,7 @@ export function generateBinaryToU32Cases(param0s: number[], param1s: number[], o
  */
 function makeScalarVectorBinaryToVectorCase(
   scalar: number,
-  vector: number[],
+  vector: readonly number[],
   op: BinaryOp,
   quantize: QuantizeFunc,
   scalarize: ScalarBuilder
@@ -1272,7 +1286,7 @@ function makeScalarVectorBinaryToVectorCase(
   }
   return {
     input: [scalarize(scalar), new Vector(vector.map(scalarize))],
-    expected: new Vector((result as number[]).map(scalarize)),
+    expected: new Vector((result as readonly number[]).map(scalarize)),
   };
 }
 
@@ -1285,8 +1299,8 @@ function makeScalarVectorBinaryToVectorCase(
  * @param scalarize function to convert numbers to Scalars
  */
 function generateScalarVectorBinaryToVectorCases(
-  scalars: number[],
-  vectors: number[][],
+  scalars: readonly number[],
+  vectors: ROArrayArray<number>,
   op: BinaryOp,
   quantize: QuantizeFunc,
   scalarize: ScalarBuilder
@@ -1312,7 +1326,7 @@ function generateScalarVectorBinaryToVectorCases(
  * @param scalarize function to convert numbers to Scalars
  */
 function makeVectorScalarBinaryToVectorCase(
-  vector: number[],
+  vector: readonly number[],
   scalar: number,
   op: BinaryOp,
   quantize: QuantizeFunc,
@@ -1326,7 +1340,7 @@ function makeVectorScalarBinaryToVectorCase(
   }
   return {
     input: [new Vector(vector.map(scalarize)), scalarize(scalar)],
-    expected: new Vector((result as number[]).map(scalarize)),
+    expected: new Vector((result as readonly number[]).map(scalarize)),
   };
 }
 
@@ -1339,8 +1353,8 @@ function makeVectorScalarBinaryToVectorCase(
  * @param scalarize function to convert numbers to Scalars
  */
 function generateVectorScalarBinaryToVectorCases(
-  vectors: number[][],
-  scalars: number[],
+  vectors: ROArrayArray<number>,
+  scalars: readonly number[],
   op: BinaryOp,
   quantize: QuantizeFunc,
   scalarize: ScalarBuilder
@@ -1364,8 +1378,8 @@ function generateVectorScalarBinaryToVectorCases(
  * @param op he op to apply to each pair of scalar and vector
  */
 export function generateU32VectorBinaryToVectorCases(
-  scalars: number[],
-  vectors: number[][],
+  scalars: readonly number[],
+  vectors: ROArrayArray<number>,
   op: BinaryOp
 ): Case[] {
   return generateScalarVectorBinaryToVectorCases(scalars, vectors, op, quantizeToU32, u32);
@@ -1378,8 +1392,8 @@ export function generateU32VectorBinaryToVectorCases(
  * @param op he op to apply to each pair of vector and scalar
  */
 export function generateVectorU32BinaryToVectorCases(
-  vectors: number[][],
-  scalars: number[],
+  vectors: ROArrayArray<number>,
+  scalars: readonly number[],
   op: BinaryOp
 ): Case[] {
   return generateVectorScalarBinaryToVectorCases(vectors, scalars, op, quantizeToU32, u32);
@@ -1392,8 +1406,8 @@ export function generateVectorU32BinaryToVectorCases(
  * @param op he op to apply to each pair of scalar and vector
  */
 export function generateI32VectorBinaryToVectorCases(
-  scalars: number[],
-  vectors: number[][],
+  scalars: readonly number[],
+  vectors: ROArrayArray<number>,
   op: BinaryOp
 ): Case[] {
   return generateScalarVectorBinaryToVectorCases(scalars, vectors, op, quantizeToI32, i32);
@@ -1406,8 +1420,8 @@ export function generateI32VectorBinaryToVectorCases(
  * @param op he op to apply to each pair of vector and scalar
  */
 export function generateVectorI32BinaryToVectorCases(
-  vectors: number[][],
-  scalars: number[],
+  vectors: ROArrayArray<number>,
+  scalars: readonly number[],
   op: BinaryOp
 ): Case[] {
   return generateVectorScalarBinaryToVectorCases(vectors, scalars, op, quantizeToI32, i32);
diff --git a/src/webgpu/shader/execution/zero_init.spec.ts b/src/webgpu/shader/execution/zero_init.spec.ts
index ad7b095b8995..d209c1325420 100644
--- a/src/webgpu/shader/execution/zero_init.spec.ts
+++ b/src/webgpu/shader/execution/zero_init.spec.ts
@@ -15,7 +15,7 @@ import {
 
 type ShaderTypeInfo =
   | { type: 'container'; containerType: 'array'; elementType: ShaderTypeInfo; length: number }
-  | { type: 'container'; containerType: 'struct'; members: ShaderTypeInfo[] }
+  | { type: 'container'; containerType: 'struct'; members: readonly ShaderTypeInfo[] }
   | {
       type: 'container';
       containerType: keyof typeof kVectorContainerTypeInfo | keyof typeof kMatrixContainerTypeInfo;
diff --git a/src/webgpu/util/conversion.ts b/src/webgpu/util/conversion.ts
index f94c2b918806..e78af9783288 100644
--- a/src/webgpu/util/conversion.ts
+++ b/src/webgpu/util/conversion.ts
@@ -1,4 +1,5 @@
 import { Colors } from '../../common/util/colors.js';
+import { ROArrayArray } from '../../common/util/types.js';
 import { assert, objectEquals, TypedArrayBufferView, unreachable } from '../../common/util/util.js';
 import { Float16Array } from '../../external/petamoriken/float16/float16.js';
 
@@ -353,7 +354,7 @@ export function unpackRGB9E5UFloat(encoded: number): { R: number; G: number; B:
 export function pack2x16float(x: number, y: number): (number | undefined)[] {
   // Generates all possible valid u16 bit fields for a given f32 to f16 conversion.
   // Assumes FTZ for both the f32 and f16 value is allowed.
-  const generateU16s = (n: number): number[] => {
+  const generateU16s = (n: number): readonly number[] => {
     let contains_subnormals = isSubnormalNumberF32(n);
     const n_f16s = correctlyRoundedF16(n);
     contains_subnormals ||= n_f16s.some(isSubnormalNumberF16);
@@ -668,7 +669,7 @@ export class VectorType {
   }
 
   /** Constructs a Vector of this type with the given values */
-  public create(value: number | number[]): Vector {
+  public create(value: number | readonly number[]): Vector {
     if (value instanceof Array) {
       assert(value.length === this.width);
     } else {
@@ -1184,7 +1185,7 @@ export function vec4(x: Scalar, y: Scalar, z: Scalar, w: Scalar) {
  * @param v array of numbers to be converted, must contain 2, 3 or 4 elements
  * @param op function to convert from number to Scalar, e.g. 'f32`
  */
-export function toVector(v: number[], op: (n: number) => Scalar): Vector {
+export function toVector(v: readonly number[], op: (n: number) => Scalar): Vector {
   switch (v.length) {
     case 2:
       return vec2(op(v[0]), op(v[1]));
@@ -1266,7 +1267,7 @@ export class Matrix {
  *          be of the same length. All Arrays must have 2, 3, or 4 elements.
  * @param op function to convert from number to Scalar, e.g. 'f32`
  */
-export function toMatrix(m: number[][], op: (n: number) => Scalar): Matrix {
+export function toMatrix(m: ROArrayArray<number>, op: (n: number) => Scalar): Matrix {
   const cols = m.length;
   const rows = m[0].length;
   const elements: Scalar[][] = [...Array<Scalar[]>(cols)].map(_ => [...Array<Scalar>(rows)]);
@@ -1291,13 +1292,13 @@ export type SerializedValueScalar = {
 export type SerializedValueVector = {
   kind: 'vector';
   type: ScalarKind;
-  value: boolean[] | number[];
+  value: boolean[] | readonly number[];
 };
 
 export type SerializedValueMatrix = {
   kind: 'matrix';
   type: ScalarKind;
-  value: number[][];
+  value: ROArrayArray<number>;
 };
 
 export type SerializedValue = SerializedValueScalar | SerializedValueVector | SerializedValueMatrix;
@@ -1326,7 +1327,7 @@ export function serializeValue(v: Value): SerializedValue {
     return {
       kind: 'vector',
       type: kind,
-      value: v.elements.map(e => value(kind, e)) as boolean[] | number[],
+      value: v.elements.map(e => value(kind, e)) as boolean[] | readonly number[],
     };
   }
   if (v instanceof Matrix) {
@@ -1334,7 +1335,7 @@ export function serializeValue(v: Value): SerializedValue {
     return {
       kind: 'matrix',
       type: kind,
-      value: v.elements.map(c => c.map(r => value(kind, r))) as number[][],
+      value: v.elements.map(c => c.map(r => value(kind, r))) as ROArrayArray<number>,
     };
   }
 
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 70109f5cab9e..18a640f43403 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -1,3 +1,4 @@
+import { ROArrayArray, ROArrayArrayArray } from '../../common/util/types.js';
 import { assert, unreachable } from '../../common/util/util.js';
 import { Float16Array } from '../../external/petamoriken/float16/float16.js';
 import { Case, IntervalFilter } from '../shader/execution/expression/expression.js';
@@ -59,7 +60,7 @@ export type FPKind = 'f32' | 'f16' | 'abstract';
  * two elements, the first is the lower bound of the interval and the second is
  * the upper bound.
  */
-export type IntervalBounds = [number] | [number, number];
+export type IntervalBounds = readonly [number] | readonly [number, number];
 
 /** Represents a closed interval of floating point numbers */
 export class FPInterval {
@@ -224,47 +225,54 @@ export type FPVector =
   | [FPInterval, FPInterval, FPInterval, FPInterval];
 
 /** Shorthand for an Array of Arrays that contains a column-major matrix */
-type Array2D<T> = T[][];
+type Array2D<T> = ROArrayArray<T>;
 
 /**
  * Representation of a matCxR of floating point intervals as an array of arrays
  * of FPIntervals. This maps onto the WGSL concept of matrix. Internally
  */
 export type FPMatrix =
-  | [[FPInterval, FPInterval], [FPInterval, FPInterval]]
-  | [[FPInterval, FPInterval], [FPInterval, FPInterval], [FPInterval, FPInterval]]
-  | [
-      [FPInterval, FPInterval],
-      [FPInterval, FPInterval],
-      [FPInterval, FPInterval],
-      [FPInterval, FPInterval]
+  | readonly [readonly [FPInterval, FPInterval], readonly [FPInterval, FPInterval]]
+  | readonly [
+      readonly [FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval]
     ]
-  | [[FPInterval, FPInterval, FPInterval], [FPInterval, FPInterval, FPInterval]]
-  | [
-      [FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval]
+  | readonly [
+      readonly [FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval]
     ]
-  | [
-      [FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval]
+  | readonly [
+      readonly [FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval]
     ]
-  | [
-      [FPInterval, FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval, FPInterval]
+  | readonly [
+      readonly [FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval]
     ]
-  | [
-      [FPInterval, FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval, FPInterval]
+  | readonly [
+      readonly [FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval]
     ]
-  | [
-      [FPInterval, FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval, FPInterval],
-      [FPInterval, FPInterval, FPInterval, FPInterval]
+  | readonly [
+      readonly [FPInterval, FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval, FPInterval]
+    ]
+  | readonly [
+      readonly [FPInterval, FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval, FPInterval]
+    ]
+  | readonly [
+      readonly [FPInterval, FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval, FPInterval],
+      readonly [FPInterval, FPInterval, FPInterval, FPInterval]
     ];
 
 // Utilities
@@ -272,7 +280,7 @@ export type FPMatrix =
 /** @returns input with an appended 0, if inputs contains non-zero subnormals */
 // When f16 traits is defined, this can be replaced with something like
 // `FP.f16..addFlushIfNeeded`
-function addFlushedIfNeededF16(values: number[]): number[] {
+function addFlushedIfNeededF16(values: readonly number[]): readonly number[] {
   return values.some(v => v !== 0 && isSubnormalNumberF16(v)) ? values.concat(0) : values;
 }
 
@@ -343,8 +351,8 @@ interface ScalarPairToIntervalOp {
 /** Domain for a ScalarPairToInterval implementation */
 interface ScalarPairToIntervalDomain {
   // Arrays to support discrete valid domain intervals
-  x: FPInterval[];
-  y: FPInterval[];
+  x: readonly FPInterval[];
+  y: readonly FPInterval[];
 }
 
 /**
@@ -384,7 +392,7 @@ export interface ScalarToVector {
  * from tests.
  */
 export interface VectorToInterval {
-  (x: number[]): FPInterval;
+  (x: readonly number[]): FPInterval;
 }
 
 /** Operation used to implement a VectorToInterval */
@@ -400,7 +408,7 @@ interface VectorToIntervalOp {
  * from tests.
  */
 export interface VectorPairToInterval {
-  (x: number[], y: number[]): FPInterval;
+  (x: readonly number[], y: readonly number[]): FPInterval;
 }
 
 /** Operation used to implement a VectorPairToInterval */
@@ -416,7 +424,7 @@ interface VectorPairToIntervalOp {
  * from tests.
  */
 export interface VectorToVector {
-  (x: number[]): FPVector;
+  (x: readonly number[]): FPVector;
 }
 
 /** Operation used to implement a VectorToVector */
@@ -433,7 +441,7 @@ interface VectorToVectorOp {
  * from tests.
  */
 export interface VectorPairToVector {
-  (x: number[], y: number[]): FPVector;
+  (x: readonly number[], y: readonly number[]): FPVector;
 }
 
 /** Operation used to implement a VectorPairToVector */
@@ -450,7 +458,7 @@ interface VectorPairToVectorOp {
  * from tests.
  */
 export interface VectorScalarToVector {
-  (x: number[], y: number): FPVector;
+  (x: readonly number[], y: number): FPVector;
 }
 
 /**
@@ -460,7 +468,7 @@ export interface VectorScalarToVector {
  * from tests.
  */
 export interface ScalarVectorToVector {
-  (x: number, y: number[]): FPVector;
+  (x: number, y: readonly number[]): FPVector;
 }
 
 /**
@@ -525,7 +533,7 @@ export interface ScalarMatrixToMatrix {
  * from tests.
  */
 export interface MatrixVectorToVector {
-  (x: Array2D<number>, y: number[]): FPVector;
+  (x: Array2D<number>, y: readonly number[]): FPVector;
 }
 
 /**
@@ -535,7 +543,7 @@ export interface MatrixVectorToVector {
  * from tests.
  */
 export interface VectorMatrixToVector {
-  (x: number[], y: Array2D<number>): FPVector;
+  (x: readonly number[], y: Array2D<number>): FPVector;
 }
 
 // Traits
@@ -684,7 +692,7 @@ export abstract class FPTraits {
    * @returns an interval with the tightest bounds that includes all provided
    *          intervals
    */
-  public spanIntervals(...intervals: FPInterval[]): FPInterval {
+  public spanIntervals(...intervals: readonly FPInterval[]): FPInterval {
     assert(intervals.length > 0, `span of an empty list of FPIntervals is not allowed`);
     assert(
       intervals.every(i => i.kind === this.kind),
@@ -700,7 +708,7 @@ export abstract class FPTraits {
   }
 
   /** Narrow an array of values to FPVector if possible */
-  public isVector(v: (number | IntervalBounds | FPInterval)[]): v is FPVector {
+  public isVector(v: ReadonlyArray<number | IntervalBounds | FPInterval>): v is FPVector {
     if (v.every(e => e instanceof FPInterval && e.kind === this.kind)) {
       return v.length === 2 || v.length === 3 || v.length === 4;
     }
@@ -708,13 +716,13 @@ export abstract class FPTraits {
   }
 
   /** @returns an FPVector representation of an array of values if possible */
-  public toVector(v: (number | IntervalBounds | FPInterval)[]): FPVector {
+  public toVector(v: ReadonlyArray<number | IntervalBounds | FPInterval>): FPVector {
     if (this.isVector(v) && v.every(e => e.kind === this.kind)) {
       return v;
     }
 
     const f = v.map(e => this.toInterval(e));
-    // The return of the map above is a FPInterval[], which needs to be narrowed
+    // The return of the map above is a readonly FPInterval[], which needs to be narrowed
     // to FPVector, since FPVector is defined as fixed length tuples.
     if (this.isVector(f)) {
       return f;
@@ -751,13 +759,13 @@ export abstract class FPTraits {
     if (!m.every(c => c.every(e => e instanceof FPInterval && e.kind === this.kind))) {
       return false;
     }
-    // At this point m guaranteed to be a FPInterval[][], but maybe typed as a
+    // At this point m guaranteed to be a ROArrayArray<FPInterval>, but maybe typed as a
     // FPVector[].
     // Coercing the type since FPVector[] is functionally equivalent to
-    // FPInterval[][] for .length and .every, but they are type compatible,
+    // ROArrayArray<FPInterval> for .length and .every, but they are type compatible,
     // since tuples are not equivalent to arrays, so TS considers c in .every to
     // be unresolvable below, even though our usage is safe.
-    m = m as FPInterval[][];
+    m = m as ROArrayArray<FPInterval>;
 
     if (m.length > 4 || m.length < 2) {
       return false;
@@ -784,7 +792,7 @@ export abstract class FPTraits {
 
     const result = map2DArray(m, this.toInterval.bind(this));
 
-    // The return of the map above is a FPInterval[][], which needs to be
+    // The return of the map above is a ROArrayArray<FPInterval>, which needs to be
     // narrowed to FPMatrix, since FPMatrix is defined as fixed length tuples.
     if (this.isMatrix(result)) {
       return result;
@@ -808,7 +816,7 @@ export abstract class FPTraits {
       `Matrix span is not defined for Matrices of differing dimensions`
     );
 
-    const result: Array2D<FPInterval> = [...Array(num_cols)].map(_ => [...Array(num_rows)]);
+    const result: FPInterval[][] = [...Array(num_cols)].map(_ => [...Array(num_rows)]);
     for (let i = 0; i < num_cols; i++) {
       for (let j = 0; j < num_rows; j++) {
         result[i][j] = this.spanIntervals(...ms.map(m => m[i][j]));
@@ -819,7 +827,7 @@ export abstract class FPTraits {
   }
 
   /** @returns input with an appended 0, if inputs contains non-zero subnormals */
-  public addFlushedIfNeeded(values: number[]): number[] {
+  public addFlushedIfNeeded(values: readonly number[]): readonly number[] {
     const subnormals = values.filter(this.isSubnormal);
     const needs_zero = subnormals.length > 0 && subnormals.every(s => s !== 0);
     return needs_zero ? values.concat(0) : values;
@@ -904,22 +912,25 @@ export abstract class FPTraits {
   /** Stub for vector pair to interval generator */
   protected unimplementedVectorPairToInterval(
     name: string,
-    _x: (number | FPInterval)[],
-    _y: (number | FPInterval)[]
+    _x: readonly (number | FPInterval)[],
+    _y: readonly (number | FPInterval)[]
   ): FPInterval {
     unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for vector to vector generator */
-  protected unimplementedVectorToVector(name: string, _x: (number | FPInterval)[]): FPVector {
+  protected unimplementedVectorToVector(
+    name: string,
+    _x: readonly (number | FPInterval)[]
+  ): FPVector {
     unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for vector pair to vector generator */
   protected unimplementedVectorPairToVector(
     name: string,
-    _x: (number | FPInterval)[],
-    _y: (number | FPInterval)[]
+    _x: readonly (number | FPInterval)[],
+    _y: readonly (number | FPInterval)[]
   ): FPVector {
     unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
@@ -927,7 +938,7 @@ export abstract class FPTraits {
   /** Stub for vector-scalar to vector generator */
   protected unimplementedVectorScalarToVector(
     name: string,
-    _x: (number | FPInterval)[],
+    _x: readonly (number | FPInterval)[],
     _y: number | FPInterval
   ): FPVector {
     unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
@@ -983,7 +994,7 @@ export abstract class FPTraits {
   protected unimplementedMatrixVectorToVector(
     name: string,
     _x: Array2D<number>,
-    _y: (number | FPInterval)[]
+    _y: readonly (number | FPInterval)[]
   ): FPVector {
     unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
@@ -991,28 +1002,33 @@ export abstract class FPTraits {
   /** Stub for vector-matrix to vector generator  */
   protected unimplementedVectorMatrixToVector(
     name: string,
-    _x: (number | FPInterval)[],
+    _x: readonly (number | FPInterval)[],
     _y: Array2D<number>
   ): FPVector {
     unreachable(`'${name}' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for distance generator */
-  protected unimplementedDistance(_x: number | number[], _y: number | number[]): FPInterval {
+  protected unimplementedDistance(
+    _x: number | readonly number[],
+    _y: number | readonly number[]
+  ): FPInterval {
     unreachable(`'distance' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for faceForward */
   protected unimplementedFaceForward(
-    _x: number[],
-    _y: number[],
-    _z: number[]
+    _x: readonly number[],
+    _y: readonly number[],
+    _z: readonly number[]
   ): (FPVector | undefined)[] {
     unreachable(`'faceForward' is not yet implemented for '${this.kind}'`);
   }
 
   /** Stub for length generator */
-  protected unimplementedLength(_x: number | FPInterval | number[] | FPVector): FPInterval {
+  protected unimplementedLength(
+    _x: number | FPInterval | readonly number[] | FPVector
+  ): FPInterval {
     unreachable(`'length' is not yet implemented for '${this.kind}'`);
   }
 
@@ -1022,7 +1038,11 @@ export abstract class FPTraits {
   }
 
   /** Stub for refract generator */
-  protected unimplementedRefract(_i: number[], _s: number[], _r: number): FPVector {
+  protected unimplementedRefract(
+    _i: readonly number[],
+    _s: readonly number[],
+    _r: number
+  ): FPVector {
     unreachable(`'refract' is not yet implemented for '${this.kind}'`);
   }
 
@@ -1043,7 +1063,7 @@ export abstract class FPTraits {
    */
   public abstract readonly quantize: (n: number) => number;
   /** @returns all valid roundings of input */
-  public abstract readonly correctlyRounded: (n: number) => number[];
+  public abstract readonly correctlyRounded: (n: number) => readonly number[];
   /** @returns true if input is considered finite, otherwise false */
   public abstract readonly isFinite: (n: number) => boolean;
   /** @returns true if input is considered subnormal, otherwise false */
@@ -1085,7 +1105,7 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   public generateScalarToIntervalCases(
-    params: number[],
+    params: readonly number[],
     filter: IntervalFilter,
     ...ops: ScalarToInterval[]
   ): Case[] {
@@ -1133,8 +1153,8 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   public generateScalarPairToIntervalCases(
-    param0s: number[],
-    param1s: number[],
+    param0s: readonly number[],
+    param1s: readonly number[],
     filter: IntervalFilter,
     ...ops: ScalarPairToInterval[]
   ): Case[] {
@@ -1186,9 +1206,9 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   public generateScalarTripleToIntervalCases(
-    param0s: number[],
-    param1s: number[],
-    param2s: number[],
+    param0s: readonly number[],
+    param1s: readonly number[],
+    param2s: readonly number[],
     filter: IntervalFilter,
     ...ops: ScalarTripleToInterval[]
   ): Case[] {
@@ -1209,7 +1229,7 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   private makeVectorToIntervalCase(
-    param: number[],
+    param: readonly number[],
     filter: IntervalFilter,
     ...ops: VectorToInterval[]
   ): Case | undefined {
@@ -1232,7 +1252,7 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   public generateVectorToIntervalCases(
-    params: number[][],
+    params: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: VectorToInterval[]
   ): Case[] {
@@ -1254,8 +1274,8 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   private makeVectorPairToIntervalCase(
-    param0: number[],
-    param1: number[],
+    param0: readonly number[],
+    param1: readonly number[],
     filter: IntervalFilter,
     ...ops: VectorPairToInterval[]
   ): Case | undefined {
@@ -1280,8 +1300,8 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   public generateVectorPairToIntervalCases(
-    param0s: number[][],
-    param1s: number[][],
+    param0s: ROArrayArray<number>,
+    param1s: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: VectorPairToInterval[]
   ): Case[] {
@@ -1302,7 +1322,7 @@ export abstract class FPTraits {
    *            intervals.
    */
   private makeVectorToVectorCase(
-    param: number[],
+    param: readonly number[],
     filter: IntervalFilter,
     ...ops: VectorToVector[]
   ): Case | undefined {
@@ -1326,7 +1346,7 @@ export abstract class FPTraits {
    *            intervals.
    */
   public generateVectorToVectorCases(
-    params: number[][],
+    params: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: VectorToVector[]
   ): Case[] {
@@ -1349,7 +1369,7 @@ export abstract class FPTraits {
    */
   private makeScalarVectorToVectorCase(
     scalar: number,
-    vector: number[],
+    vector: readonly number[],
     filter: IntervalFilter,
     ...ops: ScalarVectorToVector[]
   ): Case | undefined {
@@ -1374,8 +1394,8 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating a vector of acceptance intervals
    */
   public generateScalarVectorToVectorCases(
-    scalars: number[],
-    vectors: number[][],
+    scalars: readonly number[],
+    vectors: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: ScalarVectorToVector[]
   ): Case[] {
@@ -1401,7 +1421,7 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating a vector of acceptance intervals
    */
   private makeVectorScalarToVectorCase(
-    vector: number[],
+    vector: readonly number[],
     scalar: number,
     filter: IntervalFilter,
     ...ops: VectorScalarToVector[]
@@ -1427,8 +1447,8 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating a vector of acceptance intervals
    */
   public generateVectorScalarToVectorCases(
-    vectors: number[][],
-    scalars: number[],
+    vectors: ROArrayArray<number>,
+    scalars: readonly number[],
     filter: IntervalFilter,
     ...ops: VectorScalarToVector[]
   ): Case[] {
@@ -1454,8 +1474,8 @@ export abstract class FPTraits {
    *            intervals.
    */
   private makeVectorPairToVectorCase(
-    param0: number[],
-    param1: number[],
+    param0: readonly number[],
+    param1: readonly number[],
     filter: IntervalFilter,
     ...ops: VectorPairToVector[]
   ): Case | undefined {
@@ -1480,8 +1500,8 @@ export abstract class FPTraits {
    *            intervals.
    */
   public generateVectorPairToVectorCases(
-    param0s: number[][],
-    param1s: number[][],
+    param0s: ROArrayArray<number>,
+    param1s: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: VectorPairToVector[]
   ): Case[] {
@@ -1505,8 +1525,8 @@ export abstract class FPTraits {
    *                         one component result at a time.
    */
   private makeVectorPairScalarToVectorComponentWiseCase(
-    param0: number[],
-    param1: number[],
+    param0: readonly number[],
+    param1: readonly number[],
     param2: number,
     filter: IntervalFilter,
     ...componentWiseOps: ScalarTripleToInterval[]
@@ -1545,9 +1565,9 @@ export abstract class FPTraits {
    * @param componentWiseOpscallbacks that implement generating a component-wise acceptance interval
    */
   public generateVectorPairScalarToVectorComponentWiseCase(
-    param0s: number[][],
-    param1s: number[][],
-    param2s: number[],
+    param0s: ROArrayArray<number>,
+    param1s: ROArrayArray<number>,
+    param2s: readonly number[],
     filter: IntervalFilter,
     ...componentWiseOps: ScalarTripleToInterval[]
   ): Case[] {
@@ -1579,7 +1599,7 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   private makeMatrixToScalarCase(
-    param: number[][],
+    param: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: MatrixToScalar[]
   ): Case | undefined {
@@ -1603,7 +1623,7 @@ export abstract class FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   public generateMatrixToScalarCases(
-    params: number[][][],
+    params: ROArrayArrayArray<number>,
     filter: IntervalFilter,
     ...ops: MatrixToScalar[]
   ): Case[] {
@@ -1624,7 +1644,7 @@ export abstract class FPTraits {
    *            intervals
    */
   private makeMatrixToMatrixCase(
-    param: number[][],
+    param: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: MatrixToMatrix[]
   ): Case | undefined {
@@ -1649,7 +1669,7 @@ export abstract class FPTraits {
    *            intervals
    */
   public generateMatrixToMatrixCases(
-    params: number[][][],
+    params: ROArrayArrayArray<number>,
     filter: IntervalFilter,
     ...ops: MatrixToMatrix[]
   ): Case[] {
@@ -1671,8 +1691,8 @@ export abstract class FPTraits {
    *            intervals
    */
   private makeMatrixPairToMatrixCase(
-    param0: number[][],
-    param1: number[][],
+    param0: ROArrayArray<number>,
+    param1: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: MatrixPairToMatrix[]
   ): Case | undefined {
@@ -1698,8 +1718,8 @@ export abstract class FPTraits {
    *            intervals
    */
   public generateMatrixPairToMatrixCases(
-    param0s: number[][][],
-    param1s: number[][][],
+    param0s: ROArrayArrayArray<number>,
+    param1s: ROArrayArrayArray<number>,
     filter: IntervalFilter,
     ...ops: MatrixPairToMatrix[]
   ): Case[] {
@@ -1721,7 +1741,7 @@ export abstract class FPTraits {
    *            intervals
    */
   private makeMatrixScalarToMatrixCase(
-    mat: number[][],
+    mat: ROArrayArray<number>,
     scalar: number,
     filter: IntervalFilter,
     ...ops: MatrixScalarToMatrix[]
@@ -1748,8 +1768,8 @@ export abstract class FPTraits {
    *            intervals
    */
   public generateMatrixScalarToMatrixCases(
-    mats: number[][][],
-    scalars: number[],
+    mats: ROArrayArrayArray<number>,
+    scalars: readonly number[],
     filter: IntervalFilter,
     ...ops: MatrixScalarToMatrix[]
   ): Case[] {
@@ -1776,7 +1796,7 @@ export abstract class FPTraits {
    */
   private makeScalarMatrixToMatrixCase(
     scalar: number,
-    mat: number[][],
+    mat: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: ScalarMatrixToMatrix[]
   ): Case | undefined {
@@ -1802,8 +1822,8 @@ export abstract class FPTraits {
    *            intervals
    */
   public generateScalarMatrixToMatrixCases(
-    scalars: number[],
-    mats: number[][][],
+    scalars: readonly number[],
+    mats: ROArrayArrayArray<number>,
     filter: IntervalFilter,
     ...ops: ScalarMatrixToMatrix[]
   ): Case[] {
@@ -1829,8 +1849,8 @@ export abstract class FPTraits {
    *            intervals
    */
   private makeMatrixVectorToVectorCase(
-    mat: number[][],
-    vec: number[],
+    mat: ROArrayArray<number>,
+    vec: readonly number[],
     filter: IntervalFilter,
     ...ops: MatrixVectorToVector[]
   ): Case | undefined {
@@ -1856,8 +1876,8 @@ export abstract class FPTraits {
    *            intervals
    */
   public generateMatrixVectorToVectorCases(
-    mats: number[][][],
-    vecs: number[][],
+    mats: ROArrayArrayArray<number>,
+    vecs: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: MatrixVectorToVector[]
   ): Case[] {
@@ -1883,8 +1903,8 @@ export abstract class FPTraits {
    *            intervals
    */
   private makeVectorMatrixToVectorCase(
-    vec: number[],
-    mat: number[][],
+    vec: readonly number[],
+    mat: ROArrayArray<number>,
     filter: IntervalFilter,
     ...ops: VectorMatrixToVector[]
   ): Case | undefined {
@@ -1910,8 +1930,8 @@ export abstract class FPTraits {
    *            intervals
    */
   public generateVectorMatrixToVectorCases(
-    vecs: number[][],
-    mats: number[][][],
+    vecs: ROArrayArray<number>,
+    mats: ROArrayArrayArray<number>,
     filter: IntervalFilter,
     ...ops: VectorMatrixToVector[]
   ): Case[] {
@@ -2035,14 +2055,14 @@ export abstract class FPTraits {
    * @param op operation defining the function being run
    * @returns a span over all the outputs of op.impl
    */
-  private roundAndFlushVectorToInterval(x: number[], op: VectorToIntervalOp): FPInterval {
+  private roundAndFlushVectorToInterval(x: readonly number[], op: VectorToIntervalOp): FPInterval {
     assert(
       x.every(e => !Number.isNaN(e)),
       `flush not defined for NaN`
     );
 
-    const x_rounded: number[][] = x.map(this.correctlyRounded);
-    const x_flushed: number[][] = x_rounded.map(this.addFlushedIfNeeded.bind(this));
+    const x_rounded: ROArrayArray<number> = x.map(this.correctlyRounded);
+    const x_flushed: ROArrayArray<number> = x_rounded.map(this.addFlushedIfNeeded.bind(this));
     const x_inputs = cartesianProduct<number>(...x_flushed);
 
     const intervals = new Set<FPInterval>();
@@ -2066,8 +2086,8 @@ export abstract class FPTraits {
    * @returns a span over all the outputs of op.impl
    */
   private roundAndFlushVectorPairToInterval(
-    x: number[],
-    y: number[],
+    x: readonly number[],
+    y: readonly number[],
     op: VectorPairToIntervalOp
   ): FPInterval {
     assert(
@@ -2079,10 +2099,10 @@ export abstract class FPTraits {
       `flush not defined for NaN`
     );
 
-    const x_rounded: number[][] = x.map(this.correctlyRounded);
-    const y_rounded: number[][] = y.map(this.correctlyRounded);
-    const x_flushed: number[][] = x_rounded.map(this.addFlushedIfNeeded.bind(this));
-    const y_flushed: number[][] = y_rounded.map(this.addFlushedIfNeeded.bind(this));
+    const x_rounded: ROArrayArray<number> = x.map(this.correctlyRounded);
+    const y_rounded: ROArrayArray<number> = y.map(this.correctlyRounded);
+    const x_flushed: ROArrayArray<number> = x_rounded.map(this.addFlushedIfNeeded.bind(this));
+    const y_flushed: ROArrayArray<number> = y_rounded.map(this.addFlushedIfNeeded.bind(this));
     const x_inputs = cartesianProduct<number>(...x_flushed);
     const y_inputs = cartesianProduct<number>(...y_flushed);
 
@@ -2106,14 +2126,14 @@ export abstract class FPTraits {
    * @param op operation defining the function being run
    * @returns a vector of spans for each outputs of op.impl
    */
-  private roundAndFlushVectorToVector(x: number[], op: VectorToVectorOp): FPVector {
+  private roundAndFlushVectorToVector(x: readonly number[], op: VectorToVectorOp): FPVector {
     assert(
       x.every(e => !Number.isNaN(e)),
       `flush not defined for NaN`
     );
 
-    const x_rounded: number[][] = x.map(this.correctlyRounded);
-    const x_flushed: number[][] = x_rounded.map(this.addFlushedIfNeeded.bind(this));
+    const x_rounded: ROArrayArray<number> = x.map(this.correctlyRounded);
+    const x_flushed: ROArrayArray<number> = x_rounded.map(this.addFlushedIfNeeded.bind(this));
     const x_inputs = cartesianProduct<number>(...x_flushed);
 
     const interval_vectors = new Set<FPVector>();
@@ -2137,8 +2157,8 @@ export abstract class FPTraits {
    * @returns a vector of spans for each output of op.impl
    */
   private roundAndFlushVectorPairToVector(
-    x: number[],
-    y: number[],
+    x: readonly number[],
+    y: readonly number[],
     op: VectorPairToVectorOp
   ): FPVector {
     assert(
@@ -2150,10 +2170,10 @@ export abstract class FPTraits {
       `flush not defined for NaN`
     );
 
-    const x_rounded: number[][] = x.map(this.correctlyRounded);
-    const y_rounded: number[][] = y.map(this.correctlyRounded);
-    const x_flushed: number[][] = x_rounded.map(this.addFlushedIfNeeded.bind(this));
-    const y_flushed: number[][] = y_rounded.map(this.addFlushedIfNeeded.bind(this));
+    const x_rounded: ROArrayArray<number> = x.map(this.correctlyRounded);
+    const y_rounded: ROArrayArray<number> = y.map(this.correctlyRounded);
+    const x_flushed: ROArrayArray<number> = x_rounded.map(this.addFlushedIfNeeded.bind(this));
+    const y_flushed: ROArrayArray<number> = y_rounded.map(this.addFlushedIfNeeded.bind(this));
     const x_inputs = cartesianProduct<number>(...x_flushed);
     const y_inputs = cartesianProduct<number>(...y_flushed);
 
@@ -2187,10 +2207,12 @@ export abstract class FPTraits {
     );
 
     const m_flat = flatten2DArray(m);
-    const m_rounded: number[][] = m_flat.map(this.correctlyRounded);
-    const m_flushed: number[][] = m_rounded.map(this.addFlushedIfNeeded.bind(this));
-    const m_options: number[][] = cartesianProduct<number>(...m_flushed);
-    const m_inputs: Array2D<number>[] = m_options.map(e => unflatten2DArray(e, num_cols, num_rows));
+    const m_rounded: ROArrayArray<number> = m_flat.map(this.correctlyRounded);
+    const m_flushed: ROArrayArray<number> = m_rounded.map(this.addFlushedIfNeeded.bind(this));
+    const m_options: ROArrayArray<number> = cartesianProduct<number>(...m_flushed);
+    const m_inputs: ROArrayArrayArray<number> = m_options.map(e =>
+      unflatten2DArray(e, num_cols, num_rows)
+    );
 
     const interval_matrices = new Set<FPMatrix>();
     m_inputs.forEach(inner_m => {
@@ -2470,8 +2492,8 @@ export abstract class FPTraits {
       return this.constants().unboundedMatrix[num_cols][num_rows];
     }
 
-    const m_flat: FPInterval[] = flatten2DArray(m);
-    const m_values: number[][] = cartesianProduct<number>(...m_flat.map(e => e.bounds()));
+    const m_flat: readonly FPInterval[] = flatten2DArray(m);
+    const m_values: ROArrayArray<number> = cartesianProduct<number>(...m_flat.map(e => e.bounds()));
 
     const outputs = new Set<FPMatrix>();
     m_values.forEach(inner_m => {
@@ -2483,10 +2505,10 @@ export abstract class FPTraits {
     const result_cols = result.length;
     const result_rows = result[0].length;
 
-    // FPMatrix has to be coerced to FPInterval[][] to use .every. This should
+    // FPMatrix has to be coerced to ROArrayArray<FPInterval> to use .every. This should
     // always be safe, since FPMatrix are defined as fixed length array of
     // arrays.
-    return (result as FPInterval[][]).every(c => c.every(r => r.isFinite()))
+    return (result as ROArrayArray<FPInterval>).every(c => c.every(r => r.isFinite()))
       ? result
       : this.constants().unboundedMatrix[result_cols][result_rows];
   }
@@ -2991,7 +3013,7 @@ export abstract class FPTraits {
   public abstract readonly coshInterval: (n: number) => FPInterval;
 
   private readonly CrossIntervalOp: VectorPairToVectorOp = {
-    impl: (x: number[], y: number[]): FPVector => {
+    impl: (x: readonly number[], y: readonly number[]): FPVector => {
       assert(x.length === 3, `CrossIntervalOp received x with ${x.length} instead of 3`);
       assert(y.length === 3, `CrossIntervalOp received y with ${y.length} instead of 3`);
 
@@ -3016,14 +3038,14 @@ export abstract class FPTraits {
     },
   };
 
-  protected crossIntervalImpl(x: number[], y: number[]): FPVector {
+  protected crossIntervalImpl(x: readonly number[], y: readonly number[]): FPVector {
     assert(x.length === 3, `Cross is only defined for vec3`);
     assert(y.length === 3, `Cross is only defined for vec3`);
     return this.runVectorPairToVectorOp(this.toVector(x), this.toVector(y), this.CrossIntervalOp);
   }
 
   /** Calculate a vector of acceptance intervals for cross(x, y) */
-  public abstract readonly crossInterval: (x: number[], y: number[]) => FPVector;
+  public abstract readonly crossInterval: (x: readonly number[], y: readonly number[]) => FPVector;
 
   private readonly DegreesIntervalOp: ScalarToIntervalOp = {
     impl: (n: number): FPInterval => {
@@ -3050,10 +3072,10 @@ export abstract class FPTraits {
     assert(col >= 0 && col < dim, `col ${col} needs be in [0, # of columns '${dim}')`);
     assert(row >= 0 && row < dim, `row ${row} needs be in [0, # of rows '${dim}')`);
 
-    const result: Array2D<number> = [...Array(dim - 1)].map(_ => [...Array(dim - 1)]);
+    const result: number[][] = [...Array(dim - 1)].map(_ => [...Array(dim - 1)]);
 
-    const col_indices: number[] = [...Array(dim).keys()].filter(e => e !== col);
-    const row_indices: number[] = [...Array(dim).keys()].filter(e => e !== row);
+    const col_indices: readonly number[] = [...Array(dim).keys()].filter(e => e !== col);
+    const row_indices: readonly number[] = [...Array(dim).keys()].filter(e => e !== row);
 
     col_indices.forEach((c, i) => {
       row_indices.forEach((r, j) => {
@@ -3104,7 +3126,7 @@ export abstract class FPTraits {
 
     // Need to calculate permutations, since for fp addition is not associative,
     // so A + B + C is not guaranteed to equal B + C + A, etc.
-    const permutations: FPInterval[][] = calculatePermutations([A, B, C]);
+    const permutations: ROArrayArray<FPInterval> = calculatePermutations([A, B, C]);
     return this.spanIntervals(
       ...permutations.map(p =>
         p.reduce((prev: FPInterval, cur: FPInterval) => this.additionInterval(prev, cur))
@@ -3145,7 +3167,7 @@ export abstract class FPTraits {
 
     // Need to calculate permutations, since for fp addition is not associative
     // so A + B + C + D is not guaranteed to equal B + C + A + D, etc.
-    const permutations: FPInterval[][] = calculatePermutations([A, B, C, D]);
+    const permutations: ROArrayArray<FPInterval> = calculatePermutations([A, B, C, D]);
     return this.spanIntervals(
       ...permutations.map(p =>
         p.reduce((prev: FPInterval, cur: FPInterval) => this.additionInterval(prev, cur))
@@ -3200,7 +3222,7 @@ export abstract class FPTraits {
   };
 
   private readonly DistanceIntervalVectorOp: VectorPairToIntervalOp = {
-    impl: (x: number[], y: number[]): FPInterval => {
+    impl: (x: readonly number[], y: readonly number[]): FPInterval => {
       return this.lengthInterval(
         this.runScalarPairToIntervalOpVectorComponentWise(
           this.toVector(x),
@@ -3211,7 +3233,10 @@ export abstract class FPTraits {
     },
   };
 
-  protected distanceIntervalImpl(x: number | number[], y: number | number[]): FPInterval {
+  protected distanceIntervalImpl(
+    x: number | readonly number[],
+    y: number | readonly number[]
+  ): FPInterval {
     if (x instanceof Array && y instanceof Array) {
       assert(
         x.length === y.length,
@@ -3236,8 +3261,8 @@ export abstract class FPTraits {
 
   /** Calculate an acceptance interval of distance(x, y) */
   public abstract readonly distanceInterval: (
-    x: number | number[],
-    y: number | number[]
+    x: number | readonly number[],
+    y: number | readonly number[]
   ) => FPInterval;
 
   // This op is implemented differently for f32 and f16.
@@ -3286,7 +3311,7 @@ export abstract class FPTraits {
   ) => FPInterval;
 
   private readonly DotIntervalOp: VectorPairToIntervalOp = {
-    impl: (x: number[], y: number[]): FPInterval => {
+    impl: (x: readonly number[], y: readonly number[]): FPInterval => {
       // dot(x, y) = sum of x[i] * y[i]
       const multiplications = this.runScalarPairToIntervalOpVectorComponentWise(
         this.toVector(x),
@@ -3303,22 +3328,25 @@ export abstract class FPTraits {
       // permutations are calculated and their results spanned, since addition
       // of more than two floats is not transitive, i.e. a + b + c is not
       // guaranteed to equal b + a + c
-      const permutations: FPInterval[][] = calculatePermutations(multiplications);
+      const permutations: ROArrayArray<FPInterval> = calculatePermutations(multiplications);
       return this.spanIntervals(
         ...permutations.map(p => p.reduce((prev, cur) => this.additionInterval(prev, cur)))
       );
     },
   };
 
-  protected dotIntervalImpl(x: number[] | FPInterval[], y: number[] | FPInterval[]): FPInterval {
+  protected dotIntervalImpl(
+    x: readonly number[] | readonly FPInterval[],
+    y: readonly number[] | readonly FPInterval[]
+  ): FPInterval {
     assert(x.length === y.length, `dot not defined for vectors with different lengths`);
     return this.runVectorPairToIntervalOp(this.toVector(x), this.toVector(y), this.DotIntervalOp);
   }
 
   /** Calculated the acceptance interval for dot(x, y) */
   public abstract readonly dotInterval: (
-    x: number[] | FPInterval[],
-    y: number[] | FPInterval[]
+    x: readonly number[] | readonly FPInterval[],
+    y: readonly number[] | readonly FPInterval[]
   ) => FPInterval;
 
   private readonly ExpIntervalOp: ScalarToIntervalOp = {
@@ -3362,9 +3390,9 @@ export abstract class FPTraits {
    * defining an Op and running that through the framework.
    */
   protected faceForwardIntervalsImpl(
-    x: number[],
-    y: number[],
-    z: number[]
+    x: readonly number[],
+    y: readonly number[],
+    z: readonly number[]
   ): (FPVector | undefined)[] {
     const x_vec = this.toVector(x);
     // Running vector through this.runScalarToIntervalOpComponentWise to make
@@ -3412,9 +3440,9 @@ export abstract class FPTraits {
 
   /** Calculate the acceptance intervals for faceForward(x, y, z) */
   public abstract readonly faceForwardIntervals: (
-    x: number[],
-    y: number[],
-    z: number[]
+    x: readonly number[],
+    y: readonly number[],
+    z: readonly number[]
   ) => (FPVector | undefined)[];
 
   private readonly FloorIntervalOp: ScalarToIntervalOp = {
@@ -3552,12 +3580,12 @@ export abstract class FPTraits {
   };
 
   private readonly LengthIntervalVectorOp: VectorToIntervalOp = {
-    impl: (n: number[]): FPInterval => {
+    impl: (n: readonly number[]): FPInterval => {
       return this.sqrtInterval(this.dotInterval(n, n));
     },
   };
 
-  protected lengthIntervalImpl(n: number | FPInterval | number[] | FPVector): FPInterval {
+  protected lengthIntervalImpl(n: number | FPInterval | readonly number[] | FPVector): FPInterval {
     if (n instanceof Array) {
       return this.runVectorToIntervalOp(this.toVector(n), this.LengthIntervalVectorOp);
     } else {
@@ -3567,7 +3595,7 @@ export abstract class FPTraits {
 
   /** Calculate an acceptance interval of length(x) */
   public abstract readonly lengthInterval: (
-    n: number | FPInterval | number[] | FPVector
+    n: number | FPInterval | readonly number[] | FPVector
   ) => FPInterval;
 
   private readonly LogIntervalOp: ScalarToIntervalOp = {
@@ -3751,7 +3779,7 @@ export abstract class FPTraits {
    * @returns the vector result of multiplying the given vector by the given
    *          scalar
    */
-  private multiplyVectorByScalar(v: number[], c: number | FPInterval): FPVector {
+  private multiplyVectorByScalar(v: readonly number[], c: number | FPInterval): FPVector {
     return this.toVector(v.map(x => this.multiplicationInterval(x, c)));
   }
 
@@ -3795,14 +3823,14 @@ export abstract class FPTraits {
 
     const x_transposed = this.transposeInterval(mat_x);
 
-    const result: Array2D<FPInterval> = [...Array(y_cols)].map(_ => [...Array(x_rows)]);
+    const result: FPInterval[][] = [...Array(y_cols)].map(_ => [...Array(x_rows)]);
     mat_y.forEach((y, i) => {
       x_transposed.forEach((x, j) => {
         result[i][j] = this.dotInterval(x, y);
       });
     });
 
-    return result as FPMatrix;
+    return (result as ROArrayArray<FPInterval>) as FPMatrix;
   }
 
   /** Calculate an acceptance interval of x * y, when x is a matrix and y is a matrix */
@@ -3811,7 +3839,10 @@ export abstract class FPTraits {
     mat_y: Array2D<number>
   ) => FPMatrix;
 
-  protected multiplicationMatrixVectorIntervalImpl(x: Array2D<number>, y: number[]): FPVector {
+  protected multiplicationMatrixVectorIntervalImpl(
+    x: Array2D<number>,
+    y: readonly number[]
+  ): FPVector {
     const cols = x.length;
     const rows = x[0].length;
     assert(y.length === cols, `'mat${cols}x${rows} * vec${y.length}' is not defined`);
@@ -3822,10 +3853,13 @@ export abstract class FPTraits {
   /** Calculate an acceptance interval of x * y, when x is a matrix and y is a vector */
   public abstract readonly multiplicationMatrixVectorInterval: (
     x: Array2D<number>,
-    y: number[]
+    y: readonly number[]
   ) => FPVector;
 
-  protected multiplicationVectorMatrixIntervalImpl(x: number[], y: Array2D<number>): FPVector {
+  protected multiplicationVectorMatrixIntervalImpl(
+    x: readonly number[],
+    y: Array2D<number>
+  ): FPVector {
     const cols = y.length;
     const rows = y[0].length;
     assert(x.length === rows, `'vec${x.length} * mat${cols}x${rows}' is not defined`);
@@ -3835,7 +3869,7 @@ export abstract class FPTraits {
 
   /** Calculate an acceptance interval of x * y, when x is a vector and y is a matrix */
   public abstract readonly multiplicationVectorMatrixInterval: (
-    x: number[],
+    x: readonly number[],
     y: Array2D<number>
   ) => FPVector;
 
@@ -3853,17 +3887,17 @@ export abstract class FPTraits {
   public abstract readonly negationInterval: (n: number) => FPInterval;
 
   private readonly NormalizeIntervalOp: VectorToVectorOp = {
-    impl: (n: number[]): FPVector => {
+    impl: (n: readonly number[]): FPVector => {
       const length = this.lengthInterval(n);
       return this.toVector(n.map(e => this.divisionInterval(e, length)));
     },
   };
 
-  protected normalizeIntervalImpl(n: number[]): FPVector {
+  protected normalizeIntervalImpl(n: readonly number[]): FPVector {
     return this.runVectorToVectorOp(this.toVector(n), this.NormalizeIntervalOp);
   }
 
-  public abstract readonly normalizeInterval: (n: number[]) => FPVector;
+  public abstract readonly normalizeInterval: (n: readonly number[]) => FPVector;
 
   private readonly PowIntervalOp: ScalarPairToIntervalOp = {
     // pow(x, y) has no explicit domain restrictions, but inherits the x <= 0
@@ -3902,7 +3936,7 @@ export abstract class FPTraits {
   public abstract readonly radiansInterval: (n: number) => FPInterval;
 
   private readonly ReflectIntervalOp: VectorPairToVectorOp = {
-    impl: (x: number[], y: number[]): FPVector => {
+    impl: (x: readonly number[], y: readonly number[]): FPVector => {
       assert(
         x.length === y.length,
         `ReflectIntervalOp received x (${x}) and y (${y}) with different numbers of elements`
@@ -3922,7 +3956,7 @@ export abstract class FPTraits {
     },
   };
 
-  protected reflectIntervalImpl(x: number[], y: number[]): FPVector {
+  protected reflectIntervalImpl(x: readonly number[], y: readonly number[]): FPVector {
     assert(
       x.length === y.length,
       `reflect is only defined for vectors with the same number of elements`
@@ -3931,7 +3965,10 @@ export abstract class FPTraits {
   }
 
   /** Calculate an acceptance interval of reflect(x, y) */
-  public abstract readonly reflectInterval: (x: number[], y: number[]) => FPVector;
+  public abstract readonly reflectInterval: (
+    x: readonly number[],
+    y: readonly number[]
+  ) => FPVector;
 
   /**
    * refract is a singular function in the sense that it is the only builtin that
@@ -3942,7 +3979,7 @@ export abstract class FPTraits {
    * own operation type, etc, it instead has a bespoke implementation that is a
    * composition of other builtin functions that use the framework.
    */
-  protected refractIntervalImpl(i: number[], s: number[], r: number): FPVector {
+  protected refractIntervalImpl(i: readonly number[], s: readonly number[], r: number): FPVector {
     assert(
       i.length === s.length,
       `refract is only defined for vectors with the same number of elements`
@@ -3979,7 +4016,11 @@ export abstract class FPTraits {
   }
 
   /** Calculate acceptance interval vectors of reflect(i, s, r) */
-  public abstract readonly refractInterval: (i: number[], s: number[], r: number) => FPVector;
+  public abstract readonly refractInterval: (
+    i: readonly number[],
+    s: readonly number[],
+    r: number
+  ) => FPVector;
 
   private readonly RemainderIntervalOp: ScalarPairToIntervalOp = {
     impl: (x: number, y: number): FPInterval => {
@@ -4245,7 +4286,7 @@ export abstract class FPTraits {
     impl: (m: Array2D<number>): FPMatrix => {
       const num_cols = m.length;
       const num_rows = m[0].length;
-      const result: Array2D<FPInterval> = [...Array(num_rows)].map(_ => [...Array(num_cols)]);
+      const result: FPInterval[][] = [...Array(num_rows)].map(_ => [...Array(num_cols)]);
 
       for (let i = 0; i < num_cols; i++) {
         for (let j = 0; j < num_rows; j++) {
@@ -4595,7 +4636,7 @@ class F32Traits extends FPTraits {
    * @param ops callbacks that implement generating an acceptance interval
    */
   public generateU32ToIntervalCases(
-    params: number[],
+    params: readonly number[],
     filter: IntervalFilter,
     ...ops: ScalarToVector[]
   ): Case[] {
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index c22b4f395024..6e8c9951ce34 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -1,3 +1,4 @@
+import { ROArrayArray, ROArrayArrayArray } from '../../common/util/types.js';
 import { assert } from '../../common/util/util.js';
 import {
   Float16Array,
@@ -470,7 +471,7 @@ export function oneULPF16(target: number, mode: FlushMode = 'flush'): number {
  * @returns all of the acceptable roundings for quantizing to 64-bits in
  *          ascending order.
  */
-export function correctlyRoundedF64(n: number): number[] {
+export function correctlyRoundedF64(n: number): readonly number[] {
   assert(!Number.isNaN(n), `correctlyRoundedF32 not defined for NaN`);
   // Above f64 range
   if (n === Number.POSITIVE_INFINITY) {
@@ -510,7 +511,7 @@ export function correctlyRoundedF64(n: number): number[] {
  * @returns all of the acceptable roundings for quantizing to 32-bits in
  *          ascending order.
  */
-export function correctlyRoundedF32(n: number): number[] {
+export function correctlyRoundedF32(n: number): readonly number[] {
   if (Number.isNaN(n)) {
     return [n];
   }
@@ -578,7 +579,7 @@ export function correctlyRoundedF32(n: number): number[] {
  * @returns all of the acceptable roundings for quantizing to 16-bits in
  *          ascending order.
  */
-export function correctlyRoundedF16(n: number): number[] {
+export function correctlyRoundedF16(n: number): readonly number[] {
   if (Number.isNaN(n)) {
     return [n];
   }
@@ -824,7 +825,7 @@ export function lerpBigInt(a: bigint, b: bigint, idx: number, steps: number): bi
 }
 
 /** @returns a linear increasing range of numbers. */
-export function linearRange(a: number, b: number, num_steps: number): number[] {
+export function linearRange(a: number, b: number, num_steps: number): readonly number[] {
   if (num_steps <= 0) {
     return [];
   }
@@ -865,7 +866,7 @@ export function linearRangeBigInt(a: bigint, b: bigint, num_steps: number): Arra
  * This biased range is then scaled to the desired range using lerp.
  * Different curves could be generated by changing c, where greater values of c will bias more towards 0.
  */
-export function biasedRange(a: number, b: number, num_steps: number): number[] {
+export function biasedRange(a: number, b: number, num_steps: number): readonly number[] {
   const c = 2;
   if (num_steps <= 0) {
     return [];
@@ -1108,7 +1109,7 @@ export function filteredF64Range(
 }
 
 /** Short list of i32 values of interest to test against */
-const kInterestingI32Values: number[] = [
+const kInterestingI32Values: readonly number[] = [
   kValue.i32.negative.max,
   Math.trunc(kValue.i32.negative.max / 2),
   -256,
@@ -1128,7 +1129,7 @@ const kInterestingI32Values: number[] = [
  * generated is a super linear function of the length of i32 values which is
  * leading to time outs.
  */
-export function sparseI32Range(): number[] {
+export function sparseI32Range(): readonly number[] {
   return kInterestingI32Values;
 }
 
@@ -1172,7 +1173,7 @@ const kVectorI32Values = {
  * vector to get a spread of testing over the entire range. This reduces the
  * number of cases being run substantially, but maintains coverage.
  */
-export function vectorI32Range(dim: number): number[][] {
+export function vectorI32Range(dim: number): ROArrayArray<number> {
   assert(dim === 2 || dim === 3 || dim === 4, 'vectorI32Range only accepts dimensions 2, 3, and 4');
   return kVectorI32Values[dim];
 }
@@ -1200,7 +1201,7 @@ export function fullI32Range(
 }
 
 /** Short list of u32 values of interest to test against */
-const kInterestingU32Values: number[] = [
+const kInterestingU32Values: readonly number[] = [
   0,
   1,
   10,
@@ -1215,7 +1216,7 @@ const kInterestingU32Values: number[] = [
  * generated is a super linear function of the length of u32 values which is
  * leading to time outs.
  */
-export function sparseU32Range(): number[] {
+export function sparseU32Range(): readonly number[] {
   return kInterestingU32Values;
 }
 
@@ -1250,7 +1251,7 @@ const kVectorU32Values = {
  * vector to get a spread of testing over the entire range. This reduces the
  * number of cases being run substantially, but maintains coverage.
  */
-export function vectorU32Range(dim: number): number[][] {
+export function vectorU32Range(dim: number): ROArrayArray<number> {
   assert(dim === 2 || dim === 3 || dim === 4, 'vectorU32Range only accepts dimensions 2, 3, and 4');
   return kVectorU32Values[dim];
 }
@@ -1267,7 +1268,7 @@ export function fullU32Range(count: number = 50): Array<number> {
 }
 
 /** Short list of f32 values of interest to test against */
-const kInterestingF32Values: number[] = [
+const kInterestingF32Values: readonly number[] = [
   kValue.f32.negative.min,
   -10.0,
   -1.0,
@@ -1298,7 +1299,7 @@ const kInterestingF32Values: number[] = [
  * specific values of interest. If there are known values of interest they
  * should be appended to this list in the test generation code.
  */
-export function sparseF32Range(): number[] {
+export function sparseF32Range(): readonly number[] {
   return kInterestingF32Values;
 }
 
@@ -1342,7 +1343,7 @@ const kVectorF32Values = {
  * vector to get a spread of testing over the entire range. This reduces the
  * number of cases being run substantially, but maintains coverage.
  */
-export function vectorF32Range(dim: number): number[][] {
+export function vectorF32Range(dim: number): ROArrayArray<number> {
   assert(dim === 2 || dim === 3 || dim === 4, 'vectorF32Range only accepts dimensions 2, 3, and 4');
   return kVectorF32Values[dim];
 }
@@ -1371,7 +1372,7 @@ const kSparseVectorF32Values = {
  * All of the interesting floats from sparseF32 are guaranteed to be tested, but
  * not in every position.
  */
-export function sparseVectorF32Range(dim: number): number[][] {
+export function sparseVectorF32Range(dim: number): ROArrayArray<number> {
   assert(
     dim === 2 || dim === 3 || dim === 4,
     'sparseVectorF32Range only accepts dimensions 2, 3, and 4'
@@ -1490,7 +1491,7 @@ const kSparseMatrixF32Values = {
  * All of the interesting floats from sparseF32 are guaranteed to be tested, but
  * not in every position.
  */
-export function sparseMatrixF32Range(c: number, r: number): number[][][] {
+export function sparseMatrixF32Range(c: number, r: number): ROArrayArrayArray<number> {
   assert(
     c === 2 || c === 3 || c === 4,
     'sparseMatrixF32Range only accepts column counts of 2, 3, and 4'
@@ -1503,7 +1504,7 @@ export function sparseMatrixF32Range(c: number, r: number): number[][][] {
 }
 
 /** Short list of f16 values of interest to test against */
-const kInterestingF16Values: number[] = [
+const kInterestingF16Values: readonly number[] = [
   kValue.f16.negative.min,
   -10.0,
   -1.0,
@@ -1534,7 +1535,7 @@ const kInterestingF16Values: number[] = [
  * specific values of interest. If there are known values of interest they
  * should be appended to this list in the test generation code.
  */
-export function sparseF16Range(): number[] {
+export function sparseF16Range(): readonly number[] {
   return kInterestingF16Values;
 }
 
@@ -1578,7 +1579,7 @@ const kVectorF16Values = {
  * vector to get a spread of testing over the entire range. This reduces the
  * number of cases being run substantially, but maintains coverage.
  */
-export function vectorF16Range(dim: number): number[][] {
+export function vectorF16Range(dim: number): ROArrayArray<number> {
   assert(dim === 2 || dim === 3 || dim === 4, 'vectorF16Range only accepts dimensions 2, 3, and 4');
   return kVectorF16Values[dim];
 }
@@ -1607,7 +1608,7 @@ const kSparseVectorF16Values = {
  * All of the interesting floats from sparseF16 are guaranteed to be tested, but
  * not in every position.
  */
-export function sparseVectorF16Range(dim: number): number[][] {
+export function sparseVectorF16Range(dim: number): ROArrayArray<number> {
   assert(
     dim === 2 || dim === 3 || dim === 4,
     'sparseVectorF16Range only accepts dimensions 2, 3, and 4'
@@ -1726,7 +1727,7 @@ const kSparseMatrixF16Values = {
  * All of the interesting floats from sparseF16 are guaranteed to be tested, but
  * not in every position.
  */
-export function sparseMatrixF16Range(c: number, r: number): number[][][] {
+export function sparseMatrixF16Range(c: number, r: number): ROArrayArray<number>[] {
   assert(
     c === 2 || c === 3 || c === 4,
     'sparseMatrixF16Range only accepts column counts of 2, 3, and 4'
@@ -1739,7 +1740,7 @@ export function sparseMatrixF16Range(c: number, r: number): number[][][] {
 }
 
 /** Short list of f64 values of interest to test against */
-const kInterestingF64Values: number[] = [
+const kInterestingF64Values: readonly number[] = [
   kValue.f64.negative.min,
   -10.0,
   -1.0,
@@ -1770,7 +1771,7 @@ const kInterestingF64Values: number[] = [
  * specific values of interest. If there are known values of interest they
  * should be appended to this list in the test generation code.
  */
-export function sparseF64Range(): number[] {
+export function sparseF64Range(): readonly number[] {
   return kInterestingF64Values;
 }
 
@@ -1814,7 +1815,7 @@ const kVectorF64Values = {
  * vector to get a spread of testing over the entire range. This reduces the
  * number of cases being run substantially, but maintains coverage.
  */
-export function vectorF64Range(dim: number): number[][] {
+export function vectorF64Range(dim: number): ROArrayArray<number> {
   assert(dim === 2 || dim === 3 || dim === 4, 'vectorF64Range only accepts dimensions 2, 3, and 4');
   return kVectorF64Values[dim];
 }
@@ -1843,7 +1844,7 @@ const kSparseVectorF64Values = {
  * All the interesting floats from sparseF64 are guaranteed to be tested, but
  * not in every position.
  */
-export function sparseVectorF64Range(dim: number): number[][] {
+export function sparseVectorF64Range(dim: number): ROArrayArray<number> {
   assert(
     dim === 2 || dim === 3 || dim === 4,
     'sparseVectorF64Range only accepts dimensions 2, 3, and 4'
@@ -1962,7 +1963,7 @@ const kSparseMatrixF64Values = {
  * All the interesting floats from sparseF64 are guaranteed to be tested, but
  * not in every position.
  */
-export function sparseMatrixF64Range(c: number, r: number): number[][][] {
+export function sparseMatrixF64Range(c: number, r: number): ROArrayArray<number>[] {
   assert(
     c === 2 || c === 3 || c === 4,
     'sparseMatrixF64Range only accepts column counts of 2, 3, and 4'
@@ -2074,11 +2075,14 @@ export function lcm(a: number, b: number): number {
  * @param intermediate arrays of values representing the partial result of
  *                     cartesianProduct
  */
-function cartesianProductImpl<T>(elements: T[], intermediate: T[][]): T[][] {
+function cartesianProductImpl<T>(
+  elements: readonly T[],
+  intermediate: ROArrayArray<T>
+): ROArrayArray<T> {
   const result: T[][] = [];
   elements.forEach((e: T) => {
     if (intermediate.length > 0) {
-      intermediate.forEach((i: T[]) => {
+      intermediate.forEach((i: readonly T[]) => {
         result.push([...i, e]);
       });
     } else {
@@ -2098,9 +2102,9 @@ function cartesianProductImpl<T>(elements: T[], intermediate: T[][]): T[][] {
  *
  * @param inputs arrays of numbers to calculate cartesian product over
  */
-export function cartesianProduct<T>(...inputs: T[][]): T[][] {
-  let result: T[][] = [];
-  inputs.forEach((i: T[]) => {
+export function cartesianProduct<T>(...inputs: ROArrayArray<T>): ROArrayArray<T> {
+  let result: ROArrayArray<T> = [];
+  inputs.forEach((i: readonly T[]) => {
     result = cartesianProductImpl<T>(i, result);
   });
 
@@ -2122,7 +2126,7 @@ export function cartesianProduct<T>(...inputs: T[][]): T[][] {
  *
  * @param input the array to get permutations of
  */
-export function calculatePermutations<T>(input: T[]): T[][] {
+export function calculatePermutations<T>(input: readonly T[]): ROArrayArray<T> {
   if (input.length === 0) {
     return [];
   }
@@ -2155,7 +2159,7 @@ export function calculatePermutations<T>(input: T[]): T[][] {
  *
  * @param m Matrix to convert
  */
-export function flatten2DArray<T>(m: T[][]): T[] {
+export function flatten2DArray<T>(m: ROArrayArray<T>): T[] {
   const c = m.length;
   const r = m[0].length;
   assert(
@@ -2177,7 +2181,7 @@ export function flatten2DArray<T>(m: T[][]): T[] {
  * @param c number of elements in the array containing arrays
  * @param r number of elements in the arrays that are contained
  */
-export function unflatten2DArray<T>(n: T[], c: number, r: number): T[][] {
+export function unflatten2DArray<T>(n: readonly T[], c: number, r: number): ROArrayArray<T> {
   assert(
     c > 0 && Number.isInteger(c) && r > 0 && Number.isInteger(r),
     `columns (${c}) and rows (${r}) need to be positive integers`
@@ -2200,7 +2204,7 @@ export function unflatten2DArray<T>(n: T[], c: number, r: number): T[][] {
  * @param op operation that converts an element of type T to one of type S
  * @returns a matrix with elements of type S that are calculated by applying op element by element
  */
-export function map2DArray<T, S>(m: T[][], op: (input: T) => S): S[][] {
+export function map2DArray<T, S>(m: ROArrayArray<T>, op: (input: T) => S): ROArrayArray<S> {
   const c = m.length;
   const r = m[0].length;
   assert(
@@ -2223,7 +2227,7 @@ export function map2DArray<T, S>(m: T[][], op: (input: T) => S): S[][] {
  * @param op operation that performs a test on an element
  * @returns a boolean indicating if the test passed for every element
  */
-export function every2DArray<T>(m: T[][], op: (input: T) => boolean): boolean {
+export function every2DArray<T>(m: ROArrayArray<T>, op: (input: T) => boolean): boolean {
   const r = m[0].length;
   assert(
     m.every(c => c.length === r),

From 6e21caa15fc9077f4ef9f41d7a9c39dcc696f921 Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Wed, 25 Oct 2023 19:21:56 +0100
Subject: [PATCH 154/166] Replace JSON case cache serialization with binary
 files

This removes a the need to create bunch of temporary JSON objects,
reducing the amount of garbage collection we need to do.

This change also changes the DataCache to be unbounded to a 4-element
LRU cache, capping the amount of memory used.
---
 src/common/framework/data_cache.ts            | 119 ++++++--
 src/common/runtime/cmdline.ts                 |   4 +-
 src/common/runtime/server.ts                  |   4 +-
 src/common/runtime/standalone.ts              |   2 +-
 src/common/tools/gen_cache.ts                 |   6 +-
 src/unittests/serialization.spec.ts           |  46 ++-
 .../shader/execution/expression/case_cache.ts | 222 ++++++--------
 src/webgpu/util/binary_stream.ts              | 283 ++++++++++++++++++
 src/webgpu/util/compare.ts                    | 136 +++++----
 src/webgpu/util/conversion.ts                 | 251 ++++++++++++----
 src/webgpu/util/floating_point.ts             | 162 +++++-----
 11 files changed, 865 insertions(+), 370 deletions(-)
 create mode 100644 src/webgpu/util/binary_stream.ts

diff --git a/src/common/framework/data_cache.ts b/src/common/framework/data_cache.ts
index 6f6e80288a8f..be5bde8e224b 100644
--- a/src/common/framework/data_cache.ts
+++ b/src/common/framework/data_cache.ts
@@ -3,15 +3,64 @@
  * expensive to build using a two-level cache (in-memory, pre-computed file).
  */
 
+import { assert } from '../util/util.js';
+
 interface DataStore {
-  load(path: string): Promise<string>;
+  load(path: string): Promise<Uint8Array>;
 }
 
 /** Logger is a basic debug logger function */
 export type Logger = (s: string) => void;
 
-/** DataCache is an interface to a data store used to hold cached data */
+/**
+ * DataCacheNode represents a single cache entry in the LRU DataCache.
+ * DataCacheNode is a doubly linked list, so that least-recently-used entries can be removed, and
+ * cache hits can move the node to the front of the list.
+ */
+class DataCacheNode {
+  public constructor(path: string, data: unknown) {
+    this.path = path;
+    this.data = data;
+  }
+
+  /** insertAfter() re-inserts this node in the doubly-linked list after @p prev */
+  public insertAfter(prev: DataCacheNode) {
+    this.unlink();
+    this.next = prev.next;
+    this.prev = prev;
+    prev.next = this;
+    if (this.next) {
+      this.next.prev = this;
+    }
+  }
+
+  /** unlink() removes this node from the doubly-linked list */
+  public unlink() {
+    const prev = this.prev;
+    const next = this.next;
+    if (prev) {
+      prev.next = next;
+    }
+    if (next) {
+      next.prev = prev;
+    }
+    this.prev = null;
+    this.next = null;
+  }
+
+  public readonly path: string; // The file path this node represents
+  public readonly data: unknown; // The deserialized data for this node
+  public prev: DataCacheNode | null = null; // The previous node in the doubly-linked list
+  public next: DataCacheNode | null = null; // The next node in the doubly-linked list
+}
+
+/** DataCache is an interface to a LRU-cached data store used to hold data cached by path */
 export class DataCache {
+  public constructor() {
+    this.lruHeadNode.next = this.lruTailNode;
+    this.lruTailNode.prev = this.lruHeadNode;
+  }
+
   /** setDataStore() sets the backing data store used by the data cache */
   public setStore(dataStore: DataStore) {
     this.dataStore = dataStore;
@@ -28,17 +77,20 @@ export class DataCache {
    * building the data and storing it in the cache.
    */
   public async fetch<Data>(cacheable: Cacheable<Data>): Promise<Data> {
-    // First check the in-memory cache
-    let data = this.cache.get(cacheable.path);
-    if (data !== undefined) {
-      this.log('in-memory cache hit');
-      return Promise.resolve(data as Data);
+    {
+      // First check the in-memory cache
+      const node = this.cache.get(cacheable.path);
+      if (node !== undefined) {
+        this.log('in-memory cache hit');
+        node.insertAfter(this.lruHeadNode);
+        return Promise.resolve(node.data as Data);
+      }
     }
     this.log('in-memory cache miss');
     // In in-memory cache miss.
     // Next, try the data store.
     if (this.dataStore !== null && !this.unavailableFiles.has(cacheable.path)) {
-      let serialized: string | undefined;
+      let serialized: Uint8Array | undefined;
       try {
         serialized = await this.dataStore.load(cacheable.path);
         this.log('loaded serialized');
@@ -49,16 +101,37 @@ export class DataCache {
       }
       if (serialized !== undefined) {
         this.log(`deserializing`);
-        data = cacheable.deserialize(serialized);
-        this.cache.set(cacheable.path, data);
-        return data as Data;
+        const data = cacheable.deserialize(serialized);
+        this.addToCache(cacheable.path, data);
+        return data;
       }
     }
     // Not found anywhere. Build the data, and cache for future lookup.
     this.log(`cache: building (${cacheable.path})`);
-    data = await cacheable.build();
-    this.cache.set(cacheable.path, data);
-    return data as Data;
+    const data = await cacheable.build();
+    this.addToCache(cacheable.path, data);
+    return data;
+  }
+
+  /**
+   * addToCache() creates a new node for @p path and @p data, inserting the new node at the front of
+   * the doubly-linked list. If the number of entries in the cache exceeds this.maxCount, then the
+   * least recently used entry is evicted
+   * @param path the file path for the data
+   * @param data the deserialized data
+   */
+  private addToCache(path: string, data: unknown) {
+    if (this.cache.size >= this.maxCount) {
+      const toEvict = this.lruTailNode.prev;
+      assert(toEvict !== null);
+      toEvict.unlink();
+      this.cache.delete(toEvict.path);
+      this.log(`evicting ${toEvict.path}`);
+    }
+    const node = new DataCacheNode(path, data);
+    node.insertAfter(this.lruHeadNode);
+    this.cache.set(path, node);
+    this.log(`added ${path}. new count: ${this.cache.size}`);
   }
 
   private log(msg: string) {
@@ -67,7 +140,12 @@ export class DataCache {
     }
   }
 
-  private cache = new Map<string, unknown>();
+  // Max number of entries in the cache before LRU entries are evicted.
+  private readonly maxCount = 4;
+
+  private cache = new Map<string, DataCacheNode>();
+  private lruHeadNode = new DataCacheNode('', null); // placeholder node (no path or data)
+  private lruTailNode = new DataCacheNode('', null); // placeholder node (no path or data)
   private unavailableFiles = new Set<string>();
   private dataStore: DataStore | null = null;
   private debugLogger: Logger | null = null;
@@ -107,14 +185,13 @@ export interface Cacheable<Data> {
   build(): Promise<Data>;
 
   /**
-   * serialize() transforms `data` to a string (usually JSON encoded) so that it
-   * can be stored in a text cache file.
+   * serialize() encodes `data` to a binary representation so that it can be stored in a cache file.
    */
-  serialize(data: Data): string;
+  serialize(data: Data): Uint8Array;
 
   /**
-   * deserialize() is the inverse of serialize(), transforming the string back
-   * to the Data object.
+   * deserialize() is the inverse of serialize(), decoding the binary representation back to a Data
+   * object.
    */
-  deserialize(serialized: string): Data;
+  deserialize(binary: Uint8Array): Data;
 }
diff --git a/src/common/runtime/cmdline.ts b/src/common/runtime/cmdline.ts
index 1fb39b68ce8c..44a73fb38b34 100644
--- a/src/common/runtime/cmdline.ts
+++ b/src/common/runtime/cmdline.ts
@@ -135,8 +135,8 @@ Did you remember to build with code coverage instrumentation enabled?`
 if (dataPath !== undefined) {
   dataCache.setStore({
     load: (path: string) => {
-      return new Promise<string>((resolve, reject) => {
-        fs.readFile(`${dataPath}/${path}`, 'utf8', (err, data) => {
+      return new Promise<Uint8Array>((resolve, reject) => {
+        fs.readFile(`${dataPath}/${path}`, (err, data) => {
           if (err !== null) {
             reject(err.message);
           } else {
diff --git a/src/common/runtime/server.ts b/src/common/runtime/server.ts
index 8903d5a53293..8310784e3a2c 100644
--- a/src/common/runtime/server.ts
+++ b/src/common/runtime/server.ts
@@ -133,8 +133,8 @@ Did you remember to build with code coverage instrumentation enabled?`
 if (dataPath !== undefined) {
   dataCache.setStore({
     load: (path: string) => {
-      return new Promise<string>((resolve, reject) => {
-        fs.readFile(`${dataPath}/${path}`, 'utf8', (err, data) => {
+      return new Promise<Uint8Array>((resolve, reject) => {
+        fs.readFile(`${dataPath}/${path}`, (err, data) => {
           if (err !== null) {
             reject(err.message);
           } else {
diff --git a/src/common/runtime/standalone.ts b/src/common/runtime/standalone.ts
index 4ec300d30684..be5887c1721e 100644
--- a/src/common/runtime/standalone.ts
+++ b/src/common/runtime/standalone.ts
@@ -84,7 +84,7 @@ dataCache.setStore({
     if (!response.ok) {
       return Promise.reject(response.statusText);
     }
-    return await response.text();
+    return new Uint8Array(await response.arrayBuffer());
   },
 });
 
diff --git a/src/common/tools/gen_cache.ts b/src/common/tools/gen_cache.ts
index 4d1a9da726da..ce0854aa2046 100644
--- a/src/common/tools/gen_cache.ts
+++ b/src/common/tools/gen_cache.ts
@@ -87,8 +87,8 @@ const outRootDir = nonFlagsArgs[2];
 
 dataCache.setStore({
   load: (path: string) => {
-    return new Promise<string>((resolve, reject) => {
-      fs.readFile(`data/${path}`, 'utf8', (err, data) => {
+    return new Promise<Uint8Array>((resolve, reject) => {
+      fs.readFile(`data/${path}`, (err, data) => {
         if (err !== null) {
           reject(err.message);
         } else {
@@ -180,7 +180,7 @@ and
             const data = await cacheable.build();
             const serialized = cacheable.serialize(data);
             fs.mkdirSync(path.dirname(outPath), { recursive: true });
-            fs.writeFileSync(outPath, serialized);
+            fs.writeFileSync(outPath, serialized, 'binary');
             break;
           }
           case 'list': {
diff --git a/src/unittests/serialization.spec.ts b/src/unittests/serialization.spec.ts
index 25aa44561fab..76ac1f715545 100644
--- a/src/unittests/serialization.spec.ts
+++ b/src/unittests/serialization.spec.ts
@@ -7,6 +7,7 @@ import {
   deserializeExpectation,
   serializeExpectation,
 } from '../webgpu/shader/execution/expression/case_cache.js';
+import BinaryStream from '../webgpu/util/binary_stream.js';
 import {
   anyOf,
   deserializeComparator,
@@ -206,11 +207,14 @@ g.test('value').fn(t => {
       f32
     ),
   ]) {
-    const serialized = serializeValue(value);
-    const deserialized = deserializeValue(serialized);
+    const s = new BinaryStream(new Uint8Array(1024));
+    serializeValue(s, value);
+    const d = new BinaryStream(s.buffer());
+    const deserialized = deserializeValue(d);
     t.expect(
       objectEquals(value, deserialized),
-      `value ${value} -> serialize -> deserialize -> ${deserialized}`
+      `${value.type} ${value} -> serialize -> deserialize -> ${deserialized}
+buffer: ${s.buffer()}`
     );
   }
 });
@@ -240,8 +244,10 @@ g.test('fpinterval_f32').fn(t => {
     FP.f32.toInterval([kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max]),
     FP.f32.toInterval([kValue.f32.negative.infinity, kValue.f32.positive.infinity]),
   ]) {
-    const serialized = serializeFPInterval(interval);
-    const deserialized = deserializeFPInterval(serialized);
+    const s = new BinaryStream(new Uint8Array(1024));
+    serializeFPInterval(s, interval);
+    const d = new BinaryStream(s.buffer());
+    const deserialized = deserializeFPInterval(d);
     t.expect(
       objectEquals(interval, deserialized),
       `interval ${interval} -> serialize -> deserialize -> ${deserialized}`
@@ -274,8 +280,10 @@ g.test('fpinterval_f16').fn(t => {
     FP.f16.toInterval([kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max]),
     FP.f16.toInterval([kValue.f16.negative.infinity, kValue.f16.positive.infinity]),
   ]) {
-    const serialized = serializeFPInterval(interval);
-    const deserialized = deserializeFPInterval(serialized);
+    const s = new BinaryStream(new Uint8Array(1024));
+    serializeFPInterval(s, interval);
+    const d = new BinaryStream(s.buffer());
+    const deserialized = deserializeFPInterval(d);
     t.expect(
       objectEquals(interval, deserialized),
       `interval ${interval} -> serialize -> deserialize -> ${deserialized}`
@@ -308,8 +316,10 @@ g.test('fpinterval_abstract').fn(t => {
     FP.abstract.toInterval([kValue.f64.negative.subnormal.min, kValue.f64.negative.subnormal.max]),
     FP.abstract.toInterval([kValue.f64.negative.infinity, kValue.f64.positive.infinity]),
   ]) {
-    const serialized = serializeFPInterval(interval);
-    const deserialized = deserializeFPInterval(serialized);
+    const s = new BinaryStream(new Uint8Array(1024));
+    serializeFPInterval(s, interval);
+    const d = new BinaryStream(s.buffer());
+    const deserialized = deserializeFPInterval(d);
     t.expect(
       objectEquals(interval, deserialized),
       `interval ${interval} -> serialize -> deserialize -> ${deserialized}`
@@ -328,8 +338,10 @@ g.test('expression_expectation').fn(t => {
     // Intervals
     [FP.f32.toInterval([-8.0, 0.5]), FP.f32.toInterval([2.0, 4.0])],
   ]) {
-    const serialized = serializeExpectation(expectation);
-    const deserialized = deserializeExpectation(serialized);
+    const s = new BinaryStream(new Uint8Array(1024));
+    serializeExpectation(s, expectation);
+    const d = new BinaryStream(s.buffer());
+    const deserialized = deserializeExpectation(d);
     t.expect(
       objectEquals(expectation, deserialized),
       `expectation ${expectation} -> serialize -> deserialize -> ${deserialized}`
@@ -356,8 +368,10 @@ g.test('anyOf').fn(t => {
         testCases: [f32(0), f32(10), f32(122), f32(123), f32(124), f32(200)],
       },
     ]) {
-      const serialized = serializeComparator(c.comparator);
-      const deserialized = deserializeComparator(serialized);
+      const s = new BinaryStream(new Uint8Array(1024));
+      serializeComparator(s, c.comparator);
+      const d = new BinaryStream(s.buffer());
+      const deserialized = deserializeComparator(d);
       for (const val of c.testCases) {
         const got = deserialized.compare(val);
         const expect = c.comparator.compare(val);
@@ -382,8 +396,10 @@ g.test('skipUndefined').fn(t => {
         testCases: [f32(0), f32(10), f32(122), f32(123), f32(124), f32(200)],
       },
     ]) {
-      const serialized = serializeComparator(c.comparator);
-      const deserialized = deserializeComparator(serialized);
+      const s = new BinaryStream(new Uint8Array(1024));
+      serializeComparator(s, c.comparator);
+      const d = new BinaryStream(s.buffer());
+      const deserialized = deserializeComparator(d);
       for (const val of c.testCases) {
         const got = deserialized.compare(val);
         const expect = c.comparator.compare(val);
diff --git a/src/webgpu/shader/execution/expression/case_cache.ts b/src/webgpu/shader/execution/expression/case_cache.ts
index e0aaa377192f..88f4a48df4c8 100644
--- a/src/webgpu/shader/execution/expression/case_cache.ts
+++ b/src/webgpu/shader/execution/expression/case_cache.ts
@@ -1,164 +1,125 @@
 import { Cacheable, dataCache } from '../../../../common/framework/data_cache.js';
 import { unreachable } from '../../../../common/util/util.js';
-import {
-  SerializedComparator,
-  deserializeComparator,
-  serializeComparator,
-} from '../../../util/compare.js';
+import BinaryStream from '../../../util/binary_stream.js';
+import { deserializeComparator, serializeComparator } from '../../../util/compare.js';
 import {
   Scalar,
   Vector,
   serializeValue,
-  SerializedValue,
   deserializeValue,
   Matrix,
+  Value,
 } from '../../../util/conversion.js';
 import {
   deserializeFPInterval,
   FPInterval,
-  SerializedFPInterval,
   serializeFPInterval,
 } from '../../../util/floating_point.js';
 import { flatten2DArray, unflatten2DArray } from '../../../util/math.js';
 
 import { Case, CaseList, Expectation, isComparator } from './expression.js';
 
-/**
- * SerializedExpectationValue holds the serialized form of an Expectation when
- * the Expectation is a Value
- * This form can be safely encoded to JSON.
- */
-type SerializedExpectationValue = {
-  kind: 'value';
-  value: SerializedValue;
-};
-
-/**
- * SerializedExpectationInterval holds the serialized form of an Expectation when
- * the Expectation is an Interval
- * This form can be safely encoded to JSON.
- */
-type SerializedExpectationInterval = {
-  kind: 'interval';
-  value: SerializedFPInterval;
-};
-
-/**
- * SerializedExpectationIntervals holds the serialized form of an Expectation when
- * the Expectation is a list of Intervals
- * This form can be safely encoded to JSON.
- */
-type SerializedExpectationIntervals = {
-  kind: 'intervals';
-  value: SerializedFPInterval[];
-};
-
-/**
- * SerializedExpectation2DIntervalArray holds the serialized form of an
- * Expectation when the Expectation is a 2d array of Intervals. The array is
- * flattened to a 1D array for storage.
- * This form can be safely encoded to JSON.
- */
-type SerializedExpectation2DIntervalArray = {
-  kind: '2d-interval-array';
-  cols: number;
-  rows: number;
-  value: SerializedFPInterval[];
-};
-
-/**
- * SerializedExpectationValue holds the serialized form of an Expectation when
- * the Expectation is a Comparator
- * This form can be safely encoded to JSON.
- */
-type SerializedExpectationComparator = {
-  kind: 'comparator';
-  value: SerializedComparator;
-};
-
-/**
- * SerializedExpectation holds the serialized form of an Expectation.
- * This form can be safely encoded to JSON.
- */
-export type SerializedExpectation =
-  | SerializedExpectationValue
-  | SerializedExpectationInterval
-  | SerializedExpectationIntervals
-  | SerializedExpectation2DIntervalArray
-  | SerializedExpectationComparator;
+enum SerializedExpectationKind {
+  Value,
+  Interval,
+  Interval1DArray,
+  Interval2DArray,
+  Array,
+  Comparator,
+}
 
-/** serializeExpectation() converts an Expectation to a SerializedExpectation */
-export function serializeExpectation(e: Expectation): SerializedExpectation {
+/** serializeExpectation() serializes an Expectation to a BinaryStream */
+export function serializeExpectation(s: BinaryStream, e: Expectation) {
   if (e instanceof Scalar || e instanceof Vector || e instanceof Matrix) {
-    return { kind: 'value', value: serializeValue(e) };
+    s.writeU8(SerializedExpectationKind.Value);
+    serializeValue(s, e);
+    return;
   }
   if (e instanceof FPInterval) {
-    return { kind: 'interval', value: serializeFPInterval(e) };
+    s.writeU8(SerializedExpectationKind.Interval);
+    serializeFPInterval(s, e);
+    return;
   }
   if (e instanceof Array) {
     if (e[0] instanceof Array) {
       e = e as FPInterval[][];
       const cols = e.length;
       const rows = e[0].length;
-      return {
-        kind: '2d-interval-array',
-        cols,
-        rows,
-        value: flatten2DArray(e).map(serializeFPInterval),
-      };
+      s.writeU8(SerializedExpectationKind.Interval2DArray);
+      s.writeU16(cols);
+      s.writeU16(rows);
+      s.writeArray(flatten2DArray(e), serializeFPInterval);
     } else {
       e = e as FPInterval[];
-      return { kind: 'intervals', value: e.map(serializeFPInterval) };
+      s.writeU8(SerializedExpectationKind.Interval1DArray);
+      s.writeArray(e, serializeFPInterval);
     }
+    return;
   }
   if (isComparator(e)) {
-    return { kind: 'comparator', value: serializeComparator(e) };
+    s.writeU8(SerializedExpectationKind.Comparator);
+    serializeComparator(s, e);
+    return;
   }
   unreachable(`cannot serialize Expectation ${e}`);
 }
 
-/** deserializeExpectation() converts a SerializedExpectation to a Expectation */
-export function deserializeExpectation(data: SerializedExpectation): Expectation {
-  switch (data.kind) {
-    case 'value':
-      return deserializeValue(data.value);
-    case 'interval':
-      return deserializeFPInterval(data.value);
-    case 'intervals':
-      return data.value.map(deserializeFPInterval);
-    case '2d-interval-array':
-      return unflatten2DArray(data.value.map(deserializeFPInterval), data.cols, data.rows);
-    case 'comparator':
-      return deserializeComparator(data.value);
+/** deserializeExpectation() deserializes an Expectation from a BinaryStream */
+export function deserializeExpectation(s: BinaryStream): Expectation {
+  const kind = s.readU8();
+  switch (kind) {
+    case SerializedExpectationKind.Value: {
+      return deserializeValue(s);
+    }
+    case SerializedExpectationKind.Interval: {
+      return deserializeFPInterval(s);
+    }
+    case SerializedExpectationKind.Interval1DArray: {
+      return s.readArray(deserializeFPInterval);
+    }
+    case SerializedExpectationKind.Interval2DArray: {
+      const cols = s.readU16();
+      const rows = s.readU16();
+      return unflatten2DArray(s.readArray(deserializeFPInterval), cols, rows);
+    }
+    case SerializedExpectationKind.Comparator: {
+      return deserializeComparator(s);
+    }
+    default: {
+      unreachable(`invalid serialized expectation kind: ${kind}`);
+    }
   }
 }
 
-/**
- * SerializedCase holds the serialized form of a Case.
- * This form can be safely encoded to JSON.
- */
-export type SerializedCase = {
-  input: SerializedValue | SerializedValue[];
-  expected: SerializedExpectation;
-};
-
-/** serializeCase() converts an Case to a SerializedCase */
-export function serializeCase(c: Case): SerializedCase {
-  return {
-    input: c.input instanceof Array ? c.input.map(v => serializeValue(v)) : serializeValue(c.input),
-    expected: serializeExpectation(c.expected),
-  };
+/** serializeCase() serializes a Case to a BinaryStream */
+export function serializeCase(s: BinaryStream, c: Case) {
+  s.writeCond(c.input instanceof Array, {
+    if_true: () => {
+      // c.input is array
+      s.writeArray(c.input as Value[], serializeValue);
+    },
+    if_false: () => {
+      // c.input is not array
+      serializeValue(s, c.input as Value);
+    },
+  });
+  serializeExpectation(s, c.expected);
 }
 
-/** serializeCase() converts an SerializedCase to a Case */
-export function deserializeCase(data: SerializedCase): Case {
-  return {
-    input:
-      data.input instanceof Array
-        ? data.input.map(v => deserializeValue(v))
-        : deserializeValue(data.input),
-    expected: deserializeExpectation(data.expected),
-  };
+/** deserializeCase() deserializes a Case from a BinaryStream */
+export function deserializeCase(s: BinaryStream): Case {
+  const input = s.readCond({
+    if_true: () => {
+      // c.input is array
+      return s.readArray(deserializeValue);
+    },
+    if_false: () => {
+      // c.input is not array
+      return deserializeValue(s);
+    },
+  });
+  const expected = deserializeExpectation(s);
+  return { input, expected };
 }
 
 /** CaseListBuilder is a function that builds a CaseList */
@@ -176,7 +137,7 @@ export class CaseCache implements Cacheable<Record<string, CaseList>> {
    * @param builders a Record of case-list name to case-list builder.
    */
   constructor(name: string, builders: Record<string, CaseListBuilder>) {
-    this.path = `webgpu/shader/execution/case-cache/${name}.json`;
+    this.path = `webgpu/shader/execution/case-cache/${name}.bin`;
     this.builders = builders;
   }
 
@@ -203,23 +164,28 @@ export class CaseCache implements Cacheable<Record<string, CaseList>> {
    * serialize() implements the Cacheable.serialize interface.
    * @returns the serialized data.
    */
-  serialize(data: Record<string, CaseList>): string {
-    const serialized: Record<string, SerializedCase[]> = {};
+  serialize(data: Record<string, CaseList>): Uint8Array {
+    const maxSize = 32 << 20; // 32MB - max size for a file
+    const s = new BinaryStream(new Uint8Array(maxSize));
+    s.writeU32(Object.keys(data).length);
     for (const name in data) {
-      serialized[name] = data[name].map(c => serializeCase(c));
+      s.writeString(name);
+      s.writeArray(data[name], serializeCase);
     }
-    return JSON.stringify(serialized);
+    return s.buffer();
   }
 
   /**
    * deserialize() implements the Cacheable.deserialize interface.
    * @returns the deserialize data.
    */
-  deserialize(serialized: string): Record<string, CaseList> {
-    const data = JSON.parse(serialized) as Record<string, SerializedCase[]>;
+  deserialize(buffer: Uint8Array): Record<string, CaseList> {
+    const s = new BinaryStream(buffer);
     const casesByName: Record<string, CaseList> = {};
-    for (const name in data) {
-      const cases = data[name].map(caseData => deserializeCase(caseData));
+    const numRecords = s.readU32();
+    for (let i = 0; i < numRecords; i++) {
+      const name = s.readString();
+      const cases = s.readArray(deserializeCase);
       casesByName[name] = cases;
     }
     return casesByName;
diff --git a/src/webgpu/util/binary_stream.ts b/src/webgpu/util/binary_stream.ts
new file mode 100644
index 000000000000..1a17f4524d58
--- /dev/null
+++ b/src/webgpu/util/binary_stream.ts
@@ -0,0 +1,283 @@
+import { assert } from '../../common/util/util.js';
+import { Float16Array } from '../../external/petamoriken/float16/float16.js';
+
+import { align } from './math.js';
+
+/**
+ * BinaryStream is a utility to efficiently encode and decode numbers to / from a Uint8Array.
+ * BinaryStream uses a number of internal typed arrays to avoid small array allocations when reading
+ * and writing.
+ */
+export default class BinaryStream {
+  /**
+   * Constructor
+   * @param buffer the buffer to read from / write to. Array length must be a multiple of 8 bytes.
+   */
+  constructor(buffer: Uint8Array) {
+    this.offset = 0;
+    this.u8 = buffer;
+    this.u16 = new Uint16Array(this.u8.buffer);
+    this.u32 = new Uint32Array(this.u8.buffer);
+    this.i8 = new Int8Array(this.u8.buffer);
+    this.i16 = new Int16Array(this.u8.buffer);
+    this.i32 = new Int32Array(this.u8.buffer);
+    this.f16 = new Float16Array(this.u8.buffer);
+    this.f32 = new Float32Array(this.u8.buffer);
+    this.f64 = new Float64Array(this.u8.buffer);
+  }
+
+  /** buffer() returns the stream's buffer sliced to the 8-byte rounded read or write offset */
+  buffer(): Uint8Array {
+    return this.u8.slice(0, align(this.offset, 8));
+  }
+
+  /** writeBool() writes a boolean as 255 or 0 to the buffer at the next byte offset */
+  writeBool(value: boolean) {
+    this.u8[this.offset++] = value ? 255 : 0;
+  }
+
+  /** readBool() reads a boolean from the buffer at the next byte offset */
+  readBool(): boolean {
+    const val = this.u8[this.offset++];
+    assert(val === 0 || val === 255);
+    return val !== 0;
+  }
+
+  /** writeU8() writes a uint8 to the buffer at the next byte offset */
+  writeU8(value: number) {
+    this.u8[this.offset++] = value;
+  }
+
+  /** readU8() reads a uint8 from the buffer at the next byte offset */
+  readU8(): number {
+    return this.u8[this.offset++];
+  }
+
+  /** u8View() returns a Uint8Array view of the uint8 at the next byte offset */
+  u8View(): Uint8Array {
+    const at = this.offset++;
+    return new Uint8Array(this.u8.buffer, at, 1);
+  }
+
+  /** writeU16() writes a uint16 to the buffer at the next 16-bit aligned offset */
+  writeU16(value: number) {
+    this.u16[this.bumpWord(2)] = value;
+  }
+
+  /** readU16() reads a uint16 from the buffer at the next 16-bit aligned offset */
+  readU16(): number {
+    return this.u16[this.bumpWord(2)];
+  }
+
+  /** u16View() returns a Uint16Array view of the uint16 at the next 16-bit aligned offset */
+  u16View(): Uint16Array {
+    const at = this.bumpWord(2);
+    return new Uint16Array(this.u16.buffer, at * 2, 1);
+  }
+
+  /** writeU32() writes a uint32 to the buffer at the next 32-bit aligned offset */
+  writeU32(value: number) {
+    this.u32[this.bumpWord(4)] = value;
+  }
+
+  /** readU32() reads a uint32 from the buffer at the next 32-bit aligned offset */
+  readU32(): number {
+    return this.u32[this.bumpWord(4)];
+  }
+
+  /** u32View() returns a Uint32Array view of the uint32 at the next 32-bit aligned offset */
+  u32View(): Uint32Array {
+    const at = this.bumpWord(4);
+    return new Uint32Array(this.u32.buffer, at * 4, 1);
+  }
+
+  /** writeI8() writes a int8 to the buffer at the next byte offset */
+  writeI8(value: number) {
+    this.i8[this.offset++] = value;
+  }
+
+  /** readI8() reads a int8 from the buffer at the next byte offset */
+  readI8(): number {
+    return this.i8[this.offset++];
+  }
+
+  /** i8View() returns a Uint8Array view of the uint8 at the next byte offset */
+  i8View(): Int8Array {
+    const at = this.offset++;
+    return new Int8Array(this.i8.buffer, at, 1);
+  }
+
+  /** writeI16() writes a int16 to the buffer at the next 16-bit aligned offset */
+  writeI16(value: number) {
+    this.i16[this.bumpWord(2)] = value;
+  }
+
+  /** readI16() reads a int16 from the buffer at the next 16-bit aligned offset */
+  readI16(): number {
+    return this.i16[this.bumpWord(2)];
+  }
+
+  /** i16View() returns a Int16Array view of the uint16 at the next 16-bit aligned offset */
+  i16View(): Int16Array {
+    const at = this.bumpWord(2);
+    return new Int16Array(this.i16.buffer, at * 2, 1);
+  }
+
+  /** writeI32() writes a int32 to the buffer at the next 32-bit aligned offset */
+  writeI32(value: number) {
+    this.i32[this.bumpWord(4)] = value;
+  }
+
+  /** readI32() reads a int32 from the buffer at the next 32-bit aligned offset */
+  readI32(): number {
+    return this.i32[this.bumpWord(4)];
+  }
+
+  /** i32View() returns a Int32Array view of the uint32 at the next 32-bit aligned offset */
+  i32View(): Int32Array {
+    const at = this.bumpWord(4);
+    return new Int32Array(this.i32.buffer, at * 4, 1);
+  }
+
+  /** writeF16() writes a float16 to the buffer at the next 16-bit aligned offset */
+  writeF16(value: number) {
+    this.f16[this.bumpWord(2)] = value;
+  }
+
+  /** readF16() reads a float16 from the buffer at the next 16-bit aligned offset */
+  readF16(): number {
+    return this.f16[this.bumpWord(2)];
+  }
+
+  /** f16View() returns a Float16Array view of the uint16 at the next 16-bit aligned offset */
+  f16View(): Float16Array {
+    const at = this.bumpWord(2);
+    return new Float16Array(this.f16.buffer, at * 2, 1);
+  }
+
+  /** writeF32() writes a float32 to the buffer at the next 32-bit aligned offset */
+  writeF32(value: number) {
+    this.f32[this.bumpWord(4)] = value;
+  }
+
+  /** readF32() reads a float32 from the buffer at the next 32-bit aligned offset */
+  readF32(): number {
+    return this.f32[this.bumpWord(4)];
+  }
+
+  /** f32View() returns a Float32Array view of the uint32 at the next 32-bit aligned offset */
+  f32View(): Float32Array {
+    const at = this.bumpWord(4);
+    return new Float32Array(this.f32.buffer, at * 4, 1);
+  }
+
+  /** writeF64() writes a float64 to the buffer at the next 64-bit aligned offset */
+  writeF64(value: number) {
+    this.f64[this.bumpWord(8)] = value;
+  }
+
+  /** readF64() reads a float64 from the buffer at the next 64-bit aligned offset */
+  readF64(): number {
+    return this.f64[this.bumpWord(8)];
+  }
+
+  /** f64View() returns a Float64Array view of the uint64 at the next 64-bit aligned offset */
+  f64View(): Float64Array {
+    const at = this.bumpWord(8);
+    return new Float64Array(this.f64.buffer, at * 8, 1);
+  }
+
+  /**
+   * writeString() writes a length-prefixed UTF-16 string to the buffer at the next 32-bit aligned
+   * offset
+   */
+  writeString(value: string) {
+    this.writeU32(value.length);
+    for (let i = 0; i < value.length; i++) {
+      this.writeU16(value.charCodeAt(i));
+    }
+  }
+
+  /**
+   * readString() writes a length-prefixed UTF-16 string from the buffer at the next 32-bit aligned
+   * offset
+   */
+  readString(): string {
+    const len = this.readU32();
+    const codes = new Array<number>(len);
+    for (let i = 0; i < len; i++) {
+      codes[i] = this.readU16();
+    }
+    return String.fromCharCode(...codes);
+  }
+
+  /**
+   * writeArray() writes a length-prefixed array of T elements to the buffer at the next 32-bit
+   * aligned offset, using the provided callback to write the individual elements
+   */
+  writeArray<T>(value: readonly T[], writeElement: (s: BinaryStream, element: T) => void) {
+    this.writeU32(value.length);
+    for (const element of value) {
+      writeElement(this, element);
+    }
+  }
+
+  /**
+   * readArray() reads a length-prefixed array of T elements from the buffer at the next 32-bit
+   * aligned offset, using the provided callback to read the individual elements
+   */
+  readArray<T>(readElement: (s: BinaryStream) => T): T[] {
+    const len = this.readU32();
+    const array = new Array<T>(len);
+    for (let i = 0; i < len; i++) {
+      array[i] = readElement(this);
+    }
+    return array;
+  }
+
+  /**
+   * writeCond() writes the boolean condition @p cond to the buffer, then either calls if_true if
+   * @p cond is true, otherwise if_false
+   */
+  writeCond<T, F>(cond: boolean, fns: { if_true: () => T; if_false: () => F }) {
+    this.writeBool(cond);
+    if (cond) {
+      return fns.if_true();
+    } else {
+      return fns.if_false();
+    }
+  }
+
+  /**
+   * readCond() reads a boolean condition from the buffer, then either calls if_true if
+   * the condition was is true, otherwise if_false
+   */
+  readCond<T, F>(fns: { if_true: () => T; if_false: () => F }) {
+    if (this.readBool()) {
+      return fns.if_true();
+    } else {
+      return fns.if_false();
+    }
+  }
+
+  /**
+   * bumpWord() increments this.offset by @p bytes, after first aligning this.offset to @p bytes.
+   * @returns the old offset aligned to the next multiple of @p bytes, divided by @p bytes.
+   */
+  private bumpWord(bytes: number) {
+    const multiple = Math.floor((this.offset + bytes - 1) / bytes);
+    this.offset = (multiple + 1) * bytes;
+    return multiple;
+  }
+
+  private offset: number;
+  private u8: Uint8Array;
+  private u16: Uint16Array;
+  private u32: Uint32Array;
+  private i8: Int8Array;
+  private i16: Int16Array;
+  private i32: Int32Array;
+  private f16: Float16Array;
+  private f32: Float32Array;
+  private f64: Float64Array;
+}
diff --git a/src/webgpu/util/compare.ts b/src/webgpu/util/compare.ts
index 6fe7b34466d7..45599d25f63c 100644
--- a/src/webgpu/util/compare.ts
+++ b/src/webgpu/util/compare.ts
@@ -3,11 +3,11 @@ import { Colors } from '../../common/util/colors.js';
 import { assert, unreachable } from '../../common/util/util.js';
 import {
   deserializeExpectation,
-  SerializedExpectation,
   serializeExpectation,
 } from '../shader/execution/expression/case_cache.js';
 import { Expectation, toComparator } from '../shader/execution/expression/expression.js';
 
+import BinaryStream from './binary_stream.js';
 import { isFloatValue, Matrix, Scalar, Value, Vector } from './conversion.js';
 import { FPInterval } from './floating_point.js';
 
@@ -40,6 +40,40 @@ export interface Comparator {
   data?: Expectation | Expectation[] | string;
 }
 
+/** SerializedComparator is an enum of all the possible serialized comparator types. */
+enum SerializedComparatorKind {
+  AnyOf,
+  SkipUndefined,
+  AlwaysPass,
+}
+
+/** serializeComparatorKind() serializes a ComparatorKind to a BinaryStream */
+function serializeComparatorKind(s: BinaryStream, value: ComparatorKind) {
+  switch (value) {
+    case 'anyOf':
+      return s.writeU8(SerializedComparatorKind.AnyOf);
+    case 'skipUndefined':
+      return s.writeU8(SerializedComparatorKind.SkipUndefined);
+    case 'alwaysPass':
+      return s.writeU8(SerializedComparatorKind.AlwaysPass);
+  }
+}
+
+/** deserializeComparatorKind() deserializes a ComparatorKind from a BinaryStream */
+function deserializeComparatorKind(s: BinaryStream): ComparatorKind {
+  const kind = s.readU8();
+  switch (kind) {
+    case SerializedComparatorKind.AnyOf:
+      return 'anyOf';
+    case SerializedComparatorKind.SkipUndefined:
+      return 'skipUndefined';
+    case SerializedComparatorKind.AlwaysPass:
+      return 'alwaysPass';
+    default:
+      unreachable(`invalid serialized ComparatorKind: ${kind}`);
+  }
+}
+
 /**
  * compares 'got' Value  to 'expected' Value, returning the Comparison information.
  * @param got the Value obtained from the test
@@ -383,54 +417,27 @@ export function alwaysPass(msg: string = 'always pass'): Comparator {
   return c;
 }
 
-/** SerializedComparatorAnyOf is the serialized type of `anyOf` comparator. */
-type SerializedComparatorAnyOf = {
-  kind: 'anyOf';
-  data: SerializedExpectation[];
-};
-
-/** SerializedComparatorSkipUndefined is the serialized type of `skipUndefined` comparator. */
-type SerializedComparatorSkipUndefined = {
-  kind: 'skipUndefined';
-  data?: SerializedExpectation;
-};
-
-/** SerializedComparatorAlwaysPass is the serialized type of `alwaysPass` comparator. */
-type SerializedComparatorAlwaysPass = {
-  kind: 'alwaysPass';
-  reason: string;
-};
-
-// Serialized forms of 'value' and 'packed' are intentionally omitted, so should
-// not be put into the cache. Attempting to will cause a runtime assert.
-
-/** SerializedComparator is a union of all the possible serialized comparator types. */
-export type SerializedComparator =
-  | SerializedComparatorAnyOf
-  | SerializedComparatorSkipUndefined
-  | SerializedComparatorAlwaysPass;
-
-/**
- * Serializes a Comparator to a SerializedComparator.
- * @param c the Comparator
- * @returns a serialized comparator
- */
-export function serializeComparator(c: Comparator): SerializedComparator {
+/** serializeComparator() serializes a Comparator to a BinaryStream */
+export function serializeComparator(s: BinaryStream, c: Comparator) {
+  serializeComparatorKind(s, c.kind);
   switch (c.kind) {
-    case 'anyOf': {
-      const d = c.data as Expectation[];
-      return { kind: 'anyOf', data: d.map(serializeExpectation) };
-    }
-    case 'skipUndefined': {
-      if (c.data !== undefined) {
-        const d = c.data as Expectation;
-        return { kind: 'skipUndefined', data: serializeExpectation(d) };
-      }
-      return { kind: 'skipUndefined', data: undefined };
-    }
+    case 'anyOf':
+      s.writeArray(c.data as Expectation[], serializeExpectation);
+      return;
+    case 'skipUndefined':
+      s.writeCond(c.data !== undefined, {
+        if_true: () => {
+          // defined data
+          serializeExpectation(s, c.data as Expectation);
+        },
+        if_false: () => {
+          // undefined data
+        },
+      });
+      return;
     case 'alwaysPass': {
-      const d = c.data as string;
-      return { kind: 'alwaysPass', reason: d };
+      s.writeString(c.data as string);
+      return;
     }
     case 'value':
     case 'packed': {
@@ -441,22 +448,25 @@ export function serializeComparator(c: Comparator): SerializedComparator {
   unreachable(`Unable serialize comparator '${c}'`);
 }
 
-/**
- * Deserializes a Comparator from a SerializedComparator.
- * @param s the SerializedComparator
- * @returns the deserialized comparator.
- */
-export function deserializeComparator(s: SerializedComparator): Comparator {
-  switch (s.kind) {
-    case 'anyOf': {
-      return anyOf(...s.data.map(e => deserializeExpectation(e)));
-    }
-    case 'skipUndefined': {
-      return skipUndefined(s.data !== undefined ? deserializeExpectation(s.data) : undefined);
-    }
-    case 'alwaysPass': {
-      return alwaysPass(s.reason);
-    }
+/** deserializeComparator() deserializes a Comparator from a BinaryStream */
+export function deserializeComparator(s: BinaryStream): Comparator {
+  const kind = deserializeComparatorKind(s);
+  switch (kind) {
+    case 'anyOf':
+      return anyOf(...s.readArray(deserializeExpectation));
+    case 'skipUndefined':
+      return s.readCond({
+        if_true: () => {
+          // defined data
+          return skipUndefined(deserializeExpectation(s));
+        },
+        if_false: () => {
+          // undefined data
+          return skipUndefined(undefined);
+        },
+      });
+    case 'alwaysPass':
+      return alwaysPass(s.readString());
   }
   unreachable(`Unable deserialize comparator '${s}'`);
 }
diff --git a/src/webgpu/util/conversion.ts b/src/webgpu/util/conversion.ts
index e78af9783288..28a6e78f9137 100644
--- a/src/webgpu/util/conversion.ts
+++ b/src/webgpu/util/conversion.ts
@@ -3,6 +3,7 @@ import { ROArrayArray } from '../../common/util/types.js';
 import { assert, objectEquals, TypedArrayBufferView, unreachable } from '../../common/util/util.js';
 import { Float16Array } from '../../external/petamoriken/float16/float16.js';
 
+import BinaryStream from './binary_stream.js';
 import { kBit } from './constants.js';
 import {
   cartesianProduct,
@@ -888,11 +889,11 @@ export class Scalar {
   }
 
   /**
-   * Copies the scalar value to the Uint8Array buffer at the provided byte offset.
+   * Copies the scalar value to the buffer at the provided byte offset.
    * @param buffer the destination buffer
-   * @param offset the byte offset within buffer
+   * @param offset the offset in buffer, in units of @p buffer
    */
-  public copyTo(buffer: Uint8Array, offset: number) {
+  public copyTo(buffer: TypedArrayBufferView, offset: number) {
     assert(this.type.kind !== 'f64', `Copying f64 values to/from buffers is not defined`);
     workingDataU32[1] = this.bits1;
     workingDataU32[0] = this.bits0;
@@ -1301,86 +1302,222 @@ export type SerializedValueMatrix = {
   value: ROArrayArray<number>;
 };
 
-export type SerializedValue = SerializedValueScalar | SerializedValueVector | SerializedValueMatrix;
+enum SerializedScalarKind {
+  AbstractFloat,
+  F64,
+  F32,
+  F16,
+  U32,
+  U16,
+  U8,
+  I32,
+  I16,
+  I8,
+  Bool,
+}
 
-export function serializeValue(v: Value): SerializedValue {
-  const value = (kind: ScalarKind, s: Scalar) => {
+/** serializeScalarKind() serializes a ScalarKind to a BinaryStream */
+function serializeScalarKind(s: BinaryStream, v: ScalarKind) {
+  switch (v) {
+    case 'abstract-float':
+      s.writeU8(SerializedScalarKind.AbstractFloat);
+      return;
+    case 'f64':
+      s.writeU8(SerializedScalarKind.F64);
+      return;
+    case 'f32':
+      s.writeU8(SerializedScalarKind.F32);
+      return;
+    case 'f16':
+      s.writeU8(SerializedScalarKind.F16);
+      return;
+    case 'u32':
+      s.writeU8(SerializedScalarKind.U32);
+      return;
+    case 'u16':
+      s.writeU8(SerializedScalarKind.U16);
+      return;
+    case 'u8':
+      s.writeU8(SerializedScalarKind.U8);
+      return;
+    case 'i32':
+      s.writeU8(SerializedScalarKind.I32);
+      return;
+    case 'i16':
+      s.writeU8(SerializedScalarKind.I16);
+      return;
+    case 'i8':
+      s.writeU8(SerializedScalarKind.I8);
+      return;
+    case 'bool':
+      s.writeU8(SerializedScalarKind.Bool);
+      return;
+  }
+}
+
+/** deserializeScalarKind() deserializes a ScalarKind from a BinaryStream */
+function deserializeScalarKind(s: BinaryStream): ScalarKind {
+  const kind = s.readU8();
+  switch (kind) {
+    case SerializedScalarKind.AbstractFloat:
+      return 'abstract-float';
+    case SerializedScalarKind.F64:
+      return 'f64';
+    case SerializedScalarKind.F32:
+      return 'f32';
+    case SerializedScalarKind.F16:
+      return 'f16';
+    case SerializedScalarKind.U32:
+      return 'u32';
+    case SerializedScalarKind.U16:
+      return 'u16';
+    case SerializedScalarKind.U8:
+      return 'u8';
+    case SerializedScalarKind.I32:
+      return 'i32';
+    case SerializedScalarKind.I16:
+      return 'i16';
+    case SerializedScalarKind.I8:
+      return 'i8';
+    case SerializedScalarKind.Bool:
+      return 'bool';
+    default:
+      unreachable(`invalid serialized ScalarKind: ${kind}`);
+  }
+}
+
+enum SerializedValueKind {
+  Scalar,
+  Vector,
+  Matrix,
+}
+
+/** serializeValue() serializes a Value to a BinaryStream */
+export function serializeValue(s: BinaryStream, v: Value) {
+  const serializeScalar = (scalar: Scalar, kind: ScalarKind) => {
     switch (kind) {
+      case 'abstract-float':
+        s.writeF64(scalar.value as number);
+        return;
+      case 'f64':
+        s.writeF64(scalar.value as number);
+        return;
       case 'f32':
-        return s.bits0;
+        s.writeF32(scalar.value as number);
+        return;
       case 'f16':
-        return s.bits0;
-      default:
-        return s.value;
+        s.writeF16(scalar.value as number);
+        return;
+      case 'u32':
+        s.writeU32(scalar.value as number);
+        return;
+      case 'u16':
+        s.writeU16(scalar.value as number);
+        return;
+      case 'u8':
+        s.writeU8(scalar.value as number);
+        return;
+      case 'i32':
+        s.writeI32(scalar.value as number);
+        return;
+      case 'i16':
+        s.writeI16(scalar.value as number);
+        return;
+      case 'i8':
+        s.writeI8(scalar.value as number);
+        return;
+      case 'bool':
+        s.writeBool(scalar.value as boolean);
+        return;
     }
   };
+
   if (v instanceof Scalar) {
-    const kind = v.type.kind;
-    return {
-      kind: 'scalar',
-      type: kind,
-      value: value(kind, v),
-    };
+    s.writeU8(SerializedValueKind.Scalar);
+    serializeScalarKind(s, v.type.kind);
+    serializeScalar(v, v.type.kind);
+    return;
   }
   if (v instanceof Vector) {
-    const kind = v.type.elementType.kind;
-    return {
-      kind: 'vector',
-      type: kind,
-      value: v.elements.map(e => value(kind, e)) as boolean[] | readonly number[],
-    };
+    s.writeU8(SerializedValueKind.Vector);
+    serializeScalarKind(s, v.type.elementType.kind);
+    s.writeU8(v.type.width);
+    for (const element of v.elements) {
+      serializeScalar(element, v.type.elementType.kind);
+    }
+    return;
   }
   if (v instanceof Matrix) {
-    const kind = v.type.elementType.kind;
-    return {
-      kind: 'matrix',
-      type: kind,
-      value: v.elements.map(c => c.map(r => value(kind, r))) as ROArrayArray<number>,
-    };
+    s.writeU8(SerializedValueKind.Matrix);
+    serializeScalarKind(s, v.type.elementType.kind);
+    s.writeU8(v.type.cols);
+    s.writeU8(v.type.rows);
+    for (const column of v.elements) {
+      for (const element of column) {
+        serializeScalar(element, v.type.elementType.kind);
+      }
+    }
+    return;
   }
 
   unreachable(`unhandled value type: ${v}`);
 }
 
-export function deserializeValue(data: SerializedValue): Value {
-  const buildScalar = (v: ScalarValue): Scalar => {
-    switch (data.type) {
+/** deserializeValue() deserializes a Value from a BinaryStream */
+export function deserializeValue(s: BinaryStream): Value {
+  const deserializeScalar = (kind: ScalarKind) => {
+    switch (kind) {
       case 'abstract-float':
-        return abstractFloat(v as number);
+        return abstractFloat(s.readF64());
       case 'f64':
-        return f64(v as number);
-      case 'i32':
-        return i32(v as number);
-      case 'u32':
-        return u32(v as number);
+        return f64(s.readF64());
       case 'f32':
-        return f32Bits(v as number);
-      case 'i16':
-        return i16(v as number);
-      case 'u16':
-        return u16(v as number);
+        return f32(s.readF32());
       case 'f16':
-        return f16Bits(v as number);
-      case 'i8':
-        return i8(v as number);
+        return f16(s.readF16());
+      case 'u32':
+        return u32(s.readU32());
+      case 'u16':
+        return u16(s.readU16());
       case 'u8':
-        return u8(v as number);
+        return u8(s.readU8());
+      case 'i32':
+        return i32(s.readI32());
+      case 'i16':
+        return i16(s.readI16());
+      case 'i8':
+        return i8(s.readI8());
       case 'bool':
-        return bool(v as boolean);
-      default:
-        unreachable(`unhandled value type: ${data.type}`);
+        return bool(s.readBool());
     }
   };
-  switch (data.kind) {
-    case 'scalar': {
-      return buildScalar(data.value);
-    }
-    case 'vector': {
-      return new Vector(data.value.map(v => buildScalar(v)));
+  const valueKind = s.readU8();
+  const scalarKind = deserializeScalarKind(s);
+  switch (valueKind) {
+    case SerializedValueKind.Scalar:
+      return deserializeScalar(scalarKind);
+    case SerializedValueKind.Vector: {
+      const width = s.readU8();
+      const scalars = new Array<Scalar>(width);
+      for (let i = 0; i < width; i++) {
+        scalars[i] = deserializeScalar(scalarKind);
+      }
+      return new Vector(scalars);
     }
-    case 'matrix': {
-      return new Matrix(data.value.map(c => c.map(buildScalar)));
+    case SerializedValueKind.Matrix: {
+      const numCols = s.readU8();
+      const numRows = s.readU8();
+      const columns = new Array<Scalar[]>(numCols);
+      for (let c = 0; c < numCols; c++) {
+        columns[c] = new Array<Scalar>(numRows);
+        for (let i = 0; i < numRows; i++) {
+          columns[c][i] = deserializeScalar(scalarKind);
+        }
+      }
+      return new Matrix(columns);
     }
+    default:
+      unreachable(`invalid serialized value kind: ${valueKind}`);
   }
 }
 
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index 18a640f43403..b13f20fd6653 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -3,6 +3,7 @@ import { assert, unreachable } from '../../common/util/util.js';
 import { Float16Array } from '../../external/petamoriken/float16/float16.js';
 import { Case, IntervalFilter } from '../shader/execution/expression/expression.js';
 
+import BinaryStream from './binary_stream.js';
 import { anyOf } from './compare.js';
 import { kValue } from './constants.js';
 import {
@@ -40,18 +41,45 @@ import {
   unflatten2DArray,
   every2DArray,
 } from './math.js';
-import {
-  reinterpretF16AsU16,
-  reinterpretF32AsU32,
-  reinterpretF64AsU32s,
-  reinterpretU16AsF16,
-  reinterpretU32AsF32,
-  reinterpretU32sAsF64,
-} from './reinterpret.js';
 
 /** Indicate the kind of WGSL floating point numbers being operated on */
 export type FPKind = 'f32' | 'f16' | 'abstract';
 
+enum SerializedFPIntervalKind {
+  Abstract,
+  F32,
+  F16,
+}
+
+/** serializeFPKind() serializes a FPKind to a BinaryStream */
+export function serializeFPKind(s: BinaryStream, value: FPKind) {
+  switch (value) {
+    case 'abstract':
+      s.writeU8(SerializedFPIntervalKind.Abstract);
+      break;
+    case 'f16':
+      s.writeU8(SerializedFPIntervalKind.F16);
+      break;
+    case 'f32':
+      s.writeU8(SerializedFPIntervalKind.F32);
+      break;
+  }
+}
+
+/** deserializeFPKind() deserializes a FPKind from a BinaryStream */
+export function deserializeFPKind(s: BinaryStream): FPKind {
+  const kind = s.readU8();
+  switch (kind) {
+    case SerializedFPIntervalKind.Abstract:
+      return 'abstract';
+    case SerializedFPIntervalKind.F16:
+      return 'f16';
+    case SerializedFPIntervalKind.F32:
+      return 'f32';
+    default:
+      unreachable(`invalid deserialized FPKind: ${kind}`);
+  }
+}
 // Containers
 
 /**
@@ -138,81 +166,59 @@ export class FPInterval {
   }
 }
 
-/**
- * SerializedFPInterval holds the serialized form of a FPInterval.
- * This form can be safely encoded to JSON.
- */
-export type SerializedFPInterval =
-  | { kind: 'f32'; unbounded: false; begin: number; end: number }
-  | { kind: 'f32'; unbounded: true }
-  | { kind: 'f16'; unbounded: false; begin: number; end: number }
-  | { kind: 'f16'; unbounded: true }
-  | { kind: 'abstract'; unbounded: false; begin: [number, number]; end: [number, number] }
-  | { kind: 'abstract'; unbounded: true };
-
-/** serializeFPInterval() converts a FPInterval to a SerializedFPInterval */
-export function serializeFPInterval(i: FPInterval): SerializedFPInterval {
+/** serializeFPInterval() serializes a FPInterval to a BinaryStream */
+export function serializeFPInterval(s: BinaryStream, i: FPInterval) {
+  serializeFPKind(s, i.kind);
   const traits = FP[i.kind];
-  switch (i.kind) {
-    case 'abstract': {
-      if (i === traits.constants().unboundedInterval) {
-        return { kind: 'abstract', unbounded: true };
-      } else {
-        return {
-          kind: 'abstract',
-          unbounded: false,
-          begin: reinterpretF64AsU32s(i.begin),
-          end: reinterpretF64AsU32s(i.end),
-        };
-      }
-    }
-    case 'f32': {
-      if (i === traits.constants().unboundedInterval) {
-        return { kind: 'f32', unbounded: true };
-      } else {
-        return {
-          kind: 'f32',
-          unbounded: false,
-          begin: reinterpretF32AsU32(i.begin),
-          end: reinterpretF32AsU32(i.end),
-        };
+  s.writeCond(i !== traits.constants().unboundedInterval, {
+    if_true: () => {
+      // Bounded
+      switch (i.kind) {
+        case 'abstract':
+          s.writeF64(i.begin);
+          s.writeF64(i.end);
+          break;
+        case 'f32':
+          s.writeF32(i.begin);
+          s.writeF32(i.end);
+          break;
+        case 'f16':
+          s.writeF16(i.begin);
+          s.writeF16(i.end);
+          break;
+        default:
+          unreachable(`Unable to serialize FPInterval ${i}`);
+          break;
       }
-    }
-    case 'f16': {
-      if (i === traits.constants().unboundedInterval) {
-        return { kind: 'f16', unbounded: true };
-      } else {
-        return {
-          kind: 'f16',
-          unbounded: false,
-          begin: reinterpretF16AsU16(i.begin),
-          end: reinterpretF16AsU16(i.end),
-        };
-      }
-    }
-  }
-  unreachable(`Unable to serialize FPInterval ${i}`);
+    },
+    if_false: () => {
+      // Unbounded
+    },
+  });
 }
 
-/** serializeFPInterval() converts a SerializedFPInterval to a FPInterval */
-export function deserializeFPInterval(data: SerializedFPInterval): FPInterval {
-  const kind = data.kind;
+/** deserializeFPInterval() deserializes a FPInterval from a BinaryStream */
+export function deserializeFPInterval(s: BinaryStream): FPInterval {
+  const kind = deserializeFPKind(s);
   const traits = FP[kind];
-  if (data.unbounded) {
-    return traits.constants().unboundedInterval;
-  }
-  switch (kind) {
-    case 'abstract': {
-      return traits.toInterval([reinterpretU32sAsF64(data.begin), reinterpretU32sAsF64(data.end)]);
-    }
-    case 'f32': {
-      return traits.toInterval([reinterpretU32AsF32(data.begin), reinterpretU32AsF32(data.end)]);
-    }
-    case 'f16': {
-      return traits.toInterval([reinterpretU16AsF16(data.begin), reinterpretU16AsF16(data.end)]);
-    }
-  }
-  unreachable(`Unable to deserialize data ${data}`);
+  return s.readCond({
+    if_true: () => {
+      // Bounded
+      switch (kind) {
+        case 'abstract':
+          return traits.toInterval([s.readF64(), s.readF64()]);
+        case 'f32':
+          return traits.toInterval([s.readF32(), s.readF32()]);
+        case 'f16':
+          return traits.toInterval([s.readF16(), s.readF16()]);
+      }
+      unreachable(`Unable to deserialize FPInterval with kind ${kind}`);
+    },
+    if_false: () => {
+      // Unbounded
+      return traits.constants().unboundedInterval;
+    },
+  });
 }
 
 /**

From 250e58356a0d37f3caf5ac274edf80d49130a731 Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Thu, 26 Oct 2023 12:00:01 +0100
Subject: [PATCH 155/166] tsdoc: Remove @p with backticks

Unlike doxygen, TSDoc doesn't support @p to link to a parameter. Use code backticks instead.
---
 src/common/framework/data_cache.ts                     |  4 ++--
 src/common/util/data_tables.ts                         |  2 +-
 src/webgpu/shader/execution/expression/expression.ts   | 10 +++++-----
 src/webgpu/shader/execution/flow_control/harness.ts    |  2 +-
 src/webgpu/shader/validation/decl/util.ts              |  2 +-
 .../call/builtin/const_override_validation.ts          |  6 +++---
 .../validation/expression/call/builtin/length.spec.ts  |  2 +-
 src/webgpu/shader/validation/shader_io/util.ts         |  2 +-
 src/webgpu/util/binary_stream.ts                       |  8 ++++----
 src/webgpu/util/conversion.ts                          |  8 ++++----
 src/webgpu/util/floating_point.ts                      |  4 ++--
 11 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/common/framework/data_cache.ts b/src/common/framework/data_cache.ts
index be5bde8e224b..c1e3a889beb3 100644
--- a/src/common/framework/data_cache.ts
+++ b/src/common/framework/data_cache.ts
@@ -23,7 +23,7 @@ class DataCacheNode {
     this.data = data;
   }
 
-  /** insertAfter() re-inserts this node in the doubly-linked list after @p prev */
+  /** insertAfter() re-inserts this node in the doubly-linked list after `prev` */
   public insertAfter(prev: DataCacheNode) {
     this.unlink();
     this.next = prev.next;
@@ -114,7 +114,7 @@ export class DataCache {
   }
 
   /**
-   * addToCache() creates a new node for @p path and @p data, inserting the new node at the front of
+   * addToCache() creates a new node for `path` and `data`, inserting the new node at the front of
    * the doubly-linked list. If the number of entries in the cache exceeds this.maxCount, then the
    * least recently used entry is evicted
    * @param path the file path for the data
diff --git a/src/common/util/data_tables.ts b/src/common/util/data_tables.ts
index 9309b9d2fd97..1a9459fb77aa 100644
--- a/src/common/util/data_tables.ts
+++ b/src/common/util/data_tables.ts
@@ -11,7 +11,7 @@ export function numericKeysOf<T>(obj: object): readonly T[] {
 }
 
 /**
- * @returns a new Record from @p objects, using the string returned by Object.toString() as the keys
+ * @returns a new Record from `objects`, using the string returned by Object.toString() as the keys
  * and the objects as the values.
  */
 export function objectsToRecord<T extends Object>(objects: readonly T[]): Record<string, T> {
diff --git a/src/webgpu/shader/execution/expression/expression.ts b/src/webgpu/shader/execution/expression/expression.ts
index 8765476831d4..33328d6a1e9d 100644
--- a/src/webgpu/shader/execution/expression/expression.ts
+++ b/src/webgpu/shader/execution/expression/expression.ts
@@ -261,7 +261,7 @@ type PipelineCache = Map<String, GPUComputePipeline>;
 
 /**
  * Searches for an entry with the given key, adding and returning the result of calling
- * @p create if the entry was not found.
+ * `create` if the entry was not found.
  * @param map the cache map
  * @param key the entry's key
  * @param create the function used to construct a value, if not found in the cache
@@ -468,9 +468,9 @@ function submitBatch(
 }
 
 /**
- * map is a helper for returning a new array with each element of @p v
- * transformed with @p fn.
- * If @p v is not an array, then @p fn is called with (v, 0).
+ * map is a helper for returning a new array with each element of `v`
+ * transformed with `fn`.
+ * If `v` is not an array, then `fn` is called with (v, 0).
  */
 function map<T, U>(v: T | readonly T[], fn: (value: T, index?: number) => U): U[] {
   if (v instanceof Array) {
@@ -992,7 +992,7 @@ ${body}
 /**
  * Constructs and returns a GPUComputePipeline and GPUBindGroup for running a
  * batch of test cases. If a pre-created pipeline can be found in
- * @p pipelineCache, then this may be returned instead of creating a new
+ * `pipelineCache`, then this may be returned instead of creating a new
  * pipeline.
  * @param t the GPUTest
  * @param shaderBuilder the shader builder
diff --git a/src/webgpu/shader/execution/flow_control/harness.ts b/src/webgpu/shader/execution/flow_control/harness.ts
index 8de19fda8e8a..94dfcdfc4d8f 100644
--- a/src/webgpu/shader/execution/flow_control/harness.ts
+++ b/src/webgpu/shader/execution/flow_control/harness.ts
@@ -49,7 +49,7 @@ interface FlowControlTestBuilder {
 /**
  * Builds, runs then checks the output of a flow control shader test.
  *
- * @p build_wgsl is a function that's called to build the WGSL shader.
+ * `build_wgsl` is a function that's called to build the WGSL shader.
  * This function takes a FlowControlTestBuilder as the single argument, and
  * returns either a string which is embedded into the WGSL entrypoint function,
  * or an object of the signature `{ entrypoint: string; extra: string }` which
diff --git a/src/webgpu/shader/validation/decl/util.ts b/src/webgpu/shader/validation/decl/util.ts
index f214fb7cc720..ab1b08e12a93 100644
--- a/src/webgpu/shader/validation/decl/util.ts
+++ b/src/webgpu/shader/validation/decl/util.ts
@@ -14,7 +14,7 @@ export const kShaderStages = ['vertex', 'fragment', 'compute'] as const;
 
 /**
  * declareEntrypoint emits the WGSL to declare an entry point with the name, stage and body.
- * The generated function will have an appropriate return type and return statement, so that @p body
+ * The generated function will have an appropriate return type and return statement, so that `body`
  * does not have to change between stage.
  * @param arg - arg specifies the
  * optional entry point function name, the shader stage, and the body of the
diff --git a/src/webgpu/shader/validation/expression/call/builtin/const_override_validation.ts b/src/webgpu/shader/validation/expression/call/builtin/const_override_validation.ts
index 3c68b192a21d..86b88cb159dc 100644
--- a/src/webgpu/shader/validation/expression/call/builtin/const_override_validation.ts
+++ b/src/webgpu/shader/validation/expression/call/builtin/const_override_validation.ts
@@ -92,7 +92,7 @@ export const kConstantAndOverrideStages = ['constant', 'override'] as const;
 export type ConstantOrOverrideStage = 'constant' | 'override';
 
 /**
- * @returns true if evaluation stage @p stage supports expressions of type @p.
+ * @returns true if evaluation stage `stage` supports expressions of type @p.
  */
 export function stageSupportsType(stage: ConstantOrOverrideStage, type: Type) {
   if (stage === 'override' && isAbstractType(elementType(type)!)) {
@@ -103,7 +103,7 @@ export function stageSupportsType(stage: ConstantOrOverrideStage, type: Type) {
 }
 
 /**
- * Runs a validation test to check that evaluation of @p builtin either evaluates with or without
+ * Runs a validation test to check that evaluation of `builtin` either evaluates with or without
  * error at shader creation time or pipeline creation time.
  * @param t the ShaderValidationTest
  * @param builtin the name of the builtin
@@ -159,7 +159,7 @@ var<private> v = ${builtin}(${callArgs.join(', ')});`,
   }
 }
 
-/** @returns a sweep of the representable values for element type of @p type */
+/** @returns a sweep of the representable values for element type of `type` */
 export function fullRangeForType(type: Type, count?: number) {
   if (count === undefined) {
     count = 25;
diff --git a/src/webgpu/shader/validation/expression/call/builtin/length.spec.ts b/src/webgpu/shader/validation/expression/call/builtin/length.spec.ts
index ed0067e6522a..60fbe6e2852b 100644
--- a/src/webgpu/shader/validation/expression/call/builtin/length.spec.ts
+++ b/src/webgpu/shader/validation/expression/call/builtin/length.spec.ts
@@ -30,7 +30,7 @@ export const g = makeTestGroup(ShaderValidationTest);
 
 /**
  * Evaluates the result and information about a call to length(), with a vector
- * formed from @p vec of the element type @p type.
+ * formed from `vec` of the element type `type`.
  */
 function calculate(
   vec: number[],
diff --git a/src/webgpu/shader/validation/shader_io/util.ts b/src/webgpu/shader/validation/shader_io/util.ts
index 075965e4163b..20610753e67c 100644
--- a/src/webgpu/shader/validation/shader_io/util.ts
+++ b/src/webgpu/shader/validation/shader_io/util.ts
@@ -167,7 +167,7 @@ export type ShaderStage = 'vertex' | 'fragment' | 'compute';
 
 /**
  * declareEntrypoint emits the WGSL to declare an entry point with the given name, stage and body.
- * The generated function will have an appropriate return type and return statement, so that @p body
+ * The generated function will have an appropriate return type and return statement, so that `body`
  * does not have to change between stage.
  * @param name the entry point function name
  * @param stage the entry point stage
diff --git a/src/webgpu/util/binary_stream.ts b/src/webgpu/util/binary_stream.ts
index 1a17f4524d58..575973afbe0b 100644
--- a/src/webgpu/util/binary_stream.ts
+++ b/src/webgpu/util/binary_stream.ts
@@ -236,8 +236,8 @@ export default class BinaryStream {
   }
 
   /**
-   * writeCond() writes the boolean condition @p cond to the buffer, then either calls if_true if
-   * @p cond is true, otherwise if_false
+   * writeCond() writes the boolean condition `cond` to the buffer, then either calls if_true if
+   * `cond` is true, otherwise if_false
    */
   writeCond<T, F>(cond: boolean, fns: { if_true: () => T; if_false: () => F }) {
     this.writeBool(cond);
@@ -261,8 +261,8 @@ export default class BinaryStream {
   }
 
   /**
-   * bumpWord() increments this.offset by @p bytes, after first aligning this.offset to @p bytes.
-   * @returns the old offset aligned to the next multiple of @p bytes, divided by @p bytes.
+   * bumpWord() increments this.offset by `bytes`, after first aligning this.offset to `bytes`.
+   * @returns the old offset aligned to the next multiple of `bytes`, divided by `bytes`.
    */
   private bumpWord(bytes: number) {
     const multiple = Math.floor((this.offset + bytes - 1) / bytes);
diff --git a/src/webgpu/util/conversion.ts b/src/webgpu/util/conversion.ts
index 28a6e78f9137..d98367447d7d 100644
--- a/src/webgpu/util/conversion.ts
+++ b/src/webgpu/util/conversion.ts
@@ -609,7 +609,7 @@ export class ScalarType {
     return this._size;
   }
 
-  /** Constructs a Scalar of this type with @p value */
+  /** Constructs a Scalar of this type with `value` */
   public create(value: number): Scalar {
     switch (this.kind) {
       case 'abstract-float':
@@ -891,7 +891,7 @@ export class Scalar {
   /**
    * Copies the scalar value to the buffer at the provided byte offset.
    * @param buffer the destination buffer
-   * @param offset the offset in buffer, in units of @p buffer
+   * @param offset the offset in buffer, in units of `buffer`
    */
   public copyTo(buffer: TypedArrayBufferView, offset: number) {
     assert(this.type.kind !== 'f64', `Copying f64 values to/from buffers is not defined`);
@@ -1527,7 +1527,7 @@ export function isFloatValue(v: Value): boolean {
 }
 
 /**
- * @returns if @p ty is an abstract numeric type.
+ * @returns if `ty` is an abstract numeric type.
  * @note this does not consider composite types.
  * Use elementType() if you want to test the element type.
  */
@@ -1539,7 +1539,7 @@ export function isAbstractType(ty: Type): boolean {
 }
 
 /**
- * @returns if @p ty is a floating point type.
+ * @returns if `ty` is a floating point type.
  * @note this does not consider composite types.
  * Use elementType() if you want to test the element type.
  */
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index b13f20fd6653..f9b9d2ca44ce 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -5426,7 +5426,7 @@ export const FP = {
   abstract: new FPAbstractTraits(),
 };
 
-/** @returns the floating-point traits for @p type */
+/** @returns the floating-point traits for `type` */
 export function fpTraitsFor(type: ScalarType): FPTraits {
   switch (type.kind) {
     case 'abstract-float':
@@ -5440,7 +5440,7 @@ export function fpTraitsFor(type: ScalarType): FPTraits {
   }
 }
 
-/** @returns true if the value @p value is representable with @p type */
+/** @returns true if the value `value` is representable with `type` */
 export function isRepresentable(value: number, type: ScalarType) {
   if (!Number.isFinite(value)) {
     return false;

From ba9e5d6b9df67e60fda82dbb4e09ab473777f761 Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Thu, 26 Oct 2023 21:41:29 +0100
Subject: [PATCH 156/166] More cache deserialization micro-optimisations

* Use DataView instead of a bunch of separate typed arrays.
* Avoid small allocations where it's trivial to do so.

Speeds up deserialization around ~10% based on profiling in Chrome.
---
 src/unittests/serialization.spec.ts           |  14 +-
 .../shader/execution/expression/case_cache.ts |   8 +-
 src/webgpu/util/binary_stream.ts              | 134 +++++-------------
 src/webgpu/util/floating_point.ts             |   9 +-
 4 files changed, 48 insertions(+), 117 deletions(-)

diff --git a/src/unittests/serialization.spec.ts b/src/unittests/serialization.spec.ts
index 76ac1f715545..7f5384ad9cb5 100644
--- a/src/unittests/serialization.spec.ts
+++ b/src/unittests/serialization.spec.ts
@@ -207,7 +207,7 @@ g.test('value').fn(t => {
       f32
     ),
   ]) {
-    const s = new BinaryStream(new Uint8Array(1024));
+    const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeValue(s, value);
     const d = new BinaryStream(s.buffer());
     const deserialized = deserializeValue(d);
@@ -244,7 +244,7 @@ g.test('fpinterval_f32').fn(t => {
     FP.f32.toInterval([kValue.f32.negative.subnormal.min, kValue.f32.negative.subnormal.max]),
     FP.f32.toInterval([kValue.f32.negative.infinity, kValue.f32.positive.infinity]),
   ]) {
-    const s = new BinaryStream(new Uint8Array(1024));
+    const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeFPInterval(s, interval);
     const d = new BinaryStream(s.buffer());
     const deserialized = deserializeFPInterval(d);
@@ -280,7 +280,7 @@ g.test('fpinterval_f16').fn(t => {
     FP.f16.toInterval([kValue.f16.negative.subnormal.min, kValue.f16.negative.subnormal.max]),
     FP.f16.toInterval([kValue.f16.negative.infinity, kValue.f16.positive.infinity]),
   ]) {
-    const s = new BinaryStream(new Uint8Array(1024));
+    const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeFPInterval(s, interval);
     const d = new BinaryStream(s.buffer());
     const deserialized = deserializeFPInterval(d);
@@ -316,7 +316,7 @@ g.test('fpinterval_abstract').fn(t => {
     FP.abstract.toInterval([kValue.f64.negative.subnormal.min, kValue.f64.negative.subnormal.max]),
     FP.abstract.toInterval([kValue.f64.negative.infinity, kValue.f64.positive.infinity]),
   ]) {
-    const s = new BinaryStream(new Uint8Array(1024));
+    const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeFPInterval(s, interval);
     const d = new BinaryStream(s.buffer());
     const deserialized = deserializeFPInterval(d);
@@ -338,7 +338,7 @@ g.test('expression_expectation').fn(t => {
     // Intervals
     [FP.f32.toInterval([-8.0, 0.5]), FP.f32.toInterval([2.0, 4.0])],
   ]) {
-    const s = new BinaryStream(new Uint8Array(1024));
+    const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeExpectation(s, expectation);
     const d = new BinaryStream(s.buffer());
     const deserialized = deserializeExpectation(d);
@@ -368,7 +368,7 @@ g.test('anyOf').fn(t => {
         testCases: [f32(0), f32(10), f32(122), f32(123), f32(124), f32(200)],
       },
     ]) {
-      const s = new BinaryStream(new Uint8Array(1024));
+      const s = new BinaryStream(new Uint8Array(1024).buffer);
       serializeComparator(s, c.comparator);
       const d = new BinaryStream(s.buffer());
       const deserialized = deserializeComparator(d);
@@ -396,7 +396,7 @@ g.test('skipUndefined').fn(t => {
         testCases: [f32(0), f32(10), f32(122), f32(123), f32(124), f32(200)],
       },
     ]) {
-      const s = new BinaryStream(new Uint8Array(1024));
+      const s = new BinaryStream(new Uint8Array(1024).buffer);
       serializeComparator(s, c.comparator);
       const d = new BinaryStream(s.buffer());
       const deserialized = deserializeComparator(d);
diff --git a/src/webgpu/shader/execution/expression/case_cache.ts b/src/webgpu/shader/execution/expression/case_cache.ts
index 88f4a48df4c8..daee31993161 100644
--- a/src/webgpu/shader/execution/expression/case_cache.ts
+++ b/src/webgpu/shader/execution/expression/case_cache.ts
@@ -166,21 +166,21 @@ export class CaseCache implements Cacheable<Record<string, CaseList>> {
    */
   serialize(data: Record<string, CaseList>): Uint8Array {
     const maxSize = 32 << 20; // 32MB - max size for a file
-    const s = new BinaryStream(new Uint8Array(maxSize));
+    const s = new BinaryStream(new Uint8Array(maxSize).buffer);
     s.writeU32(Object.keys(data).length);
     for (const name in data) {
       s.writeString(name);
       s.writeArray(data[name], serializeCase);
     }
-    return s.buffer();
+    return new Uint8Array(s.buffer());
   }
 
   /**
    * deserialize() implements the Cacheable.deserialize interface.
    * @returns the deserialize data.
    */
-  deserialize(buffer: Uint8Array): Record<string, CaseList> {
-    const s = new BinaryStream(buffer);
+  deserialize(array: Uint8Array): Record<string, CaseList> {
+    const s = new BinaryStream(array.buffer);
     const casesByName: Record<string, CaseList> = {};
     const numRecords = s.readU32();
     for (let i = 0; i < numRecords; i++) {
diff --git a/src/webgpu/util/binary_stream.ts b/src/webgpu/util/binary_stream.ts
index 575973afbe0b..4941b9a4dab9 100644
--- a/src/webgpu/util/binary_stream.ts
+++ b/src/webgpu/util/binary_stream.ts
@@ -1,6 +1,6 @@
 import { assert } from '../../common/util/util.js';
-import { Float16Array } from '../../external/petamoriken/float16/float16.js';
 
+import { float16ToUint16, uint16ToFloat16 } from './conversion.js';
 import { align } from './math.js';
 
 /**
@@ -13,178 +13,116 @@ export default class BinaryStream {
    * Constructor
    * @param buffer the buffer to read from / write to. Array length must be a multiple of 8 bytes.
    */
-  constructor(buffer: Uint8Array) {
+  constructor(buffer: ArrayBufferLike) {
     this.offset = 0;
-    this.u8 = buffer;
-    this.u16 = new Uint16Array(this.u8.buffer);
-    this.u32 = new Uint32Array(this.u8.buffer);
-    this.i8 = new Int8Array(this.u8.buffer);
-    this.i16 = new Int16Array(this.u8.buffer);
-    this.i32 = new Int32Array(this.u8.buffer);
-    this.f16 = new Float16Array(this.u8.buffer);
-    this.f32 = new Float32Array(this.u8.buffer);
-    this.f64 = new Float64Array(this.u8.buffer);
+    this.view = new DataView(buffer);
   }
 
   /** buffer() returns the stream's buffer sliced to the 8-byte rounded read or write offset */
-  buffer(): Uint8Array {
-    return this.u8.slice(0, align(this.offset, 8));
+  buffer(): ArrayBufferLike {
+    return new Uint8Array(this.view.buffer, align(this.offset, 8)).buffer;
   }
 
   /** writeBool() writes a boolean as 255 or 0 to the buffer at the next byte offset */
   writeBool(value: boolean) {
-    this.u8[this.offset++] = value ? 255 : 0;
+    this.view.setUint8(this.offset++, value ? 255 : 0);
   }
 
   /** readBool() reads a boolean from the buffer at the next byte offset */
   readBool(): boolean {
-    const val = this.u8[this.offset++];
+    const val = this.view.getUint8(this.offset++);
     assert(val === 0 || val === 255);
     return val !== 0;
   }
 
   /** writeU8() writes a uint8 to the buffer at the next byte offset */
   writeU8(value: number) {
-    this.u8[this.offset++] = value;
+    this.view.setUint8(this.offset++, value);
   }
 
   /** readU8() reads a uint8 from the buffer at the next byte offset */
   readU8(): number {
-    return this.u8[this.offset++];
-  }
-
-  /** u8View() returns a Uint8Array view of the uint8 at the next byte offset */
-  u8View(): Uint8Array {
-    const at = this.offset++;
-    return new Uint8Array(this.u8.buffer, at, 1);
+    return this.view.getUint8(this.offset++);
   }
 
   /** writeU16() writes a uint16 to the buffer at the next 16-bit aligned offset */
   writeU16(value: number) {
-    this.u16[this.bumpWord(2)] = value;
+    this.view.setUint16(this.alignedOffset(2), value, /* littleEndian */ true);
   }
 
   /** readU16() reads a uint16 from the buffer at the next 16-bit aligned offset */
   readU16(): number {
-    return this.u16[this.bumpWord(2)];
-  }
-
-  /** u16View() returns a Uint16Array view of the uint16 at the next 16-bit aligned offset */
-  u16View(): Uint16Array {
-    const at = this.bumpWord(2);
-    return new Uint16Array(this.u16.buffer, at * 2, 1);
+    return this.view.getUint16(this.alignedOffset(2), /* littleEndian */ true);
   }
 
   /** writeU32() writes a uint32 to the buffer at the next 32-bit aligned offset */
   writeU32(value: number) {
-    this.u32[this.bumpWord(4)] = value;
+    this.view.setUint32(this.alignedOffset(4), value, /* littleEndian */ true);
   }
 
   /** readU32() reads a uint32 from the buffer at the next 32-bit aligned offset */
   readU32(): number {
-    return this.u32[this.bumpWord(4)];
-  }
-
-  /** u32View() returns a Uint32Array view of the uint32 at the next 32-bit aligned offset */
-  u32View(): Uint32Array {
-    const at = this.bumpWord(4);
-    return new Uint32Array(this.u32.buffer, at * 4, 1);
+    return this.view.getUint32(this.alignedOffset(4), /* littleEndian */ true);
   }
 
   /** writeI8() writes a int8 to the buffer at the next byte offset */
   writeI8(value: number) {
-    this.i8[this.offset++] = value;
+    this.view.setInt8(this.offset++, value);
   }
 
   /** readI8() reads a int8 from the buffer at the next byte offset */
   readI8(): number {
-    return this.i8[this.offset++];
-  }
-
-  /** i8View() returns a Uint8Array view of the uint8 at the next byte offset */
-  i8View(): Int8Array {
-    const at = this.offset++;
-    return new Int8Array(this.i8.buffer, at, 1);
+    return this.view.getInt8(this.offset++);
   }
 
   /** writeI16() writes a int16 to the buffer at the next 16-bit aligned offset */
   writeI16(value: number) {
-    this.i16[this.bumpWord(2)] = value;
+    this.view.setInt16(this.alignedOffset(2), value, /* littleEndian */ true);
   }
 
   /** readI16() reads a int16 from the buffer at the next 16-bit aligned offset */
   readI16(): number {
-    return this.i16[this.bumpWord(2)];
-  }
-
-  /** i16View() returns a Int16Array view of the uint16 at the next 16-bit aligned offset */
-  i16View(): Int16Array {
-    const at = this.bumpWord(2);
-    return new Int16Array(this.i16.buffer, at * 2, 1);
+    return this.view.getInt16(this.alignedOffset(2), /* littleEndian */ true);
   }
 
   /** writeI32() writes a int32 to the buffer at the next 32-bit aligned offset */
   writeI32(value: number) {
-    this.i32[this.bumpWord(4)] = value;
+    this.view.setInt32(this.alignedOffset(4), value, /* littleEndian */ true);
   }
 
   /** readI32() reads a int32 from the buffer at the next 32-bit aligned offset */
   readI32(): number {
-    return this.i32[this.bumpWord(4)];
-  }
-
-  /** i32View() returns a Int32Array view of the uint32 at the next 32-bit aligned offset */
-  i32View(): Int32Array {
-    const at = this.bumpWord(4);
-    return new Int32Array(this.i32.buffer, at * 4, 1);
+    return this.view.getInt32(this.alignedOffset(4), /* littleEndian */ true);
   }
 
   /** writeF16() writes a float16 to the buffer at the next 16-bit aligned offset */
   writeF16(value: number) {
-    this.f16[this.bumpWord(2)] = value;
+    this.writeU16(float16ToUint16(value));
   }
 
   /** readF16() reads a float16 from the buffer at the next 16-bit aligned offset */
   readF16(): number {
-    return this.f16[this.bumpWord(2)];
-  }
-
-  /** f16View() returns a Float16Array view of the uint16 at the next 16-bit aligned offset */
-  f16View(): Float16Array {
-    const at = this.bumpWord(2);
-    return new Float16Array(this.f16.buffer, at * 2, 1);
+    return uint16ToFloat16(this.readU16());
   }
 
   /** writeF32() writes a float32 to the buffer at the next 32-bit aligned offset */
   writeF32(value: number) {
-    this.f32[this.bumpWord(4)] = value;
+    this.view.setFloat32(this.alignedOffset(4), value, /* littleEndian */ true);
   }
 
   /** readF32() reads a float32 from the buffer at the next 32-bit aligned offset */
   readF32(): number {
-    return this.f32[this.bumpWord(4)];
-  }
-
-  /** f32View() returns a Float32Array view of the uint32 at the next 32-bit aligned offset */
-  f32View(): Float32Array {
-    const at = this.bumpWord(4);
-    return new Float32Array(this.f32.buffer, at * 4, 1);
+    return this.view.getFloat32(this.alignedOffset(4), /* littleEndian */ true);
   }
 
   /** writeF64() writes a float64 to the buffer at the next 64-bit aligned offset */
   writeF64(value: number) {
-    this.f64[this.bumpWord(8)] = value;
+    this.view.setFloat64(this.alignedOffset(8), value);
   }
 
   /** readF64() reads a float64 from the buffer at the next 64-bit aligned offset */
   readF64(): number {
-    return this.f64[this.bumpWord(8)];
-  }
-
-  /** f64View() returns a Float64Array view of the uint64 at the next 64-bit aligned offset */
-  f64View(): Float64Array {
-    const at = this.bumpWord(8);
-    return new Float64Array(this.f64.buffer, at * 8, 1);
+    return this.view.getFloat64(this.alignedOffset(8));
   }
 
   /**
@@ -261,23 +199,15 @@ export default class BinaryStream {
   }
 
   /**
-   * bumpWord() increments this.offset by `bytes`, after first aligning this.offset to `bytes`.
-   * @returns the old offset aligned to the next multiple of `bytes`, divided by `bytes`.
+   * alignedOffset() aligns this.offset to `bytes`, then increments this.offset by `bytes`.
+   * @returns the old offset aligned to the next multiple of `bytes`.
    */
-  private bumpWord(bytes: number) {
-    const multiple = Math.floor((this.offset + bytes - 1) / bytes);
-    this.offset = (multiple + 1) * bytes;
-    return multiple;
+  private alignedOffset(bytes: number) {
+    const aligned = align(this.offset, bytes);
+    this.offset = aligned + bytes;
+    return aligned;
   }
 
   private offset: number;
-  private u8: Uint8Array;
-  private u16: Uint16Array;
-  private u32: Uint32Array;
-  private i8: Int8Array;
-  private i16: Int16Array;
-  private i32: Int32Array;
-  private f16: Float16Array;
-  private f32: Float32Array;
-  private f64: Float64Array;
+  private view: DataView;
 }
diff --git a/src/webgpu/util/floating_point.ts b/src/webgpu/util/floating_point.ts
index f9b9d2ca44ce..82d6403ce3ae 100644
--- a/src/webgpu/util/floating_point.ts
+++ b/src/webgpu/util/floating_point.ts
@@ -107,7 +107,8 @@ export class FPInterval {
   public constructor(kind: FPKind, ...bounds: IntervalBounds) {
     this.kind = kind;
 
-    const [begin, end] = bounds.length === 2 ? bounds : [bounds[0], bounds[0]];
+    const begin = bounds[0];
+    const end = bounds.length === 2 ? bounds[1] : bounds[0];
     assert(!Number.isNaN(begin) && !Number.isNaN(end), `bounds need to be non-NaN`);
     assert(begin <= end, `bounds[0] (${begin}) must be less than or equal to bounds[1]  (${end})`);
 
@@ -206,11 +207,11 @@ export function deserializeFPInterval(s: BinaryStream): FPInterval {
       // Bounded
       switch (kind) {
         case 'abstract':
-          return traits.toInterval([s.readF64(), s.readF64()]);
+          return new FPInterval(traits.kind, s.readF64(), s.readF64());
         case 'f32':
-          return traits.toInterval([s.readF32(), s.readF32()]);
+          return new FPInterval(traits.kind, s.readF32(), s.readF32());
         case 'f16':
-          return traits.toInterval([s.readF16(), s.readF16()]);
+          return new FPInterval(traits.kind, s.readF16(), s.readF16());
       }
       unreachable(`Unable to deserialize FPInterval with kind ${kind}`);
     },

From aa7ab4f2aa89b0ac63ccb03b5bc45d2c8ffa2650 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Thu, 26 Oct 2023 17:36:47 -0400
Subject: [PATCH 157/166] wgsl: Speed up `ldexp` execution tests (#3101)

Reduces thh number of cases by using sparse instead of full ranges,
since there is going to be a cartesian product of input values when
generating cases.

Optimizes two quantization functions that had not been updated to
re-used their TypedArray. Creation and then immediate destruction of
TypedArrays are a type of hotspot we have encountered in other areas
of the code base.
---
 .../expression/call/builtin/ldexp.spec.ts          | 14 +++++++-------
 src/webgpu/util/math.ts                            | 13 ++++++++++---
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/webgpu/shader/execution/expression/call/builtin/ldexp.spec.ts b/src/webgpu/shader/execution/expression/call/builtin/ldexp.spec.ts
index 792c7e8513ad..382986775203 100644
--- a/src/webgpu/shader/execution/expression/call/builtin/ldexp.spec.ts
+++ b/src/webgpu/shader/execution/expression/call/builtin/ldexp.spec.ts
@@ -20,10 +20,10 @@ import { i32, TypeF32, TypeF16, TypeI32 } from '../../../../../util/conversion.j
 import { FP } from '../../../../../util/floating_point.js';
 import {
   biasedRange,
-  fullF32Range,
-  fullF16Range,
-  fullI32Range,
   quantizeToI32,
+  sparseF32Range,
+  sparseI32Range,
+  sparseF16Range,
 } from '../../../../../util/math.js';
 import { makeCaseCache } from '../../case_cache.js';
 import { allInputSources, Case, run } from '../../expression.js';
@@ -63,20 +63,20 @@ const makeCase = (trait: 'f32' | 'f16', e1: number, e2: number): Case => {
 
 export const d = makeCaseCache('ldexp', {
   f32_non_const: () => {
-    return fullF32Range().flatMap(e1 => fullI32Range().map(e2 => makeCase('f32', e1, e2)));
+    return sparseF32Range().flatMap(e1 => sparseI32Range().map(e2 => makeCase('f32', e1, e2)));
   },
   f32_const: () => {
-    return fullF32Range().flatMap(e1 =>
+    return sparseF32Range().flatMap(e1 =>
       biasedRange(-bias.f32 - 10, bias.f32 + 1, 10).flatMap(e2 =>
         FP.f32.isFinite(e1 * 2 ** quantizeToI32(e2)) ? makeCase('f32', e1, e2) : []
       )
     );
   },
   f16_non_const: () => {
-    return fullF16Range().flatMap(e1 => fullI32Range().map(e2 => makeCase('f16', e1, e2)));
+    return sparseF16Range().flatMap(e1 => sparseI32Range().map(e2 => makeCase('f16', e1, e2)));
   },
   f16_const: () => {
-    return fullF16Range().flatMap(e1 =>
+    return sparseF16Range().flatMap(e1 =>
       biasedRange(-bias.f16 - 10, bias.f16 + 1, 10).flatMap(e2 =>
         FP.f16.isFinite(e1 * 2 ** quantizeToI32(e2)) ? makeCase('f16', e1, e2) : []
       )
diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 6e8c9951ce34..380832e1b857 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -7,7 +7,6 @@ import {
 } from '../../external/petamoriken/float16/float16.js';
 
 import { kBit, kValue } from './constants.js';
-import { i32, u32 } from './conversion.js';
 import {
   reinterpretF64AsU64,
   reinterpretU64AsF64,
@@ -2031,14 +2030,22 @@ export function quantizeToF16(num: number): number {
   return quantizeToF16Data[0];
 }
 
+/** Statically allocate working data, so it doesn't need per-call creation */
+const quantizeToI32Data = new Int32Array(new ArrayBuffer(4));
+
 /** @returns the closest 32-bit signed integer value to the input */
 export function quantizeToI32(num: number): number {
-  return i32(num).value as number;
+  quantizeToI32Data[0] = num;
+  return quantizeToI32Data[0];
 }
 
+/** Statically allocate working data, so it doesn't need per-call creation */
+const quantizeToU32Data = new Uint32Array(new ArrayBuffer(4));
+
 /** @returns the closest 32-bit signed integer value to the input */
 export function quantizeToU32(num: number): number {
-  return u32(num).value as number;
+  quantizeToU32Data[0] = num;
+  return quantizeToU32Data[0];
 }
 
 /** @returns whether the number is an integer and a power of two */

From 36a23bf8254095e8308ce64fcea3864b27b8a021 Mon Sep 17 00:00:00 2001
From: Jiawei Shao <jiawei.shao@intel.com>
Date: Fri, 27 Oct 2023 13:09:01 +0800
Subject: [PATCH 158/166] Use largest maxInterStageShaderVariables in
 maxInterStageShaderComponents tests (#3104)

This patch uses the largest value of maxInterStageShaderVariables supported on
current adapter in the tests about maxInterStageShaderComponents when
creating devices so that when the value we use as maxInterStageShaderComponents
is larger than the default one, we won't be limited by the default value of
maxInterStageShaderVariables.

This patch also removes the assertion that the value of
maxInterStageShaderVariables must be larger than a quarter of
maxInterStageShaderComponents as on many backends the largest value of
maxInterStageShaderComponents is equal to 4x maxInterStageShaderVaraibles, so
in "overLimit" tests the value of maxInterStageShaderComponents can be greater
than 4x device.limits.maxInterStageShaderVaraibles.
---
 .../limits/maxInterStageShaderComponents.spec.ts     | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/webgpu/api/validation/capability_checks/limits/maxInterStageShaderComponents.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxInterStageShaderComponents.spec.ts
index 7a36d1aa14e0..b9c43683b221 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxInterStageShaderComponents.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxInterStageShaderComponents.spec.ts
@@ -1,6 +1,6 @@
-import { assert, range } from '../../../../../common/util/util.js';
+import { range } from '../../../../../common/util/util.js';
 
-import { kMaximumLimitBaseParams, makeLimitTestGroup } from './limit_utils.js';
+import { kMaximumLimitBaseParams, LimitsRequest, makeLimitTestGroup } from './limit_utils.js';
 
 function getTypeForNumComponents(numComponents: number) {
   return numComponents > 1 ? `vec${numComponents}f` : 'f32';
@@ -21,7 +21,6 @@ function getPipelineDescriptor(
 
   const maxInterStageVariables = device.limits.maxInterStageShaderVariables;
   const numComponents = Math.min(maxVertexShaderOutputComponents, maxFragmentShaderInputComponents);
-  assert(Math.ceil(numComponents / 4) <= maxInterStageVariables);
 
   const num4ComponentVaryings = Math.floor(numComponents / 4);
   const lastVaryingNumComponents = numComponents % 4;
@@ -127,6 +126,10 @@ g.test('createRenderPipeline,at_over')
       sampleMaskIn,
       sampleMaskOut,
     } = t.params;
+    // Request the largest value of maxInterStageShaderVariables to allow the test using as many
+    // inter-stage shader components as possible without being limited by
+    // maxInterStageShaderVariables.
+    const extraLimits: LimitsRequest = { maxInterStageShaderVariables: 'adapterLimit' };
     await t.testDeviceWithRequestedMaximumLimits(
       limitTest,
       testValueName,
@@ -142,6 +145,7 @@ g.test('createRenderPipeline,at_over')
         );
 
         await t.testCreateRenderPipeline(pipelineDescriptor, async, shouldError, code);
-      }
+      },
+      extraLimits
     );
   });

From 2ef3f322027bec1bb5572f5083d478148d355d79 Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Fri, 27 Oct 2023 16:40:00 +0100
Subject: [PATCH 159/166] BinaryStream: Use little endian for f64

To match all the other data types
---
 src/webgpu/util/binary_stream.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/webgpu/util/binary_stream.ts b/src/webgpu/util/binary_stream.ts
index 4941b9a4dab9..2b32db9b3e06 100644
--- a/src/webgpu/util/binary_stream.ts
+++ b/src/webgpu/util/binary_stream.ts
@@ -117,12 +117,12 @@ export default class BinaryStream {
 
   /** writeF64() writes a float64 to the buffer at the next 64-bit aligned offset */
   writeF64(value: number) {
-    this.view.setFloat64(this.alignedOffset(8), value);
+    this.view.setFloat64(this.alignedOffset(8), value, /* littleEndian */ true);
   }
 
   /** readF64() reads a float64 from the buffer at the next 64-bit aligned offset */
   readF64(): number {
-    return this.view.getFloat64(this.alignedOffset(8));
+    return this.view.getFloat64(this.alignedOffset(8), /* littleEndian */ true);
   }
 
   /**

From 3dbe4ce12983ccc1ad42e228057c7d8adc17cb78 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Beaufort?= <beaufort.francois@gmail.com>
Date: Mon, 30 Oct 2023 15:00:41 +0100
Subject: [PATCH 160/166] Add missing tests for adapter capability guarantees
 (#3107)

---
 .../features/texture_formats.spec.ts           | 16 ++++++++++++++++
 .../limits/maxBindGroups.spec.ts               |  8 ++++++++
 .../limits/maxComputeWorkgroupSizeX.spec.ts    |  8 ++++++++
 .../limits/maxComputeWorkgroupSizeY.spec.ts    |  8 ++++++++
 .../limits/maxComputeWorkgroupSizeZ.spec.ts    |  8 ++++++++
 .../maxComputeWorkgroupsPerDimension.spec.ts   | 18 ++++++++++++++++++
 .../limits/maxStorageBufferBindingSize.spec.ts |  8 ++++++++
 .../limits/maxVertexBufferArrayStride.spec.ts  |  8 ++++++++
 .../limits/maxVertexBuffers.spec.ts            |  8 ++++++++
 src/webgpu/capability_info.ts                  |  1 +
 src/webgpu/listing_meta.json                   |  9 +++++++++
 11 files changed, 100 insertions(+)

diff --git a/src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts b/src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts
index 6b99f9f84f67..8654bc6feba6 100644
--- a/src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts
@@ -3,6 +3,7 @@ Tests for capability checking for features enabling optional texture formats.
 `;
 
 import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { getGPU } from '../../../../../common/util/navigator_gpu.js';
 import { assert } from '../../../../../common/util/util.js';
 import { kAllTextureFormats, kTextureFormatInfo } from '../../../../format_info.js';
 import { kAllCanvasTypes, createCanvas } from '../../../../util/create_elements.js';
@@ -437,3 +438,18 @@ g.test('render_bundle_encoder_descriptor_depth_stencil_format')
       });
     });
   });
+
+g.test('check_capability_guarantees')
+  .desc(
+    `check "texture-compression-bc" is supported or both "texture-compression-etc2" and "texture-compression-astc" are supported.`
+  )
+  .fn(async t => {
+    const adapter = await getGPU(t.rec).requestAdapter();
+    assert(adapter !== null);
+
+    const features = adapter.features;
+    t.expect(
+      features.has('texture-compression-bc') ||
+        (features.has('texture-compression-etc2') && features.has('texture-compression-astc'))
+    );
+  });
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxBindGroups.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxBindGroups.spec.ts
index 2d3e1dcc95aa..2b987175c542 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxBindGroups.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxBindGroups.spec.ts
@@ -85,3 +85,11 @@ g.test('setBindGroup,at_over')
       }
     );
   });
+
+g.test('validate,maxBindGroupsPlusVertexBuffers')
+  .desc(`Test that ${limit} <= maxBindGroupsPlusVertexBuffers`)
+  .fn(t => {
+    const { adapter, defaultLimit, adapterLimit } = t;
+    t.expect(defaultLimit <= t.getDefaultLimit('maxBindGroupsPlusVertexBuffers'));
+    t.expect(adapterLimit <= adapter.limits.maxBindGroupsPlusVertexBuffers);
+  });
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeX.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeX.spec.ts
index 7948cce8af97..6d394f998cda 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeX.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeX.spec.ts
@@ -10,3 +10,11 @@ g.test('createComputePipeline,at_over')
     const { limitTest, testValueName, async } = t.params;
     await t.testMaxComputeWorkgroupSize(limitTest, testValueName, async, 'X');
   });
+
+g.test('validate,maxComputeInvocationsPerWorkgroup')
+  .desc(`Test that ${limit} <= maxComputeInvocationsPerWorkgroup`)
+  .fn(t => {
+    const { adapter, defaultLimit, adapterLimit } = t;
+    t.expect(defaultLimit <= t.getDefaultLimit('maxComputeInvocationsPerWorkgroup'));
+    t.expect(adapterLimit <= adapter.limits.maxComputeInvocationsPerWorkgroup);
+  });
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeY.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeY.spec.ts
index 4585676fb2a4..26eeaa9a64fe 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeY.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeY.spec.ts
@@ -10,3 +10,11 @@ g.test('createComputePipeline,at_over')
     const { limitTest, testValueName, async } = t.params;
     await t.testMaxComputeWorkgroupSize(limitTest, testValueName, async, 'Y');
   });
+
+g.test('validate,maxComputeInvocationsPerWorkgroup')
+  .desc(`Test that ${limit} <= maxComputeInvocationsPerWorkgroup`)
+  .fn(t => {
+    const { adapter, defaultLimit, adapterLimit } = t;
+    t.expect(defaultLimit <= t.getDefaultLimit('maxComputeInvocationsPerWorkgroup'));
+    t.expect(adapterLimit <= adapter.limits.maxComputeInvocationsPerWorkgroup);
+  });
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeZ.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeZ.spec.ts
index 8be1aa4b4770..9a199f4cd3f5 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeZ.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeZ.spec.ts
@@ -10,3 +10,11 @@ g.test('createComputePipeline,at_over')
     const { limitTest, testValueName, async } = t.params;
     await t.testMaxComputeWorkgroupSize(limitTest, testValueName, async, 'Z');
   });
+
+g.test('validate,maxComputeInvocationsPerWorkgroup')
+  .desc(`Test that ${limit} <= maxComputeInvocationsPerWorkgroup`)
+  .fn(t => {
+    const { adapter, defaultLimit, adapterLimit } = t;
+    t.expect(defaultLimit <= t.getDefaultLimit('maxComputeInvocationsPerWorkgroup'));
+    t.expect(adapterLimit <= adapter.limits.maxComputeInvocationsPerWorkgroup);
+  });
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupsPerDimension.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupsPerDimension.spec.ts
index 997fa46a7e71..cff50726ba12 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupsPerDimension.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupsPerDimension.spec.ts
@@ -77,3 +77,21 @@ g.test('dispatchWorkgroups,at_over')
       }
     );
   });
+
+g.test('validate')
+  .desc(
+    `Test that ${limit} <= maxComputeWorkgroupSizeX x maxComputeWorkgroupSizeY x maxComputeWorkgroupSizeZ`
+  )
+  .fn(t => {
+    const { adapter, defaultLimit, adapterLimit } = t;
+    const defaultMaxComputeWorkgroupSizeProduct =
+      t.getDefaultLimit('maxComputeWorkgroupSizeX') *
+      t.getDefaultLimit('maxComputeWorkgroupSizeY') *
+      t.getDefaultLimit('maxComputeWorkgroupSizeZ');
+    const maxComputeWorkgroupSizeProduct =
+      adapter.limits.maxComputeWorkgroupSizeX *
+      adapter.limits.maxComputeWorkgroupSizeY *
+      adapter.limits.maxComputeWorkgroupSizeZ;
+    t.expect(defaultLimit <= defaultMaxComputeWorkgroupSizeProduct);
+    t.expect(adapterLimit <= maxComputeWorkgroupSizeProduct);
+  });
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts
index 15fca54445a6..d504d0b7fb64 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts
@@ -144,6 +144,14 @@ g.test('createBindGroup,at_over')
     );
   });
 
+g.test('validate')
+  .desc(`Test that ${limit} is a multiple of 4 bytes`)
+  .fn(t => {
+    const { defaultLimit, adapterLimit } = t;
+    t.expect(defaultLimit % 4 === 0);
+    t.expect(adapterLimit % 4 === 0);
+  });
+
 g.test('validate,maxBufferSize')
   .desc(`Test that ${limit} <= maxBufferSize`)
   .fn(t => {
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxVertexBufferArrayStride.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxVertexBufferArrayStride.spec.ts
index 950323105570..0af5724f2a2a 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxVertexBufferArrayStride.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxVertexBufferArrayStride.spec.ts
@@ -111,3 +111,11 @@ g.test('createRenderPipeline,at_over')
       }
     );
   });
+
+g.test('validate')
+  .desc(`Test that ${limit} is a multiple of 4 bytes`)
+  .fn(t => {
+    const { defaultLimit, adapterLimit } = t;
+    t.expect(defaultLimit % 4 === 0);
+    t.expect(adapterLimit % 4 === 0);
+  });
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxVertexBuffers.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxVertexBuffers.spec.ts
index 97a1c241287b..04e0fe72fa44 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxVertexBuffers.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxVertexBuffers.spec.ts
@@ -90,3 +90,11 @@ g.test('setVertexBuffer,at_over')
       }
     );
   });
+
+g.test('validate,maxBindGroupsPlusVertexBuffers')
+  .desc(`Test that ${limit} <= maxBindGroupsPlusVertexBuffers`)
+  .fn(t => {
+    const { adapter, defaultLimit, adapterLimit } = t;
+    t.expect(defaultLimit <= t.getDefaultLimit('maxBindGroupsPlusVertexBuffers'));
+    t.expect(adapterLimit <= adapter.limits.maxBindGroupsPlusVertexBuffers);
+  });
diff --git a/src/webgpu/capability_info.ts b/src/webgpu/capability_info.ts
index 3626877544af..f0b5e938a134 100644
--- a/src/webgpu/capability_info.ts
+++ b/src/webgpu/capability_info.ts
@@ -667,6 +667,7 @@ const [
   'maxTextureArrayLayers':                     [           ,       256,             256,                          ],
 
   'maxBindGroups':                             [           ,         4,               4,                          ],
+  'maxBindGroupsPlusVertexBuffers':            [           ,        24,              24,                          ],
   'maxBindingsPerBindGroup':                   [           ,      1000,            1000,                          ],
   'maxDynamicUniformBuffersPerPipelineLayout': [           ,         8,               8,                          ],
   'maxDynamicStorageBuffersPerPipelineLayout': [           ,         4,               4,                          ],
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index fa57ff978139..f9caeefc6ee1 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -267,6 +267,7 @@
   "webgpu:api,validation,capability_checks,features,query_types:writeTimestamp:*": { "subcaseMS": 1.200 },
   "webgpu:api,validation,capability_checks,features,texture_formats:canvas_configuration:*": { "subcaseMS": 4.339 },
   "webgpu:api,validation,capability_checks,features,texture_formats:canvas_configuration_view_formats:*": { "subcaseMS": 4.522 },
+  "webgpu:api,validation,capability_checks,features,texture_formats:check_capability_guarantees:*": { "subcaseMS": 55.901 },
   "webgpu:api,validation,capability_checks,features,texture_formats:depth_stencil_state:*": { "subcaseMS": 15.701 },
   "webgpu:api,validation,capability_checks,features,texture_formats:render_bundle_encoder_descriptor_depth_stencil_format:*": { "subcaseMS": 0.800 },
   "webgpu:api,validation,capability_checks,features,texture_formats:texture_descriptor:*": { "subcaseMS": 3.830 },
@@ -275,6 +276,7 @@
   "webgpu:api,validation,capability_checks,limits,maxBindGroups:createPipeline,at_over:*": { "subcaseMS": 10.990 },
   "webgpu:api,validation,capability_checks,limits,maxBindGroups:createPipelineLayout,at_over:*": { "subcaseMS": 9.310 },
   "webgpu:api,validation,capability_checks,limits,maxBindGroups:setBindGroup,at_over:*": { "subcaseMS": 9.984 },
+  "webgpu:api,validation,capability_checks,limits,maxBindGroups:validate,maxBindGroupsPlusVertexBuffers:*": { "subcaseMS": 11.200 },
   "webgpu:api,validation,capability_checks,limits,maxBindingsPerBindGroup:createBindGroupLayout,at_over:*": { "subcaseMS": 12.441 },
   "webgpu:api,validation,capability_checks,limits,maxBindingsPerBindGroup:createPipeline,at_over:*": { "subcaseMS": 11.179 },
   "webgpu:api,validation,capability_checks,limits,maxBindingsPerBindGroup:validate:*": { "subcaseMS": 12.401 },
@@ -289,10 +291,14 @@
   "webgpu:api,validation,capability_checks,limits,maxColorAttachments:validate,maxColorAttachmentBytesPerSample:*": { "subcaseMS": 1.101 },
   "webgpu:api,validation,capability_checks,limits,maxComputeInvocationsPerWorkgroup:createComputePipeline,at_over:*": { "subcaseMS": 13.735 },
   "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeX:createComputePipeline,at_over:*": { "subcaseMS": 14.465 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeX:validate,maxComputeInvocationsPerWorkgroup:*": { "subcaseMS": 2.701 },
   "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeY:createComputePipeline,at_over:*": { "subcaseMS": 14.131 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeY:validate,maxComputeInvocationsPerWorkgroup:*": { "subcaseMS": 2.700 },
   "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeZ:createComputePipeline,at_over:*": { "subcaseMS": 14.920 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeZ:validate,maxComputeInvocationsPerWorkgroup:*": { "subcaseMS": 2.601 },
   "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupStorageSize:createComputePipeline,at_over:*": { "subcaseMS": 12.009 },
   "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupsPerDimension:dispatchWorkgroups,at_over:*": { "subcaseMS": 13.310 },
+  "webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupsPerDimension:validate:*": { "subcaseMS": 138.900 },
   "webgpu:api,validation,capability_checks,limits,maxDynamicStorageBuffersPerPipelineLayout:createBindGroupLayout,at_over:*": { "subcaseMS": 15.680 },
   "webgpu:api,validation,capability_checks,limits,maxDynamicUniformBuffersPerPipelineLayout:createBindGroupLayout,at_over:*": { "subcaseMS": 10.268 },
   "webgpu:api,validation,capability_checks,limits,maxInterStageShaderComponents:createRenderPipeline,at_over:*": { "subcaseMS": 12.916 },
@@ -305,6 +311,7 @@
   "webgpu:api,validation,capability_checks,limits,maxSamplersPerShaderStage:createPipelineLayout,at_over:*": { "subcaseMS": 10.427 },
   "webgpu:api,validation,capability_checks,limits,maxStorageBufferBindingSize:createBindGroup,at_over:*": { "subcaseMS": 51.810 },
   "webgpu:api,validation,capability_checks,limits,maxStorageBufferBindingSize:validate,maxBufferSize:*": { "subcaseMS": 0.900 },
+  "webgpu:api,validation,capability_checks,limits,maxStorageBufferBindingSize:validate:*": { "subcaseMS": 132.400 },
   "webgpu:api,validation,capability_checks,limits,maxStorageBuffersPerShaderStage:createBindGroupLayout,at_over:*": { "subcaseMS": 4.565 },
   "webgpu:api,validation,capability_checks,limits,maxStorageBuffersPerShaderStage:createPipeline,at_over:*": { "subcaseMS": 7.884 },
   "webgpu:api,validation,capability_checks,limits,maxStorageBuffersPerShaderStage:createPipelineLayout,at_over:*": { "subcaseMS": 5.007 },
@@ -324,8 +331,10 @@
   "webgpu:api,validation,capability_checks,limits,maxUniformBuffersPerShaderStage:createPipelineLayout,at_over:*": { "subcaseMS": 6.109 },
   "webgpu:api,validation,capability_checks,limits,maxVertexAttributes:createRenderPipeline,at_over:*": { "subcaseMS": 9.090 },
   "webgpu:api,validation,capability_checks,limits,maxVertexBufferArrayStride:createRenderPipeline,at_over:*": { "subcaseMS": 10.060 },
+  "webgpu:api,validation,capability_checks,limits,maxVertexBufferArrayStride:validate:*": { "subcaseMS": 139.500 },
   "webgpu:api,validation,capability_checks,limits,maxVertexBuffers:createRenderPipeline,at_over:*": { "subcaseMS": 8.903 },
   "webgpu:api,validation,capability_checks,limits,maxVertexBuffers:setVertexBuffer,at_over:*": { "subcaseMS": 7.695 },
+  "webgpu:api,validation,capability_checks,limits,maxVertexBuffers:validate,maxBindGroupsPlusVertexBuffers:*": { "subcaseMS": 153.900 },
   "webgpu:api,validation,capability_checks,limits,minStorageBufferOffsetAlignment:createBindGroup,at_over:*": { "subcaseMS": 9.650 },
   "webgpu:api,validation,capability_checks,limits,minStorageBufferOffsetAlignment:setBindGroup,at_over:*": { "subcaseMS": 8.931 },
   "webgpu:api,validation,capability_checks,limits,minStorageBufferOffsetAlignment:validate,greaterThanOrEqualTo32:*": { "subcaseMS": 31.801 },

From ef5d2294db7a31d581f46d530c03a6089a63ac16 Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Mon, 30 Oct 2023 20:14:34 -0700
Subject: [PATCH 161/166] Test that DOMExceptions from WebGPU always have
 stacks (#3105)

---
 src/common/framework/fixture.ts               | 31 +++++++++++++++----
 src/common/util/util.ts                       | 20 ++++++++++--
 src/unittests/loaders_and_trees.spec.ts       |  5 ++-
 src/unittests/test_group.spec.ts              |  2 +-
 .../operation/adapter/requestDevice.spec.ts   |  2 ++
 .../api/validation/buffer/mapping.spec.ts     |  1 +
 .../features/texture_formats.spec.ts          | 28 +++++++++++------
 .../capability_checks/limits/limit_utils.ts   | 10 +++---
 src/webgpu/examples.spec.ts                   |  8 ++---
 src/webgpu/util/device_pool.ts                |  8 ++---
 10 files changed, 82 insertions(+), 33 deletions(-)

diff --git a/src/common/framework/fixture.ts b/src/common/framework/fixture.ts
index 381d60ba047a..795532406bd2 100644
--- a/src/common/framework/fixture.ts
+++ b/src/common/framework/fixture.ts
@@ -1,6 +1,6 @@
 import { TestCaseRecorder } from '../internal/logging/test_case_recorder.js';
 import { JSONWithUndefined } from '../internal/params_utils.js';
-import { assert, unreachable } from '../util/util.js';
+import { assert, ExceptionCheckOptions, unreachable } from '../util/util.js';
 
 export class SkipTestCase extends Error {}
 export class UnexpectedPassError extends Error {}
@@ -237,16 +237,26 @@ export class Fixture<S extends SubcaseBatchState = SubcaseBatchState> {
   }
 
   /** Expect that the provided promise rejects, with the provided exception name. */
-  shouldReject(expectedName: string, p: Promise<unknown>, msg?: string): void {
+  shouldReject(
+    expectedName: string,
+    p: Promise<unknown>,
+    { allowMissingStack = false, message }: ExceptionCheckOptions = {}
+  ): void {
     this.eventualAsyncExpectation(async niceStack => {
-      const m = msg ? ': ' + msg : '';
+      const m = message ? ': ' + message : '';
       try {
         await p;
         niceStack.message = 'DID NOT REJECT' + m;
         this.rec.expectationFailed(niceStack);
       } catch (ex) {
-        niceStack.message = 'rejected as expected' + m;
         this.expectErrorValue(expectedName, ex, niceStack);
+        if (!allowMissingStack) {
+          if (!(ex instanceof Error && typeof ex.stack === 'string')) {
+            const exMessage = ex instanceof Error ? ex.message : '?';
+            niceStack.message = `rejected as expected, but missing stack (${exMessage})${m}`;
+            this.rec.expectationFailed(niceStack);
+          }
+        }
       }
     });
   }
@@ -257,8 +267,12 @@ export class Fixture<S extends SubcaseBatchState = SubcaseBatchState> {
    *
    * MAINTENANCE_TODO: Change to `string | false` so the exception name is always checked.
    */
-  shouldThrow(expectedError: string | boolean, fn: () => void, msg?: string): void {
-    const m = msg ? ': ' + msg : '';
+  shouldThrow(
+    expectedError: string | boolean,
+    fn: () => void,
+    { allowMissingStack = false, message }: ExceptionCheckOptions = {}
+  ) {
+    const m = message ? ': ' + message : '';
     try {
       fn();
       if (expectedError === false) {
@@ -271,6 +285,11 @@ export class Fixture<S extends SubcaseBatchState = SubcaseBatchState> {
         this.rec.expectationFailed(new Error('threw unexpectedly' + m));
       } else {
         this.expectErrorValue(expectedError, ex, new Error(m));
+        if (!allowMissingStack) {
+          if (!(ex instanceof Error && typeof ex.stack === 'string')) {
+            this.rec.expectationFailed(new Error('threw as expected, but missing stack' + m));
+          }
+        }
       }
     }
   }
diff --git a/src/common/util/util.ts b/src/common/util/util.ts
index be109fc9d422..1da380036382 100644
--- a/src/common/util/util.ts
+++ b/src/common/util/util.ts
@@ -47,15 +47,29 @@ export function assertOK<T>(value: Error | T): T {
   return value;
 }
 
+/** Options for assertReject, shouldReject, and friends. */
+export type ExceptionCheckOptions = { allowMissingStack?: boolean; message?: string };
+
 /**
  * Resolves if the provided promise rejects; rejects if it does not.
  */
-export async function assertReject(p: Promise<unknown>, msg?: string): Promise<void> {
+export async function assertReject(
+  expectedName: string,
+  p: Promise<unknown>,
+  { allowMissingStack = false, message }: ExceptionCheckOptions = {}
+): Promise<void> {
   try {
     await p;
-    unreachable(msg);
+    unreachable(message);
   } catch (ex) {
-    // Assertion OK
+    // Asserted as expected
+    if (!allowMissingStack) {
+      const m = message ? ` (${message})` : '';
+      assert(
+        ex instanceof Error && typeof ex.stack === 'string',
+        'threw as expected, but missing stack' + m
+      );
+    }
   }
 }
 
diff --git a/src/unittests/loaders_and_trees.spec.ts b/src/unittests/loaders_and_trees.spec.ts
index c7ff1fa43a84..b396b0525940 100644
--- a/src/unittests/loaders_and_trees.spec.ts
+++ b/src/unittests/loaders_and_trees.spec.ts
@@ -703,7 +703,10 @@ async function testIterateCollapsed(
     subqueriesToExpand: expectations,
   });
   if (expectedResult === 'throws') {
-    t.shouldReject('Error', treePromise, 'loadTree should have thrown Error');
+    t.shouldReject('Error', treePromise, {
+      // Some errors here use StacklessError to print nicer command line outputs.
+      allowMissingStack: true,
+    });
     return;
   }
   const tree = await treePromise;
diff --git a/src/unittests/test_group.spec.ts b/src/unittests/test_group.spec.ts
index 8e1129411c74..526f577c9edf 100644
--- a/src/unittests/test_group.spec.ts
+++ b/src/unittests/test_group.spec.ts
@@ -206,7 +206,7 @@ g.test('invalid_test_name').fn(t => {
       () => {
         g.test(name).fn(() => {});
       },
-      name
+      { message: name }
     );
   }
 });
diff --git a/src/webgpu/api/operation/adapter/requestDevice.spec.ts b/src/webgpu/api/operation/adapter/requestDevice.spec.ts
index 7d930a5e19df..314da6356eb7 100644
--- a/src/webgpu/api/operation/adapter/requestDevice.spec.ts
+++ b/src/webgpu/api/operation/adapter/requestDevice.spec.ts
@@ -118,6 +118,7 @@ g.test('stale')
         // Cause a type error by requesting with an unknown feature.
         if (awaitInitialError) {
           await assertReject(
+            'TypeError',
             adapter.requestDevice({ requiredFeatures: ['unknown-feature' as GPUFeatureName] })
           );
         } else {
@@ -131,6 +132,7 @@ g.test('stale')
         // Cause an operation error by requesting with an alignment limit that is not a power of 2.
         if (awaitInitialError) {
           await assertReject(
+            'OperationError',
             adapter.requestDevice({ requiredLimits: { minUniformBufferOffsetAlignment: 255 } })
           );
         } else {
diff --git a/src/webgpu/api/validation/buffer/mapping.spec.ts b/src/webgpu/api/validation/buffer/mapping.spec.ts
index c6f3c782af6d..58d7f2767aee 100644
--- a/src/webgpu/api/validation/buffer/mapping.spec.ts
+++ b/src/webgpu/api/validation/buffer/mapping.spec.ts
@@ -45,6 +45,7 @@ class F extends ValidationTest {
         assert(expectation.rejectName === null, 'mapAsync unexpectedly passed');
       } catch (ex) {
         assert(ex instanceof Error, 'mapAsync rejected with non-error');
+        assert(typeof ex.stack === 'string', 'mapAsync rejected without a stack');
         assert(expectation.rejectName === ex.name, `mapAsync rejected unexpectedly with: ${ex}`);
         assert(
           expectation.earlyRejection === rejectedEarly,
diff --git a/src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts b/src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts
index 8654bc6feba6..eb7005dd29d0 100644
--- a/src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts
@@ -274,6 +274,7 @@ g.test('color_target_state')
   )
   .params(u =>
     u
+      .combine('isAsync', [false, true])
       .combine('format', kOptionalTextureFormats)
       .filter(t => !!kTextureFormatInfo[t.format].colorRender)
       .combine('enable_required_feature', [true, false])
@@ -287,10 +288,12 @@ g.test('color_target_state')
     }
   })
   .fn(t => {
-    const { format, enable_required_feature } = t.params;
+    const { isAsync, format, enable_required_feature } = t.params;
 
-    t.shouldThrow(enable_required_feature ? false : 'TypeError', () => {
-      t.device.createRenderPipeline({
+    t.doCreateRenderPipelineTest(
+      isAsync,
+      enable_required_feature,
+      {
         layout: 'auto',
         vertex: {
           module: t.device.createShaderModule({
@@ -313,8 +316,9 @@ g.test('color_target_state')
           entryPoint: 'main',
           targets: [{ format }],
         },
-      });
-    });
+      },
+      'TypeError'
+    );
   });
 
 g.test('depth_stencil_state')
@@ -326,6 +330,7 @@ g.test('depth_stencil_state')
   )
   .params(u =>
     u
+      .combine('isAsync', [false, true])
       .combine('format', kOptionalTextureFormats)
       .filter(t => !!(kTextureFormatInfo[t.format].depth || kTextureFormatInfo[t.format].stencil))
       .combine('enable_required_feature', [true, false])
@@ -339,10 +344,12 @@ g.test('depth_stencil_state')
     }
   })
   .fn(t => {
-    const { format, enable_required_feature } = t.params;
+    const { isAsync, format, enable_required_feature } = t.params;
 
-    t.shouldThrow(enable_required_feature ? false : 'TypeError', () => {
-      t.device.createRenderPipeline({
+    t.doCreateRenderPipelineTest(
+      isAsync,
+      enable_required_feature,
+      {
         layout: 'auto',
         vertex: {
           module: t.device.createShaderModule({
@@ -370,8 +377,9 @@ g.test('depth_stencil_state')
           entryPoint: 'main',
           targets: [{ format: 'rgba8unorm' }],
         },
-      });
-    });
+      },
+      'TypeError'
+    );
   });
 
 g.test('render_bundle_encoder_descriptor_color_format')
diff --git a/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts b/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
index f6b0f96aa805..47a5a468d7d1 100644
--- a/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
@@ -330,7 +330,9 @@ export class LimitTestsImpl extends GPUTestBase {
     requiredFeatures?: GPUFeatureName[]
   ) {
     if (shouldReject) {
-      this.shouldReject('OperationError', adapter.requestDevice({ requiredLimits }));
+      this.shouldReject('OperationError', adapter.requestDevice({ requiredLimits }), {
+        allowMissingStack: true,
+      });
       return undefined;
     } else {
       return await adapter.requestDevice({ requiredLimits, requiredFeatures });
@@ -562,12 +564,12 @@ export class LimitTestsImpl extends GPUTestBase {
     expectedName: string,
     p: Promise<unknown>,
     shouldReject: boolean,
-    msg?: string
+    message?: string
   ): Promise<void> {
     if (shouldReject) {
-      this.shouldReject(expectedName, p, msg);
+      this.shouldReject(expectedName, p, { message });
     } else {
-      this.shouldResolve(p, msg);
+      this.shouldResolve(p, message);
     }
 
     // We need to explicitly wait for the promise because the device may be
diff --git a/src/webgpu/examples.spec.ts b/src/webgpu/examples.spec.ts
index 35969543741f..4864393eca91 100644
--- a/src/webgpu/examples.spec.ts
+++ b/src/webgpu/examples.spec.ts
@@ -47,7 +47,7 @@ g.test('basic').fn(t => {
       throw new TypeError();
     },
     // Log message.
-    'function should throw Error'
+    { message: 'function should throw Error' }
   );
 });
 
@@ -59,17 +59,17 @@ g.test('basic,async').fn(t => {
     // Promise expected to reject.
     Promise.reject(new TypeError()),
     // Log message.
-    'Promise.reject should reject'
+    { message: 'Promise.reject should reject' }
   );
 
-  // Promise can also be an IIFE.
+  // Promise can also be an IIFE (immediately-invoked function expression).
   t.shouldReject(
     'TypeError',
     // eslint-disable-next-line @typescript-eslint/require-await
     (async () => {
       throw new TypeError();
     })(),
-    'Promise.reject should reject'
+    { message: 'Promise.reject should reject' }
   );
 });
 
diff --git a/src/webgpu/util/device_pool.ts b/src/webgpu/util/device_pool.ts
index e8584df19613..843d6dc83e1a 100644
--- a/src/webgpu/util/device_pool.ts
+++ b/src/webgpu/util/device_pool.ts
@@ -378,10 +378,10 @@ class DeviceHolder implements DeviceProvider {
       await this.device.queue.onSubmittedWorkDone();
     }
 
-    await assertReject(
-      this.device.popErrorScope(),
-      'There was an extra error scope on the stack after a test'
-    );
+    await assertReject('OperationError', this.device.popErrorScope(), {
+      allowMissingStack: true,
+      message: 'There was an extra error scope on the stack after a test',
+    });
 
     if (gpuOutOfMemoryError !== null) {
       assert(gpuOutOfMemoryError instanceof GPUOutOfMemoryError);

From ccee5a98c3690540184a2539aca5bee4242c35b8 Mon Sep 17 00:00:00 2001
From: Kai Ninomiya <kainino@chromium.org>
Date: Tue, 31 Oct 2023 11:12:45 -0700
Subject: [PATCH 162/166] dev_server: Serve on localhost by default (#3115)

* dev_server: serve on localhost only by default

* Limit characters in route for /out/*/listing.js
---
 src/common/tools/dev_server.ts | 57 ++++++++++++++++++++++++----------
 1 file changed, 41 insertions(+), 16 deletions(-)

diff --git a/src/common/tools/dev_server.ts b/src/common/tools/dev_server.ts
index 2e0aca21ddd4..7d576a9a25be 100644
--- a/src/common/tools/dev_server.ts
+++ b/src/common/tools/dev_server.ts
@@ -14,6 +14,19 @@ import { makeListing } from './crawl.js';
 // Make sure that makeListing doesn't cache imported spec files. See crawl().
 process.env.STANDALONE_DEV_SERVER = '1';
 
+function usage(rc: number): void {
+  console.error(`\
+Usage:
+  tools/dev_server
+  tools/dev_server 0.0.0.0
+  npm start
+  npm start 0.0.0.0
+
+By default, serves on localhost only. If the argument 0.0.0.0 is passed, serves on all interfaces.
+`);
+  process.exit(rc);
+}
+
 const srcDir = path.resolve(__dirname, '../../');
 
 // Import the project's babel.config.js. We'll use the same config for the runtime compiler.
@@ -110,7 +123,7 @@ app.use('/out-wpt', express.static(path.resolve(srcDir, '../out-wpt')));
 app.use('/docs/tsdoc', express.static(path.resolve(srcDir, '../docs/tsdoc')));
 
 // Serve a suite's listing.js file by crawling the filesystem for all tests.
-app.get('/out/:suite/listing.js', async (req, res, next) => {
+app.get('/out/:suite([a-zA-Z0-9_-]+)/listing.js', async (req, res, next) => {
   const suite = req.params['suite'];
 
   if (listingCache.has(suite)) {
@@ -162,28 +175,40 @@ app.get('/out/**/*.js', async (req, res, next) => {
   }
 });
 
-const host = '0.0.0.0';
-const port = 8080;
-// Find an available port, starting at 8080.
-portfinder.getPort({ host, port }, (err, port) => {
-  if (err) {
-    throw err;
+// Serve everything else (not .js) as static, and directories as directory listings.
+app.use('/out', serveIndex(path.resolve(srcDir, '../src')));
+app.use('/out', express.static(path.resolve(srcDir, '../src')));
+
+void (async () => {
+  let host = '127.0.0.1';
+  if (process.argv.length >= 3) {
+    if (process.argv.length !== 3) usage(1);
+    if (process.argv[2] === '0.0.0.0') {
+      host = '0.0.0.0';
+    } else {
+      usage(1);
+    }
   }
+
+  console.log(`Finding an available port on ${host}...`);
+  const kPortFinderStart = 8080;
+  const port = await portfinder.getPortPromise({ host, port: kPortFinderStart });
+
   watcher.on('ready', () => {
     // Listen on the available port.
     app.listen(port, host, () => {
       console.log('Standalone test runner running at:');
-      for (const iface of Object.values(os.networkInterfaces())) {
-        for (const details of iface || []) {
-          if (details.family === 'IPv4') {
-            console.log(`  http://${details.address}:${port}/standalone/`);
+      if (host === '0.0.0.0') {
+        for (const iface of Object.values(os.networkInterfaces())) {
+          for (const details of iface || []) {
+            if (details.family === 'IPv4') {
+              console.log(`  http://${details.address}:${port}/standalone/`);
+            }
           }
         }
+      } else {
+        console.log(`  http://${host}:${port}/standalone/`);
       }
     });
   });
-});
-
-// Serve everything else (not .js) as static, and directories as directory listings.
-app.use('/out', serveIndex(path.resolve(srcDir, '../src')));
-app.use('/out', express.static(path.resolve(srcDir, '../src')));
+})();

From fc58db8aad61b990ab734d8450d3500c6988bef7 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 31 Oct 2023 16:42:01 -0400
Subject: [PATCH 163/166] wgsl: Convert `quantizeToF16` to used `hfround`
 (#3118)

Instead of passing the input through a F16Array, use the library
provided function hfround. hfround is a fast look up table based
rounding function for f16.

Benchmarking locally this provides a ~20% improvement to fma interval
calculations, which are particularly sensitive to quantization
cost. Overall I was seeing more on the order of ~10% improvement.
---
 src/webgpu/util/math.ts | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 380832e1b857..018d350a984d 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -3,6 +3,7 @@ import { assert } from '../../common/util/util.js';
 import {
   Float16Array,
   getFloat16,
+  hfround,
   setFloat16,
 } from '../../external/petamoriken/float16/float16.js';
 
@@ -2021,13 +2022,9 @@ export function quantizeToF32(num: number): number {
   return quantizeToF32Data[0];
 }
 
-/** Statically allocate working data, so it doesn't need per-call creation */
-const quantizeToF16Data = new Float16Array(new ArrayBuffer(2));
-
 /** @returns the closest 16-bit floating point value to the input */
 export function quantizeToF16(num: number): number {
-  quantizeToF16Data[0] = num;
-  return quantizeToF16Data[0];
+  return hfround(num);
 }
 
 /** Statically allocate working data, so it doesn't need per-call creation */

From cb5b33c7d391b2beb1a14105ffe765c4930660b1 Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Tue, 31 Oct 2023 16:55:38 -0400
Subject: [PATCH 164/166] wgsl: Convert `quantizeToF32` to used `Math.fround`
 (#3119)

Instead of passing the input through a F32Array, use the builtin
Math.fround.

This leads to a ~5% improvement benchmarking locally. This is less
than the equivalent f16 change, because F32Array is provided by the
runtime, whereas F16Array is being polyfilled, so is probably more
efficient to begin with.
---
 src/webgpu/util/math.ts | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 018d350a984d..9b901bfa6da4 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -2013,13 +2013,9 @@ export interface QuantizeFunc {
   (num: number): number;
 }
 
-/** Statically allocate working data, so it doesn't need per-call creation */
-const quantizeToF32Data = new Float32Array(new ArrayBuffer(4));
-
 /** @returns the closest 32-bit floating point value to the input */
 export function quantizeToF32(num: number): number {
-  quantizeToF32Data[0] = num;
-  return quantizeToF32Data[0];
+  return Math.fround(num);
 }
 
 /** @returns the closest 16-bit floating point value to the input */

From 2f3b68c51f5a759c2496885e30643fbcd98465fd Mon Sep 17 00:00:00 2001
From: Ben Clayton <bclayton@google.com>
Date: Tue, 31 Oct 2023 20:39:25 +0000
Subject: [PATCH 165/166] Fix cache files being padded with trailing 0's

buffer() was offseting the array instead of truncating the returned
array.
---
 src/unittests/serialization.spec.ts                | 14 +++++++-------
 .../shader/execution/expression/case_cache.ts      | 10 +++++-----
 src/webgpu/util/binary_stream.ts                   |  4 ++--
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/unittests/serialization.spec.ts b/src/unittests/serialization.spec.ts
index 7f5384ad9cb5..9717ba3ecf84 100644
--- a/src/unittests/serialization.spec.ts
+++ b/src/unittests/serialization.spec.ts
@@ -209,7 +209,7 @@ g.test('value').fn(t => {
   ]) {
     const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeValue(s, value);
-    const d = new BinaryStream(s.buffer());
+    const d = new BinaryStream(s.buffer().buffer);
     const deserialized = deserializeValue(d);
     t.expect(
       objectEquals(value, deserialized),
@@ -246,7 +246,7 @@ g.test('fpinterval_f32').fn(t => {
   ]) {
     const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeFPInterval(s, interval);
-    const d = new BinaryStream(s.buffer());
+    const d = new BinaryStream(s.buffer().buffer);
     const deserialized = deserializeFPInterval(d);
     t.expect(
       objectEquals(interval, deserialized),
@@ -282,7 +282,7 @@ g.test('fpinterval_f16').fn(t => {
   ]) {
     const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeFPInterval(s, interval);
-    const d = new BinaryStream(s.buffer());
+    const d = new BinaryStream(s.buffer().buffer);
     const deserialized = deserializeFPInterval(d);
     t.expect(
       objectEquals(interval, deserialized),
@@ -318,7 +318,7 @@ g.test('fpinterval_abstract').fn(t => {
   ]) {
     const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeFPInterval(s, interval);
-    const d = new BinaryStream(s.buffer());
+    const d = new BinaryStream(s.buffer().buffer);
     const deserialized = deserializeFPInterval(d);
     t.expect(
       objectEquals(interval, deserialized),
@@ -340,7 +340,7 @@ g.test('expression_expectation').fn(t => {
   ]) {
     const s = new BinaryStream(new Uint8Array(1024).buffer);
     serializeExpectation(s, expectation);
-    const d = new BinaryStream(s.buffer());
+    const d = new BinaryStream(s.buffer().buffer);
     const deserialized = deserializeExpectation(d);
     t.expect(
       objectEquals(expectation, deserialized),
@@ -370,7 +370,7 @@ g.test('anyOf').fn(t => {
     ]) {
       const s = new BinaryStream(new Uint8Array(1024).buffer);
       serializeComparator(s, c.comparator);
-      const d = new BinaryStream(s.buffer());
+      const d = new BinaryStream(s.buffer().buffer);
       const deserialized = deserializeComparator(d);
       for (const val of c.testCases) {
         const got = deserialized.compare(val);
@@ -398,7 +398,7 @@ g.test('skipUndefined').fn(t => {
     ]) {
       const s = new BinaryStream(new Uint8Array(1024).buffer);
       serializeComparator(s, c.comparator);
-      const d = new BinaryStream(s.buffer());
+      const d = new BinaryStream(s.buffer().buffer);
       const deserialized = deserializeComparator(d);
       for (const val of c.testCases) {
         const got = deserialized.compare(val);
diff --git a/src/webgpu/shader/execution/expression/case_cache.ts b/src/webgpu/shader/execution/expression/case_cache.ts
index daee31993161..ff82792d647d 100644
--- a/src/webgpu/shader/execution/expression/case_cache.ts
+++ b/src/webgpu/shader/execution/expression/case_cache.ts
@@ -166,13 +166,13 @@ export class CaseCache implements Cacheable<Record<string, CaseList>> {
    */
   serialize(data: Record<string, CaseList>): Uint8Array {
     const maxSize = 32 << 20; // 32MB - max size for a file
-    const s = new BinaryStream(new Uint8Array(maxSize).buffer);
-    s.writeU32(Object.keys(data).length);
+    const stream = new BinaryStream(new ArrayBuffer(maxSize));
+    stream.writeU32(Object.keys(data).length);
     for (const name in data) {
-      s.writeString(name);
-      s.writeArray(data[name], serializeCase);
+      stream.writeString(name);
+      stream.writeArray(data[name], serializeCase);
     }
-    return new Uint8Array(s.buffer());
+    return stream.buffer();
   }
 
   /**
diff --git a/src/webgpu/util/binary_stream.ts b/src/webgpu/util/binary_stream.ts
index 2b32db9b3e06..a6512020e631 100644
--- a/src/webgpu/util/binary_stream.ts
+++ b/src/webgpu/util/binary_stream.ts
@@ -19,8 +19,8 @@ export default class BinaryStream {
   }
 
   /** buffer() returns the stream's buffer sliced to the 8-byte rounded read or write offset */
-  buffer(): ArrayBufferLike {
-    return new Uint8Array(this.view.buffer, align(this.offset, 8)).buffer;
+  buffer(): Uint8Array {
+    return new Uint8Array(this.view.buffer, 0, align(this.offset, 8));
   }
 
   /** writeBool() writes a boolean as 255 or 0 to the buffer at the next byte offset */

From ab09ed4f6c0811289d2d27a968b69f469cbf1d0c Mon Sep 17 00:00:00 2001
From: Ryan Harrison <rharrison@google.com>
Date: Wed, 1 Nov 2023 11:00:01 -0400
Subject: [PATCH 166/166] wgsl: Convert `quantizeToI32/U32` to used
 `Math.trunc` (#3120)

Another small bump (~5%) to be gained through using a builtin instead
of trampolining through a TypedArray.
---
 src/webgpu/util/math.ts | 34 ++++++++++++++++++++++------------
 1 file changed, 22 insertions(+), 12 deletions(-)

diff --git a/src/webgpu/util/math.ts b/src/webgpu/util/math.ts
index 9b901bfa6da4..851db40c7157 100644
--- a/src/webgpu/util/math.ts
+++ b/src/webgpu/util/math.ts
@@ -2023,22 +2023,32 @@ export function quantizeToF16(num: number): number {
   return hfround(num);
 }
 
-/** Statically allocate working data, so it doesn't need per-call creation */
-const quantizeToI32Data = new Int32Array(new ArrayBuffer(4));
-
-/** @returns the closest 32-bit signed integer value to the input */
+/**
+ * @returns the closest 32-bit signed integer value to the input, rounding
+ * towards 0, if not already an integer
+ */
 export function quantizeToI32(num: number): number {
-  quantizeToI32Data[0] = num;
-  return quantizeToI32Data[0];
+  if (num >= kValue.i32.positive.max) {
+    return kValue.i32.positive.max;
+  }
+  if (num <= kValue.i32.negative.min) {
+    return kValue.i32.negative.min;
+  }
+  return Math.trunc(num);
 }
 
-/** Statically allocate working data, so it doesn't need per-call creation */
-const quantizeToU32Data = new Uint32Array(new ArrayBuffer(4));
-
-/** @returns the closest 32-bit signed integer value to the input */
+/**
+ * @returns the closest 32-bit unsigned integer value to the input, rounding
+ * towards 0, if not already an integer
+ */
 export function quantizeToU32(num: number): number {
-  quantizeToU32Data[0] = num;
-  return quantizeToU32Data[0];
+  if (num >= kValue.u32.max) {
+    return kValue.u32.max;
+  }
+  if (num <= 0) {
+    return 0;
+  }
+  return Math.trunc(num);
 }
 
 /** @returns whether the number is an integer and a power of two */