@graphty/webgpu-graph-algorithms 0.6.26 → 0.6.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphty/webgpu-graph-algorithms",
-  "version": "0.6.26",
+  "version": "0.6.28",
   "description": "WebGPU-accelerated graph algorithms and layouts over the @graphty/graph-format snapshot, for Node (Dawn) and browsers",
   "author": "Adam Powers <apowers@ato.ms>",
   "type": "module",
@@ -21,6 +21,12 @@
       "types": "./dist/node.d.ts",
       "import": "./dist/node.js",
       "default": "./dist/node.js"
+    },
+    "./acquire": {
+      "types": "./dist/acquire.d.ts",
+      "browser": "./dist/browser.js",
+      "node": "./dist/node.js",
+      "default": "./dist/browser.js"
     }
   },
   "sideEffects": false,
@@ -61,7 +67,7 @@
   "homepage": "https://github.com/graphty-org/graphty-monorepo/tree/master/webgpu-graph-algorithms#readme",
   "dependencies": {
     "@webgpu/types": "^0.1.72",
-    "@graphty/graph-format": "^1.2.6"
+    "@graphty/graph-format": "^1.3.0"
   },
   "peerDependencies": {
     "@graphty/algorithms": "^1.0.0 || ^2.0.0 || ^3.0.0",
@@ -95,8 +101,8 @@
     "vite": "^7.0.5",
     "vitest": "4.1.11",
     "webgpu": "0.4.0",
-    "@graphty/layout": "^2.0.9",
-    "@graphty/algorithms": "^3.1.8"
+    "@graphty/layout": "^2.2.0",
+    "@graphty/algorithms": "^3.3.0"
   },
   "scripts": {
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",

package/src/accelerator.ts

@@ -175,6 +175,7 @@ export function createAccelerator(ctx: GpuContext, options?: AcceleratorOptions)
     const frozen = freezeOptions(options);
     return {
         kind: "webgpu",
+        harmonicCloseness: true,
         ctx,
         options: frozen,
         /**
@@ -357,10 +358,11 @@ export function createAccelerator(ctx: GpuContext, options?: AcceleratorOptions)
             );
         },
         /**
-         * Closeness centrality on the device (spec 8.4; P8-T13): the bit-parallel multi-source sweep, or one `sssp`
-         * per source when `weighted`. `maxIterations` / `tolerance` are refused when defined (P8 PD-25).
+         * Closeness centrality on the device (spec 8.4): the all-pairs sweep with a row sum on small and
+         * weighted graphs, the bit-parallel multi-source search otherwise, one `sssp` per source for a weighted graph
+         * above the all-pairs ceiling. `maxIterations` / `tolerance` are refused when defined (P8 PD-25).
          * @param gs - the snapshot
-         * @param o - `weighted`, and a sampled run's `sources` (undirected snapshots only)
+         * @param o - `weighted`, `harmonic` (exact runs), and a sampled run's `sources` (undirected snapshots only)
          * @returns the f32 scores with `precision: "f32"` (spec 9.7) and `sourcesUsed`
          */
         async closenessCentrality(gs: GraphSnapshot, o?: ClosenessAcceleratorOptions): Promise<GpuClosenessResult> {

package/src/algorithms/all-pairs.ts

@@ -34,14 +34,18 @@ import { APSP_PARAMS, FILL_PARAMS, graphBindings, graphOverrides, kernelSpec } f
 import { assertWholeCore } from "../primitives/core-shape.js";
 import { assertDeviceComputes } from "../primitives/verify.js";
 import { type ApspOptions, type GpuApspResult } from "../types/all-pairs.js";
+import { type Binding } from "../types/memory.js";
 import { type GpuRunOptions } from "../types/run.js";
-import { algorithmScope } from "./scope.js";
+import { type AlgorithmScope, algorithmScope } from "./scope.js";
 import { aborted, bindingOf, checkDest } from "./sssp.js";
 
 const ALGORITHM = "allPairsShortestPath";
 
-/** The rounds one submit holds by default: three dispatches per round. */
-const DEFAULT_ROUNDS_PER_SUBMIT = Math.floor(APSP_MAX_DISPATCHES_PER_SUBMIT / 3);
+/**
+ * The rounds one submit holds by default: three dispatches per round.
+ * @internal
+ */
+export const DEFAULT_ROUNDS_PER_SUBMIT = Math.floor(APSP_MAX_DISPATCHES_PER_SUBMIT / 3);
 
 /**
  * The knobs the tests need and nothing public offers.
@@ -79,6 +83,83 @@ export function allPairsCeiling(limits: Pick<GPUSupportedLimits, "maxStorageBuff
     return { maxNodes, limit, limitName };
 }
 
+/**
+ * The blocked sweep itself, shared with closeness's all-pairs route: the `n x n` matrix leased from `scope`, filled,
+ * initialised from the arcs and swept to the shortest distances, every submit awaited; the matrix stays on the device.
+ * The caller has checked the ceiling and the weights.
+ * @internal
+ * @param ctx - the context
+ * @param s - the snapshot (n > 0)
+ * @param scope - the scope that leases the matrix and the params records (`min(roundsPerSubmit, blocks) + 2` slots)
+ * @param weighted - true sums the snapshot's weights, false counts hops
+ * @param roundsPerSubmit - the rounds recorded per submit
+ * @param options - signal / onProgress (rounds done of `ceil(n / 32)`)
+ * @param algorithm - the name errors carry
+ * @returns the matrix binding (`4 n^2` bytes, row-major, `dist[i * n + j]` from `i` to `j`)
+ */
+export async function sweepAllPairs(
+    ctx: GpuContext,
+    s: GraphSnapshot,
+    scope: AlgorithmScope,
+    weighted: boolean,
+    roundsPerSubmit: number,
+    options: GpuRunOptions | undefined,
+    algorithm: string,
+): Promise<Binding> {
+    const n = s.nodeCount;
+    const core = ctx.residency.core(s);
+    assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, algorithm);
+    const blocks = Math.ceil(n / APSP_TILE);
+    const wg = ctx.workgroupSize;
+    const bytes = 4 * n * n;
+    const matrix = bindingOf(scope.scratch(bytes, "dist"), bytes);
+    await ctx.allocator.check();
+    const weightsBinding = weighted ? undefined : null;
+    const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+    const init = await ctx.pipelines.kernel(kernelSpec("apsp-init", graphOverrides(core, null, weightsBinding)));
+    const phases = await Promise.all(
+        [0, 1, 2].map((phase) => ctx.pipelines.kernel(kernelSpec("apsp-fw", { PHASE: phase }))),
+    );
+    const graph = graphBindings(core, null, weightsBinding);
+    const others = blocks - 1;
+    const phasePlans = [plan2d(1, ctx.caps), plan2d(2 * others, ctx.caps), plan2d(others * others, ctx.caps)];
+
+    for (let first = 0; first < blocks; first += roundsPerSubmit) {
+        const batch = new CommandBatch(ctx, `${algorithm}/sweep`);
+        const pass = batch.pass("apsp");
+        if (first === 0) {
+            const fillParams = scope.params(FILL_PARAMS, { count: n * n, value: F32_INF_BITS, mode: 0, pad0: 0 });
+            fill.dispatch(pass, fill.bind({ dst: matrix, P: fillParams.binding }), plan1d(n * n, wg, ctx.caps), [
+                fillParams.offset,
+            ]);
+            const initParams = scope.params(APSP_PARAMS, { n, round: 0, blocks, infBits: F32_INF_BITS });
+            init.dispatch(pass, init.bind({ ...graph, dist: matrix, P: initParams.binding }), plan1d(n, wg, ctx.caps), [
+                initParams.offset,
+            ]);
+        }
+        const last = Math.min(first + roundsPerSubmit, blocks);
+        for (let round = first; round < last; round++) {
+            const params = scope.params(APSP_PARAMS, { n, round, blocks, infBits: F32_INF_BITS });
+            for (let phase = 0; phase < 3; phase++) {
+                const kernel = phases[phase];
+                kernel.dispatch(pass, kernel.bind({ dist: matrix, P: params.binding }), phasePlans[phase], [
+                    params.offset,
+                ]);
+            }
+        }
+        batch.endPass();
+        scope.flush();
+        const submitted = batch.submit();
+        await submitted.readback;
+        ctx.assertReady();
+        options?.onProgress?.(last, blocks);
+        if (options?.signal?.aborted) {
+            throw aborted(algorithm, submitted.id);
+        }
+    }
+    return matrix;
+}
+
 /**
  * All-pairs shortest paths with the test knobs; `allPairsShortestPath` is this with an empty tuning.
  * @internal
@@ -145,61 +226,10 @@ export async function allPairsWithTuning(
         return { dist, n };
     }
     await assertDeviceComputes(ctx);
-    const core = ctx.residency.core(s);
-    assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM);
-    const blocks = Math.ceil(n / APSP_TILE);
-    const scope = algorithmScope(ctx, ALGORITHM, Math.min(roundsPerSubmit, blocks) + 2);
+    const scope = algorithmScope(ctx, ALGORITHM, Math.min(roundsPerSubmit, Math.ceil(n / APSP_TILE)) + 2);
     try {
-        const wg = ctx.workgroupSize;
+        const matrix = await sweepAllPairs(ctx, s, scope, weighted, roundsPerSubmit, options, ALGORITHM);
         const bytes = 4 * n * n;
-        const matrix = bindingOf(scope.scratch(bytes, "dist"), bytes);
-        await ctx.allocator.check();
-        const weightsBinding = weighted ? undefined : null;
-        const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
-        const init = await ctx.pipelines.kernel(kernelSpec("apsp-init", graphOverrides(core, null, weightsBinding)));
-        const phases = await Promise.all(
-            [0, 1, 2].map((phase) => ctx.pipelines.kernel(kernelSpec("apsp-fw", { PHASE: phase }))),
-        );
-        const graph = graphBindings(core, null, weightsBinding);
-        const others = blocks - 1;
-        const phasePlans = [plan2d(1, ctx.caps), plan2d(2 * others, ctx.caps), plan2d(others * others, ctx.caps)];
-
-        for (let first = 0; first < blocks; first += roundsPerSubmit) {
-            const batch = new CommandBatch(ctx, `${ALGORITHM}/sweep`);
-            const pass = batch.pass("apsp");
-            if (first === 0) {
-                const fillParams = scope.params(FILL_PARAMS, { count: n * n, value: F32_INF_BITS, mode: 0, pad0: 0 });
-                fill.dispatch(pass, fill.bind({ dst: matrix, P: fillParams.binding }), plan1d(n * n, wg, ctx.caps), [
-                    fillParams.offset,
-                ]);
-                const initParams = scope.params(APSP_PARAMS, { n, round: 0, blocks, infBits: F32_INF_BITS });
-                init.dispatch(
-                    pass,
-                    init.bind({ ...graph, dist: matrix, P: initParams.binding }),
-                    plan1d(n, wg, ctx.caps),
-                    [initParams.offset],
-                );
-            }
-            const last = Math.min(first + roundsPerSubmit, blocks);
-            for (let round = first; round < last; round++) {
-                const params = scope.params(APSP_PARAMS, { n, round, blocks, infBits: F32_INF_BITS });
-                for (let phase = 0; phase < 3; phase++) {
-                    const kernel = phases[phase];
-                    kernel.dispatch(pass, kernel.bind({ dist: matrix, P: params.binding }), phasePlans[phase], [
-                        params.offset,
-                    ]);
-                }
-            }
-            batch.endPass();
-            scope.flush();
-            const submitted = batch.submit();
-            await submitted.readback;
-            ctx.assertReady();
-            options?.onProgress?.(last, blocks);
-            if (options?.signal?.aborted) {
-                throw aborted(ALGORITHM, submitted.id);
-            }
-        }
         await ctx.readback.read(matrix.buffer, bytes, dist);
         ctx.assertReady();
         return { dist, n };

package/src/algorithms/betweenness.ts

@@ -30,7 +30,7 @@
  *
  * The batch size k is planned from the device limits at 16 bytes per (node, source) -- the three arrays design 4.7
  * counts plus the 4-byte log entry it omits -- as `min(floor(maxStorageBufferBindingSize / 4n), floor(0.25 x
- * maxBufferSize / 16n), 64)`, at least 1 (`planBatchSize`); a graph whose single source does not fit one binding is
+ * maxBufferSize / 16n), BC_MAX_BATCH)` (256), at least 1 (`planBatchSize`); a graph whose single source does not fit one binding is
  * E_TOO_LARGE. The forward form is chosen per batch: the first batch runs `bc-forward`; a later one runs the
  * edge-parallel form when the previous batch's level count -- the MAXIMUM depth over its sources, the only depth
  * figure the host has, which over-estimates the median of design 8.4's rule and so errs toward the frontier form --
@@ -153,7 +153,7 @@ interface RawBetweenness {
 
 /**
  * The source batch size (design 8.4, 10.1): `min(floor(maxStorageBufferBindingSize / 4n), floor(0.25 x maxBufferSize /
- * 16n), 64, remaining)`, at least 1. Each of the four `n x k` arrays is one binding of `4 n k` bytes, and the batch's
+ * 16n), BC_MAX_BATCH, remaining)`, at least 1. Each of the four `n x k` arrays is one binding of `4 n k` bytes, and the batch's
  * four together stay inside a quarter of the largest buffer.
  * @internal
  * @param n - the vertex count (>= 1)