@graphty/webgpu-graph-algorithms 0.6.19 → 0.6.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphty/webgpu-graph-algorithms",
-  "version": "0.6.19",
+  "version": "0.6.20",
   "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",
@@ -61,7 +61,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.5"
+    "@graphty/graph-format": "^1.2.6"
   },
   "peerDependencies": {
     "@graphty/algorithms": "^1.0.0 || ^2.0.0 || ^3.0.0",
@@ -95,8 +95,8 @@
     "vite": "^7.0.5",
     "vitest": "4.1.11",
     "webgpu": "0.4.0",
-    "@graphty/algorithms": "^3.1.3",
-    "@graphty/layout": "^2.0.5"
+    "@graphty/algorithms": "^3.1.4",
+    "@graphty/layout": "^2.0.6"
   },
   "scripts": {
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",

package/src/algorithms/bellman-ford.ts

@@ -8,7 +8,7 @@
  * `changed` after it IS `hasNegativeCycle`; the last batch is clamped so the reported round count never exceeds
  * `n - 1`. `dist` holds f32 bit patterns and the claim is a BOUNDED compare-exchange (PD-12: `MAX_RETRIES`, because
  * with a negative distance the bit-pattern order reverses and `atomicMin` is wrong, and WGSL lets the exchange fail
- * spuriously): a lane that exhausts the bound raises `retryExhausted`, which the driver treats as changed and runs
+ * spuriously; only those spurious failures count, never a loss to another lane's improvement, issue #470): a lane that exhausts the bound raises `retryExhausted`, which the driver treats as changed and runs
  * on -- the lost update is retried by the next round, which examines every edge anyway -- and tallies for the tests;
  * raised in the decision round it is E_VALIDATION, never a guess.
  *
@@ -74,7 +74,7 @@ const ALGORITHM = "bellmanFord";
 /** Design 8.4: the changed flag is read every 8 rounds (one `mapAsync` per batch). */
 const ROUNDS_PER_BATCH = 8;
 
-/** PD-12: the compare-exchange retry bound per lane (contention is per vertex, not global); `components.ts`'s `MAX_STEPS` idiom. */
+/** PD-12: the bound on one lane's SPURIOUS compare-exchange failures (a loss to another lane is not counted, issue #470). */
 const MAX_RETRIES = 16;
 
 /**
@@ -89,7 +89,7 @@ const RING_SLOTS = MAX_LEVELS_PER_SUBMIT + 16;
  * @internal
  */
 export interface BellmanFordTuning {
-    /** The compare-exchange retry bound per lane (default `MAX_RETRIES`); 1 makes every failed exchange exhaust it. */
+    /** The compare-exchange retry bound per lane (default `MAX_RETRIES`), on spurious failures only; 1 makes the first one exhaust it. */
     readonly maxRetries?: number | undefined;
     /** Rounds recorded per batch (default `ROUNDS_PER_BATCH`), each batch one readback of the flags. */
     readonly roundsPerBatch?: number | undefined;

package/src/algorithms/power-iteration.ts

@@ -124,6 +124,9 @@ export function coreOf(ctx: GpuContext, s: GraphSnapshot, algorithm: string): Co
  * @returns the reverse core
  */
 export function reverseOf(ctx: GpuContext, s: GraphSnapshot): CoreBinding {
+    // core() is what records (or re-records, after a release) the snapshot in the residency; Katz binds only this
+    // view, so without it a released snapshot is E_RELEASED instead of uploaded again (issue #623)
+    ctx.residency.core(s, ["rowPtr"]);
     const view = ctx.residency.view(s, "reverse");
     return coreOfView(view, view.scalars.arcCount[0]);
 }

package/src/wgsl/bf-relax.wgsl.ts

@@ -8,7 +8,10 @@
  * the values for NON-NEGATIVE floats only (PD-9); with a negative distance the bit-pattern order reverses, so the
  * claim is a compare-exchange loop on the pattern: read, compute, compare as floats, try to exchange. WGSL lets
  * `atomicCompareExchangeWeak` fail spuriously, so the loop is BOUNDED (PD-12: `P.maxRetries`, the driver's
- * `MAX_RETRIES`; contention is per vertex, not global) and a lane that exhausts it sets `flags[1]`
+ * `MAX_RETRIES`) -- on SPURIOUS failures only (`old_value == cur`). A failure that returns another value lost to
+ * another lane's successful exchange, which strictly lowered `dist[v]`; that happens at most once per edge into
+ * `v` per round, so those iterations are bounded by the in-degree and never counted (issue #470: counted, 32
+ * descending candidates in one 32-wide subgroup needed 31 attempts and exhausted 16). A lane that exhausts it sets `flags[1]`
  * (`retryExhausted`): the driver treats the round as changed and runs on, so the lost update is retried by the next
  * round, which examines every edge anyway; a bound hit in the decision round is E_VALIDATION, never a guess. A
  * successful exchange sets `flags[0]` (`changed`); the driver stops when a batch of rounds changed nothing, and a
@@ -26,9 +29,11 @@ fn relax(v: u32, nd: f32) {
         if (!(nd < bitcast<f32>(cur))) { break; }                     // no improvement; +Inf is greater than every finite nd
         let r = atomicCompareExchangeWeak(&dist[v], cur, bitcast<u32>(nd));
         if (r.exchanged) { atomicStore(&flags[0], 1u); break; }        // changed
-        cur = r.old_value;
-        tries = tries + 1u;
-        if (tries >= P.maxRetries) { atomicStore(&flags[1], 1u); break; }   // retryExhausted (PD-12)
+        if (r.old_value == cur) {                                      // a spurious failure: the only kind the bound counts
+            tries = tries + 1u;
+            if (tries >= P.maxRetries) { atomicStore(&flags[1], 1u); break; }   // retryExhausted (PD-12)
+        }
+        cur = r.old_value;                                             // else another lane's improvement won (issue #470)
     }
 }