@graphty/webgpu-graph-algorithms 0.6.26 → 0.6.28

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

@@ -0,0 +1,37 @@
+/**
+ * The `closeness-level` kernel body: one level of the bit-parallel multi-source breadth-first search of closeness, in
+ * ONE dispatch, plus the two seed roles of a batch. A batch runs `32 x P.words` sources at once: bit `b` of word `j`
+ * of node `v` is source lane `32 j + b`. The `bits` buffer holds five regions of `P.base` words, `P.words` words per
+ * node: `visited` at 0, three frontier regions at `P.base`, `2 P.base` and `3 P.base` that rotate by the level
+ * (level `L` reads region `1 + L % 3`, writes region `1 + (L + 1) % 3` and zeroes region `1 + (L + 2) % 3`, the
+ * frontier of level `L - 1` that nothing reads any more, so no fill runs between levels; a stale bit could never
+ * claim anything, since its node's neighbours were claimed the level after, so the clear only keeps a later frontier
+ * from re-walking old nodes), then a sampled run's
+ * per-node distance sums at `4 P.base`. The `table` buffer holds the per-level claim counts of the submit (row `P.row`
+ * at `P.row x 32 P.words`, one word per source lane), then a ring of three control slots of four words at `P.ctrl`
+ * (`any` @0: the level claimed something; `arcs` @1: the out-degree of every (node, word) that joined the next
+ * frontier; `pull` @2: `arcs` passed `P.pullAt`), then a sampled run's source list at `P.sourcesAt`.
+ *
+ * Role 0 (one invocation per node and per arc, `max(n, arcs)` in all): a level whose predecessor claimed nothing
+ * returns at once (one uniform load per workgroup), so the host can record more levels than the batch needs.
+ * Otherwise the level chooses its step from the slot its predecessor filled, the same way for every invocation:
+ *   - PUSH (the frontier is cheap to expand): one invocation per out-arc `(u, x)` -- `u` found by a binary search of
+ *     `rowPtr` -- claims the sources at `u` that `x` has not seen with `atomicOr` on `x`'s visited word; the bits it
+ *     won (`fresh`) join the next frontier;
+ *   - PULL (the frontier's arcs pass `P.pullAt`, and `P.pullOk`): one invocation per node not yet reached by every
+ *     source walks its IN-arcs, ORs the neighbours' frontier words, and keeps the bits it had not seen; it stops at
+ *     the first in-arc after which every source has reached it (the early exit). Only the owner writes a node's
+ *     words. The host allows the pull only when no node has more than a few thousand in-arcs, so no
+ *     invocation of either step loops more than a few tens of thousands of times (llvmpipe silently ends every loop
+ *     of an invocation past 65,535 iterations).
+ * Every claimed bit is tallied per source lane in workgroup memory and flushed with one global `atomicAdd` per lane
+ * per workgroup into the level's row; the host turns the counts into exact sums (`count x (L + 1)`) and harmonic
+ * sums (`count / (L + 1)`). Role 1 (one invocation per word): zeroes the regions, sets every dead lane of a partial
+ * batch as already visited (so the early exit and the "reached by every source" test see a full word), and zeroes the
+ * control ring. Role 2 (one invocation per lane): seeds lane `b`'s source -- `P.source + b`, or word `P.source + b` of
+ * the source list -- into `visited` and level 0's frontier with `atomicOr` (a node listed twice carries both bits),
+ * and fills the control slot level 0 reads. Body only; the text is normative: the sabotage rows of
+ * test/helpers/sabotage.ts are textual edits of it.
+ */
+export declare const closenessLevelWgsl = "\nconst max_words: u32 = 8u;\nvar<workgroup> tally: array<atomic<u32>, 32u * max_words>;   // 32 x max_words: this workgroup's claims per source lane\nvar<workgroup> wlive: u32;\nvar<workgroup> wpull: u32;\nvar<workgroup> wany: atomic<u32>;\nvar<workgroup> warcs: atomic<u32>;\nvar<workgroup> wover: atomic<u32>;\n\nfn dead_lanes(j: u32) -> u32 {                        // the lanes of word j at or past the batch's source count\n    let first = 32u * j;\n    if (P.count >= first + 32u) { return 0u; }\n    if (P.count <= first) { return U32_MAX; }\n    return ~((1u << (P.count - first)) - 1u);\n}\n\nfn add_arcs(slot: u32, value: u32) {                  // the arcs total of a control slot; pull once it passes P.pullAt\n    if (value == 0u) { return; }\n    let before = atomicAdd(&table[slot + 1u], value);\n    if (value > P.pullAt || before + value > P.pullAt || before + value < before) {\n        atomicStore(&table[slot + 2u], 1u);\n    }\n}\n\nfn record(j: u32, node: u32, fresh: u32, dist: u32) {   // the claims of one word: tallied per lane, a sampled run's sums\n    if (P.perNode == 1u) { atomicAdd(&bits[4u * P.base + node], countOneBits(fresh) * dist); }\n    var b = fresh;\n    loop {\n        if (b == 0u) { break; }\n        atomicAdd(&tally[32u * j + firstTrailingBit(b)], 1u);\n        b = b & (b - 1u);\n    }\n}\n\n@compute @workgroup_size(WG)\nfn closeness_level(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    let W = P.words;\n    if (P.role == 1u) {                                              // seed, part 1: one invocation per word\n        if (i == 0u) {\n            for (var k = 0u; k < 12u; k = k + 1u) { atomicStore(&table[P.ctrl + k], 0u); }\n        }\n        if (i < P.total) { atomicStore(&bits[i], select(0u, dead_lanes(i % W), i < P.base)); }\n        return;                                                      // uniform: P.role is\n    }\n    if (P.role == 2u) {                                              // seed, part 2: one invocation per source lane\n        if (i < P.count) {\n            var v = P.source + i;\n            if (P.sourcesAt != 0u) { v = atomicLoad(&table[P.sourcesAt + P.source + i]); }\n            let w = v * W + i / 32u;\n            let bit = 1u << (i % 32u);\n            atomicOr(&bits[w], bit);                                 // visited\n            let before = atomicOr(&bits[P.base + w], bit);           // level 0's frontier (region 1)\n            let slot = P.ctrl + 8u;                                  // the slot of \"level -1\", which level 0 reads\n            atomicStore(&table[slot], 1u);\n            if (before == 0u) { add_arcs(slot, rowPtr[v + 1u] - rowPtr[v]); }\n        }\n        return;\n    }\n\n    // role 0: one level\n    let L = P.level;\n    let prev = P.ctrl + 4u * ((L + 2u) % 3u);\n    let cur = P.ctrl + 4u * (L % 3u);\n    if (lid.x == 0u) {\n        wlive = atomicLoad(&table[prev]);\n        wpull = select(0u, atomicLoad(&table[prev + 2u]), P.pullOk == 1u);\n        atomicStore(&wany, 0u);\n        atomicStore(&warcs, 0u);\n        atomicStore(&wover, 0u);\n    }\n    for (var k = lid.x; k < 32u * W; k = k + WG) { atomicStore(&tally[k], 0u); }\n    let live = workgroupUniformLoad(&wlive);                         // uniform; includes a barrier\n    if (live == 0u) { return; }                                      // the previous level claimed nothing\n    let pull = workgroupUniformLoad(&wpull) == 1u;\n    if (i == 0u) {                                                   // the slot of level L + 1 held level L - 2's\n        let nxt = P.ctrl + 4u * ((L + 1u) % 3u);\n        atomicStore(&table[nxt], 0u);\n        atomicStore(&table[nxt + 1u], 0u);\n        atomicStore(&table[nxt + 2u], 0u);\n    }\n    let frontierBase = P.base * (1u + L % 3u);\n    let nextBase = P.base * (1u + (L + 1u) % 3u);\n    let staleBase = P.base * (1u + (L + 2u) % 3u);\n    let dist = L + 1u;\n    var arcs = 0u;\n    if (i < P.n) {\n        for (var j = 0u; j < W; j = j + 1u) { atomicStore(&bits[staleBase + i * W + j], 0u); }\n    }\n    if (pull) {\n        if (i < P.n) {                                               // one invocation per node: its in-arcs\n            var vis: array<u32, max_words>;\n            var unseen = 0u;\n            for (var j = 0u; j < W; j = j + 1u) {\n                vis[j] = atomicLoad(&bits[i * W + j]);\n                unseen = unseen | ~vis[j];\n            }\n            if (unseen != 0u) {                                      // some source has not reached this node yet\n                var acc: array<u32, max_words>;\n                let end = inRowPtr[i + 1u];\n                for (var a = inRowPtr[i]; a < end; a = a + 1u) {\n                    let u = inColIdx[a];\n                    var missing = 0u;\n                    for (var j = 0u; j < W; j = j + 1u) {\n                        acc[j] = acc[j] | atomicLoad(&bits[frontierBase + u * W + j]);\n                        missing = missing | ~(acc[j] | vis[j]);\n                    }\n                    if (missing == 0u) { break; }                    // every source has reached it: the early exit\n                }\n                let degree = rowPtr[i + 1u] - rowPtr[i];\n                for (var j = 0u; j < W; j = j + 1u) {\n                    let fresh = acc[j] & ~vis[j];\n                    if (fresh != 0u) {\n                        atomicStore(&bits[i * W + j], vis[j] | fresh);\n                        atomicStore(&bits[nextBase + i * W + j], fresh);\n                        arcs = arcs + degree;\n                        record(j, i, fresh, dist);\n                    }\n                }\n            }\n        }\n    } else if (i < P.arcCount) {                                     // one invocation per arc: no row is walked whole\n        var lo = 0u;                                                 // the arc's source: the last row starting at or before it\n        var hi = P.n - 1u;\n        loop {\n            if (lo >= hi) { break; }\n            let mid = (lo + hi + 1u) / 2u;\n            if (rowPtr[mid] <= i) { lo = mid; } else { hi = mid - 1u; }\n        }\n        let u = lo;\n        let x = colIdx[i];\n        for (var j = 0u; j < W; j = j + 1u) {\n            let mask = atomicLoad(&bits[frontierBase + u * W + j]) & ~atomicLoad(&bits[x * W + j]);   // at u, not yet at x\n            if (mask == 0u) { continue; }\n            let fresh = mask & ~atomicOr(&bits[x * W + j], mask);    // the claims this invocation won\n            if (fresh == 0u) { continue; }\n            if (atomicOr(&bits[nextBase + x * W + j], fresh) == 0u) {\n                arcs = arcs + (rowPtr[x + 1u] - rowPtr[x]);\n            }\n            record(j, x, fresh, dist);\n        }\n    }\n    if (arcs > P.pullAt) {\n        atomicStore(&wover, 1u);\n    } else if (arcs != 0u) {\n        let before = atomicAdd(&warcs, arcs);\n        if (before + arcs > P.pullAt || before + arcs < before) { atomicStore(&wover, 1u); }\n    }\n    workgroupBarrier();\n    let row = P.row * 32u * W;\n    for (var k = lid.x; k < 32u * W; k = k + WG) {                   // ONE global atomic per source lane per workgroup\n        let c = atomicLoad(&tally[k]);\n        if (c != 0u) {\n            atomicAdd(&table[row + k], c);\n            atomicStore(&wany, 1u);\n        }\n    }\n    workgroupBarrier();\n    if (lid.x == 0u) {\n        if (atomicLoad(&wany) != 0u) { atomicStore(&table[cur], 1u); }\n        if (atomicLoad(&wover) != 0u) {\n            atomicStore(&table[cur + 2u], 1u);\n        } else {\n            add_arcs(cur, atomicLoad(&warcs));\n        }\n    }\n}\n";
+//# sourceMappingURL=closeness-level.wgsl.d.ts.map

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

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

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

@@ -0,0 +1,204 @@
+/**
+ * The `closeness-level` kernel body: one level of the bit-parallel multi-source breadth-first search of closeness, in
+ * ONE dispatch, plus the two seed roles of a batch. A batch runs `32 x P.words` sources at once: bit `b` of word `j`
+ * of node `v` is source lane `32 j + b`. The `bits` buffer holds five regions of `P.base` words, `P.words` words per
+ * node: `visited` at 0, three frontier regions at `P.base`, `2 P.base` and `3 P.base` that rotate by the level
+ * (level `L` reads region `1 + L % 3`, writes region `1 + (L + 1) % 3` and zeroes region `1 + (L + 2) % 3`, the
+ * frontier of level `L - 1` that nothing reads any more, so no fill runs between levels; a stale bit could never
+ * claim anything, since its node's neighbours were claimed the level after, so the clear only keeps a later frontier
+ * from re-walking old nodes), then a sampled run's
+ * per-node distance sums at `4 P.base`. The `table` buffer holds the per-level claim counts of the submit (row `P.row`
+ * at `P.row x 32 P.words`, one word per source lane), then a ring of three control slots of four words at `P.ctrl`
+ * (`any` @0: the level claimed something; `arcs` @1: the out-degree of every (node, word) that joined the next
+ * frontier; `pull` @2: `arcs` passed `P.pullAt`), then a sampled run's source list at `P.sourcesAt`.
+ *
+ * Role 0 (one invocation per node and per arc, `max(n, arcs)` in all): a level whose predecessor claimed nothing
+ * returns at once (one uniform load per workgroup), so the host can record more levels than the batch needs.
+ * Otherwise the level chooses its step from the slot its predecessor filled, the same way for every invocation:
+ *   - PUSH (the frontier is cheap to expand): one invocation per out-arc `(u, x)` -- `u` found by a binary search of
+ *     `rowPtr` -- claims the sources at `u` that `x` has not seen with `atomicOr` on `x`'s visited word; the bits it
+ *     won (`fresh`) join the next frontier;
+ *   - PULL (the frontier's arcs pass `P.pullAt`, and `P.pullOk`): one invocation per node not yet reached by every
+ *     source walks its IN-arcs, ORs the neighbours' frontier words, and keeps the bits it had not seen; it stops at
+ *     the first in-arc after which every source has reached it (the early exit). Only the owner writes a node's
+ *     words. The host allows the pull only when no node has more than a few thousand in-arcs, so no
+ *     invocation of either step loops more than a few tens of thousands of times (llvmpipe silently ends every loop
+ *     of an invocation past 65,535 iterations).
+ * Every claimed bit is tallied per source lane in workgroup memory and flushed with one global `atomicAdd` per lane
+ * per workgroup into the level's row; the host turns the counts into exact sums (`count x (L + 1)`) and harmonic
+ * sums (`count / (L + 1)`). Role 1 (one invocation per word): zeroes the regions, sets every dead lane of a partial
+ * batch as already visited (so the early exit and the "reached by every source" test see a full word), and zeroes the
+ * control ring. Role 2 (one invocation per lane): seeds lane `b`'s source -- `P.source + b`, or word `P.source + b` of
+ * the source list -- into `visited` and level 0's frontier with `atomicOr` (a node listed twice carries both bits),
+ * and fills the control slot level 0 reads. Body only; the text is normative: the sabotage rows of
+ * test/helpers/sabotage.ts are textual edits of it.
+ */
+export const closenessLevelWgsl = /* wgsl */ `
+const max_words: u32 = 8u;
+var<workgroup> tally: array<atomic<u32>, 32u * max_words>;   // 32 x max_words: this workgroup's claims per source lane
+var<workgroup> wlive: u32;
+var<workgroup> wpull: u32;
+var<workgroup> wany: atomic<u32>;
+var<workgroup> warcs: atomic<u32>;
+var<workgroup> wover: atomic<u32>;
+
+fn dead_lanes(j: u32) -> u32 {                        // the lanes of word j at or past the batch's source count
+    let first = 32u * j;
+    if (P.count >= first + 32u) { return 0u; }
+    if (P.count <= first) { return U32_MAX; }
+    return ~((1u << (P.count - first)) - 1u);
+}
+
+fn add_arcs(slot: u32, value: u32) {                  // the arcs total of a control slot; pull once it passes P.pullAt
+    if (value == 0u) { return; }
+    let before = atomicAdd(&table[slot + 1u], value);
+    if (value > P.pullAt || before + value > P.pullAt || before + value < before) {
+        atomicStore(&table[slot + 2u], 1u);
+    }
+}
+
+fn record(j: u32, node: u32, fresh: u32, dist: u32) {   // the claims of one word: tallied per lane, a sampled run's sums
+    if (P.perNode == 1u) { atomicAdd(&bits[4u * P.base + node], countOneBits(fresh) * dist); }
+    var b = fresh;
+    loop {
+        if (b == 0u) { break; }
+        atomicAdd(&tally[32u * j + firstTrailingBit(b)], 1u);
+        b = b & (b - 1u);
+    }
+}
+
+@compute @workgroup_size(WG)
+fn closeness_level(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    let W = P.words;
+    if (P.role == 1u) {                                              // seed, part 1: one invocation per word
+        if (i == 0u) {
+            for (var k = 0u; k < 12u; k = k + 1u) { atomicStore(&table[P.ctrl + k], 0u); }
+        }
+        if (i < P.total) { atomicStore(&bits[i], select(0u, dead_lanes(i % W), i < P.base)); }
+        return;                                                      // uniform: P.role is
+    }
+    if (P.role == 2u) {                                              // seed, part 2: one invocation per source lane
+        if (i < P.count) {
+            var v = P.source + i;
+            if (P.sourcesAt != 0u) { v = atomicLoad(&table[P.sourcesAt + P.source + i]); }
+            let w = v * W + i / 32u;
+            let bit = 1u << (i % 32u);
+            atomicOr(&bits[w], bit);                                 // visited
+            let before = atomicOr(&bits[P.base + w], bit);           // level 0's frontier (region 1)
+            let slot = P.ctrl + 8u;                                  // the slot of "level -1", which level 0 reads
+            atomicStore(&table[slot], 1u);
+            if (before == 0u) { add_arcs(slot, rowPtr[v + 1u] - rowPtr[v]); }
+        }
+        return;
+    }
+
+    // role 0: one level
+    let L = P.level;
+    let prev = P.ctrl + 4u * ((L + 2u) % 3u);
+    let cur = P.ctrl + 4u * (L % 3u);
+    if (lid.x == 0u) {
+        wlive = atomicLoad(&table[prev]);
+        wpull = select(0u, atomicLoad(&table[prev + 2u]), P.pullOk == 1u);
+        atomicStore(&wany, 0u);
+        atomicStore(&warcs, 0u);
+        atomicStore(&wover, 0u);
+    }
+    for (var k = lid.x; k < 32u * W; k = k + WG) { atomicStore(&tally[k], 0u); }
+    let live = workgroupUniformLoad(&wlive);                         // uniform; includes a barrier
+    if (live == 0u) { return; }                                      // the previous level claimed nothing
+    let pull = workgroupUniformLoad(&wpull) == 1u;
+    if (i == 0u) {                                                   // the slot of level L + 1 held level L - 2's
+        let nxt = P.ctrl + 4u * ((L + 1u) % 3u);
+        atomicStore(&table[nxt], 0u);
+        atomicStore(&table[nxt + 1u], 0u);
+        atomicStore(&table[nxt + 2u], 0u);
+    }
+    let frontierBase = P.base * (1u + L % 3u);
+    let nextBase = P.base * (1u + (L + 1u) % 3u);
+    let staleBase = P.base * (1u + (L + 2u) % 3u);
+    let dist = L + 1u;
+    var arcs = 0u;
+    if (i < P.n) {
+        for (var j = 0u; j < W; j = j + 1u) { atomicStore(&bits[staleBase + i * W + j], 0u); }
+    }
+    if (pull) {
+        if (i < P.n) {                                               // one invocation per node: its in-arcs
+            var vis: array<u32, max_words>;
+            var unseen = 0u;
+            for (var j = 0u; j < W; j = j + 1u) {
+                vis[j] = atomicLoad(&bits[i * W + j]);
+                unseen = unseen | ~vis[j];
+            }
+            if (unseen != 0u) {                                      // some source has not reached this node yet
+                var acc: array<u32, max_words>;
+                let end = inRowPtr[i + 1u];
+                for (var a = inRowPtr[i]; a < end; a = a + 1u) {
+                    let u = inColIdx[a];
+                    var missing = 0u;
+                    for (var j = 0u; j < W; j = j + 1u) {
+                        acc[j] = acc[j] | atomicLoad(&bits[frontierBase + u * W + j]);
+                        missing = missing | ~(acc[j] | vis[j]);
+                    }
+                    if (missing == 0u) { break; }                    // every source has reached it: the early exit
+                }
+                let degree = rowPtr[i + 1u] - rowPtr[i];
+                for (var j = 0u; j < W; j = j + 1u) {
+                    let fresh = acc[j] & ~vis[j];
+                    if (fresh != 0u) {
+                        atomicStore(&bits[i * W + j], vis[j] | fresh);
+                        atomicStore(&bits[nextBase + i * W + j], fresh);
+                        arcs = arcs + degree;
+                        record(j, i, fresh, dist);
+                    }
+                }
+            }
+        }
+    } else if (i < P.arcCount) {                                     // one invocation per arc: no row is walked whole
+        var lo = 0u;                                                 // the arc's source: the last row starting at or before it
+        var hi = P.n - 1u;
+        loop {
+            if (lo >= hi) { break; }
+            let mid = (lo + hi + 1u) / 2u;
+            if (rowPtr[mid] <= i) { lo = mid; } else { hi = mid - 1u; }
+        }
+        let u = lo;
+        let x = colIdx[i];
+        for (var j = 0u; j < W; j = j + 1u) {
+            let mask = atomicLoad(&bits[frontierBase + u * W + j]) & ~atomicLoad(&bits[x * W + j]);   // at u, not yet at x
+            if (mask == 0u) { continue; }
+            let fresh = mask & ~atomicOr(&bits[x * W + j], mask);    // the claims this invocation won
+            if (fresh == 0u) { continue; }
+            if (atomicOr(&bits[nextBase + x * W + j], fresh) == 0u) {
+                arcs = arcs + (rowPtr[x + 1u] - rowPtr[x]);
+            }
+            record(j, x, fresh, dist);
+        }
+    }
+    if (arcs > P.pullAt) {
+        atomicStore(&wover, 1u);
+    } else if (arcs != 0u) {
+        let before = atomicAdd(&warcs, arcs);
+        if (before + arcs > P.pullAt || before + arcs < before) { atomicStore(&wover, 1u); }
+    }
+    workgroupBarrier();
+    let row = P.row * 32u * W;
+    for (var k = lid.x; k < 32u * W; k = k + WG) {                   // ONE global atomic per source lane per workgroup
+        let c = atomicLoad(&tally[k]);
+        if (c != 0u) {
+            atomicAdd(&table[row + k], c);
+            atomicStore(&wany, 1u);
+        }
+    }
+    workgroupBarrier();
+    if (lid.x == 0u) {
+        if (atomicLoad(&wany) != 0u) { atomicStore(&table[cur], 1u); }
+        if (atomicLoad(&wover) != 0u) {
+            atomicStore(&table[cur + 2u], 1u);
+        } else {
+            add_arcs(cur, atomicLoad(&warcs));
+        }
+    }
+}
+`;
+//# sourceMappingURL=closeness-level.wgsl.js.map

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * The `closeness-rowsum` kernel body: closeness from a finished all-pairs distance matrix, one workgroup per row.
+ * Every lane walks its strided columns of row `r` (the distances FROM `r`), skips the diagonal and every unreachable
+ * entry (`+Infinity`, compared by its bit pattern because WGSL lets a compiler assume no infinities), and adds, by
+ * `P.role`: 0 the hop count as an integer (exact: a row of at most 23,170 hops below 23,170 sums below 2^32), 1 the
+ * f32 distance, 2 its reciprocal (harmonic closeness; a zero distance adds nothing, as in the CPU port). A tree reduction in workgroup memory folds the lanes and lane
+ * 0 writes `out[r]` -- the integer, or the f32 bit pattern. The host turns the row into the score. Body only; the text
+ * is normative: the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export declare const closenessRowsumWgsl = "\nvar<workgroup> partial: array<u32, WG>;\n\n@compute @workgroup_size(WG)\nfn closeness_rowsum(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let row = group_id(wid);                                         // uniform: one workgroup per row\n    if (row >= P.n) { return; }\n    var whole = 0u;\n    var real = 0.0;\n    for (var c = lid.x; c < P.n; c = c + WG) {\n        let d = dist[row * P.n + c];\n        if (c == row || bitcast<u32>(d) == F32_INF_BITS) { continue; }\n        if (P.role == 0u) {\n            whole = whole + u32(d);\n        } else if (P.role == 1u) {\n            real = real + d;\n        } else if (d > 0.0) {\n            real = real + 1.0 / d;                                    // a zero distance adds nothing, as on the CPU\n        }\n    }\n    partial[lid.x] = select(whole, bitcast<u32>(real), P.role != 0u);\n    for (var s = WG / 2u; s > 0u; s = s / 2u) {\n        workgroupBarrier();\n        if (lid.x < s) {\n            let a = partial[lid.x];\n            let b = partial[lid.x + s];\n            partial[lid.x] = select(a + b, bitcast<u32>(bitcast<f32>(a) + bitcast<f32>(b)), P.role != 0u);\n        }\n    }\n    if (lid.x == 0u) { out[row] = partial[0]; }\n}\n";
+//# sourceMappingURL=closeness-rowsum.wgsl.d.ts.map

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

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

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

@@ -0,0 +1,42 @@
+/**
+ * The `closeness-rowsum` kernel body: closeness from a finished all-pairs distance matrix, one workgroup per row.
+ * Every lane walks its strided columns of row `r` (the distances FROM `r`), skips the diagonal and every unreachable
+ * entry (`+Infinity`, compared by its bit pattern because WGSL lets a compiler assume no infinities), and adds, by
+ * `P.role`: 0 the hop count as an integer (exact: a row of at most 23,170 hops below 23,170 sums below 2^32), 1 the
+ * f32 distance, 2 its reciprocal (harmonic closeness; a zero distance adds nothing, as in the CPU port). A tree reduction in workgroup memory folds the lanes and lane
+ * 0 writes `out[r]` -- the integer, or the f32 bit pattern. The host turns the row into the score. Body only; the text
+ * is normative: the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export const closenessRowsumWgsl = /* wgsl */ `
+var<workgroup> partial: array<u32, WG>;
+
+@compute @workgroup_size(WG)
+fn closeness_rowsum(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let row = group_id(wid);                                         // uniform: one workgroup per row
+    if (row >= P.n) { return; }
+    var whole = 0u;
+    var real = 0.0;
+    for (var c = lid.x; c < P.n; c = c + WG) {
+        let d = dist[row * P.n + c];
+        if (c == row || bitcast<u32>(d) == F32_INF_BITS) { continue; }
+        if (P.role == 0u) {
+            whole = whole + u32(d);
+        } else if (P.role == 1u) {
+            real = real + d;
+        } else if (d > 0.0) {
+            real = real + 1.0 / d;                                    // a zero distance adds nothing, as on the CPU
+        }
+    }
+    partial[lid.x] = select(whole, bitcast<u32>(real), P.role != 0u);
+    for (var s = WG / 2u; s > 0u; s = s / 2u) {
+        workgroupBarrier();
+        if (lid.x < s) {
+            let a = partial[lid.x];
+            let b = partial[lid.x + s];
+            partial[lid.x] = select(a + b, bitcast<u32>(bitcast<f32>(a) + bitcast<f32>(b)), P.role != 0u);
+        }
+    }
+    if (lid.x == 0u) { out[row] = partial[0]; }
+}
+`;
+//# sourceMappingURL=closeness-rowsum.wgsl.js.map

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

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

package/dist/src/wgsl/grid-centroid-hub.wgsl.d.ts

@@ -1,6 +1,6 @@
 /**
- * G4b, the `grid-centroid-hub` kernel body (spec 7.7; P4-T9): one workgroup per hub cell of hubList, dispatched
- * indirectly from hubArgs (the T1 finalize over hubCounters[0]); a WG-strided mass-weighted sum reduced by the
+ * G4b, the `grid-centroid-hub` kernel body (spec 7.7; P4-T9): one workgroup per word of hubList, dispatched
+ * directly (issue #732), so the workgroups past hubCounters[0] idle; a WG-strided mass-weighted sum reduced by the
  * prelude's tree. The work is guarded by `valid`, never an early return, so the reduction is uniform (PD-13). Body
  * only; normative text.
  */

package/dist/src/wgsl/grid-centroid-hub.wgsl.js

@@ -1,6 +1,6 @@
 /**
- * G4b, the `grid-centroid-hub` kernel body (spec 7.7; P4-T9): one workgroup per hub cell of hubList, dispatched
- * indirectly from hubArgs (the T1 finalize over hubCounters[0]); a WG-strided mass-weighted sum reduced by the
+ * G4b, the `grid-centroid-hub` kernel body (spec 7.7; P4-T9): one workgroup per word of hubList, dispatched
+ * directly (issue #732), so the workgroups past hubCounters[0] idle; a WG-strided mass-weighted sum reduced by the
  * prelude's tree. The work is guarded by `valid`, never an early return, so the reduction is uniform (PD-13). Body
  * only; normative text.
  */