@graphty/webgpu-graph-algorithms 0.6.15 → 0.6.17

package/dist/src/wgsl/group-by-key-row.wgsl.js

@@ -0,0 +1,146 @@
+/**
+ * The `group-by-key-row` kernel body (design 8.6; the per-row group-by-key): for every listed row `v`, the arcs of
+ * the row are grouped by the key of their target (`keyIn[colIdx[a]]`), the weights are summed per key, and the key
+ * with the largest sum wins, ties going to the LOWEST key -- which makes the answer independent of the order the arcs
+ * are visited in, and so bitwise reproducible. `bestKey[v]` gets the key (`INVALID_INDEX` for an empty row) and
+ * `bestScore[v]` the summed weight.
+ *
+ * The sums are u32 fixed point, because WGSL has no float atomic: every weight is scaled by `2^s`, a power of two
+ * chosen from the exponents of the row's largest weight and of its degree alone so that `maxWeight x degree x 2^s`
+ * lies in [2^28, 2^30), and rounded to the nearest integer, halves up. No step rounds a float: the scale needs no
+ * product, scaling by a power of two is exact, and so are the integer part and the fraction of the scaled weight.
+ * That matters because WGSL lets `x + y` and `x * y` round to EITHER neighbour of an inexact result, so a rounded
+ * step could differ between devices; as written, both tiers, every device and any CPU reference compute identical
+ * integers. A weight smaller than `2^-s / 2` contributes nothing, and a negative weight counts as zero. Without
+ * WEIGHTED every weight is 1.
+ *
+ * TIER 0: one thread per row (`rows[P.rowsBase + i]`), a pairwise scan in registers -- for short rows, and at most
+ * GROUP_ROW_THREAD_LIMIT arcs, since llvmpipe stops an invocation's loops after 65,535 steps. Any other TIER: one
+ * workgroup per row (`rows[P.rowsBase + g]`) over its own open-addressing region of `GROUP_HASH_LOAD_FACTOR x degree`
+ * slot pairs (key, sum) starting at word `rows[P.basesBase + g]` of `hashRegion`, cleared by the workgroup itself;
+ * a key is claimed by a bounded compare-exchange loop with linear probing, and a lane that exhausts its bound raises
+ * `hashRegion[0]`, which the driver reads and refuses. Every barrier is reached in uniform control flow: the only
+ * early return keys on the workgroup id and a uniform. Body only (spec 3.5, D9); normative text.
+ */
+export const groupByKeyRowWgsl = /* wgsl */ `
+var<workgroup> shMax: array<f32, WG>;
+var<workgroup> shKey: array<u32, WG>;
+var<workgroup> shSum: array<u32, WG>;
+
+fn weight_of(a: u32) -> f32 {
+    if (WEIGHTED) { return weights[a]; }
+    return 1.0;
+}
+fn scale_of(maxW: f32, d: u32) -> f32 {                            // 2^s, maxW x d x 2^s in [2^28, 2^30), from exponents alone
+    let em = i32((bitcast<u32>(maxW) >> 23u) & 255u) - 127;
+    let ed = i32(firstLeadingBit(max(d, 1u)));
+    let s = clamp(28 - em - ed, -126, 126);
+    return bitcast<f32>(u32(s + 127) << 23u);
+}
+fn inverse_of(scale: f32) -> f32 {                                 // 2^-s, exact
+    let s = i32((bitcast<u32>(scale) >> 23u) & 255u) - 127;
+    return bitcast<f32>(u32(127 - s) << 23u);
+}
+fn quantize(w: f32, scale: f32) -> u32 {                           // nearest integer, halves up; every step exact
+    let x = max(w * scale, 0.0);
+    let i = u32(x);
+    return select(i, i + 1u, x - f32(i) >= 0.5);
+}
+fn better(sum: u32, key: u32, bestSum: u32, bestKey0: u32) -> bool { return sum > bestSum || (sum == bestSum && key < bestKey0); }
+
+fn row_thread(v: u32) {
+    let lo = rowPtr[v];
+    let hi = rowPtr[v + 1u];
+    var maxW = 0.0;
+    for (var a = lo; a < hi; a = a + 1u) { maxW = max(maxW, weight_of(a)); }
+    let scale = scale_of(maxW, hi - lo);
+    var bk = INVALID_INDEX;
+    var bs = 0u;
+    for (var a = lo; a < hi; a = a + 1u) {
+        let k = keyIn[colIdx[a]];
+        var seen = false;
+        for (var b = lo; b < a; b = b + 1u) { if (keyIn[colIdx[b]] == k) { seen = true; break; } }
+        if (seen) { continue; }                                    // this key was summed at its first arc
+        var sum = 0u;
+        for (var b = a; b < hi; b = b + 1u) { if (keyIn[colIdx[b]] == k) { sum = sum + quantize(weight_of(b), scale); } }
+        if (better(sum, k, bs, bk)) { bk = k; bs = sum; }
+    }
+    bestKey[v] = bk;
+    bestScore[v] = f32(bs) * inverse_of(scale);
+}
+
+fn row_hash(g: u32, lid: u32) {
+    let v = rows[P.rowsBase + g];
+    let base = rows[P.basesBase + g];
+    let lo = rowPtr[v];
+    let hi = rowPtr[v + 1u];
+    let cap = GROUP_HASH_LOAD_FACTOR * (hi - lo);
+    var m = 0.0;
+    for (var a = lo + lid; a < hi; a = a + WG) { m = max(m, weight_of(a)); }
+    shMax[lid] = m;
+    workgroupBarrier();
+    for (var s = WG / 2u; s > 0u; s = s / 2u) {
+        if (lid < s) { shMax[lid] = max(shMax[lid], shMax[lid + s]); }
+        workgroupBarrier();
+    }
+    let scale = scale_of(shMax[0], hi - lo);
+    for (var j = lid; j < cap; j = j + WG) {                       // the region is this workgroup's alone: clear it
+        atomicStore(&hashRegion[base + 2u * j], INVALID_INDEX);
+        atomicStore(&hashRegion[base + 2u * j + 1u], 0u);
+    }
+    storageBarrier();
+    var exhausted = false;
+    for (var a = lo + lid; a < hi; a = a + WG) {
+        let k = keyIn[colIdx[a]];
+        let q = quantize(weight_of(a), scale);
+        var slot = lowbias32(k) % cap;
+        var steps = 0u;
+        loop {
+            if (steps >= cap + 64u) { exhausted = true; break; }   // bounded: a spurious compare-exchange failure is legal (WGSL 17.8.5)
+            steps = steps + 1u;
+            let r = atomicCompareExchangeWeak(&hashRegion[base + 2u * slot], INVALID_INDEX, k);
+            if (r.exchanged || r.old_value == k) { atomicAdd(&hashRegion[base + 2u * slot + 1u], q); break; }
+            if (r.old_value == INVALID_INDEX) { continue; }        // a spurious failure: the same slot again
+            slot = (slot + 1u) % cap;                              // linear probing
+        }
+    }
+    if (exhausted) { atomicStore(&hashRegion[0], 1u); }
+    storageBarrier();
+    var bk = INVALID_INDEX;
+    var bs = 0u;
+    for (var j = lid; j < cap; j = j + WG) {
+        let k = atomicLoad(&hashRegion[base + 2u * j]);
+        if (k != INVALID_INDEX) {
+            let sum = atomicLoad(&hashRegion[base + 2u * j + 1u]);
+            if (better(sum, k, bs, bk)) { bk = k; bs = sum; }
+        }
+    }
+    shKey[lid] = bk;
+    shSum[lid] = bs;
+    workgroupBarrier();
+    for (var s = WG / 2u; s > 0u; s = s / 2u) {
+        if (lid < s && better(shSum[lid + s], shKey[lid + s], shSum[lid], shKey[lid])) {
+            shKey[lid] = shKey[lid + s];
+            shSum[lid] = shSum[lid + s];
+        }
+        workgroupBarrier();
+    }
+    if (lid == 0u) {
+        bestKey[v] = shKey[0];
+        bestScore[v] = f32(shSum[0]) * inverse_of(scale);
+    }
+}
+
+@compute @workgroup_size(WG)
+fn group_by_key_row(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (TIER == 0u) {
+        let i = linear_id(wid, lid.x);
+        if (i < P.count) { row_thread(rows[P.rowsBase + i]); }
+        return;                                                    // TIER is an override: uniform
+    }
+    let g = group_id(wid);
+    if (g >= P.count) { return; }                                  // uniform: the workgroup id and a uniform
+    row_hash(g, lid.x);
+}
+`;
+//# sourceMappingURL=group-by-key-row.wgsl.js.map

package/dist/src/wgsl/group-by-key-row.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by-key-row.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/group-by-key-row.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwH3C,CAAC"}

package/dist/src/wgsl/lpa-step.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `lpa-step` kernel body (design 8.6; label propagation): after `group-by-key-row` has written every vertex's
+ * best neighbour label into `bestKey`, a vertex adopts it only when the move goes the way the pass allows -- down to
+ * a lower label on a pass whose `P.direction` is 0, up to a higher one when it is 1. That is cuGraph's swap-avoidance
+ * rule: two neighbours can no longer trade labels forever, because on any one pass only one of the two moves is
+ * legal. Updates are synchronous (`labelsIn` read, `labelsOut` written) and the moves of a workgroup are added to
+ * `counters[P.counterIndex]` with ONE atomic per workgroup. Body only (spec 3.5, D9); normative text.
+ */
+export declare const lpaStepWgsl = "\nvar<workgroup> moved: atomic<u32>;\n\n@compute @workgroup_size(WG)\nfn lpa_step(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x == 0u) { atomicStore(&moved, 0u); }\n    workgroupBarrier();\n    let v = linear_id(wid, lid.x);\n    if (v < P.n) {\n        let cur = labelsIn[v];\n        let best = bestKey[v];\n        var next = cur;\n        if (best != INVALID_INDEX && best != cur) {\n            let down = best < cur;\n            if (down == (P.direction == 0u)) { next = best; }        // the alternating direction rule\n        }\n        labelsOut[v] = next;\n        if (next != cur) { atomicAdd(&moved, 1u); }\n    }\n    workgroupBarrier();                                            // every lane, unconditionally\n    if (lid.x == 0u) {\n        let m = atomicLoad(&moved);\n        if (m > 0u) { atomicAdd(&counters[P.counterIndex], m); }  // one atomic per workgroup\n    }\n}\n";
+//# sourceMappingURL=lpa-step.wgsl.d.ts.map

package/dist/src/wgsl/lpa-step.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lpa-step.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/lpa-step.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,27BAyBvB,CAAC"}

package/dist/src/wgsl/lpa-step.wgsl.js

@@ -0,0 +1,35 @@
+/**
+ * The `lpa-step` kernel body (design 8.6; label propagation): after `group-by-key-row` has written every vertex's
+ * best neighbour label into `bestKey`, a vertex adopts it only when the move goes the way the pass allows -- down to
+ * a lower label on a pass whose `P.direction` is 0, up to a higher one when it is 1. That is cuGraph's swap-avoidance
+ * rule: two neighbours can no longer trade labels forever, because on any one pass only one of the two moves is
+ * legal. Updates are synchronous (`labelsIn` read, `labelsOut` written) and the moves of a workgroup are added to
+ * `counters[P.counterIndex]` with ONE atomic per workgroup. Body only (spec 3.5, D9); normative text.
+ */
+export const lpaStepWgsl = /* wgsl */ `
+var<workgroup> moved: atomic<u32>;
+
+@compute @workgroup_size(WG)
+fn lpa_step(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x == 0u) { atomicStore(&moved, 0u); }
+    workgroupBarrier();
+    let v = linear_id(wid, lid.x);
+    if (v < P.n) {
+        let cur = labelsIn[v];
+        let best = bestKey[v];
+        var next = cur;
+        if (best != INVALID_INDEX && best != cur) {
+            let down = best < cur;
+            if (down == (P.direction == 0u)) { next = best; }        // the alternating direction rule
+        }
+        labelsOut[v] = next;
+        if (next != cur) { atomicAdd(&moved, 1u); }
+    }
+    workgroupBarrier();                                            // every lane, unconditionally
+    if (lid.x == 0u) {
+        let m = atomicLoad(&moved);
+        if (m > 0u) { atomicAdd(&counters[P.counterIndex], m); }  // one atomic per workgroup
+    }
+}
+`;
+//# sourceMappingURL=lpa-step.wgsl.js.map

package/dist/src/wgsl/lpa-step.wgsl.js.map

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

package/dist/src/wgsl/orient-flags.wgsl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The `orient-flags` kernel body (design 8.5; triangle counting): over the arcs of the simple symmetric graph, arc
+ * `(u, v)` is kept when `(degree(v), v)` is above `(degree(u), u)` lexicographically. The order is strict and total,
+ * so exactly one arc of every undirected edge survives and every triangle is found once, at its lowest-ranked vertex;
+ * the rows stay sorted by target because a compaction preserves order. `src` holds each arc's source. Body only
+ * (spec 3.5, D9); normative text.
+ */
+export declare const orientFlagsWgsl = "\n@compute @workgroup_size(WG)\nfn orient_flags(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let a = linear_id(wid, lid.x);\n    if (a >= P.count) { return; }                                  // no barrier follows\n    let u = src[a];\n    let v = colIdx[a];\n    let du = rowPtr[u + 1u] - rowPtr[u];\n    let dv = rowPtr[v + 1u] - rowPtr[v];\n    let keep = dv > du || (dv == du && v > u);                     // (degree, id) of the target above the source's\n    flags[a] = select(0u, 1u, keep);\n}\n";
+//# sourceMappingURL=orient-flags.wgsl.d.ts.map

package/dist/src/wgsl/orient-flags.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orient-flags.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/orient-flags.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,0iBAY3B,CAAC"}

package/dist/src/wgsl/orient-flags.wgsl.js

@@ -0,0 +1,21 @@
+/**
+ * The `orient-flags` kernel body (design 8.5; triangle counting): over the arcs of the simple symmetric graph, arc
+ * `(u, v)` is kept when `(degree(v), v)` is above `(degree(u), u)` lexicographically. The order is strict and total,
+ * so exactly one arc of every undirected edge survives and every triangle is found once, at its lowest-ranked vertex;
+ * the rows stay sorted by target because a compaction preserves order. `src` holds each arc's source. Body only
+ * (spec 3.5, D9); normative text.
+ */
+export const orientFlagsWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn orient_flags(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let a = linear_id(wid, lid.x);
+    if (a >= P.count) { return; }                                  // no barrier follows
+    let u = src[a];
+    let v = colIdx[a];
+    let du = rowPtr[u + 1u] - rowPtr[u];
+    let dv = rowPtr[v + 1u] - rowPtr[v];
+    let keep = dv > du || (dv == du && v > u);                     // (degree, id) of the target above the source's
+    flags[a] = select(0u, 1u, keep);
+}
+`;
+//# sourceMappingURL=orient-flags.wgsl.js.map

package/dist/src/wgsl/orient-flags.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orient-flags.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/orient-flags.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;CAYzC,CAAC"}

package/dist/src/wgsl/run-flags.wgsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The `run-flags` kernel body (design 6 row 10; the simple symmetric graph build): over arcs sorted by the pair
+ * (`keysA`, `keysB`), `flags[i]` is 1 exactly when arc `i` opens a run of equal pairs -- the first arc, or one whose
+ * pair differs from its predecessor's -- and is not a dropped arc (`keysA[i] == INVALID_INDEX`). An exclusive scan
+ * of the flags numbers the runs, which is how parallel arcs merge into one. Body only (spec 3.5, D9); normative text.
+ */
+export declare const runFlagsWgsl = "\n@compute @workgroup_size(WG)\nfn run_flags(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    if (i >= P.count) { return; }                                  // no barrier follows\n    let a = keysA[i];\n    var first = a != INVALID_INDEX;                                // a dropped arc never opens a run\n    if (i > 0u) { first = first && (a != keysA[i - 1u] || keysB[i] != keysB[i - 1u]); }\n    flags[i] = select(0u, 1u, first);\n}\n";
+//# sourceMappingURL=run-flags.wgsl.d.ts.map

package/dist/src/wgsl/run-flags.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-flags.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/run-flags.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,YAAY,ygBAUxB,CAAC"}

package/dist/src/wgsl/run-flags.wgsl.js

@@ -0,0 +1,18 @@
+/**
+ * The `run-flags` kernel body (design 6 row 10; the simple symmetric graph build): over arcs sorted by the pair
+ * (`keysA`, `keysB`), `flags[i]` is 1 exactly when arc `i` opens a run of equal pairs -- the first arc, or one whose
+ * pair differs from its predecessor's -- and is not a dropped arc (`keysA[i] == INVALID_INDEX`). An exclusive scan
+ * of the flags numbers the runs, which is how parallel arcs merge into one. Body only (spec 3.5, D9); normative text.
+ */
+export const runFlagsWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn run_flags(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i >= P.count) { return; }                                  // no barrier follows
+    let a = keysA[i];
+    var first = a != INVALID_INDEX;                                // a dropped arc never opens a run
+    if (i > 0u) { first = first && (a != keysA[i - 1u] || keysB[i] != keysB[i - 1u]); }
+    flags[i] = select(0u, 1u, first);
+}
+`;
+//# sourceMappingURL=run-flags.wgsl.js.map

package/dist/src/wgsl/run-flags.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-flags.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/run-flags.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;CAUtC,CAAC"}

package/dist/src/wgsl/tri-intersect.wgsl.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The `tri-intersect` kernel body (design 8.5): one invocation per ORIENTED arc `(u, v)`; every common target `w` of
+ * the oriented rows of `u` and `v` closes a triangle, found exactly once. The rows are sorted by target, so they are
+ * intersected by a merge, or -- when one row is more than TRIANGLE_BINARY_SEARCH_RATIO times the other -- by a binary
+ * search of each element of the shorter row in the longer. SEARCH forces a path: 0 chooses, 1 always merges, 2
+ * always searches (the tier-agreement tests compare the two). `counts` gains one per triangle at `w` as it is found
+ * and the arc's triangle count at `u` and `v` once at the end: u32 atomics, so the counts are exact and
+ * order-independent. Body only (spec 3.5, D9); normative text.
+ */
+export declare const triIntersectWgsl = "\nfn contains(lo0: u32, hi0: u32, x: u32) -> bool {                  // binary search of x in colIdx[lo0, hi0), sorted ascending\n    var lo = lo0;\n    var hi = hi0;\n    loop {\n        if (lo >= hi) { break; }\n        let mid = lo + (hi - lo) / 2u;\n        let y = colIdx[mid];\n        if (y == x) { return true; }\n        if (y < x) { lo = mid + 1u; } else { hi = mid; }\n    }\n    return false;\n}\n\n@compute @workgroup_size(WG)\nfn tri_intersect(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let a = linear_id(wid, lid.x);\n    if (a >= P.count) { return; }                                  // no barrier follows\n    let u = src[a];\n    let v = colIdx[a];\n    let uLo = rowPtr[u];\n    let uHi = rowPtr[u + 1u];\n    let vLo = rowPtr[v];\n    let vHi = rowPtr[v + 1u];\n    let du = uHi - uLo;\n    let dv = vHi - vLo;\n    var search = SEARCH == 2u;\n    if (SEARCH == 0u) { search = du / TRIANGLE_BINARY_SEARCH_RATIO > dv || dv / TRIANGLE_BINARY_SEARCH_RATIO > du; }\n    var found = 0u;\n    if (search) {\n        var sLo = uLo;\n        var sHi = uHi;\n        var lLo = vLo;\n        var lHi = vHi;\n        if (du > dv) { sLo = vLo; sHi = vHi; lLo = uLo; lHi = uHi; }\n        for (var k = sLo; k < sHi; k = k + 1u) {\n            let w = colIdx[k];\n            if (contains(lLo, lHi, w)) { atomicAdd(&counts[w], 1u); found = found + 1u; }\n        }\n    } else {\n        var i = uLo;\n        var j = vLo;\n        loop {\n            if (i >= uHi || j >= vHi) { break; }\n            let x = colIdx[i];\n            let y = colIdx[j];\n            if (x == y) { atomicAdd(&counts[x], 1u); found = found + 1u; i = i + 1u; j = j + 1u; }\n            else if (x < y) { i = i + 1u; }\n            else { j = j + 1u; }\n        }\n    }\n    if (found > 0u) { atomicAdd(&counts[u], found); atomicAdd(&counts[v], found); }\n}\n";
+//# sourceMappingURL=tri-intersect.wgsl.d.ts.map

package/dist/src/wgsl/tri-intersect.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri-intersect.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/tri-intersect.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,22DAqD5B,CAAC"}

package/dist/src/wgsl/tri-intersect.wgsl.js

@@ -0,0 +1,64 @@
+/**
+ * The `tri-intersect` kernel body (design 8.5): one invocation per ORIENTED arc `(u, v)`; every common target `w` of
+ * the oriented rows of `u` and `v` closes a triangle, found exactly once. The rows are sorted by target, so they are
+ * intersected by a merge, or -- when one row is more than TRIANGLE_BINARY_SEARCH_RATIO times the other -- by a binary
+ * search of each element of the shorter row in the longer. SEARCH forces a path: 0 chooses, 1 always merges, 2
+ * always searches (the tier-agreement tests compare the two). `counts` gains one per triangle at `w` as it is found
+ * and the arc's triangle count at `u` and `v` once at the end: u32 atomics, so the counts are exact and
+ * order-independent. Body only (spec 3.5, D9); normative text.
+ */
+export const triIntersectWgsl = /* wgsl */ `
+fn contains(lo0: u32, hi0: u32, x: u32) -> bool {                  // binary search of x in colIdx[lo0, hi0), sorted ascending
+    var lo = lo0;
+    var hi = hi0;
+    loop {
+        if (lo >= hi) { break; }
+        let mid = lo + (hi - lo) / 2u;
+        let y = colIdx[mid];
+        if (y == x) { return true; }
+        if (y < x) { lo = mid + 1u; } else { hi = mid; }
+    }
+    return false;
+}
+
+@compute @workgroup_size(WG)
+fn tri_intersect(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let a = linear_id(wid, lid.x);
+    if (a >= P.count) { return; }                                  // no barrier follows
+    let u = src[a];
+    let v = colIdx[a];
+    let uLo = rowPtr[u];
+    let uHi = rowPtr[u + 1u];
+    let vLo = rowPtr[v];
+    let vHi = rowPtr[v + 1u];
+    let du = uHi - uLo;
+    let dv = vHi - vLo;
+    var search = SEARCH == 2u;
+    if (SEARCH == 0u) { search = du / TRIANGLE_BINARY_SEARCH_RATIO > dv || dv / TRIANGLE_BINARY_SEARCH_RATIO > du; }
+    var found = 0u;
+    if (search) {
+        var sLo = uLo;
+        var sHi = uHi;
+        var lLo = vLo;
+        var lHi = vHi;
+        if (du > dv) { sLo = vLo; sHi = vHi; lLo = uLo; lHi = uHi; }
+        for (var k = sLo; k < sHi; k = k + 1u) {
+            let w = colIdx[k];
+            if (contains(lLo, lHi, w)) { atomicAdd(&counts[w], 1u); found = found + 1u; }
+        }
+    } else {
+        var i = uLo;
+        var j = vLo;
+        loop {
+            if (i >= uHi || j >= vHi) { break; }
+            let x = colIdx[i];
+            let y = colIdx[j];
+            if (x == y) { atomicAdd(&counts[x], 1u); found = found + 1u; i = i + 1u; j = j + 1u; }
+            else if (x < y) { i = i + 1u; }
+            else { j = j + 1u; }
+        }
+    }
+    if (found > 0u) { atomicAdd(&counts[u], found); atomicAdd(&counts[v], found); }
+}
+`;
+//# sourceMappingURL=tri-intersect.wgsl.js.map

package/dist/src/wgsl/tri-intersect.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri-intersect.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/tri-intersect.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqD1C,CAAC"}