SSSP-Del: Dynamic Distributed SSSP Algorithm

• The paper introduces SSSP-Del, a fully dynamic distributed algorithm designed to maintain exact single-source shortest paths under both edge insertions and deletions.
• It employs a hybrid update strategy that uses asynchronous monotonic propagation for insertions and a stop-the-world two-phase approach for deletions, ensuring accurate distance updates.
• Empirical evaluations show that SSSP-Del achieves up to 40× lower query latency and high solution stability while efficiently handling mixed update streams.

SSSP-Del is a fully dynamic distributed algorithm for exact single-source shortest path (SSSP) maintenance on large weighted directed graphs undergoing both edge insertions and edge deletions. It is formulated for a vertex-centric, asynchronous, shared-nothing environment, and is designed to support on-demand queries of the current predecessor tree without recomputing the entire SSSP solution from scratch after every topology change. Its central design combines monotonic propagation for insertions with a stop-the-world two-phase invalidation and recomputation procedure for deletions, yielding exact distances at epoch boundaries while preserving low-latency behavior under mixed update streams (Javanrood et al., 20 Aug 2025).

1. Problem setting and distributed model

SSSP-Del assumes a weighted directed graph $G=(V,E)$ with $|V|=n$ and $|E|=m$, where every edge $(u,v)\in E$ has positive weight $w(u,v)>0$, and a distinguished source vertex $s\in V$. For each vertex $v\in V$, the algorithm maintains a distance label $d(v)$, defined as the length of the current best-known shortest path from $s$ to $v$, or $|V|=n$0 if $|V|=n$1 is unreachable. The dynamic input is an unbounded stream of topology-change events

$|V|=n$2

where each event is either an insertion $|V|=n$3 or a deletion $|V|=n$4. The operational objective is to answer on-demand queries for the full SSSP tree $|V|=n$5 at arbitrary times while processing updates online and without ever recomputing the entire tree from scratch (Javanrood et al., 20 Aug 2025).

The computational model is explicitly shared-nothing, asynchronous, and vertex-centric. The graph is partitioned arbitrarily across $|V|=n$6 compute nodes; each node owns a subset of vertices and their incident edges. Each vertex maintains only local state and communicates through FIFO-ordered point-to-point messages. Topology events are delivered to the endpoints of the modified edge and trigger user-defined handlers. The system also provides epoch barriers that temporarily pause ingestion of new topology events, wait for all in-flight algorithmic messages to drain, and then resume. This model is central to the algorithm’s semantics: insertions are handled asynchronously, whereas deletions invoke controlled synchronization.

2. Hybrid update strategy

SSSP-Del interleaves two distinct mechanisms. For edge insertions, it uses monotonic propagation. When a new edge $|V|=n$7 is inserted, $|V|=n$8 sends $|V|=n$9 a DistanceUpdate offering the candidate value $|E|=m$0. If this proposal strictly lowers $|E|=m$1, then $|E|=m$2 accepts the new distance, rebinds its predecessor, and propagates reduced distance values along outgoing edges. Because all weights are positive, distances only decrease during insertion handling, and the process converges quickly (Javanrood et al., 20 Aug 2025).

For edge deletions, the algorithm switches to a stop-the-world two-phase procedure. Upon deletion of $|E|=m$3, the system first enforces an epoch, draining in-flight messages. It then checks whether the deleted edge lies on the current shortest-path tree, i.e., whether $|E|=m$4. If not, no structural repair is required. If so, the algorithm initiates an invalidation phase followed by a recomputation phase. In the invalidation phase, $|E|=m$5 and recursively all of its successors in the current tree are set to $|E|=m$6 and marked affected. In the recomputation phase, each invalidated vertex queries all incoming neighbors for alternative paths, waits for the best response, resets its distance accordingly, and propagates any resulting decrease to its outgoing edges. Once deletion handling converges, the epoch barrier is lifted and normal event ingestion resumes (Javanrood et al., 20 Aug 2025).

This hybrid organization is the defining feature of SSSP-Del. The insert path is fully asynchronous and exploits the monotonicity induced by positive weights. The deletion path introduces short global coordination only when required to preserve exactness. The paper’s own implementation guidance states that topology events should be prioritized over algorithmic messages so that graph structure remains up to date before relaxation, and that short stop-the-world epochs should be used only upon deletions.

3. Local state and message protocol

Each vertex $|E|=m$7 maintains six pieces of local state: the current distance $|E|=m$8; the predecessor pointer $|E|=m$9; the successor set $(u,v)\in E$0 in the current SSSP tree; the incoming edge list $(u,v)\in E$1; the outgoing edge list $(u,v)\in E$2; and the boolean invalidation flag $(u,v)\in E$3 (Javanrood et al., 20 Aug 2025).

Item	Role
$(u,v)\in E$4	Current shortest-path distance or $(u,v)\in E$5
$(u,v)\in E$6	Predecessor on the SSSP tree
$(u,v)\in E$7	Successors for invalidation propagation
$(u,v)\in E$8	Incoming edges with weights
$(u,v)\in E$9	Outgoing edges with weights
$w(u,v)>0$0	Flag used during invalidation

The message protocol consists of five FIFO message types: DistanceUpdate(dist), SetToInfinity(), DistanceQuery(), AddToSuccessor(), and RemoveFromSuccessor(). The topology-event handlers are minimal. On edge addition $w(u,v)>0$1, the endpoint logic sends $w(u,v)>0$2 a DistanceUpdate with value $w(u,v)>0$3. On edge deletion $w(u,v)>0$4, the logic invokes epoch.drain(), checks whether $w(u,v)>0$5, sends SetToInfinity() to $w(u,v)>0$6 if the edge is tree-critical, and then drains again before resuming (Javanrood et al., 20 Aug 2025).

The message handlers implement the algorithm’s local semantics. A DistanceUpdate is accepted only if the received candidate is smaller than the current $w(u,v)>0$7. In that case, the old predecessor, if any, is notified through RemoveFromSuccessor(), the new predecessor is installed, the source vertex is notified through AddToSuccessor(), and the reduced distance is propagated to all outgoing neighbors. SetToInfinity() marks the vertex invalid, sets $w(u,v)>0$8, recursively propagates invalidation to all vertices in $w(u,v)>0$9, clears the successor set, and removes the predecessor. DistanceQuery() requests a neighbor’s current distance; if the queried vertex has finite distance, it responds with a DistanceUpdate equal to its own distance plus the weight of the edge back to the requester. Recomputation after deletion is therefore driven by the interplay between invalidation, incoming-neighbor queries, and subsequent relaxations.

An important implementation choice is the explicit maintenance of $s\in V$0. The paper identifies this as the mechanism that allows efficient invalidation propagation without global rescans. A plausible implication is that, in distributed memory, successor materialization is not merely auxiliary bookkeeping but a structural requirement for making subtree invalidation local.

4. Invariants, exactness, and complexity

The static correctness target is the Bellman–Ford invariant

$s\in V$1

Under insertion of $s\in V$2, SSSP-Del performs a relaxation step:

$s\in V$3

Because $s\in V$4 only decreases and all weights are positive, each vertex’s distance can be updated at most $s\in V$5 times for any positive minimum weight $s\in V$6. Under deletion, the algorithm temporarily sets to $s\in V$7 every vertex whose unique path in the old tree used the deleted edge, and then recomputes exactly by querying all in-neighbors and setting

$s\in V$8

once those neighbors have converged (Javanrood et al., 20 Aug 2025).

The paper states a termination theorem: every message type triggers only finitely many further messages. The reason is twofold. First, DistanceUpdate messages can only induce strictly decreasing distances. Second, SetToInfinity propagates only once per successor edge. Hence every update episode converges after finitely many steps. The main correctness theorem states that at the end of each epoch—between deletions or after all insertions—every vertex satisfies $s\in V$9, where $v\in V$0 is the true shortest-path distance in the current graph. Insert-only epochs preserve a valid tree by standard relaxation arguments. A deletion epoch invalidates exactly the affected subtree and recomputes each invalidated vertex’s distance by checking all incoming edges; an ordering by final distance establishes eventual recovery of the true solution (Javanrood et al., 20 Aug 2025).

The per-update costs are expressed in terms of the affected region rather than the whole graph. For an insertion, time and communication are proportional to the size of the region whose distances strictly decrease; the worst case is $v\in V$1, where $v\in V$2 is the number of relaxations. For a deletion, the worst-case time is

$v\in V$3

where $v\in V$4 is the invalidated subtree, and communication is

$v\in V$5

Amortized over a stream of $v\in V$6 events, deletion cost is proportional to the sum of degrees of all once-invalidated vertices. Space per vertex is

$v\in V$7

The paper explicitly emphasizes that communication complexity per update is linear in the actually affected portion of the tree, not in the entire graph.

5. Empirical behavior and operating trade-offs

The empirical evaluation uses both real-world and synthetic graphs with millions of vertices. The reported datasets are hive-comments with $v\in V$8M vertices and $v\in V$9M edges, wikipedia-growth with $d(v)$0M vertices and $d(v)$1M edges, web-Google with $d(v)$2M vertices and $d(v)$3M edges, and RMAT-20 with $d(v)$4M vertices and $d(v)$5M edges. The workload follows a sliding-window model of size $d(v)$6, deletion probability $d(v)$7, and query frequency every $d(v)$8 events; three “hot” sources are chosen by PageRank. The evaluation measures query latency, defined as wall-clock time for on-demand SSSP extraction including waiting for convergence; solution stability, defined as the fraction of vertices whose predecessor remains unchanged between consecutive queries; and ingestion throughput, defined as maximal sustained event-processing rate (Javanrood et al., 20 Aug 2025).

Across datasets and window configurations, SSSP-Del achieves $d(v)$9–$s$0 lower median query latency than an increment-only ReMo SSSP baseline that runs from scratch on each query snapshot. The speedup is reported as up to $s$1 on web-Google under mixed $s$2, and the effect grows with graph size. Solution stability remains high, often with more than $s$3 of predecessor pointers unchanged between consecutive queries, whereas the baseline’s stability is effectively $s$4 because it recomputes. Ingestion throughput exceeds $s$5 events/sec even under $s$6 on commodity hardware, which is stated to be comfortably above update rates of real-world systems such as Reddit at approximately $s$7/s and Twitter at approximately $s$8/s. Against GraphBolt, described as batch-synchronous, SSSP-Del achieves up to $s$9 lower latency for fine-grained queries (Javanrood et al., 20 Aug 2025).

The paper also records several operational trade-offs. Larger sliding-window $v$0 reduces deletion frequency and boosts throughput, but allowing stale edges may temporarily inflate the tree. Processing-thread counts and message-queue depths require tuning to avoid backpressure during large invalidation waves. These recommendations are implementation-specific, but they also clarify the intended operating regime: insertions are expected to be the common case, while deletions are comparatively rarer but correctness-critical synchronization points.

6. Position within dynamic shortest-path research

SSSP-Del occupies a distinct point in the dynamic shortest-path design space. Its contribution is not a centralized dynamic data structure with a total-update-time objective, but a fully distributed algorithm tailored to shared-nothing memory, asynchronous execution, and low-latency extraction of the current SSSP tree under mixed insertions and deletions. The paper explicitly motivates this position by noting that existing dynamic SSSP algorithms often cannot simultaneously handle both edge additions and deletions, operate in distributed memory, and provide low-latency query results (Javanrood et al., 20 Aug 2025).

This distinguishes SSSP-Del from the decremental SSSP line represented by work such as "Near-Optimal Decremental SSSP in Dense Weighted Digraphs" (Bernstein et al., 2020). That line studies a directed graph undergoing only edge deletions and weight increases, fixes a source $v$1, and seeks a data structure maintaining $v$2-approximate distances with $v$3 query time and $v$4 path output. Its principal metrics are total update time over the entire deletion sequence, with results including $v$5 in dense graphs and $v$6 in sparse graphs, together with the use of approximate topological orders and bucketed ES-trees (Bernstein et al., 2020). SSSP-Del, by contrast, is fully dynamic rather than decremental, exact at epoch boundaries rather than $v$7-approximate, and structured around message-driven repair rather than centralized hierarchical decompositions.

A common misconception in this area is to treat all dynamic SSSP approaches as variants of the same problem. The literature in the provided sources shows that they optimize different objectives under different computational models. The decremental framework emphasizes total update time, approximation, and path-query complexity in a centralized setting; SSSP-Del emphasizes mixed updates, distributed-memory execution, low median query latency, and solution stability under streaming workloads. This suggests that direct asymptotic comparisons across the two lines are informative only when the differing assumptions—exactness versus approximation, decremental versus fully dynamic updates, and centralized versus distributed execution—are made explicit.