webgpu-bench 0.1.0

package/dist/shaders/flopsF32Scalar.js

@@ -0,0 +1,72 @@
+/**
+ * Raw fp32 FLOPS probe. Eight *independent* scalar FMA chains per thread,
+ * with the loop body unrolled 4x, so the ALU always has work in flight:
+ * a single dependent chain would measure FMA latency (plus loop overhead)
+ * rather than throughput. `a`/`b`/the trip count are runtime values, and
+ * every chain starts from a different value so the compiler can't merge
+ * them. One tiny write per thread at the end; everything else is pure ALU.
+ * 8 chains x 4 unrolled steps = 32 FMAs (64 FLOPs) per loop iteration.
+ */
+export const flopsF32ScalarWgsl = /* wgsl */ `
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let a: f32 = 1.0 - f32(idx & 15u) * 0.001;
+  let b: f32 = 0.5 + f32(idx & 7u) * 0.001;
+  var x0: f32 = f32(idx & 255u) * 0.0001 + 0.01;
+  var x1: f32 = f32(idx & 255u) * 0.0001 + 0.02;
+  var x2: f32 = f32(idx & 255u) * 0.0001 + 0.03;
+  var x3: f32 = f32(idx & 255u) * 0.0001 + 0.04;
+  var x4: f32 = f32(idx & 255u) * 0.0001 + 0.05;
+  var x5: f32 = f32(idx & 255u) * 0.0001 + 0.06;
+  var x6: f32 = f32(idx & 255u) * 0.0001 + 0.07;
+  var x7: f32 = f32(idx & 255u) * 0.0001 + 0.08;
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x0 = x0 * a + b;
+    x1 = x1 * a + b;
+    x2 = x2 * a + b;
+    x3 = x3 * a + b;
+    x4 = x4 * a + b;
+    x5 = x5 * a + b;
+    x6 = x6 * a + b;
+    x7 = x7 * a + b;
+    x0 = x0 * a + b;
+    x1 = x1 * a + b;
+    x2 = x2 * a + b;
+    x3 = x3 * a + b;
+    x4 = x4 * a + b;
+    x5 = x5 * a + b;
+    x6 = x6 * a + b;
+    x7 = x7 * a + b;
+    x0 = x0 * a + b;
+    x1 = x1 * a + b;
+    x2 = x2 * a + b;
+    x3 = x3 * a + b;
+    x4 = x4 * a + b;
+    x5 = x5 * a + b;
+    x6 = x6 * a + b;
+    x7 = x7 * a + b;
+    x0 = x0 * a + b;
+    x1 = x1 * a + b;
+    x2 = x2 * a + b;
+    x3 = x3 * a + b;
+    x4 = x4 * a + b;
+    x5 = x5 * a + b;
+    x6 = x6 * a + b;
+    x7 = x7 * a + b;
+  }
+  out[idx] = x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7;
+}
+`;
+//# sourceMappingURL=flopsF32Scalar.js.map

package/dist/shaders/flopsF32Scalar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF32Scalar.js","sourceRoot":"","sources":["../../src/shaders/flopsF32Scalar.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6D5C,CAAC"}

package/dist/shaders/flopsF32Sincos.d.ts

@@ -0,0 +1,9 @@
+/**
+ * fp32 sin/cos FLOPS probe. Same shape as {@link flopsF32ScalarWgsl} but
+ * `x = cos(sin(x))` in place of the FMA: sin then cos, both naturally
+ * bounded to [-1, 1] so the chain needs no extra stabilization. 64 ops (32
+ * sins + 32 coss) per loop iteration, same MAC-as-2 convention as the
+ * multiply version.
+ */
+export declare const flopsF32SincosWgsl = "\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  var x0: f32 = f32(idx & 255u) * 0.01 + 0.1;\n  var x1: f32 = f32(idx & 255u) * 0.01 + 0.2;\n  var x2: f32 = f32(idx & 255u) * 0.01 + 0.3;\n  var x3: f32 = f32(idx & 255u) * 0.01 + 0.4;\n  var x4: f32 = f32(idx & 255u) * 0.01 + 0.5;\n  var x5: f32 = f32(idx & 255u) * 0.01 + 0.6;\n  var x6: f32 = f32(idx & 255u) * 0.01 + 0.7;\n  var x7: f32 = f32(idx & 255u) * 0.01 + 0.8;\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    x0 = cos(sin(x0));\n    x1 = cos(sin(x1));\n    x2 = cos(sin(x2));\n    x3 = cos(sin(x3));\n    x4 = cos(sin(x4));\n    x5 = cos(sin(x5));\n    x6 = cos(sin(x6));\n    x7 = cos(sin(x7));\n    x0 = cos(sin(x0));\n    x1 = cos(sin(x1));\n    x2 = cos(sin(x2));\n    x3 = cos(sin(x3));\n    x4 = cos(sin(x4));\n    x5 = cos(sin(x5));\n    x6 = cos(sin(x6));\n    x7 = cos(sin(x7));\n    x0 = cos(sin(x0));\n    x1 = cos(sin(x1));\n    x2 = cos(sin(x2));\n    x3 = cos(sin(x3));\n    x4 = cos(sin(x4));\n    x5 = cos(sin(x5));\n    x6 = cos(sin(x6));\n    x7 = cos(sin(x7));\n    x0 = cos(sin(x0));\n    x1 = cos(sin(x1));\n    x2 = cos(sin(x2));\n    x3 = cos(sin(x3));\n    x4 = cos(sin(x4));\n    x5 = cos(sin(x5));\n    x6 = cos(sin(x6));\n    x7 = cos(sin(x7));\n  }\n  out[idx] = x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7;\n}\n";
+//# sourceMappingURL=flopsF32Sincos.d.ts.map

package/dist/shaders/flopsF32Sincos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF32Sincos.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsF32Sincos.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,2kDA2D9B,CAAC"}

package/dist/shaders/flopsF32Sincos.js

@@ -0,0 +1,68 @@
+/**
+ * fp32 sin/cos FLOPS probe. Same shape as {@link flopsF32ScalarWgsl} but
+ * `x = cos(sin(x))` in place of the FMA: sin then cos, both naturally
+ * bounded to [-1, 1] so the chain needs no extra stabilization. 64 ops (32
+ * sins + 32 coss) per loop iteration, same MAC-as-2 convention as the
+ * multiply version.
+ */
+export const flopsF32SincosWgsl = /* wgsl */ `
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  var x0: f32 = f32(idx & 255u) * 0.01 + 0.1;
+  var x1: f32 = f32(idx & 255u) * 0.01 + 0.2;
+  var x2: f32 = f32(idx & 255u) * 0.01 + 0.3;
+  var x3: f32 = f32(idx & 255u) * 0.01 + 0.4;
+  var x4: f32 = f32(idx & 255u) * 0.01 + 0.5;
+  var x5: f32 = f32(idx & 255u) * 0.01 + 0.6;
+  var x6: f32 = f32(idx & 255u) * 0.01 + 0.7;
+  var x7: f32 = f32(idx & 255u) * 0.01 + 0.8;
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x0 = cos(sin(x0));
+    x1 = cos(sin(x1));
+    x2 = cos(sin(x2));
+    x3 = cos(sin(x3));
+    x4 = cos(sin(x4));
+    x5 = cos(sin(x5));
+    x6 = cos(sin(x6));
+    x7 = cos(sin(x7));
+    x0 = cos(sin(x0));
+    x1 = cos(sin(x1));
+    x2 = cos(sin(x2));
+    x3 = cos(sin(x3));
+    x4 = cos(sin(x4));
+    x5 = cos(sin(x5));
+    x6 = cos(sin(x6));
+    x7 = cos(sin(x7));
+    x0 = cos(sin(x0));
+    x1 = cos(sin(x1));
+    x2 = cos(sin(x2));
+    x3 = cos(sin(x3));
+    x4 = cos(sin(x4));
+    x5 = cos(sin(x5));
+    x6 = cos(sin(x6));
+    x7 = cos(sin(x7));
+    x0 = cos(sin(x0));
+    x1 = cos(sin(x1));
+    x2 = cos(sin(x2));
+    x3 = cos(sin(x3));
+    x4 = cos(sin(x4));
+    x5 = cos(sin(x5));
+    x6 = cos(sin(x6));
+    x7 = cos(sin(x7));
+  }
+  out[idx] = x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7;
+}
+`;
+//# sourceMappingURL=flopsF32Sincos.js.map

package/dist/shaders/flopsF32Sincos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF32Sincos.js","sourceRoot":"","sources":["../../src/shaders/flopsF32Sincos.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2D5C,CAAC"}

package/dist/shaders/flopsF32Sqrt.d.ts

@@ -0,0 +1,9 @@
+/**
+ * fp32 sqrt-add FLOPS probe. Same shape as {@link flopsF32ScalarWgsl} but
+ * `x = sqrt(x) + b` in place of the FMA: sqrt(x) for x > 1 is a contraction
+ * towards 1, so adding a positive `b` each step keeps the chain bounded and
+ * positive forever. 64 ops (32 sqrts + 32 adds) per loop iteration, same
+ * MAC-as-2 convention as the multiply version.
+ */
+export declare const flopsF32SqrtWgsl = "\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let b: f32 = 0.5 + f32(idx & 7u) * 0.001;\n  var x0: f32 = f32(idx & 255u) * 0.0001 + 0.01;\n  var x1: f32 = f32(idx & 255u) * 0.0001 + 0.02;\n  var x2: f32 = f32(idx & 255u) * 0.0001 + 0.03;\n  var x3: f32 = f32(idx & 255u) * 0.0001 + 0.04;\n  var x4: f32 = f32(idx & 255u) * 0.0001 + 0.05;\n  var x5: f32 = f32(idx & 255u) * 0.0001 + 0.06;\n  var x6: f32 = f32(idx & 255u) * 0.0001 + 0.07;\n  var x7: f32 = f32(idx & 255u) * 0.0001 + 0.08;\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    x0 = sqrt(x0) + b;\n    x1 = sqrt(x1) + b;\n    x2 = sqrt(x2) + b;\n    x3 = sqrt(x3) + b;\n    x4 = sqrt(x4) + b;\n    x5 = sqrt(x5) + b;\n    x6 = sqrt(x6) + b;\n    x7 = sqrt(x7) + b;\n    x0 = sqrt(x0) + b;\n    x1 = sqrt(x1) + b;\n    x2 = sqrt(x2) + b;\n    x3 = sqrt(x3) + b;\n    x4 = sqrt(x4) + b;\n    x5 = sqrt(x5) + b;\n    x6 = sqrt(x6) + b;\n    x7 = sqrt(x7) + b;\n    x0 = sqrt(x0) + b;\n    x1 = sqrt(x1) + b;\n    x2 = sqrt(x2) + b;\n    x3 = sqrt(x3) + b;\n    x4 = sqrt(x4) + b;\n    x5 = sqrt(x5) + b;\n    x6 = sqrt(x6) + b;\n    x7 = sqrt(x7) + b;\n    x0 = sqrt(x0) + b;\n    x1 = sqrt(x1) + b;\n    x2 = sqrt(x2) + b;\n    x3 = sqrt(x3) + b;\n    x4 = sqrt(x4) + b;\n    x5 = sqrt(x5) + b;\n    x6 = sqrt(x6) + b;\n    x7 = sqrt(x7) + b;\n  }\n  out[idx] = x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7;\n}\n";
+//# sourceMappingURL=flopsF32Sqrt.d.ts.map

package/dist/shaders/flopsF32Sqrt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF32Sqrt.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsF32Sqrt.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,gpDA4D5B,CAAC"}

package/dist/shaders/flopsF32Sqrt.js

@@ -0,0 +1,69 @@
+/**
+ * fp32 sqrt-add FLOPS probe. Same shape as {@link flopsF32ScalarWgsl} but
+ * `x = sqrt(x) + b` in place of the FMA: sqrt(x) for x > 1 is a contraction
+ * towards 1, so adding a positive `b` each step keeps the chain bounded and
+ * positive forever. 64 ops (32 sqrts + 32 adds) per loop iteration, same
+ * MAC-as-2 convention as the multiply version.
+ */
+export const flopsF32SqrtWgsl = /* wgsl */ `
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let b: f32 = 0.5 + f32(idx & 7u) * 0.001;
+  var x0: f32 = f32(idx & 255u) * 0.0001 + 0.01;
+  var x1: f32 = f32(idx & 255u) * 0.0001 + 0.02;
+  var x2: f32 = f32(idx & 255u) * 0.0001 + 0.03;
+  var x3: f32 = f32(idx & 255u) * 0.0001 + 0.04;
+  var x4: f32 = f32(idx & 255u) * 0.0001 + 0.05;
+  var x5: f32 = f32(idx & 255u) * 0.0001 + 0.06;
+  var x6: f32 = f32(idx & 255u) * 0.0001 + 0.07;
+  var x7: f32 = f32(idx & 255u) * 0.0001 + 0.08;
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x0 = sqrt(x0) + b;
+    x1 = sqrt(x1) + b;
+    x2 = sqrt(x2) + b;
+    x3 = sqrt(x3) + b;
+    x4 = sqrt(x4) + b;
+    x5 = sqrt(x5) + b;
+    x6 = sqrt(x6) + b;
+    x7 = sqrt(x7) + b;
+    x0 = sqrt(x0) + b;
+    x1 = sqrt(x1) + b;
+    x2 = sqrt(x2) + b;
+    x3 = sqrt(x3) + b;
+    x4 = sqrt(x4) + b;
+    x5 = sqrt(x5) + b;
+    x6 = sqrt(x6) + b;
+    x7 = sqrt(x7) + b;
+    x0 = sqrt(x0) + b;
+    x1 = sqrt(x1) + b;
+    x2 = sqrt(x2) + b;
+    x3 = sqrt(x3) + b;
+    x4 = sqrt(x4) + b;
+    x5 = sqrt(x5) + b;
+    x6 = sqrt(x6) + b;
+    x7 = sqrt(x7) + b;
+    x0 = sqrt(x0) + b;
+    x1 = sqrt(x1) + b;
+    x2 = sqrt(x2) + b;
+    x3 = sqrt(x3) + b;
+    x4 = sqrt(x4) + b;
+    x5 = sqrt(x5) + b;
+    x6 = sqrt(x6) + b;
+    x7 = sqrt(x7) + b;
+  }
+  out[idx] = x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7;
+}
+`;
+//# sourceMappingURL=flopsF32Sqrt.js.map

package/dist/shaders/flopsF32Sqrt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF32Sqrt.js","sourceRoot":"","sources":["../../src/shaders/flopsF32Sqrt.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4D1C,CAAC"}

package/dist/shaders/flopsF32Vec4.d.ts

@@ -0,0 +1,9 @@
+/**
+ * fp32 vec4 FLOPS probe: a single FMA chain held in a `vec4<f32>` register.
+ * On scalar-SIMT GPUs (Apple, NVIDIA, AMD) this compiles to 4 independent
+ * scalar FMAs per step, so it measures 4-wide instruction-level parallelism
+ * rather than a wider ALU. Same runtime-derived operands/loop count as the
+ * scalar probe to defeat constant folding.
+ */
+export declare const flopsF32Vec4Wgsl = "\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let s: f32 = f32(idx & 15u) * 0.001;\n  let a: vec4<f32> = vec4<f32>(1.0 - s, 1.0 - 2.0 * s, 1.0 - 3.0 * s, 1.0 - 4.0 * s);\n  let b: vec4<f32> = vec4<f32>(0.5 + s, 0.5 + 2.0 * s, 0.5 + 3.0 * s, 0.5 + 4.0 * s);\n  var x: vec4<f32> = vec4<f32>(f32(idx & 255u) * 0.0001);\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    x = x * a + b;\n  }\n  out[idx] = x.x + x.y + x.z + x.w;\n}\n";
+//# sourceMappingURL=flopsF32Vec4.d.ts.map

package/dist/shaders/flopsF32Vec4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF32Vec4.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsF32Vec4.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,wuBAwB5B,CAAC"}

package/dist/shaders/flopsF32Vec4.js

@@ -0,0 +1,33 @@
+/**
+ * fp32 vec4 FLOPS probe: a single FMA chain held in a `vec4<f32>` register.
+ * On scalar-SIMT GPUs (Apple, NVIDIA, AMD) this compiles to 4 independent
+ * scalar FMAs per step, so it measures 4-wide instruction-level parallelism
+ * rather than a wider ALU. Same runtime-derived operands/loop count as the
+ * scalar probe to defeat constant folding.
+ */
+export const flopsF32Vec4Wgsl = /* wgsl */ `
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let s: f32 = f32(idx & 15u) * 0.001;
+  let a: vec4<f32> = vec4<f32>(1.0 - s, 1.0 - 2.0 * s, 1.0 - 3.0 * s, 1.0 - 4.0 * s);
+  let b: vec4<f32> = vec4<f32>(0.5 + s, 0.5 + 2.0 * s, 0.5 + 3.0 * s, 0.5 + 4.0 * s);
+  var x: vec4<f32> = vec4<f32>(f32(idx & 255u) * 0.0001);
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x = x * a + b;
+  }
+  out[idx] = x.x + x.y + x.z + x.w;
+}
+`;
+//# sourceMappingURL=flopsF32Vec4.js.map

package/dist/shaders/flopsF32Vec4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF32Vec4.js","sourceRoot":"","sources":["../../src/shaders/flopsF32Vec4.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwB1C,CAAC"}

package/dist/shaders/flopsI32Div.d.ts

@@ -0,0 +1,10 @@
+/**
+ * i32 divide-add ops probe. Same shape as {@link flopsI8ScalarWgsl} (eight
+ * independent chains, unrolled 4x) but with the multiply replaced by integer
+ * division: `x = x / a + b`. `a` is always >= 2 so each step shrinks `x`
+ * (bounded, no overflow) and never divides by zero. 64 ops (32 divides + 32
+ * adds) per loop iteration, same MAC-as-2 convention as the other scalar
+ * probes.
+ */
+export declare const flopsI32DivWgsl = "\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let a: i32 = 2 + i32(idx & 3u);\n  let b: i32 = 5 + i32(idx & 7u);\n  var x0: i32 = i32(idx & 255u) + 1000;\n  var x1: i32 = i32(idx & 255u) + 2000;\n  var x2: i32 = i32(idx & 255u) + 3000;\n  var x3: i32 = i32(idx & 255u) + 4000;\n  var x4: i32 = i32(idx & 255u) + 5000;\n  var x5: i32 = i32(idx & 255u) + 6000;\n  var x6: i32 = i32(idx & 255u) + 7000;\n  var x7: i32 = i32(idx & 255u) + 8000;\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    x0 = x0 / a + b;\n    x1 = x1 / a + b;\n    x2 = x2 / a + b;\n    x3 = x3 / a + b;\n    x4 = x4 / a + b;\n    x5 = x5 / a + b;\n    x6 = x6 / a + b;\n    x7 = x7 / a + b;\n    x0 = x0 / a + b;\n    x1 = x1 / a + b;\n    x2 = x2 / a + b;\n    x3 = x3 / a + b;\n    x4 = x4 / a + b;\n    x5 = x5 / a + b;\n    x6 = x6 / a + b;\n    x7 = x7 / a + b;\n    x0 = x0 / a + b;\n    x1 = x1 / a + b;\n    x2 = x2 / a + b;\n    x3 = x3 / a + b;\n    x4 = x4 / a + b;\n    x5 = x5 / a + b;\n    x6 = x6 / a + b;\n    x7 = x7 / a + b;\n    x0 = x0 / a + b;\n    x1 = x1 / a + b;\n    x2 = x2 / a + b;\n    x3 = x3 / a + b;\n    x4 = x4 / a + b;\n    x5 = x5 / a + b;\n    x6 = x6 / a + b;\n    x7 = x7 / a + b;\n  }\n  out[idx] = f32(x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7);\n}\n";
+//# sourceMappingURL=flopsI32Div.d.ts.map

package/dist/shaders/flopsI32Div.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsI32Div.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsI32Div.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,siDA6D3B,CAAC"}

package/dist/shaders/flopsI32Div.js

@@ -0,0 +1,71 @@
+/**
+ * i32 divide-add ops probe. Same shape as {@link flopsI8ScalarWgsl} (eight
+ * independent chains, unrolled 4x) but with the multiply replaced by integer
+ * division: `x = x / a + b`. `a` is always >= 2 so each step shrinks `x`
+ * (bounded, no overflow) and never divides by zero. 64 ops (32 divides + 32
+ * adds) per loop iteration, same MAC-as-2 convention as the other scalar
+ * probes.
+ */
+export const flopsI32DivWgsl = /* wgsl */ `
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let a: i32 = 2 + i32(idx & 3u);
+  let b: i32 = 5 + i32(idx & 7u);
+  var x0: i32 = i32(idx & 255u) + 1000;
+  var x1: i32 = i32(idx & 255u) + 2000;
+  var x2: i32 = i32(idx & 255u) + 3000;
+  var x3: i32 = i32(idx & 255u) + 4000;
+  var x4: i32 = i32(idx & 255u) + 5000;
+  var x5: i32 = i32(idx & 255u) + 6000;
+  var x6: i32 = i32(idx & 255u) + 7000;
+  var x7: i32 = i32(idx & 255u) + 8000;
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x0 = x0 / a + b;
+    x1 = x1 / a + b;
+    x2 = x2 / a + b;
+    x3 = x3 / a + b;
+    x4 = x4 / a + b;
+    x5 = x5 / a + b;
+    x6 = x6 / a + b;
+    x7 = x7 / a + b;
+    x0 = x0 / a + b;
+    x1 = x1 / a + b;
+    x2 = x2 / a + b;
+    x3 = x3 / a + b;
+    x4 = x4 / a + b;
+    x5 = x5 / a + b;
+    x6 = x6 / a + b;
+    x7 = x7 / a + b;
+    x0 = x0 / a + b;
+    x1 = x1 / a + b;
+    x2 = x2 / a + b;
+    x3 = x3 / a + b;
+    x4 = x4 / a + b;
+    x5 = x5 / a + b;
+    x6 = x6 / a + b;
+    x7 = x7 / a + b;
+    x0 = x0 / a + b;
+    x1 = x1 / a + b;
+    x2 = x2 / a + b;
+    x3 = x3 / a + b;
+    x4 = x4 / a + b;
+    x5 = x5 / a + b;
+    x6 = x6 / a + b;
+    x7 = x7 / a + b;
+  }
+  out[idx] = f32(x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7);
+}
+`;
+//# sourceMappingURL=flopsI32Div.js.map

package/dist/shaders/flopsI32Div.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsI32Div.js","sourceRoot":"","sources":["../../src/shaders/flopsI32Div.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DzC,CAAC"}

package/dist/shaders/flopsI32F16Convert.d.ts

@@ -0,0 +1,10 @@
+/**
+ * i32<->fp16 round-trip FLOPS probe: `xi -> f32 -> pack2x16float ->
+ * unpack2x16float -> f32*a+b -> xi`. There's no native int<->f16 builtin, so
+ * this is what that conversion actually costs — chained through f32, like
+ * the real path. `a` < 1 keeps the round-tripped integer bounded. Eight
+ * independent i32 lanes, unrolled 4x; 6 ops/lane/step (f32-convert, pack,
+ * unpack, multiply, add, i32-convert). 192 ops per loop iteration.
+ */
+export declare const flopsI32F16ConvertWgsl = "\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let a: f32 = 0.9 + f32(idx & 15u) * 0.005;\n  let b: f32 = 3.0 + f32(idx & 7u) * 0.1;\n  var x0: i32 = i32(idx & 255u) + 100;\n  var x1: i32 = i32(idx & 255u) + 200;\n  var x2: i32 = i32(idx & 255u) + 300;\n  var x3: i32 = i32(idx & 255u) + 400;\n  var x4: i32 = i32(idx & 255u) + 500;\n  var x5: i32 = i32(idx & 255u) + 600;\n  var x6: i32 = i32(idx & 255u) + 700;\n  var x7: i32 = i32(idx & 255u) + 800;\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    x0 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x0)))).x * a + b);\n    x1 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x1)))).x * a + b);\n    x2 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x2)))).x * a + b);\n    x3 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x3)))).x * a + b);\n    x4 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x4)))).x * a + b);\n    x5 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x5)))).x * a + b);\n    x6 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x6)))).x * a + b);\n    x7 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x7)))).x * a + b);\n    x0 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x0)))).x * a + b);\n    x1 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x1)))).x * a + b);\n    x2 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x2)))).x * a + b);\n    x3 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x3)))).x * a + b);\n    x4 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x4)))).x * a + b);\n    x5 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x5)))).x * a + b);\n    x6 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x6)))).x * a + b);\n    x7 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x7)))).x * a + b);\n    x0 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x0)))).x * a + b);\n    x1 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x1)))).x * a + b);\n    x2 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x2)))).x * a + b);\n    x3 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x3)))).x * a + b);\n    x4 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x4)))).x * a + b);\n    x5 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x5)))).x * a + b);\n    x6 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x6)))).x * a + b);\n    x7 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x7)))).x * a + b);\n    x0 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x0)))).x * a + b);\n    x1 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x1)))).x * a + b);\n    x2 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x2)))).x * a + b);\n    x3 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x3)))).x * a + b);\n    x4 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x4)))).x * a + b);\n    x5 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x5)))).x * a + b);\n    x6 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x6)))).x * a + b);\n    x7 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x7)))).x * a + b);\n  }\n  out[idx] = f32(x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7);\n}\n";
+//# sourceMappingURL=flopsI32F16Convert.d.ts.map

package/dist/shaders/flopsI32F16Convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsI32F16Convert.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsI32F16Convert.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,ixGA6DlC,CAAC"}

package/dist/shaders/flopsI32F16Convert.js

@@ -0,0 +1,71 @@
+/**
+ * i32<->fp16 round-trip FLOPS probe: `xi -> f32 -> pack2x16float ->
+ * unpack2x16float -> f32*a+b -> xi`. There's no native int<->f16 builtin, so
+ * this is what that conversion actually costs — chained through f32, like
+ * the real path. `a` < 1 keeps the round-tripped integer bounded. Eight
+ * independent i32 lanes, unrolled 4x; 6 ops/lane/step (f32-convert, pack,
+ * unpack, multiply, add, i32-convert). 192 ops per loop iteration.
+ */
+export const flopsI32F16ConvertWgsl = /* wgsl */ `
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let a: f32 = 0.9 + f32(idx & 15u) * 0.005;
+  let b: f32 = 3.0 + f32(idx & 7u) * 0.1;
+  var x0: i32 = i32(idx & 255u) + 100;
+  var x1: i32 = i32(idx & 255u) + 200;
+  var x2: i32 = i32(idx & 255u) + 300;
+  var x3: i32 = i32(idx & 255u) + 400;
+  var x4: i32 = i32(idx & 255u) + 500;
+  var x5: i32 = i32(idx & 255u) + 600;
+  var x6: i32 = i32(idx & 255u) + 700;
+  var x7: i32 = i32(idx & 255u) + 800;
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x0 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x0)))).x * a + b);
+    x1 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x1)))).x * a + b);
+    x2 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x2)))).x * a + b);
+    x3 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x3)))).x * a + b);
+    x4 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x4)))).x * a + b);
+    x5 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x5)))).x * a + b);
+    x6 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x6)))).x * a + b);
+    x7 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x7)))).x * a + b);
+    x0 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x0)))).x * a + b);
+    x1 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x1)))).x * a + b);
+    x2 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x2)))).x * a + b);
+    x3 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x3)))).x * a + b);
+    x4 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x4)))).x * a + b);
+    x5 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x5)))).x * a + b);
+    x6 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x6)))).x * a + b);
+    x7 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x7)))).x * a + b);
+    x0 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x0)))).x * a + b);
+    x1 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x1)))).x * a + b);
+    x2 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x2)))).x * a + b);
+    x3 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x3)))).x * a + b);
+    x4 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x4)))).x * a + b);
+    x5 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x5)))).x * a + b);
+    x6 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x6)))).x * a + b);
+    x7 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x7)))).x * a + b);
+    x0 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x0)))).x * a + b);
+    x1 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x1)))).x * a + b);
+    x2 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x2)))).x * a + b);
+    x3 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x3)))).x * a + b);
+    x4 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x4)))).x * a + b);
+    x5 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x5)))).x * a + b);
+    x6 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x6)))).x * a + b);
+    x7 = i32(unpack2x16float(pack2x16float(vec2<f32>(f32(x7)))).x * a + b);
+  }
+  out[idx] = f32(x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7);
+}
+`;
+//# sourceMappingURL=flopsI32F16Convert.js.map

package/dist/shaders/flopsI32F16Convert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsI32F16Convert.js","sourceRoot":"","sources":["../../src/shaders/flopsI32F16Convert.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DhD,CAAC"}

package/dist/shaders/flopsI32F32Convert.d.ts

@@ -0,0 +1,10 @@
+/**
+ * i32<->f32 conversion FLOPS probe. Same shape as {@link flopsF32ScalarWgsl}
+ * but each step is `xf = f32(xi) * a + b; xi = i32(xf)`: two conversions
+ * plus the same FMA as the fp32 scalar test, so the delta against that test
+ * isolates conversion cost. `a` < 1 keeps the round-tripped integer bounded.
+ * 128 ops (32 x [f32-convert, multiply, add, i32-convert]) per loop
+ * iteration.
+ */
+export declare const flopsI32F32ConvertWgsl = "\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let a: f32 = 0.9 + f32(idx & 15u) * 0.005;\n  let b: f32 = 3.0 + f32(idx & 7u) * 0.1;\n  var x0: i32 = i32(idx & 255u) + 100;\n  var x1: i32 = i32(idx & 255u) + 200;\n  var x2: i32 = i32(idx & 255u) + 300;\n  var x3: i32 = i32(idx & 255u) + 400;\n  var x4: i32 = i32(idx & 255u) + 500;\n  var x5: i32 = i32(idx & 255u) + 600;\n  var x6: i32 = i32(idx & 255u) + 700;\n  var x7: i32 = i32(idx & 255u) + 800;\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    x0 = i32(f32(x0) * a + b);\n    x1 = i32(f32(x1) * a + b);\n    x2 = i32(f32(x2) * a + b);\n    x3 = i32(f32(x3) * a + b);\n    x4 = i32(f32(x4) * a + b);\n    x5 = i32(f32(x5) * a + b);\n    x6 = i32(f32(x6) * a + b);\n    x7 = i32(f32(x7) * a + b);\n    x0 = i32(f32(x0) * a + b);\n    x1 = i32(f32(x1) * a + b);\n    x2 = i32(f32(x2) * a + b);\n    x3 = i32(f32(x3) * a + b);\n    x4 = i32(f32(x4) * a + b);\n    x5 = i32(f32(x5) * a + b);\n    x6 = i32(f32(x6) * a + b);\n    x7 = i32(f32(x7) * a + b);\n    x0 = i32(f32(x0) * a + b);\n    x1 = i32(f32(x1) * a + b);\n    x2 = i32(f32(x2) * a + b);\n    x3 = i32(f32(x3) * a + b);\n    x4 = i32(f32(x4) * a + b);\n    x5 = i32(f32(x5) * a + b);\n    x6 = i32(f32(x6) * a + b);\n    x7 = i32(f32(x7) * a + b);\n    x0 = i32(f32(x0) * a + b);\n    x1 = i32(f32(x1) * a + b);\n    x2 = i32(f32(x2) * a + b);\n    x3 = i32(f32(x3) * a + b);\n    x4 = i32(f32(x4) * a + b);\n    x5 = i32(f32(x5) * a + b);\n    x6 = i32(f32(x6) * a + b);\n    x7 = i32(f32(x7) * a + b);\n  }\n  out[idx] = f32(x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7);\n}\n";
+//# sourceMappingURL=flopsI32F32Convert.d.ts.map

package/dist/shaders/flopsI32F32Convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsI32F32Convert.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsI32F32Convert.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,i3DA6DlC,CAAC"}

package/dist/shaders/flopsI32F32Convert.js

@@ -0,0 +1,71 @@
+/**
+ * i32<->f32 conversion FLOPS probe. Same shape as {@link flopsF32ScalarWgsl}
+ * but each step is `xf = f32(xi) * a + b; xi = i32(xf)`: two conversions
+ * plus the same FMA as the fp32 scalar test, so the delta against that test
+ * isolates conversion cost. `a` < 1 keeps the round-tripped integer bounded.
+ * 128 ops (32 x [f32-convert, multiply, add, i32-convert]) per loop
+ * iteration.
+ */
+export const flopsI32F32ConvertWgsl = /* wgsl */ `
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let a: f32 = 0.9 + f32(idx & 15u) * 0.005;
+  let b: f32 = 3.0 + f32(idx & 7u) * 0.1;
+  var x0: i32 = i32(idx & 255u) + 100;
+  var x1: i32 = i32(idx & 255u) + 200;
+  var x2: i32 = i32(idx & 255u) + 300;
+  var x3: i32 = i32(idx & 255u) + 400;
+  var x4: i32 = i32(idx & 255u) + 500;
+  var x5: i32 = i32(idx & 255u) + 600;
+  var x6: i32 = i32(idx & 255u) + 700;
+  var x7: i32 = i32(idx & 255u) + 800;
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x0 = i32(f32(x0) * a + b);
+    x1 = i32(f32(x1) * a + b);
+    x2 = i32(f32(x2) * a + b);
+    x3 = i32(f32(x3) * a + b);
+    x4 = i32(f32(x4) * a + b);
+    x5 = i32(f32(x5) * a + b);
+    x6 = i32(f32(x6) * a + b);
+    x7 = i32(f32(x7) * a + b);
+    x0 = i32(f32(x0) * a + b);
+    x1 = i32(f32(x1) * a + b);
+    x2 = i32(f32(x2) * a + b);
+    x3 = i32(f32(x3) * a + b);
+    x4 = i32(f32(x4) * a + b);
+    x5 = i32(f32(x5) * a + b);
+    x6 = i32(f32(x6) * a + b);
+    x7 = i32(f32(x7) * a + b);
+    x0 = i32(f32(x0) * a + b);
+    x1 = i32(f32(x1) * a + b);
+    x2 = i32(f32(x2) * a + b);
+    x3 = i32(f32(x3) * a + b);
+    x4 = i32(f32(x4) * a + b);
+    x5 = i32(f32(x5) * a + b);
+    x6 = i32(f32(x6) * a + b);
+    x7 = i32(f32(x7) * a + b);
+    x0 = i32(f32(x0) * a + b);
+    x1 = i32(f32(x1) * a + b);
+    x2 = i32(f32(x2) * a + b);
+    x3 = i32(f32(x3) * a + b);
+    x4 = i32(f32(x4) * a + b);
+    x5 = i32(f32(x5) * a + b);
+    x6 = i32(f32(x6) * a + b);
+    x7 = i32(f32(x7) * a + b);
+  }
+  out[idx] = f32(x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7);
+}
+`;
+//# sourceMappingURL=flopsI32F32Convert.js.map

package/dist/shaders/flopsI32F32Convert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsI32F32Convert.js","sourceRoot":"","sources":["../../src/shaders/flopsI32F32Convert.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DhD,CAAC"}

package/dist/shaders/flopsI8Dp4a.d.ts

@@ -0,0 +1,23 @@
+/**
+ * int8 packed-dot-product FLOPS probe: uses the `packed_4x8_integer_dot_product`
+ * extension's `dot4I8Packed` builtin directly (two u32s, each four packed
+ * signed int8 lanes, one instruction) in a tight accumulation loop, to
+ * isolate the instruction's peak throughput. `a` is fed back from the
+ * running accumulator every iteration (not just `idx`-derived and fixed),
+ * so `dot4I8Packed(a, b)` is genuinely loop-carried — a compiler that
+ * noticed `a`/`b` were loop-invariant could otherwise hoist the call out of
+ * the loop and replace all `iterations` of it with one call + a multiply,
+ * which is exactly what happened before this fix (the loop collapsed to
+ * ~free, and the dispatch finished faster than the timestamp-query clock's
+ * resolution, reading back as a literal 0ns elapsed).
+ *
+ * `packed_4x8_integer_dot_product` is a WGSL *language extension* (gated by
+ * `navigator.gpu.wgslLanguageFeatures`, checked as `ctx.info.supportsI8Dot`
+ * in flopsCommon.ts), not an enable-extension tied to a GPUFeatureName like
+ * `f16` — so it's opted into with the `requires` directive, not `enable`.
+ * Using `enable` here fails shader compilation ("Expected 'clip_distances',
+ * 'f16', or 'primitive_index'" — the compiler listing valid enable-extension
+ * names), which used to go undetected and read back as a silent 0ns result.
+ */
+export declare const flopsI8Dp4aWgsl = "\nrequires packed_4x8_integer_dot_product;\n\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let b: u32 = 0x05060708u ^ (idx * 0x85ebca6bu);\n  var a: u32 = 0x01020304u ^ (idx * 0x9e3779b1u);\n  var acc: i32 = i32(idx & 255u);\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    acc = acc + dot4I8Packed(a, b);\n    a = a ^ u32(acc);\n  }\n  out[idx] = f32(acc);\n}\n";
+//# sourceMappingURL=flopsI8Dp4a.d.ts.map

package/dist/shaders/flopsI8Dp4a.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsI8Dp4a.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsI8Dp4a.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,uqBA0B3B,CAAC"}