@graphty/webgpu-graph-algorithms 0.6.13 → 0.6.15

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

@@ -1 +1 @@
-{"version":3,"file":"closeness-reduce.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/closeness-reduce.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgD7C,CAAC"}
+{"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

@@ -13,8 +13,10 @@
  * 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. Body only (spec 3.5, D9); the text is normative: the
+ * 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\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) { wcount = atomicLoad(&counters[0]); }          // the frontier list's length (compact's total)\n    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers\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                    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";
+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 +1 @@
-{"version":3,"file":"closeness-sweep.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/closeness-sweep.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,ymJA4E9B,CAAC"}
+{"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

@@ -13,7 +13,9 @@
  * 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. Body only (spec 3.5, D9); the text is normative: the
+ * 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 */ `
@@ -22,11 +24,16 @@ var<workgroup> rowStart: array<u32, WG>;          // the first bound arc of each
 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)
+    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
@@ -74,6 +81,9 @@ fn closeness_sweep(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocat
                 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; }

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

@@ -1 +1 @@
-{"version":3,"file":"closeness-sweep.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/closeness-sweep.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4E5C,CAAC"}
+{"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"}