@graphty/webgpu-graph-algorithms 0.6.15 → 0.6.17

package/src/wgsl/apsp-fw.wgsl.ts

@@ -0,0 +1,112 @@
+/**
+ * The `apsp-fw` kernel body (design 8.7): one phase of one round of blocked Floyd-Warshall over `APSP_TILE x
+ * APSP_TILE` blocks of the row-major `n x n` matrix `dist`. Round `r` (`P.round`) runs three dispatches in order,
+ * the `PHASE` override choosing which:
+ *
+ * - PHASE 0, one workgroup: the pivot block `(r, r)`, staged in `tileA` and updated in place.
+ * - PHASE 1, `2 (B - 1)` workgroups (`B` = `P.blocks`): every other block of block row `r` (the first `B - 1`
+ *   workgroups) and of block column `r` (the rest). The pivot block is staged in `tileA`, the block itself in
+ *   `tileB`, updated in place.
+ * - PHASE 2, `(B - 1)^2` workgroups: every block `(i, j)` off the pivot row and column. Its two operands are the
+ *   pivot-COLUMN block `(i, r)` in `tileA` and the pivot-ROW block `(r, j)` in `tileB`; its own cells are read,
+ *   minimised over the 32 steps and written by one lane each, never shared, so they stay in registers.
+ *
+ * In-place updates are race-free because a cell is written only when the candidate is STRICTLY smaller: the cells
+ * every lane reads in step `k` (column `k` and row `k` of the tile) would be updated with `d + d[k][k]`, and the
+ * diagonal is `0` (weights are non-negative, which the driver checks) or `+Infinity` outside the matrix, so they are
+ * never written in step `k`. Every barrier is reached in uniform control flow: the early return keys on the workgroup
+ * id and uniforms only, the per-lane loops hold no barrier, and the lanes of an edge tile load `+Infinity` for a cell
+ * outside `n x n` (it offers no path; read from `P.infBits` because Tint refuses `+Infinity` as a constant) and
+ * store nothing there -- the matrix is exactly `n * n`, never padded, so the
+ * ceiling is `floor(sqrt(maxStorageBufferBindingSize / 4))`. 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 apspFwWgsl = /* wgsl */ `
+var<workgroup> tileA: array<f32, APSP_TILE * APSP_TILE>;
+var<workgroup> tileB: array<f32, APSP_TILE * APSP_TILE>;
+
+fn tile_row(block: vec2<u32>, c: u32) -> u32 { return block.x * APSP_TILE + c / APSP_TILE; }
+fn tile_col(block: vec2<u32>, c: u32) -> u32 { return block.y * APSP_TILE + c % APSP_TILE; }
+
+fn load_cell(block: vec2<u32>, c: u32) -> f32 {
+    let i = tile_row(block, c);
+    let j = tile_col(block, c);
+    if (i < P.n && j < P.n) { return dist[i * P.n + j]; }
+    return bitcast<f32>(P.infBits);                                   // outside the matrix: no path through it
+}
+
+fn store_cell(block: vec2<u32>, c: u32, v: f32) {
+    let i = tile_row(block, c);
+    let j = tile_col(block, c);
+    if (i >= P.n || j >= P.n) { return; }                            // an edge tile stores nothing outside n x n
+    dist[i * P.n + j] = v;
+}
+
+@compute @workgroup_size(WG)
+fn apsp_fw(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let g = group_id(wid);
+    let r = P.round;
+    let others = max(P.blocks, 2u) - 1u;                             // the blocks of a strip, the pivot excluded
+    let cells = APSP_TILE * APSP_TILE;
+    var count = 1u;
+    var own = vec2<u32>(r, r);                                        // the block this workgroup updates
+    var a = vec2<u32>(r, r);                                          // staged in tileA
+    var b = vec2<u32>(r, r);                                          // staged in tileB
+    if (PHASE == 1u) {
+        count = 2u * others;
+        let s = g % others;
+        let o = select(s, s + 1u, s >= r);                            // a strip skips the pivot block
+        own = select(vec2<u32>(o, r), vec2<u32>(r, o), g < others);   // block row r first, then block column r
+        b = own;
+    }
+    if (PHASE == 2u) {
+        count = others * others;
+        let i = g / others;
+        let j = g % others;
+        own = vec2<u32>(select(i, i + 1u, i >= r), select(j, j + 1u, j >= r));
+        a = vec2<u32>(own.x, r);                                      // the pivot-column block (i, r)
+        b = vec2<u32>(r, own.y);                                      // the pivot-row block (r, j)
+    }
+    if (g >= count) { return; }                                       // uniform: the workgroup id and uniforms only
+
+    for (var c = lid.x; c < cells; c = c + WG) {
+        tileA[c] = load_cell(a, c);
+        if (PHASE != 0u) { tileB[c] = load_cell(b, c); }
+    }
+    workgroupBarrier();                                               // every staged cell is visible
+
+    if (PHASE == 2u) {
+        for (var c = lid.x; c < cells; c = c + WG) {
+            let x = c / APSP_TILE;
+            let y = c % APSP_TILE;
+            var v = load_cell(own, c);
+            for (var kr = 0u; kr < APSP_TILE; kr = kr + 1u) {
+                v = min(v, tileA[x * APSP_TILE + kr] + tileB[kr * APSP_TILE + y]);
+            }
+            store_cell(own, c, v);
+        }
+        return;
+    }
+
+    let pivotRow = PHASE == 1u && own.x == r;                          // block row r reads d[x][k] from the pivot
+    for (var k = 0u; k < APSP_TILE; k = k + 1u) {
+        for (var c = lid.x; c < cells; c = c + WG) {
+            let x = c / APSP_TILE;
+            let y = c % APSP_TILE;
+            if (PHASE == 0u) {
+                let via = tileA[x * APSP_TILE + k] + tileA[k * APSP_TILE + y];
+                if (via < tileA[c]) { tileA[c] = via; }
+            } else {
+                let left = select(tileB[x * APSP_TILE + k], tileA[x * APSP_TILE + k], pivotRow);
+                let right = select(tileA[k * APSP_TILE + y], tileB[k * APSP_TILE + y], pivotRow);
+                let via = left + right;
+                if (via < tileB[c]) { tileB[c] = via; }
+            }
+        }
+        workgroupBarrier();                                           // step k is complete before step k + 1 reads
+    }
+    for (var c = lid.x; c < cells; c = c + WG) {
+        store_cell(own, c, select(tileB[c], tileA[c], PHASE == 0u));
+    }
+}
+`;

package/src/wgsl/apsp-init.wgsl.ts

@@ -0,0 +1,25 @@
+/**
+ * The `apsp-init` kernel body (design 8.7): writes the arcs into the `n x n` distance matrix after `fill` has set
+ * every entry to `+Infinity`. One lane per ROW `u`: it walks `u`'s arcs and keeps the cheapest weight per target
+ * (`min`), so parallel arcs collapse to the cheapest one, then writes the diagonal zero LAST, so a self-loop never
+ * displaces it. Every arc of row `u` lands in row `u` of the matrix and only this lane writes that row, so there is
+ * no race and no atomic. Unweighted (`HAS_WEIGHTS` false) every arc costs 1. A directed snapshot writes its one
+ * direction; an undirected one stores both arcs of every edge, so both halves are written. The driver refuses
+ * negative and non-finite weights before any dispatch. 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 apspInitWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn apsp_init(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let u = linear_id(wid, lid.x);
+    if (u >= P.n) { return; }
+    let rowBase = u * P.n;
+    let end = rowPtr[u + 1u];
+    for (var a = rowPtr[u]; a < end; a = a + 1u) {
+        let v = colIdx[a];
+        let w = select(1.0, weights[a], HAS_WEIGHTS);
+        dist[rowBase + v] = min(dist[rowBase + v], w);               // parallel arcs collapse to the cheapest
+    }
+    dist[rowBase + u] = 0.0;                                          // last: a self-loop never displaces the zero
+}
+`;

package/src/wgsl/coo-emit.wgsl.ts

@@ -0,0 +1,32 @@
+/**
+ * The `coo-emit` kernel body (design 6 row 10, 8.6; the first step of the simple symmetric graph build): position `i`
+ * takes arc `a` -- `i` itself, or `order[i]` under INDEXED, which is how a sorted permutation is materialised -- and
+ * writes that arc's source, target and weight. Arc `2e` is logical edge `e` as declared and arc `2e + 1` its reverse,
+ * so every edge lands in both directions and the result is symmetric whatever the snapshot's directedness. A
+ * self-loop is dropped: both of its arcs are written as `INVALID_INDEX`, which sorts after every node index and which
+ * `run-flags` never marks. Weights are 1 without WEIGHTED. Body only (spec 3.5, D9); normative text.
+ */
+export const cooEmitWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn coo_emit(@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
+    var a = i;
+    if (INDEXED) { a = order[i]; }                                 // the arc this position takes
+    let e = a / 2u;                                                // arc 2e is edge e as declared, arc 2e + 1 its reverse
+    let forward = (a % 2u) == 0u;
+    let u = edgeSrc[e];
+    let v = edgeDst[e];
+    var w = 1.0;
+    if (WEIGHTED) { w = edgeWeight[e]; }
+    if (u == v) {                                                  // a self-loop is dropped: both arcs sort last and never open a run
+        outSrc[i] = INVALID_INDEX;
+        outDst[i] = INVALID_INDEX;
+        outWeight[i] = 0.0;
+        return;
+    }
+    outSrc[i] = select(v, u, forward);
+    outDst[i] = select(u, v, forward);
+    outWeight[i] = w;
+}
+`;

package/src/wgsl/coo-scatter.wgsl.ts

@@ -0,0 +1,31 @@
+/**
+ * The `coo-scatter` kernel body (design 6 row 10): the last step of `cooToCsr`, after the histogram of the sources
+ * and its exclusive scan into `rowPtr`. Two modes under SORTED_INPUT.
+ *
+ * SORTED_INPUT false is the design's cursor scatter: an arc reserves its slot with `atomicAdd` on its row's cursor
+ * (`cursors`, zeroed by the caller), so slots are handed out in race order and a row is NOT sorted by target even when
+ * the input was.
+ *
+ * SORTED_INPUT true takes arcs already ordered by source: arc `i` then sits at its own index minus its row's start
+ * inside the row, no cursor and no atomic, so the write is a pure function of the input and the input order survives
+ * into every row. The precondition is checked, not trusted: an arc whose source is below its predecessor's raises
+ * `cursors[0]`, the word the driver reads back and refuses. Body only (spec 3.5, D9); normative text.
+ */
+export const cooScatterWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn coo_scatter(@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 s = src[i];
+    var slot = 0u;
+    if (SORTED_INPUT) {
+        if (i > 0u && s < src[i - 1u]) { atomicStore(&cursors[0], 1u); }   // unsorted input: the flag the driver refuses
+        let within = i - rowPtr[s];                                // the arc's place in its row
+        slot = rowPtr[s] + within;
+    } else {
+        slot = rowPtr[s] + atomicAdd(&cursors[s], 1u);             // race order: the row is not sorted in this mode
+    }
+    colIdx[slot] = dst[i];
+    if (WEIGHTED) { outWeight[slot] = weight[i]; }
+}
+`;

package/src/wgsl/group-by-key-row.wgsl.ts

@@ -0,0 +1,145 @@
+/**
+ * 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);
+}
+`;

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

@@ -0,0 +1,34 @@
+/**
+ * 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
+    }
+}
+`;

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

@@ -0,0 +1,20 @@
+/**
+ * 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);
+}
+`;

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

@@ -0,0 +1,17 @@
+/**
+ * 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);
+}
+`;

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

@@ -0,0 +1,63 @@
+/**
+ * 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); }
+}
+`;