Distributed Algorithms for Computing Alternate Paths Avoiding Failed Nodes and Links

A recent study characterizing failures in computer networks shows that transient single element (node/link) failures are the dominant failures in large communication networks like the Internet. Thus, having the routing paths globally recomputed on a failure does not pay off since the failed element recovers fairly quickly, and the recomputed routing paths need to be discarded. In this paper, we present the first distributed algorithm that computes the alternate paths required by some “proactive recovery schemes” for handling transient failures. Our algorithm computes paths that avoid a failed node, and provides an alternate path to a particular destination from an upstream neighbor of the failed node. With minor modifications, we can have the algorithm compute alternate paths that avoid a failed link as well. To the best of our knowledge all previous algorithms proposed for computing alternate paths are centralized, and need complete information of the network graph as input to the algorithm.

💡 Research Summary

The paper addresses a fundamental problem in large‑scale communication networks: handling transient failures of single network elements (nodes or links) without incurring the overhead of globally recomputing routing tables. Empirical studies show that such transient single‑element failures account for the majority of outages, yet they typically last only seconds or minutes. Because the failed component often recovers quickly, disseminating failure information throughout the network and recomputing shortest‑path trees is both costly and unnecessary.

To solve this, the authors formalize the Single Node Failure Recovery (SNFR) problem. Given a biconnected, undirected, edge‑weighted graph G = (V, E) and a destination node s, let Tₛ be the shortest‑path tree rooted at s. For any non‑root node x, the tree splits into kₓ + 1 components when x fails: the component containing s and one component for each child xᵢ of x in Tₛ. The goal is to compute, for every child xᵢ, a path from xᵢ to s that does not traverse x.

The key insight is to classify edges of G relative to the failure of x:

• Green edges connect a node inside the subtree of a child xᵢ to a node outside the entire subtree of x. Such an edge provides a direct “escape” from the failed region; a path using a green edge has the form
  xᵢ → … → u –v → … → s.

• Blue edges connect nodes belonging to two different child subtrees (say xᵢ and xⱼ). They enable a two‑step escape: xᵢ reaches xⱼ’s subtree via the blue edge, then uses xⱼ’s green edge to reach s.

• Red edges have both endpoints inside the same child subtree; they are irrelevant for recovery because they cannot bypass the failed node.

Using only green and blue edges, the authors construct a compact recovery graph Rₓ for each potential failure node x. Rₓ contains a special node sₓ representing the original destination s and one node yᵢ for each child xᵢ. A green edge becomes an edge (yᵢ, sₓ) with weight equal to the total cost of the corresponding sub‑path in G. A blue edge becomes an edge (yᵢ, yⱼ) with weight equal to the cost of traveling from xᵢ to xⱼ via the blue edge. The weight formulas are:

• Green weight: d_G(s,u) + cost(u,v) + d_G(v,s) (independent of which child uses it).
• Blue weight: d_G(xᵢ,p) + cost(p,q) + d_G(q,xⱼ).

Because the weight of a green edge does not depend on the specific child, the same edge can be reused across many Rₓ graphs, dramatically reducing storage.

Once Rₓ is built, a single‑source shortest‑path computation (e.g., Dijkstra) from sₓ yields optimal recovery paths for all children of x simultaneously. The algorithm therefore avoids running a separate computation for each child.

Distributed implementation: The authors adopt a request‑response model. Each router knows only its incident edges, its parent in Tₛ, and its children. When a node detects that its parent x has failed, it sends a request to its own children asking for the list of incident green/blue edges and their weights. Neighbors reply with locally computable information (e.g., distances to the endpoints of the edge). Because each edge is examined at most twice (once from each endpoint), the total number of messages exchanged across the network is O(m + n). Memory usage per router is proportional to its degree (number of incident edges) plus the number of siblings it has in Tₛ, which in realistic topologies is modest (average degree 20–40 even for networks with thousands of nodes).

Complexity:

• Message complexity: O(m + n).
• Space complexity (global): O(m + n), which matches the size of the input graph and is asymptotically optimal.
• Per‑node space: O(degree + siblings), bounded by O(n) in the worst case but typically O(1) in practice.

The authors argue that this distributed approach offers several advantages over prior centralized solutions:

1. No single point of failure – the algorithm continues to operate as long as the underlying graph remains biconnected.
2. Scalability – message traffic grows linearly with network size, making it suitable for Internet‑scale deployments.
3. Speed – recovery paths can be computed locally immediately after a failure, eliminating the latency of global recomputation.

The paper also notes that the same framework can be adapted to related problems:

• Single link failure recovery – by treating a failed link as a pair of adjacent node failures.
• Minimum spanning tree sensitivity – recomputing MST after a single edge removal.
• Detour‑critical edge identification – finding edges whose removal forces long detours.

Limitations: The algorithm assumes the network is biconnected; if a node or link removal disconnects the graph, the method does not guarantee a recovery path. It also handles only single simultaneous failures; multiple concurrent failures would require extensions. Finally, the computation of the base distances d_G(·,·) (used in weight formulas) presumes that each router can obtain distances to the destination s, which may involve an initial all‑pairs shortest‑path preprocessing step or a distance‑vector protocol.

Evaluation: While the paper does not present extensive simulation results, it provides analytical arguments that the message overhead remains modest and that storage requirements are feasible for real‑world topologies. The authors compare their approach to earlier centralized algorithms with O(n³) or O(m + n log n) time, highlighting the reduction in both computational and communication costs.

Conclusion: This work introduces the first fully distributed algorithm for computing alternate paths that avoid a failed node (or link) in a biconnected network. By exploiting the structure of the shortest‑path tree and classifying edges into green and blue categories, the algorithm achieves linear message complexity, optimal global space usage, and per‑node storage that scales with local degree. It eliminates the need for a central controller, reduces recovery latency, and can be extended to several other network‑reliability problems, making it a valuable contribution to resilient routing design.