@graphty/webgpu-graph-algorithms 0.6.23 → 0.6.25

package/dist/src/wgsl/bc-count.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-count.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-count.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,WAAW,61CAwBvB,CAAC"}

package/dist/src/wgsl/bc-count.wgsl.js

@@ -0,0 +1,46 @@
+/**
+ * The `bc-count` kernel body (design 8.4, issue #719): the shortest-path counts of the depth a betweenness forward
+ * level has just claimed, PULLED once the claims are complete. It runs only in a batch rerun because its u32 counts
+ * wrapped (the forward bodies then run with `SCALED` and count nothing); `sigmaK` holds f32 bits throughout. One invocation per entry `t = s * n + x` of the range
+ * `S[ends[level + 1] .. stackTop)` (the entries the forward dispatch appended), each summing `sigma[s][v]` over the
+ * in-arcs `(v, x)` with `depth[s][v] == level` in CSR order -- the reverse adjacency, which on an undirected snapshot
+ * is the forward one. No atomic touches a count, so the sums are bitwise reproducible, and both forward bodies leave
+ * the same counts.
+ *
+ * The counts are f32 and rescaled per depth, because a lattice outgrows any fixed width (a 40 x 40 grid has C(78, 39),
+ * about 2.6e22, corner-to-corner paths): each sum is multiplied by `2^-sigma_shift(levelMax[level])`, the power of
+ * two that brings the previous depth's largest count down to 2^BC_SIGMA_EXPONENT_CAP, and the result's bits go into
+ * `levelMax[level + 1]` by `atomicMax` (positive f32 bits order like the values). Every count of one (depth, batch)
+ * shares that scale, and Brandes' backward pass reads only ratios of a count to its successors', so `bc-backward`
+ * undoes the one step between two depths and nothing else. A count that leaves f32's normal range anyway -- zero,
+ * subnormal, infinite -- raises `sigmaOverflow` (counters word 27): the counts at one depth spread wider than f32 can
+ * hold, and the scores are wrong. Grid-stride loop (`P.stride`); the range is read from the device, so the host
+ * dispatches for the largest possible level. Body only; the sabotage rows of test/helpers/sabotage.ts are textual
+ * edits of it.
+ */
+export const bcCountWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn bc_count(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let level = atomicLoad(&counters[11]);
+    let start = ends[level + 1u];                                    // the boundary closed the claim-from level here
+    let count = atomicLoad(&counters[26]) - start;                   // stackTop: what the forward dispatch appended
+    let shift = sigma_shift(atomicLoad(&levelMax[level]));
+    for (var i = linear_id(wid, lid.x); i < count; i = i + P.stride) {
+        let t = S[start + i];                                        // s * n + x, at depth level + 1
+        let x = t % P.n;
+        let base = t - x;                                            // s * n
+        var acc = 0.0;
+        for (var a = rowPtr[x]; a < rowPtr[x + 1u]; a = a + 1u) {    // the in-arcs (v, x)
+            let v = base + colIdx[a];
+            if (depthK[v] == level) { acc = acc + bitcast<f32>(sigmaK[v]); }   // every predecessor's paths, CSR order
+        }
+        let sigma = ldexp(acc, -shift);
+        let bits = bitcast<u32>(sigma);
+        sigmaK[t] = bits;
+        let exponent = (bits >> 23u) & 0xffu;
+        if (exponent == 0u || exponent == 0xffu) { atomicOr(&counters[27], 1u); }   // out of f32's normal range
+        atomicMax(&levelMax[level + 1u], bits);
+    }
+}
+`;
+//# sourceMappingURL=bc-count.wgsl.js.map

package/dist/src/wgsl/bc-count.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-count.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-count.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBrC,CAAC"}

package/dist/src/wgsl/bc-edge-gather.wgsl.d.ts

@@ -3,10 +3,11 @@
  * twin of `bc-gather`, run once per batch after the backward sweep. One invocation per ARC (`P.count` arcs,
  * grid-stride): it finds the row `w` that owns the arc by an upper-bound search over `rowPtr`, then adds over the
  * batch's sources in order the term the backward pass summed -- `sigma[s][w] / sigma[s][v] * (1 + delta[s][v])`
- * whenever `w` was reached and `depth[s][v] == depth[s][w] + 1` -- into `arcScores[arc]`. Each arc is written by one
+ * whenever `w` was reached and `depth[s][v] == depth[s][w] + 1`, with `bc-backward`'s depth scale step under `SCALED` -- into
+ * `arcScores[arc]`. Each arc is written by one
  * invocation: no atomic, a fixed order. Arc-parallel rather than row-parallel so a hub row is not one lane's loop
  * (llvmpipe caps a shader loop at 65,535 iterations, and a 1,000-arc hub times 64 sources passed it). Body only;
  * the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
  */
-export declare const bcEdgeGatherWgsl = "\n@compute @workgroup_size(WG)\nfn bc_edge_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    for (var a = linear_id(wid, lid.x); a < P.count; a = a + P.stride) {\n        var lo = 0u;                                                 // the row w with rowPtr[w] <= a < rowPtr[w + 1]\n        var hi = P.n;\n        loop {\n            if (lo >= hi) { break; }\n            let mid = (lo + hi) / 2u;\n            if (rowPtr[mid + 1u] <= a) { lo = mid + 1u; } else { hi = mid; }\n        }\n        let w = lo;\n        let nbr = colIdx[a];\n        var acc = arcScores[a];\n        for (var s = 0u; s < P.k; s = s + 1u) {\n            let base = s * P.n;\n            let dw = depthK[base + w];\n            if (dw != INVALID_INDEX && depthK[base + nbr] == dw + 1u) {   // (w, nbr) is on a shortest path from s\n                acc = acc + (f32(sigmaK[base + w]) / f32(sigmaK[base + nbr])) * (1.0 + deltaK[base + nbr]);\n            }\n        }\n        arcScores[a] = acc;\n    }\n}\n";
+export declare const bcEdgeGatherWgsl = "\nfn sigma_of(word: u32) -> f32 {                                     // a stored count: u32, or f32 bits when SCALED\n    if (SCALED) { return bitcast<f32>(word); }\n    return f32(word);\n}\n\n@compute @workgroup_size(WG)\nfn bc_edge_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    for (var a = linear_id(wid, lid.x); a < P.count; a = a + P.stride) {\n        var lo = 0u;                                                 // the row w with rowPtr[w] <= a < rowPtr[w + 1]\n        var hi = P.n;\n        loop {\n            if (lo >= hi) { break; }\n            let mid = (lo + hi) / 2u;\n            if (rowPtr[mid + 1u] <= a) { lo = mid + 1u; } else { hi = mid; }\n        }\n        let w = lo;\n        let nbr = colIdx[a];\n        var acc = arcScores[a];\n        for (var s = 0u; s < P.k; s = s + 1u) {\n            let base = s * P.n;\n            let dw = depthK[base + w];\n            if (dw != INVALID_INDEX && depthK[base + nbr] == dw + 1u) {   // (w, nbr) is on a shortest path from s\n                let shift = select(0i, sigma_shift(levelMax[dw]), SCALED);\n                let ratio = ldexp(sigma_of(sigmaK[base + w]) / sigma_of(sigmaK[base + nbr]), -shift);\n                acc = acc + ratio * (1.0 + deltaK[base + nbr]);\n            }\n        }\n        arcScores[a] = acc;\n    }\n}\n";
 //# sourceMappingURL=bc-edge-gather.wgsl.d.ts.map

package/dist/src/wgsl/bc-edge-gather.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bc-edge-gather.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-edge-gather.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,6gCAwB5B,CAAC"}
+{"version":3,"file":"bc-edge-gather.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-edge-gather.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,q1CA+B5B,CAAC"}

package/dist/src/wgsl/bc-edge-gather.wgsl.js

@@ -3,12 +3,18 @@
  * twin of `bc-gather`, run once per batch after the backward sweep. One invocation per ARC (`P.count` arcs,
  * grid-stride): it finds the row `w` that owns the arc by an upper-bound search over `rowPtr`, then adds over the
  * batch's sources in order the term the backward pass summed -- `sigma[s][w] / sigma[s][v] * (1 + delta[s][v])`
- * whenever `w` was reached and `depth[s][v] == depth[s][w] + 1` -- into `arcScores[arc]`. Each arc is written by one
+ * whenever `w` was reached and `depth[s][v] == depth[s][w] + 1`, with `bc-backward`'s depth scale step under `SCALED` -- into
+ * `arcScores[arc]`. Each arc is written by one
  * invocation: no atomic, a fixed order. Arc-parallel rather than row-parallel so a hub row is not one lane's loop
  * (llvmpipe caps a shader loop at 65,535 iterations, and a 1,000-arc hub times 64 sources passed it). Body only;
  * the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
  */
 export const bcEdgeGatherWgsl = /* wgsl */ `
+fn sigma_of(word: u32) -> f32 {                                     // a stored count: u32, or f32 bits when SCALED
+    if (SCALED) { return bitcast<f32>(word); }
+    return f32(word);
+}
+
 @compute @workgroup_size(WG)
 fn bc_edge_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
     for (var a = linear_id(wid, lid.x); a < P.count; a = a + P.stride) {
@@ -26,7 +32,9 @@ fn bc_edge_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocati
             let base = s * P.n;
             let dw = depthK[base + w];
             if (dw != INVALID_INDEX && depthK[base + nbr] == dw + 1u) {   // (w, nbr) is on a shortest path from s
-                acc = acc + (f32(sigmaK[base + w]) / f32(sigmaK[base + nbr])) * (1.0 + deltaK[base + nbr]);
+                let shift = select(0i, sigma_shift(levelMax[dw]), SCALED);
+                let ratio = ldexp(sigma_of(sigmaK[base + w]) / sigma_of(sigmaK[base + nbr]), -shift);
+                acc = acc + ratio * (1.0 + deltaK[base + nbr]);
             }
         }
         arcScores[a] = acc;

package/dist/src/wgsl/bc-edge-gather.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"bc-edge-gather.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-edge-gather.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwB1C,CAAC"}
+{"version":3,"file":"bc-edge-gather.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-edge-gather.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B1C,CAAC"}

package/dist/src/wgsl/bc-finalize.wgsl.d.ts

@@ -5,8 +5,9 @@
  * entries at depth `L` are `S[ends[L] .. ends[L + 1])`. That log is Brandes' stack, so the backward pass walks the
  * same ranges from the deepest level up and nothing is ever copied between levels.
  *
- * Role 1 seeds the batch: the k seed entries the host wrote into `S[0 .. k)` get depth 0 and one shortest path,
- * `ends[0] = 0`, the append cursor `stackTop` (counters word 26) starts at k, the overflow flag (word 27) is cleared,
+ * Role 1 seeds the batch: the k seed entries the host wrote into `S[0 .. k)` get depth 0 and one shortest path (the
+ * u32 1, or under `SCALED` the bits of the f32 1.0), `levelMax[0]` the bits of 1.0 (the largest count at depth 0,
+ * which `bc-count` scales depth 1 from), `ends[0] = 0`, the append cursor `stackTop` (counters word 26) starts at k, the overflow flag (word 27) is cleared,
  * `level` (word 11) is U32_MAX so the first boundary lands on 0, and `done` (word 15) is cleared.
  *
  * Role 0 is the level boundary, recorded before every forward level: it advances `level`, closes the level just
@@ -17,5 +18,5 @@
  * early return of the others (spec 3.5 rule 1). Body only; the sabotage rows of test/helpers/sabotage.ts are
  * textual edits of it.
  */
-export declare const bcFinalizeWgsl = "\n@compute @workgroup_size(WG)\nfn bc_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)\n    if (P.role == 1u) {                                              // the seed of a batch\n        for (var i = 0u; i < P.k; i = i + 1u) {\n            let t = S[i];\n            depthK[t] = 0u;                                          // the source is at depth 0\n            sigmaK[t] = 1u;                                          // with one shortest path, itself\n        }\n        ends[0] = 0u;\n        atomicStore(&counters[26], P.k);                             // stackTop: the seeds are the log's first k entries\n        atomicStore(&counters[27], 0u);                              // sigmaOverflow\n        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0\n        atomicStore(&counters[15], 0u);                              // done\n        return;\n    }\n    if (atomicLoad(&counters[15]) != 0u) { return; }                 // done: a no-op level the host recorded past the end\n    let level = atomicLoad(&counters[11]) + 1u;\n    let top = atomicLoad(&counters[26]);\n    ends[level + 1u] = top;                                          // the level's entries end where the log ends now\n    let count = top - ends[level];\n    atomicStore(&counters[0], count);                                // frontierCount (the inspect seam reads it)\n    atomicStore(&counters[11], level);\n    atomicStore(&counters[15], select(0u, 1u, count == 0u));         // an empty level ends the batch\n}\n";
+export declare const bcFinalizeWgsl = "\n@compute @workgroup_size(WG)\nfn bc_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)\n    if (P.role == 1u) {                                              // the seed of a batch\n        for (var i = 0u; i < P.k; i = i + 1u) {\n            let t = S[i];\n            depthK[t] = 0u;                                          // the source is at depth 0\n            sigmaK[t] = select(1u, bitcast<u32>(1.0), SCALED);       // with one shortest path, itself (f32 bits when SCALED)\n        }\n        levelMax[0] = bitcast<u32>(1.0);                             // the largest count at depth 0\n        ends[0] = 0u;\n        atomicStore(&counters[26], P.k);                             // stackTop: the seeds are the log's first k entries\n        atomicStore(&counters[27], 0u);                              // sigmaOverflow\n        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0\n        atomicStore(&counters[15], 0u);                              // done\n        return;\n    }\n    if (atomicLoad(&counters[15]) != 0u) { return; }                 // done: a no-op level the host recorded past the end\n    let level = atomicLoad(&counters[11]) + 1u;\n    let top = atomicLoad(&counters[26]);\n    ends[level + 1u] = top;                                          // the level's entries end where the log ends now\n    let count = top - ends[level];\n    atomicStore(&counters[0], count);                                // frontierCount (the inspect seam reads it)\n    atomicStore(&counters[11], level);\n    atomicStore(&counters[15], select(0u, 1u, count == 0u));         // an empty level ends the batch\n}\n";
 //# sourceMappingURL=bc-finalize.wgsl.d.ts.map

package/dist/src/wgsl/bc-finalize.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bc-finalize.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,+oDA0B1B,CAAC"}
+{"version":3,"file":"bc-finalize.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,4wDA2B1B,CAAC"}

package/dist/src/wgsl/bc-finalize.wgsl.js

@@ -5,8 +5,9 @@
  * entries at depth `L` are `S[ends[L] .. ends[L + 1])`. That log is Brandes' stack, so the backward pass walks the
  * same ranges from the deepest level up and nothing is ever copied between levels.
  *
- * Role 1 seeds the batch: the k seed entries the host wrote into `S[0 .. k)` get depth 0 and one shortest path,
- * `ends[0] = 0`, the append cursor `stackTop` (counters word 26) starts at k, the overflow flag (word 27) is cleared,
+ * Role 1 seeds the batch: the k seed entries the host wrote into `S[0 .. k)` get depth 0 and one shortest path (the
+ * u32 1, or under `SCALED` the bits of the f32 1.0), `levelMax[0]` the bits of 1.0 (the largest count at depth 0,
+ * which `bc-count` scales depth 1 from), `ends[0] = 0`, the append cursor `stackTop` (counters word 26) starts at k, the overflow flag (word 27) is cleared,
  * `level` (word 11) is U32_MAX so the first boundary lands on 0, and `done` (word 15) is cleared.
  *
  * Role 0 is the level boundary, recorded before every forward level: it advances `level`, closes the level just
@@ -25,8 +26,9 @@ fn bc_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
         for (var i = 0u; i < P.k; i = i + 1u) {
             let t = S[i];
             depthK[t] = 0u;                                          // the source is at depth 0
-            sigmaK[t] = 1u;                                          // with one shortest path, itself
+            sigmaK[t] = select(1u, bitcast<u32>(1.0), SCALED);       // with one shortest path, itself (f32 bits when SCALED)
         }
+        levelMax[0] = bitcast<u32>(1.0);                             // the largest count at depth 0
         ends[0] = 0u;
         atomicStore(&counters[26], P.k);                             // stackTop: the seeds are the log's first k entries
         atomicStore(&counters[27], 0u);                              // sigmaOverflow

package/dist/src/wgsl/bc-finalize.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"bc-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BxC,CAAC"}
+{"version":3,"file":"bc-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BxC,CAAC"}

package/dist/src/wgsl/bc-forward-edge.wgsl.d.ts

@@ -5,11 +5,11 @@
  * and source `s`, when `depth[s][u]` is the level the edge is relaxed toward `x` with EXACTLY the claim and the count
  * of `bc-forward` (the pre-check, `atomicMin`, the winner appends `s * n + x` to the same claim log, every arc on a
  * shortest path adds `sigma[s][u]`, a u32 wrap raises word 27); `UNDIRECTED` relaxes the other direction too, the
- * edge list holding each undirected edge once. So the two forward bodies are interchangeable level by level and the
+ * edge list holding each undirected edge once. Under `SCALED` the count is skipped, as in `bc-forward`. So the two forward bodies are interchangeable level by level and the
  * backward pass cannot tell which ran. A workgroup does nothing when the level is empty (the done boundary). The
  * winners of a strip are packed into the log with one global `atomicAdd` per strip; every barrier is in uniform
  * control flow (the loop bounds are uniforms and the workgroup id). Body only; the sabotage rows of
  * test/helpers/sabotage.ts are textual edits of it.
  */
-export declare const bcForwardEdgeWgsl = "\nvar<workgroup> wlive: u32;                        // 1 when the level has entries\nvar<workgroup> wwon: atomic<u32>;                 // the strip's winners\nvar<workgroup> wbase: u32;                        // where the strip's winners go in the log\n\nfn claim(x: u32, next: u32) -> bool {\n    if (atomicLoad(&depthK[x]) != INVALID_INDEX) { return false; }   // the pre-check of design 16.1\n    return atomicMin(&depthK[x], next) == INVALID_INDEX;\n}\n\nfn count_paths(origin: u32, x: u32, next: u32) {\n    if (atomicLoad(&depthK[x]) == next) {                            // every arc on a shortest path adds\n        let add = atomicLoad(&sigmaK[origin]);\n        let old = atomicAdd(&sigmaK[x], add);\n        if (old + add < old) { atomicOr(&counters[27], 1u); }        // the u32 wrap, reported\n    }\n}\n\n@compute @workgroup_size(WG)\nfn bc_forward_edge(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let level = atomicLoad(&counters[11]);\n    if (lid.x == 0u) { wlive = select(0u, 1u, ends[level + 1u] > ends[level]); }\n    if (workgroupUniformLoad(&wlive) == 0u) { return; }              // uniform: nothing below runs on an empty level\n    let next = level + 1u;\n    for (var s = 0u; s < P.k; s = s + 1u) {\n        let base = s * P.n;\n        for (var e0 = group_id(wid) * WG; e0 < P.count; e0 = e0 + P.stride) {   // grid-stride over the edges\n            let e = e0 + lid.x;\n            var a = INVALID_INDEX;                                   // the claims this lane won\n            var b = INVALID_INDEX;\n            if (e < P.count) {\n                let u = base + edgeSrc[e];\n                let x = base + edgeDst[e];\n                if (atomicLoad(&depthK[u]) == level) {\n                    if (claim(x, next)) { a = x; }\n                    count_paths(u, x, next);\n                }\n                if (UNDIRECTED) {                                    // the other direction of an undirected edge\n                    if (atomicLoad(&depthK[x]) == level) {\n                        if (claim(u, next)) { b = u; }\n                        count_paths(x, u, next);\n                    }\n                }\n            }\n            let mine = select(0u, 1u, a != INVALID_INDEX) + select(0u, 1u, b != INVALID_INDEX);\n            var slot = 0u;\n            if (mine != 0u) { slot = atomicAdd(&wwon, mine); }\n            workgroupBarrier();\n            if (lid.x == 0u) {\n                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip\n                atomicStore(&wwon, 0u);\n            }\n            workgroupBarrier();\n            if (a != INVALID_INDEX) {\n                S[wbase + slot] = a;\n                slot = slot + 1u;\n            }\n            if (b != INVALID_INDEX) { S[wbase + slot] = b; }\n        }\n    }\n}\n";
+export declare const bcForwardEdgeWgsl = "\nvar<workgroup> wlive: u32;                        // 1 when the level has entries\nvar<workgroup> wwon: atomic<u32>;                 // the strip's winners\nvar<workgroup> wbase: u32;                        // where the strip's winners go in the log\n\nfn claim(x: u32, next: u32) -> bool {\n    if (atomicLoad(&depthK[x]) != INVALID_INDEX) { return false; }   // the pre-check of design 16.1\n    return atomicMin(&depthK[x], next) == INVALID_INDEX;\n}\n\nfn count_paths(origin: u32, x: u32, next: u32) {\n    if (!SCALED && atomicLoad(&depthK[x]) == next) {                 // every arc on a shortest path adds\n        let add = atomicLoad(&sigmaK[origin]);\n        let old = atomicAdd(&sigmaK[x], add);\n        if (old + add < old) { atomicOr(&counters[27], 1u); }        // the u32 wrap, reported\n    }\n}\n\n@compute @workgroup_size(WG)\nfn bc_forward_edge(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let level = atomicLoad(&counters[11]);\n    if (lid.x == 0u) { wlive = select(0u, 1u, ends[level + 1u] > ends[level]); }\n    if (workgroupUniformLoad(&wlive) == 0u) { return; }              // uniform: nothing below runs on an empty level\n    let next = level + 1u;\n    for (var s = 0u; s < P.k; s = s + 1u) {\n        let base = s * P.n;\n        for (var e0 = group_id(wid) * WG; e0 < P.count; e0 = e0 + P.stride) {   // grid-stride over the edges\n            let e = e0 + lid.x;\n            var a = INVALID_INDEX;                                   // the claims this lane won\n            var b = INVALID_INDEX;\n            if (e < P.count) {\n                let u = base + edgeSrc[e];\n                let x = base + edgeDst[e];\n                if (atomicLoad(&depthK[u]) == level) {\n                    if (claim(x, next)) { a = x; }\n                    count_paths(u, x, next);\n                }\n                if (UNDIRECTED) {                                    // the other direction of an undirected edge\n                    if (atomicLoad(&depthK[x]) == level) {\n                        if (claim(u, next)) { b = u; }\n                        count_paths(x, u, next);\n                    }\n                }\n            }\n            let mine = select(0u, 1u, a != INVALID_INDEX) + select(0u, 1u, b != INVALID_INDEX);\n            var slot = 0u;\n            if (mine != 0u) { slot = atomicAdd(&wwon, mine); }\n            workgroupBarrier();\n            if (lid.x == 0u) {\n                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip\n                atomicStore(&wwon, 0u);\n            }\n            workgroupBarrier();\n            if (a != INVALID_INDEX) {\n                S[wbase + slot] = a;\n                slot = slot + 1u;\n            }\n            if (b != INVALID_INDEX) { S[wbase + slot] = b; }\n        }\n    }\n}\n";
 //# sourceMappingURL=bc-forward-edge.wgsl.d.ts.map

package/dist/src/wgsl/bc-forward-edge.wgsl.js

@@ -5,7 +5,7 @@
  * and source `s`, when `depth[s][u]` is the level the edge is relaxed toward `x` with EXACTLY the claim and the count
  * of `bc-forward` (the pre-check, `atomicMin`, the winner appends `s * n + x` to the same claim log, every arc on a
  * shortest path adds `sigma[s][u]`, a u32 wrap raises word 27); `UNDIRECTED` relaxes the other direction too, the
- * edge list holding each undirected edge once. So the two forward bodies are interchangeable level by level and the
+ * edge list holding each undirected edge once. Under `SCALED` the count is skipped, as in `bc-forward`. So the two forward bodies are interchangeable level by level and the
  * backward pass cannot tell which ran. A workgroup does nothing when the level is empty (the done boundary). The
  * winners of a strip are packed into the log with one global `atomicAdd` per strip; every barrier is in uniform
  * control flow (the loop bounds are uniforms and the workgroup id). Body only; the sabotage rows of
@@ -22,7 +22,7 @@ fn claim(x: u32, next: u32) -> bool {
 }
 
 fn count_paths(origin: u32, x: u32, next: u32) {
-    if (atomicLoad(&depthK[x]) == next) {                            // every arc on a shortest path adds
+    if (!SCALED && atomicLoad(&depthK[x]) == next) {                 // every arc on a shortest path adds
         let add = atomicLoad(&sigmaK[origin]);
         let old = atomicAdd(&sigmaK[x], add);
         if (old + add < old) { atomicOr(&counters[27], 1u); }        // the u32 wrap, reported

package/dist/src/wgsl/bc-forward.wgsl.d.ts

@@ -12,12 +12,14 @@
  * observes INVALID_INDEX the unique winner, which appends `t` to the log; and, as a SEPARATE condition, the COUNT:
  * every arc that reaches `t` at `level + 1` adds `sigma[s][u]` into `sigma[s][x]`, winner or not, which is what makes
  * sigma the number of shortest paths rather than of claims. The add detects a u32 wrap from `atomicAdd`'s return
- * value (`old + add < old`) and raises `sigmaOverflow` (counters word 27); the count is never clamped. The winners of
+ * value (`old + add < old`) and raises `sigmaOverflow` (counters word 27); the count is never clamped. Under
+ * `SCALED` (a batch rerun because the u32 counts wrapped) the count is skipped and `bc-count` pulls rescaled f32
+ * counts after the level instead. The winners of
  * a strip are packed into the log with one workgroup-memory counter and ONE global `atomicAdd` on `stackTop` (word
  * 26) per strip. Uniformity (spec 3.5 rule 1): the range and the aggregate are `workgroupUniformLoad`s and the strip
  * loop steps a uniform `p0`, so every barrier is in uniform control flow. The order of the log inside a level is
  * not deterministic; nothing downstream depends on it (the counts are integers and every dependency is written by
  * index). Body only; the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
  */
-export declare const bcForwardWgsl = "\nvar<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan\nvar<workgroup> rowStart: array<u32, WG>;          // the first arc of each entry's row\nvar<workgroup> entryOf: array<u32, WG>;           // each entry, s * n + u\nvar<workgroup> wstart: u32;                       // the level's first log index\nvar<workgroup> wcount: u32;                       // the level's entry count\nvar<workgroup> wwon: atomic<u32>;                 // the strip's winners\nvar<workgroup> wbase: u32;                        // where the strip's winners go in the log\n\n@compute @workgroup_size(WG)\nfn bc_forward(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let level = atomicLoad(&counters[11]);\n    if (lid.x == 0u) {\n        let lo = ends[level];\n        wstart = lo;\n        wcount = ends[level + 1u] - lo;\n    }\n    let start = workgroupUniformLoad(&wstart);\n    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers\n    let next = level + 1u;\n    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries\n        let i = b0 + lid.x;\n        var deg = 0u;\n        var first = 0u;\n        var entry = 0u;\n        if (i < count) {                                             // guarded loads into locals (3.5 rule 1)\n            entry = S[start + i];\n            let u = entry % P.n;\n            first = rowPtr[u];\n            deg = rowPtr[u + 1u] - first;\n        }\n        sh[lid.x] = deg;\n        rowStart[lid.x] = first;\n        entryOf[lid.x] = entry;\n        workgroupBarrier();\n        for (var s = 1u; s < WG; s = s * 2u) {                       // Hillis-Steele inclusive scan of the degrees\n            var t = 0u;\n            if (lid.x >= s) { t = sh[lid.x - s]; }\n            workgroupBarrier();\n            sh[lid.x] = sh[lid.x] + t;\n            workgroupBarrier();\n        }\n        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);          // uniform; includes a barrier\n        for (var p0 = 0u; p0 < aggregate; p0 = p0 + WG) {            // strip [0, aggregate) WG arcs at a time\n            let p = p0 + lid.x;\n            var won = false;\n            var claimed = 0u;\n            if (p < aggregate) {\n                var lo = 0u;                                         // upper_bound: the first k with sh[k] > p owns arc p\n                var hi = WG;\n                loop {\n                    if (lo >= hi) { break; }\n                    let mid = (lo + hi) / 2u;\n                    if (sh[mid] > p) { hi = mid; } else { lo = mid + 1u; }\n                }\n                let k = lo;\n                var exclusive = 0u;\n                if (k > 0u) { exclusive = sh[k - 1u]; }\n                let origin = entryOf[k];                             // s * n + u\n                let x = (origin - (origin % P.n)) + colIdx[rowStart[k] + (p - exclusive)];   // s * n + x\n                if (atomicLoad(&depthK[x]) == INVALID_INDEX) {       // the pre-check of design 16.1\n                    won = atomicMin(&depthK[x], next) == INVALID_INDEX;   // the claim: the one winner appends\n                }\n                if (atomicLoad(&depthK[x]) == next) {                // the count: EVERY arc on a shortest path adds\n                    let add = atomicLoad(&sigmaK[origin]);\n                    let old = atomicAdd(&sigmaK[x], add);\n                    if (old + add < old) { atomicOr(&counters[27], 1u); }   // the u32 wrap, reported\n                }\n                claimed = x;\n            }\n            var slot = 0u;\n            if (won) { slot = atomicAdd(&wwon, 1u); }\n            workgroupBarrier();\n            if (lid.x == 0u) {\n                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip\n                atomicStore(&wwon, 0u);\n            }\n            workgroupBarrier();\n            if (won) { S[wbase + slot] = claimed; }\n        }\n        workgroupBarrier();                                          // sh, rowStart and entryOf are reused by the next block\n    }\n}\n";
+export declare const bcForwardWgsl = "\nvar<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan\nvar<workgroup> rowStart: array<u32, WG>;          // the first arc of each entry's row\nvar<workgroup> entryOf: array<u32, WG>;           // each entry, s * n + u\nvar<workgroup> wstart: u32;                       // the level's first log index\nvar<workgroup> wcount: u32;                       // the level's entry count\nvar<workgroup> wwon: atomic<u32>;                 // the strip's winners\nvar<workgroup> wbase: u32;                        // where the strip's winners go in the log\n\n@compute @workgroup_size(WG)\nfn bc_forward(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let level = atomicLoad(&counters[11]);\n    if (lid.x == 0u) {\n        let lo = ends[level];\n        wstart = lo;\n        wcount = ends[level + 1u] - lo;\n    }\n    let start = workgroupUniformLoad(&wstart);\n    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers\n    let next = level + 1u;\n    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries\n        let i = b0 + lid.x;\n        var deg = 0u;\n        var first = 0u;\n        var entry = 0u;\n        if (i < count) {                                             // guarded loads into locals (3.5 rule 1)\n            entry = S[start + i];\n            let u = entry % P.n;\n            first = rowPtr[u];\n            deg = rowPtr[u + 1u] - first;\n        }\n        sh[lid.x] = deg;\n        rowStart[lid.x] = first;\n        entryOf[lid.x] = entry;\n        workgroupBarrier();\n        for (var s = 1u; s < WG; s = s * 2u) {                       // Hillis-Steele inclusive scan of the degrees\n            var t = 0u;\n            if (lid.x >= s) { t = sh[lid.x - s]; }\n            workgroupBarrier();\n            sh[lid.x] = sh[lid.x] + t;\n            workgroupBarrier();\n        }\n        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);          // uniform; includes a barrier\n        for (var p0 = 0u; p0 < aggregate; p0 = p0 + WG) {            // strip [0, aggregate) WG arcs at a time\n            let p = p0 + lid.x;\n            var won = false;\n            var claimed = 0u;\n            if (p < aggregate) {\n                var lo = 0u;                                         // upper_bound: the first k with sh[k] > p owns arc p\n                var hi = WG;\n                loop {\n                    if (lo >= hi) { break; }\n                    let mid = (lo + hi) / 2u;\n                    if (sh[mid] > p) { hi = mid; } else { lo = mid + 1u; }\n                }\n                let k = lo;\n                var exclusive = 0u;\n                if (k > 0u) { exclusive = sh[k - 1u]; }\n                let origin = entryOf[k];                             // s * n + u\n                let x = (origin - (origin % P.n)) + colIdx[rowStart[k] + (p - exclusive)];   // s * n + x\n                if (atomicLoad(&depthK[x]) == INVALID_INDEX) {       // the pre-check of design 16.1\n                    won = atomicMin(&depthK[x], next) == INVALID_INDEX;   // the claim: the one winner appends\n                }\n                if (!SCALED && atomicLoad(&depthK[x]) == next) {     // the count: EVERY arc on a shortest path adds\n                    let add = atomicLoad(&sigmaK[origin]);\n                    let old = atomicAdd(&sigmaK[x], add);\n                    if (old + add < old) { atomicOr(&counters[27], 1u); }   // the u32 wrap, reported\n                }\n                claimed = x;\n            }\n            var slot = 0u;\n            if (won) { slot = atomicAdd(&wwon, 1u); }\n            workgroupBarrier();\n            if (lid.x == 0u) {\n                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip\n                atomicStore(&wwon, 0u);\n            }\n            workgroupBarrier();\n            if (won) { S[wbase + slot] = claimed; }\n        }\n        workgroupBarrier();                                          // sh, rowStart and entryOf are reused by the next block\n    }\n}\n";
 //# sourceMappingURL=bc-forward.wgsl.d.ts.map

package/dist/src/wgsl/bc-forward.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bc-forward.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-forward.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,+nIAmFzB,CAAC"}
+{"version":3,"file":"bc-forward.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-forward.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,aAAa,+nIAmFzB,CAAC"}

package/dist/src/wgsl/bc-forward.wgsl.js

@@ -12,7 +12,9 @@
  * observes INVALID_INDEX the unique winner, which appends `t` to the log; and, as a SEPARATE condition, the COUNT:
  * every arc that reaches `t` at `level + 1` adds `sigma[s][u]` into `sigma[s][x]`, winner or not, which is what makes
  * sigma the number of shortest paths rather than of claims. The add detects a u32 wrap from `atomicAdd`'s return
- * value (`old + add < old`) and raises `sigmaOverflow` (counters word 27); the count is never clamped. The winners of
+ * value (`old + add < old`) and raises `sigmaOverflow` (counters word 27); the count is never clamped. Under
+ * `SCALED` (a batch rerun because the u32 counts wrapped) the count is skipped and `bc-count` pulls rescaled f32
+ * counts after the level instead. The winners of
  * a strip are packed into the log with one workgroup-memory counter and ONE global `atomicAdd` on `stackTop` (word
  * 26) per strip. Uniformity (spec 3.5 rule 1): the range and the aggregate are `workgroupUniformLoad`s and the strip
  * loop steps a uniform `p0`, so every barrier is in uniform control flow. The order of the log inside a level is
@@ -82,7 +84,7 @@ fn bc_forward(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_i
                 if (atomicLoad(&depthK[x]) == INVALID_INDEX) {       // the pre-check of design 16.1
                     won = atomicMin(&depthK[x], next) == INVALID_INDEX;   // the claim: the one winner appends
                 }
-                if (atomicLoad(&depthK[x]) == next) {                // the count: EVERY arc on a shortest path adds
+                if (!SCALED && atomicLoad(&depthK[x]) == next) {     // the count: EVERY arc on a shortest path adds
                     let add = atomicLoad(&sigmaK[origin]);
                     let old = atomicAdd(&sigmaK[x], add);
                     if (old + add < old) { atomicOr(&counters[27], 1u); }   // the u32 wrap, reported

package/dist/src/wgsl/bc-forward.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"bc-forward.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-forward.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFvC,CAAC"}
+{"version":3,"file":"bc-forward.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-forward.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFvC,CAAC"}