@graphty/webgpu-graph-algorithms 0.6.26 → 0.6.28

package/dist/src/wgsl/closeness-reduce.wgsl.d.ts

@@ -1,20 +0,0 @@
-/**
- * The `closeness-reduce` kernel body (design 8.4, 9.7 "integer distances before division"; P8-T11, the P8 plan's
- * PD-13): the one-lane bookkeeping of the bit-parallel sweep, two roles by `P.role`. Role 0 is the level boundary,
- * recorded BEFORE the level's `compact` and sweep: `done` is whether the previous level's compacted count is 0 (so the
- * traversal ends one level after the last claim, one empty sweep and no wrong sum), then for every source `s` the
- * claims the level just run made (`newCount[s]`) are folded into `reached[s]` and into the 64-bit `sum[s]` at the
- * distance `level + 1` -- the product as a 16-bit split into a low and a high word, then the add with its carry --
- * `newCount[s]` is zeroed and `level` advances. Role 1 is the seed of a batch: for the batch's `k = min(32, n -
- * P.source)` sources, bit `s` into `visited[source_s]` and into the frontier region level 0 reads (region 1, since
- * level 0's parity is 0), `flags[source_s] = 1` (level 0's `compact` turns the flags into the list; a seeded list
- * would be overwritten by a compaction of all-zero flags), `counters[0] = k` (not done) and `level = U32_MAX` (so
- * level 0's boundary accumulates nothing and brings the word to 0, and level 1's counts the distance-1 claims at 1).
- * Role 2 is role 1 for a sampled run: source `s` of the batch is word `P.source + s` of the source list the host
- * wrote after the per-node sums (`perSource[128 + P.bitsBase + ...]`), `P.n` is the list's length, and a node listed
- * twice in one batch carries both bits (the seed ORs, so a duplicate runs twice).
- * No barrier follows the early return of the other lanes (3.5 rule 1). Body only (spec 3.5, D9); the text is
- * normative: the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
- */
-export declare const closenessReduceWgsl = "\n@compute @workgroup_size(WG)\nfn closeness_reduce(@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 != 0u) {                                              // the seed of a batch: P.source is its first source\n        let k = min(32u, P.n - P.source);\n        for (var s = 0u; s < k; s = s + 1u) {\n            var v = P.source + s;\n            if (P.role == 2u) { v = atomicLoad(&perSource[128u + P.bitsBase + P.source + s]); }   // a sampled run's list\n            let bit = 1u << s;\n            bits[v] = bits[v] | bit;                                 // visited\n            bits[P.bitsBase + v] = bits[P.bitsBase + v] | bit;       // the frontier level 0 reads (region 1: level 0's parity is 0)\n            bits[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list\n        }\n        atomicStore(&counters[0], k);                                // not done\n        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0\n        atomicStore(&counters[15], 0u);                              // done\n        return;\n    }\n    // role 0: the level boundary -- done from the previous level's compacted count, then the accumulation\n    let count = atomicLoad(&counters[0]);\n    atomicStore(&counters[15], select(0u, 1u, count == 0u));\n    let level = atomicLoad(&counters[11]);\n    let d = level + 1u;                                              // the distance of the claims the level just run made\n    for (var s = 0u; s < 32u; s = s + 1u) {\n        let c = atomicLoad(&perSource[s]);                           // newCount[s]\n        atomicStore(&perSource[32u + s], atomicLoad(&perSource[32u + s]) + c);   // reached[s]\n        // sum[s] += c x d in 64 bits: the 16-bit split product (pLo, pHi), then the add with its carry\n        let cLo = c & 0xFFFFu;\n        let cHi = c >> 16u;\n        let dLo = d & 0xFFFFu;\n        let dHi = d >> 16u;\n        let ll = cLo * dLo;\n        let lh = cLo * dHi;\n        let hl = cHi * dLo;\n        let mid = (ll >> 16u) + (lh & 0xFFFFu) + (hl & 0xFFFFu);\n        let pLo = (ll & 0xFFFFu) | ((mid & 0xFFFFu) << 16u);\n        let pHi = (cHi * dHi) + (lh >> 16u) + (hl >> 16u) + (mid >> 16u);\n        var lo = atomicLoad(&perSource[64u + s]);                    // sumLo[s]\n        var hi = atomicLoad(&perSource[96u + s]);                    // sumHi[s]\n        let before = lo;\n        lo = lo + pLo;\n        hi = hi + pHi + select(0u, 1u, lo < before);\n        atomicStore(&perSource[64u + s], lo);\n        atomicStore(&perSource[96u + s], hi);\n        atomicStore(&perSource[s], 0u);\n    }\n    atomicStore(&counters[11], level + 1u);\n}\n";
-//# sourceMappingURL=closeness-reduce.wgsl.d.ts.map

package/dist/src/wgsl/closeness-reduce.wgsl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"closeness-reduce.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/closeness-reduce.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,qyFAiD/B,CAAC"}

package/dist/src/wgsl/closeness-reduce.wgsl.js

@@ -1,69 +0,0 @@
-/**
- * The `closeness-reduce` kernel body (design 8.4, 9.7 "integer distances before division"; P8-T11, the P8 plan's
- * PD-13): the one-lane bookkeeping of the bit-parallel sweep, two roles by `P.role`. Role 0 is the level boundary,
- * recorded BEFORE the level's `compact` and sweep: `done` is whether the previous level's compacted count is 0 (so the
- * traversal ends one level after the last claim, one empty sweep and no wrong sum), then for every source `s` the
- * claims the level just run made (`newCount[s]`) are folded into `reached[s]` and into the 64-bit `sum[s]` at the
- * distance `level + 1` -- the product as a 16-bit split into a low and a high word, then the add with its carry --
- * `newCount[s]` is zeroed and `level` advances. Role 1 is the seed of a batch: for the batch's `k = min(32, n -
- * P.source)` sources, bit `s` into `visited[source_s]` and into the frontier region level 0 reads (region 1, since
- * level 0's parity is 0), `flags[source_s] = 1` (level 0's `compact` turns the flags into the list; a seeded list
- * would be overwritten by a compaction of all-zero flags), `counters[0] = k` (not done) and `level = U32_MAX` (so
- * level 0's boundary accumulates nothing and brings the word to 0, and level 1's counts the distance-1 claims at 1).
- * Role 2 is role 1 for a sampled run: source `s` of the batch is word `P.source + s` of the source list the host
- * wrote after the per-node sums (`perSource[128 + P.bitsBase + ...]`), `P.n` is the list's length, and a node listed
- * twice in one batch carries both bits (the seed ORs, so a duplicate runs twice).
- * No barrier follows the early return of the other lanes (3.5 rule 1). Body only (spec 3.5, D9); the text is
- * normative: the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
- */
-export const closenessReduceWgsl = /* wgsl */ `
-@compute @workgroup_size(WG)
-fn closeness_reduce(@builtin(local_invocation_id) lid: vec3<u32>) {
-    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)
-    if (P.role != 0u) {                                              // the seed of a batch: P.source is its first source
-        let k = min(32u, P.n - P.source);
-        for (var s = 0u; s < k; s = s + 1u) {
-            var v = P.source + s;
-            if (P.role == 2u) { v = atomicLoad(&perSource[128u + P.bitsBase + P.source + s]); }   // a sampled run's list
-            let bit = 1u << s;
-            bits[v] = bits[v] | bit;                                 // visited
-            bits[P.bitsBase + v] = bits[P.bitsBase + v] | bit;       // the frontier level 0 reads (region 1: level 0's parity is 0)
-            bits[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list
-        }
-        atomicStore(&counters[0], k);                                // not done
-        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0
-        atomicStore(&counters[15], 0u);                              // done
-        return;
-    }
-    // role 0: the level boundary -- done from the previous level's compacted count, then the accumulation
-    let count = atomicLoad(&counters[0]);
-    atomicStore(&counters[15], select(0u, 1u, count == 0u));
-    let level = atomicLoad(&counters[11]);
-    let d = level + 1u;                                              // the distance of the claims the level just run made
-    for (var s = 0u; s < 32u; s = s + 1u) {
-        let c = atomicLoad(&perSource[s]);                           // newCount[s]
-        atomicStore(&perSource[32u + s], atomicLoad(&perSource[32u + s]) + c);   // reached[s]
-        // sum[s] += c x d in 64 bits: the 16-bit split product (pLo, pHi), then the add with its carry
-        let cLo = c & 0xFFFFu;
-        let cHi = c >> 16u;
-        let dLo = d & 0xFFFFu;
-        let dHi = d >> 16u;
-        let ll = cLo * dLo;
-        let lh = cLo * dHi;
-        let hl = cHi * dLo;
-        let mid = (ll >> 16u) + (lh & 0xFFFFu) + (hl & 0xFFFFu);
-        let pLo = (ll & 0xFFFFu) | ((mid & 0xFFFFu) << 16u);
-        let pHi = (cHi * dHi) + (lh >> 16u) + (hl >> 16u) + (mid >> 16u);
-        var lo = atomicLoad(&perSource[64u + s]);                    // sumLo[s]
-        var hi = atomicLoad(&perSource[96u + s]);                    // sumHi[s]
-        let before = lo;
-        lo = lo + pLo;
-        hi = hi + pHi + select(0u, 1u, lo < before);
-        atomicStore(&perSource[64u + s], lo);
-        atomicStore(&perSource[96u + s], hi);
-        atomicStore(&perSource[s], 0u);
-    }
-    atomicStore(&counters[11], level + 1u);
-}
-`;
-//# sourceMappingURL=closeness-reduce.wgsl.js.map

package/dist/src/wgsl/closeness-reduce.wgsl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"closeness-reduce.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/closeness-reduce.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiD7C,CAAC"}

package/dist/src/wgsl/closeness-sweep.wgsl.d.ts

@@ -1,22 +0,0 @@
-/**
- * The `closeness-sweep` kernel body (design 8.4 "32 sources per u32 word"; P8-T11, the P8 plan's PD-13 / DEP-P8-E):
- * one level of the bit-parallel multi-source breadth-first search. The batch's state is one `bits` buffer of four
- * regions of `P.bitsBase` words each -- `visited` at 0, the two frontier regions at `P.bitsBase` and `2 x P.bitsBase`
- * (which one is the frontier and which the next swaps by the level's parity, `P.mode`, so nothing is copied between
- * levels), `flags` at `3 x P.bitsBase` -- with bit `s` of word `v` meaning "source `s` has reached / is at / is next
- * at `v`". The expansion is `advance-expand`'s block-mapped strip (P8-T5): each workgroup loads up to `WG` entries of
- * the frontier LIST (the vertices any source is at, compacted from the flags by the host's `compact`), scans their
- * degrees with the inlined Hillis-Steele scan of `bfs-contract` (this is not a twin kernel: `needs: []`), and every
- * invocation strips the aggregate by binary search. The claim is inline: for the arc `(u, x)` the mask is the sources
- * at `u` that have not reached `x`; `atomicOr` on `visited[x]` returns the bits this lane won (`fresh`), which go into
- * the next region, set `flags[x]` (the flags region is part of the one atomic binding, so a plain store is a compile
- * error), and are tallied per source in WORKGROUP memory -- one global `atomicAdd` per source per workgroup after the
- * strip loop, never one per arc. Uniformity (spec 3.5 rule 1): the guarded loads write locals, the scan and the
- * `workgroupUniformLoad` sit unconditionally after the guard, the strip loop is bounded by the uniform aggregate, and
- * the flush's barrier follows it in uniform control flow. A sampled run (`P.perNode == 1`) also adds each claim's
- * distance (`level + 1`, one per won bit) into the per-node sum of `x`, `perSource[128 + x]`: the distance from each
- * of the batch's sources TO `x`, which is what a node's sampled closeness sums on an undirected graph. Body only (spec 3.5, D9); the text is normative: the
- * sabotage rows of test/helpers/sabotage.ts are textual edits of it.
- */
-export declare const closenessSweepWgsl = "\nvar<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan\nvar<workgroup> rowStart: array<u32, WG>;          // the first bound arc of each entry's row\nvar<workgroup> rowOf: array<u32, WG>;             // the frontier vertex of each entry (the source end of its arcs)\nvar<workgroup> local: array<atomic<u32>, 32>;     // this workgroup's fresh claims per source\nvar<workgroup> wcount: u32;                       // the frontier list's length\nvar<workgroup> wdist: u32;                        // the distance of this level's claims\n\n@compute @workgroup_size(WG)\nfn closeness_sweep(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x == 0u) {\n        wcount = atomicLoad(&counters[0]);                           // the frontier list's length (compact's total)\n        wdist = atomicLoad(&counters[11]) + 1u;                      // the level word: this level claims at level + 1\n    }\n    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers\n    let dist = workgroupUniformLoad(&wdist);\n    let nextBase = select(2u * P.bitsBase, P.bitsBase, P.mode == 1u);   // the region that is next this level\n    let frontierBase = 3u * P.bitsBase - nextBase;                   // the other one: the region that is the frontier\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;                                          // this lane's frontier entry\n        var deg = 0u;\n        var start = 0u;\n        var u = 0u;\n        if (i < count) {                                                 // guarded loads into locals (3.5 rule 1)\n            u = frontierList[i];\n            let lo = max(rowPtr[u], P.arcBase);\n            let hi = min(rowPtr[u + 1u], P.arcEnd);\n            start = lo;\n            deg = select(0u, hi - lo, hi > lo);\n        }\n        if (lid.x < 32u) { atomicStore(&local[lid.x], 0u); }            // zeroed before the strip loop (WebGPU zero-initialises workgroup memory; said anyway)\n        sh[lid.x] = deg;\n        rowStart[lid.x] = start;\n        rowOf[lid.x] = u;\n        workgroupBarrier();\n        for (var s = 1u; s < WG; s = s * 2u) {                           // Hillis-Steele inclusive scan of the degrees (bfs-contract's, inlined)\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 p = lid.x; p < aggregate; p = p + WG) {                 // strip [0, aggregate): lane j takes j, j + WG, ...\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 arc = rowStart[k] + (p - exclusive);\n            let x = colIdx[arc - P.arcBase];\n            let mask = atomicLoad(&bits[frontierBase + rowOf[k]]) & ~atomicLoad(&bits[x]);   // the sources at u that have not reached x\n            if (mask != 0u) {\n                let old = atomicOr(&bits[x], mask);                      // visited: the claim, one read-modify-write\n                let fresh = mask & ~old;                                 // the sources whose claim this lane won\n                if (fresh != 0u) {\n                    atomicOr(&bits[nextBase + x], fresh);\n                    atomicStore(&bits[3u * P.bitsBase + x], 1u);         // flags: x is in the next frontier list (compact reads it)\n                    if (P.perNode == 1u) {                               // a sampled run: x's distance to each source won\n                        atomicAdd(&perSource[128u + x], countOneBits(fresh) * dist);\n                    }\n                    var b = fresh;\n                    loop {                                               // one tally per set bit of fresh\n                        if (b == 0u) { break; }\n                        let s = firstTrailingBit(b);\n                        atomicAdd(&local[s], 1u);\n                        b = b & (b - 1u);\n                    }\n                }\n            }\n        }\n        workgroupBarrier();                                              // uniform: the loop's bound is the uniform aggregate\n        if (lid.x < 32u) {                                               // ONE global atomic per source per workgroup\n            let c = atomicLoad(&local[lid.x]);\n            if (c != 0u) { atomicAdd(&perSource[lid.x], c); }            // newCount[s]\n        }\n        workgroupBarrier();                                              // sh, rowStart, rowOf and local are reused by the next block\n    }\n}\n";
-//# sourceMappingURL=closeness-sweep.wgsl.d.ts.map

package/dist/src/wgsl/closeness-sweep.wgsl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"closeness-sweep.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/closeness-sweep.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kBAAkB,inKAoF9B,CAAC"}

package/dist/src/wgsl/closeness-sweep.wgsl.js

@@ -1,106 +0,0 @@
-/**
- * The `closeness-sweep` kernel body (design 8.4 "32 sources per u32 word"; P8-T11, the P8 plan's PD-13 / DEP-P8-E):
- * one level of the bit-parallel multi-source breadth-first search. The batch's state is one `bits` buffer of four
- * regions of `P.bitsBase` words each -- `visited` at 0, the two frontier regions at `P.bitsBase` and `2 x P.bitsBase`
- * (which one is the frontier and which the next swaps by the level's parity, `P.mode`, so nothing is copied between
- * levels), `flags` at `3 x P.bitsBase` -- with bit `s` of word `v` meaning "source `s` has reached / is at / is next
- * at `v`". The expansion is `advance-expand`'s block-mapped strip (P8-T5): each workgroup loads up to `WG` entries of
- * the frontier LIST (the vertices any source is at, compacted from the flags by the host's `compact`), scans their
- * degrees with the inlined Hillis-Steele scan of `bfs-contract` (this is not a twin kernel: `needs: []`), and every
- * invocation strips the aggregate by binary search. The claim is inline: for the arc `(u, x)` the mask is the sources
- * at `u` that have not reached `x`; `atomicOr` on `visited[x]` returns the bits this lane won (`fresh`), which go into
- * the next region, set `flags[x]` (the flags region is part of the one atomic binding, so a plain store is a compile
- * error), and are tallied per source in WORKGROUP memory -- one global `atomicAdd` per source per workgroup after the
- * strip loop, never one per arc. Uniformity (spec 3.5 rule 1): the guarded loads write locals, the scan and the
- * `workgroupUniformLoad` sit unconditionally after the guard, the strip loop is bounded by the uniform aggregate, and
- * the flush's barrier follows it in uniform control flow. A sampled run (`P.perNode == 1`) also adds each claim's
- * distance (`level + 1`, one per won bit) into the per-node sum of `x`, `perSource[128 + x]`: the distance from each
- * of the batch's sources TO `x`, which is what a node's sampled closeness sums on an undirected graph. Body only (spec 3.5, D9); the text is normative: the
- * sabotage rows of test/helpers/sabotage.ts are textual edits of it.
- */
-export const closenessSweepWgsl = /* wgsl */ `
-var<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan
-var<workgroup> rowStart: array<u32, WG>;          // the first bound arc of each entry's row
-var<workgroup> rowOf: array<u32, WG>;             // the frontier vertex of each entry (the source end of its arcs)
-var<workgroup> local: array<atomic<u32>, 32>;     // this workgroup's fresh claims per source
-var<workgroup> wcount: u32;                       // the frontier list's length
-var<workgroup> wdist: u32;                        // the distance of this level's claims
-
-@compute @workgroup_size(WG)
-fn closeness_sweep(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
-    if (lid.x == 0u) {
-        wcount = atomicLoad(&counters[0]);                           // the frontier list's length (compact's total)
-        wdist = atomicLoad(&counters[11]) + 1u;                      // the level word: this level claims at level + 1
-    }
-    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers
-    let dist = workgroupUniformLoad(&wdist);
-    let nextBase = select(2u * P.bitsBase, P.bitsBase, P.mode == 1u);   // the region that is next this level
-    let frontierBase = 3u * P.bitsBase - nextBase;                   // the other one: the region that is the frontier
-    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries
-        let i = b0 + lid.x;                                          // this lane's frontier entry
-        var deg = 0u;
-        var start = 0u;
-        var u = 0u;
-        if (i < count) {                                                 // guarded loads into locals (3.5 rule 1)
-            u = frontierList[i];
-            let lo = max(rowPtr[u], P.arcBase);
-            let hi = min(rowPtr[u + 1u], P.arcEnd);
-            start = lo;
-            deg = select(0u, hi - lo, hi > lo);
-        }
-        if (lid.x < 32u) { atomicStore(&local[lid.x], 0u); }            // zeroed before the strip loop (WebGPU zero-initialises workgroup memory; said anyway)
-        sh[lid.x] = deg;
-        rowStart[lid.x] = start;
-        rowOf[lid.x] = u;
-        workgroupBarrier();
-        for (var s = 1u; s < WG; s = s * 2u) {                           // Hillis-Steele inclusive scan of the degrees (bfs-contract's, inlined)
-            var t = 0u;
-            if (lid.x >= s) { t = sh[lid.x - s]; }
-            workgroupBarrier();
-            sh[lid.x] = sh[lid.x] + t;
-            workgroupBarrier();
-        }
-        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);              // uniform; includes a barrier
-        for (var p = lid.x; p < aggregate; p = p + WG) {                 // strip [0, aggregate): lane j takes j, j + WG, ...
-            var lo = 0u;                                                 // upper_bound: the first k with sh[k] > p owns arc p
-            var hi = WG;
-            loop {
-                if (lo >= hi) { break; }
-                let mid = (lo + hi) / 2u;
-                if (sh[mid] > p) { hi = mid; } else { lo = mid + 1u; }
-            }
-            let k = lo;
-            var exclusive = 0u;
-            if (k > 0u) { exclusive = sh[k - 1u]; }
-            let arc = rowStart[k] + (p - exclusive);
-            let x = colIdx[arc - P.arcBase];
-            let mask = atomicLoad(&bits[frontierBase + rowOf[k]]) & ~atomicLoad(&bits[x]);   // the sources at u that have not reached x
-            if (mask != 0u) {
-                let old = atomicOr(&bits[x], mask);                      // visited: the claim, one read-modify-write
-                let fresh = mask & ~old;                                 // the sources whose claim this lane won
-                if (fresh != 0u) {
-                    atomicOr(&bits[nextBase + x], fresh);
-                    atomicStore(&bits[3u * P.bitsBase + x], 1u);         // flags: x is in the next frontier list (compact reads it)
-                    if (P.perNode == 1u) {                               // a sampled run: x's distance to each source won
-                        atomicAdd(&perSource[128u + x], countOneBits(fresh) * dist);
-                    }
-                    var b = fresh;
-                    loop {                                               // one tally per set bit of fresh
-                        if (b == 0u) { break; }
-                        let s = firstTrailingBit(b);
-                        atomicAdd(&local[s], 1u);
-                        b = b & (b - 1u);
-                    }
-                }
-            }
-        }
-        workgroupBarrier();                                              // uniform: the loop's bound is the uniform aggregate
-        if (lid.x < 32u) {                                               // ONE global atomic per source per workgroup
-            let c = atomicLoad(&local[lid.x]);
-            if (c != 0u) { atomicAdd(&perSource[lid.x], c); }            // newCount[s]
-        }
-        workgroupBarrier();                                              // sh, rowStart, rowOf and local are reused by the next block
-    }
-}
-`;
-//# sourceMappingURL=closeness-sweep.wgsl.js.map

package/dist/src/wgsl/closeness-sweep.wgsl.js.map

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

package/src/wgsl/closeness-reduce.wgsl.ts

@@ -1,68 +0,0 @@
-/**
- * The `closeness-reduce` kernel body (design 8.4, 9.7 "integer distances before division"; P8-T11, the P8 plan's
- * PD-13): the one-lane bookkeeping of the bit-parallel sweep, two roles by `P.role`. Role 0 is the level boundary,
- * recorded BEFORE the level's `compact` and sweep: `done` is whether the previous level's compacted count is 0 (so the
- * traversal ends one level after the last claim, one empty sweep and no wrong sum), then for every source `s` the
- * claims the level just run made (`newCount[s]`) are folded into `reached[s]` and into the 64-bit `sum[s]` at the
- * distance `level + 1` -- the product as a 16-bit split into a low and a high word, then the add with its carry --
- * `newCount[s]` is zeroed and `level` advances. Role 1 is the seed of a batch: for the batch's `k = min(32, n -
- * P.source)` sources, bit `s` into `visited[source_s]` and into the frontier region level 0 reads (region 1, since
- * level 0's parity is 0), `flags[source_s] = 1` (level 0's `compact` turns the flags into the list; a seeded list
- * would be overwritten by a compaction of all-zero flags), `counters[0] = k` (not done) and `level = U32_MAX` (so
- * level 0's boundary accumulates nothing and brings the word to 0, and level 1's counts the distance-1 claims at 1).
- * Role 2 is role 1 for a sampled run: source `s` of the batch is word `P.source + s` of the source list the host
- * wrote after the per-node sums (`perSource[128 + P.bitsBase + ...]`), `P.n` is the list's length, and a node listed
- * twice in one batch carries both bits (the seed ORs, so a duplicate runs twice).
- * No barrier follows the early return of the other lanes (3.5 rule 1). Body only (spec 3.5, D9); the text is
- * normative: the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
- */
-export const closenessReduceWgsl = /* wgsl */ `
-@compute @workgroup_size(WG)
-fn closeness_reduce(@builtin(local_invocation_id) lid: vec3<u32>) {
-    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)
-    if (P.role != 0u) {                                              // the seed of a batch: P.source is its first source
-        let k = min(32u, P.n - P.source);
-        for (var s = 0u; s < k; s = s + 1u) {
-            var v = P.source + s;
-            if (P.role == 2u) { v = atomicLoad(&perSource[128u + P.bitsBase + P.source + s]); }   // a sampled run's list
-            let bit = 1u << s;
-            bits[v] = bits[v] | bit;                                 // visited
-            bits[P.bitsBase + v] = bits[P.bitsBase + v] | bit;       // the frontier level 0 reads (region 1: level 0's parity is 0)
-            bits[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list
-        }
-        atomicStore(&counters[0], k);                                // not done
-        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0
-        atomicStore(&counters[15], 0u);                              // done
-        return;
-    }
-    // role 0: the level boundary -- done from the previous level's compacted count, then the accumulation
-    let count = atomicLoad(&counters[0]);
-    atomicStore(&counters[15], select(0u, 1u, count == 0u));
-    let level = atomicLoad(&counters[11]);
-    let d = level + 1u;                                              // the distance of the claims the level just run made
-    for (var s = 0u; s < 32u; s = s + 1u) {
-        let c = atomicLoad(&perSource[s]);                           // newCount[s]
-        atomicStore(&perSource[32u + s], atomicLoad(&perSource[32u + s]) + c);   // reached[s]
-        // sum[s] += c x d in 64 bits: the 16-bit split product (pLo, pHi), then the add with its carry
-        let cLo = c & 0xFFFFu;
-        let cHi = c >> 16u;
-        let dLo = d & 0xFFFFu;
-        let dHi = d >> 16u;
-        let ll = cLo * dLo;
-        let lh = cLo * dHi;
-        let hl = cHi * dLo;
-        let mid = (ll >> 16u) + (lh & 0xFFFFu) + (hl & 0xFFFFu);
-        let pLo = (ll & 0xFFFFu) | ((mid & 0xFFFFu) << 16u);
-        let pHi = (cHi * dHi) + (lh >> 16u) + (hl >> 16u) + (mid >> 16u);
-        var lo = atomicLoad(&perSource[64u + s]);                    // sumLo[s]
-        var hi = atomicLoad(&perSource[96u + s]);                    // sumHi[s]
-        let before = lo;
-        lo = lo + pLo;
-        hi = hi + pHi + select(0u, 1u, lo < before);
-        atomicStore(&perSource[64u + s], lo);
-        atomicStore(&perSource[96u + s], hi);
-        atomicStore(&perSource[s], 0u);
-    }
-    atomicStore(&counters[11], level + 1u);
-}
-`;

package/src/wgsl/closeness-sweep.wgsl.ts

@@ -1,105 +0,0 @@
-/**
- * The `closeness-sweep` kernel body (design 8.4 "32 sources per u32 word"; P8-T11, the P8 plan's PD-13 / DEP-P8-E):
- * one level of the bit-parallel multi-source breadth-first search. The batch's state is one `bits` buffer of four
- * regions of `P.bitsBase` words each -- `visited` at 0, the two frontier regions at `P.bitsBase` and `2 x P.bitsBase`
- * (which one is the frontier and which the next swaps by the level's parity, `P.mode`, so nothing is copied between
- * levels), `flags` at `3 x P.bitsBase` -- with bit `s` of word `v` meaning "source `s` has reached / is at / is next
- * at `v`". The expansion is `advance-expand`'s block-mapped strip (P8-T5): each workgroup loads up to `WG` entries of
- * the frontier LIST (the vertices any source is at, compacted from the flags by the host's `compact`), scans their
- * degrees with the inlined Hillis-Steele scan of `bfs-contract` (this is not a twin kernel: `needs: []`), and every
- * invocation strips the aggregate by binary search. The claim is inline: for the arc `(u, x)` the mask is the sources
- * at `u` that have not reached `x`; `atomicOr` on `visited[x]` returns the bits this lane won (`fresh`), which go into
- * the next region, set `flags[x]` (the flags region is part of the one atomic binding, so a plain store is a compile
- * error), and are tallied per source in WORKGROUP memory -- one global `atomicAdd` per source per workgroup after the
- * strip loop, never one per arc. Uniformity (spec 3.5 rule 1): the guarded loads write locals, the scan and the
- * `workgroupUniformLoad` sit unconditionally after the guard, the strip loop is bounded by the uniform aggregate, and
- * the flush's barrier follows it in uniform control flow. A sampled run (`P.perNode == 1`) also adds each claim's
- * distance (`level + 1`, one per won bit) into the per-node sum of `x`, `perSource[128 + x]`: the distance from each
- * of the batch's sources TO `x`, which is what a node's sampled closeness sums on an undirected graph. Body only (spec 3.5, D9); the text is normative: the
- * sabotage rows of test/helpers/sabotage.ts are textual edits of it.
- */
-export const closenessSweepWgsl = /* wgsl */ `
-var<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan
-var<workgroup> rowStart: array<u32, WG>;          // the first bound arc of each entry's row
-var<workgroup> rowOf: array<u32, WG>;             // the frontier vertex of each entry (the source end of its arcs)
-var<workgroup> local: array<atomic<u32>, 32>;     // this workgroup's fresh claims per source
-var<workgroup> wcount: u32;                       // the frontier list's length
-var<workgroup> wdist: u32;                        // the distance of this level's claims
-
-@compute @workgroup_size(WG)
-fn closeness_sweep(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
-    if (lid.x == 0u) {
-        wcount = atomicLoad(&counters[0]);                           // the frontier list's length (compact's total)
-        wdist = atomicLoad(&counters[11]) + 1u;                      // the level word: this level claims at level + 1
-    }
-    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers
-    let dist = workgroupUniformLoad(&wdist);
-    let nextBase = select(2u * P.bitsBase, P.bitsBase, P.mode == 1u);   // the region that is next this level
-    let frontierBase = 3u * P.bitsBase - nextBase;                   // the other one: the region that is the frontier
-    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries
-        let i = b0 + lid.x;                                          // this lane's frontier entry
-        var deg = 0u;
-        var start = 0u;
-        var u = 0u;
-        if (i < count) {                                                 // guarded loads into locals (3.5 rule 1)
-            u = frontierList[i];
-            let lo = max(rowPtr[u], P.arcBase);
-            let hi = min(rowPtr[u + 1u], P.arcEnd);
-            start = lo;
-            deg = select(0u, hi - lo, hi > lo);
-        }
-        if (lid.x < 32u) { atomicStore(&local[lid.x], 0u); }            // zeroed before the strip loop (WebGPU zero-initialises workgroup memory; said anyway)
-        sh[lid.x] = deg;
-        rowStart[lid.x] = start;
-        rowOf[lid.x] = u;
-        workgroupBarrier();
-        for (var s = 1u; s < WG; s = s * 2u) {                           // Hillis-Steele inclusive scan of the degrees (bfs-contract's, inlined)
-            var t = 0u;
-            if (lid.x >= s) { t = sh[lid.x - s]; }
-            workgroupBarrier();
-            sh[lid.x] = sh[lid.x] + t;
-            workgroupBarrier();
-        }
-        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);              // uniform; includes a barrier
-        for (var p = lid.x; p < aggregate; p = p + WG) {                 // strip [0, aggregate): lane j takes j, j + WG, ...
-            var lo = 0u;                                                 // upper_bound: the first k with sh[k] > p owns arc p
-            var hi = WG;
-            loop {
-                if (lo >= hi) { break; }
-                let mid = (lo + hi) / 2u;
-                if (sh[mid] > p) { hi = mid; } else { lo = mid + 1u; }
-            }
-            let k = lo;
-            var exclusive = 0u;
-            if (k > 0u) { exclusive = sh[k - 1u]; }
-            let arc = rowStart[k] + (p - exclusive);
-            let x = colIdx[arc - P.arcBase];
-            let mask = atomicLoad(&bits[frontierBase + rowOf[k]]) & ~atomicLoad(&bits[x]);   // the sources at u that have not reached x
-            if (mask != 0u) {
-                let old = atomicOr(&bits[x], mask);                      // visited: the claim, one read-modify-write
-                let fresh = mask & ~old;                                 // the sources whose claim this lane won
-                if (fresh != 0u) {
-                    atomicOr(&bits[nextBase + x], fresh);
-                    atomicStore(&bits[3u * P.bitsBase + x], 1u);         // flags: x is in the next frontier list (compact reads it)
-                    if (P.perNode == 1u) {                               // a sampled run: x's distance to each source won
-                        atomicAdd(&perSource[128u + x], countOneBits(fresh) * dist);
-                    }
-                    var b = fresh;
-                    loop {                                               // one tally per set bit of fresh
-                        if (b == 0u) { break; }
-                        let s = firstTrailingBit(b);
-                        atomicAdd(&local[s], 1u);
-                        b = b & (b - 1u);
-                    }
-                }
-            }
-        }
-        workgroupBarrier();                                              // uniform: the loop's bound is the uniform aggregate
-        if (lid.x < 32u) {                                               // ONE global atomic per source per workgroup
-            let c = atomicLoad(&local[lid.x]);
-            if (c != 0u) { atomicAdd(&perSource[lid.x], c); }            // newCount[s]
-        }
-        workgroupBarrier();                                              // sh, rowStart, rowOf and local are reused by the next block
-    }
-}
-`;