Robust and Scalable Renaming with Subquadratic Bits

2025-04-30

AI Summary

Distributed renaming requires mapping $n$ processes with unique identifiers from a large namespace $[N]$ into a compact target namespace $[n]$, while tolerating crash or Byzantine failures. This paper presents the first strongly renaming algorithms achieving subquadratic communication complexity: a crash-tolerant variant with $ ilde{O}((f+1)n)$ total messages and a Byzantine-tolerant one with $ ilde{O}(f+n)$, both using only $O(log N)$ bits per message and requiring $O(log n)$ and $ ilde{O}(max{f,1})$ rounds, respectively. Our approach integrates distributed consensus, shared randomness, message authentication codes, and probabilistic analysis, supported by tight information-theoretic lower bounds. All algorithms are adaptive to the actual number $f$ of failures—breaking the classical $Omega(n^2)$ message and $Omega(n)$-bit-per-message barriers. The resulting communication efficiency approaches theoretical optimality, significantly enhancing scalability and practicality for large-scale distributed systems.

Technology Category

• Search and Optimization: Distributed Search
• Constraint Satisfaction and Optimization: Distributed CSP/Optimization
• Planning, Routing, and Scheduling: Optimization of Spatio-temporal Systems

Application Category

• Graph Algorithms and Modeling for the Web: Algorithms and analysis for incomplete, noisy, or partially observed Web-related graphs
• Systems and Infrastructure for Web, Mobile and WoT: Experiences and lessons learnt from Web-based algorithms and system deployments
• Security and Privacy: Large-scale security measurements

Abstract

In the renaming problem, a set of $n$ nodes, each with a unique identity from a large namespace $[N]$, needs to obtain new unique identities in a smaller namespace $[M]$. A renaming algorithm is strong if $M=n$. Renaming is a classical problem in distributed computing with a range of applications, and there exist many time-efficient solutions for fault-tolerant renaming in synchronous message-passing systems. However, all previous algorithms send $Omega(n^2)$ messages, and many of them also send large messages each containing $Omega(n)$ bits. Moreover, most algorithms' performance do not scale with the actual number of failures. These limitations restrict their practical performance. We develop two new strong renaming algorithms, one tolerates up to $n-1$ crash failures, and the other tolerates up to $(1/3-epsilon_0)n$ Byzantine failures for an arbitrarily small constant $epsilon_0>0$. The crash-resilient algorithm is always correct and always finishes within $O(log{n})$ rounds. It sends $ ilde{O}((f+1)cdot n)$ messages with high probability, where $f$ is the actual number of crashes. This implies that it sends subquadratic messages as long as $f=o(n/log{n})$. The Byzantine-resilient algorithm trades time for communication: it finishes within $ ilde{O}(max{f,1})$ rounds and sends only $ ilde{O}(f+n)$ messages, with high probability. Here, $f$ is the actual number of Byzantine nodes. To obtain such strong guarantees, the Byzantine-resilient algorithm leverages shared randomness and message authentication. Both algorithms only send messages of size $O(log{N})$ bits. Therefore, our crash-resilient algorithm incurs $o(n^2)$ communication cost as long as $f=o(n/(log{n}log{N}))$; and our Byzantine resilient algorithm incurs almost-linear communication cost. By deriving a lower bound, we conclude that our algorithms achieve near-optimal communication cost in many cases.

Problem

• Develops crash-tolerant renaming algorithm with subquadratic message complexity
• Creates Byzantine-tolerant renaming with near-linear communication cost
• Optimizes namespace reduction in distributed systems efficiently

Innovation

• Subquadratic message complexity for crash failures
• Near-linear communication cost for Byzantine failures
• Small message size with O(log N) bits