Redundancy Strategies for Low-Latency Distributed Systems

This direction is split into other directions: redundancy-latency trade-off. Its last version stays readable and citable here.

Version 1 of 138 papers68 conceptsfrozen 2026-10-04

In distributed systems, the fastest way to get a result is often to ask for it twice. Whether you are waiting for a disk head to spin, a cloud server to respond, or a robot to reach a destination, the primary enemy of performance is tail latency—those rare but inevitable "straggler" events where a single component takes significantly longer than average to complete a task.

Researchers across fields as diverse as disk manufacturing, cloud storage, and robotics have converged on a shared solution: strategic redundancy. By performing redundant work, systems can "bypass" slow components, effectively trading increased system load for a more predictable, lower-latency response.

The Intuition of Hedging Bets

The core idea is simple: if you send a request to three independent servers instead of one, you only have to wait for the fastest one to respond. This "fork-join" or parallel access strategy is the foundation of modern low-latency design.

In the context of disk I/O, Xinrong Zhou, Peng Cheng, and Jiangling Zhang demonstrated this principle with the Continuous Operating Cache Schedule (COCS). They found that it is often faster to read extra, unrequested disk sectors than to wait for a disk to complete a full rotation if a sector is missed. Even though the system transfers more data (redundant work), the millisecond-scale penalty of rotational latency is so high that the extra work actually saves time Performance of Continuous Operating Cache Schedule for Discontinuous Sector's Transferring.

Similarly, in geo-distributed systems, Tim Kraska notes that "mission-critical" performance now requires surviving entire data-center outages and mitigating the unpredictable delays of the global internet through redundant requests Letter from the Special Issue Editor.

The Paradox of Redundancy

If redundancy reduces latency, why not replicate every task a hundred times? The papers reveal a fundamental tension: redundancy consumes the very resources needed for throughput.

As Mehmet S. Aktaş, Emina Soljanin, and Alex Sprintson explain, dispatching requests to every available recovery group in a storage system minimizes individual latency but imposes a massive cumulative load. If every user does this, the system quickly becomes congested, leading to queueing delays that can paradoxically increase the time it takes to get data Download Time Analysis for Distributed Storage Codes with Locality and Availability.

This "congestion effect" appears in several forms:

  • Network Contention: Steven Y. Ko and colleagues found that aggressively replicating intermediate data in cloud computations can double job completion times because the background replication traffic competes with the actual computation for bandwidth On Availability of Intermediate Data in Cloud Computations.
  • Protocol Overhead: In peer-to-peer networks like IPFS, Ruizhe Shi and Yue Cheng observed that having too many replicas can degrade performance. The overhead of managing connections and negotiating with multiple sources can outweigh the benefits of parallel retrieval Centralization in Decentralized Web: Challenges and Opportunities in IPFS’s Data Management.
  • Computational Bottlenecks: In search systems like LinkedIn's LANNS, routing queries to multiple index segments to ensure high recall increases the total computational load, which eventually hits a ceiling on total query throughput LANNS: A Web-Scale Approximate Nearest Neighbor Lookup System.

Diminishing Returns and Adaptive Control

Because redundancy is not free, the research focuses on finding the "sweet spot." Longbo Zhang and Hai Jin highlight that increasing the number of message copies beyond a certain threshold yields negligible latency improvements while causing an exponential rise in network overhead Dynamic Spray and Wait Routing Protocol for Delay Tolerant Networks.

To manage this, researchers have moved toward adaptive redundancy. Maria Chtepen and Filip De Turck proposed the ACRS algorithm, which dynamically switches between task replication and checkpointing based on real-time system load. When the system is idle, replication is used to ensure speed; when the system is congested, it switches to checkpointing to save resources Providing Fault-Tolerance in Unreliable Grid Systems Through Adaptive Checkpointing and Replication.

Even in physical systems, the math remains the same. Amanda Prorok demonstrated that deploying "extra" robots to a task can minimize waiting times in uncertain environments. However, she notes the inherent challenge of balancing the operational cost of these extra agents against the diminishing returns of further reducing wait times Resilient Assignment Using Redundant Robots on Transport Networks with Uncertain Travel Time.

Beyond Simple Replication: Coded Redundancy

A significant portion of recent work, such as that by Zhengyi Jiang and Hanxu Hou, explores using Erasure Coding (like MDS codes) as a more efficient form of redundancy. Instead of making full copies of data, these codes allow a system to reconstruct a missing piece of information from any $k$ out of $n$ fragments. This provides the same "bypass" capability as replication but with a much lower storage and bandwidth footprint Accelerating Data Access for Single Node in Distributed Storage Systems via MDS Codes.

As Avishek Ghosh and Kannan Ramchandran argue, these coded systems can reduce data access latency by over 20% compared to traditional replication, provided the system can efficiently handle the signaling overhead of canceling redundant requests once the first few fragments arrive Faster Data-access in Large-scale Systems: Network-scale Latency Analysis under General Service-time Distributions.

Papers in this version

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_redundancy_strategies_for_low_latency_di_03a1d302,
  title = {Redundancy Strategies for Low-Latency Distributed Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/redundancy-strategies-for-low-latency-distributed-systems/rdr_03a1d302f55e4e22bdfc303af9fd89fb},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_redundancy_strategies_for_low_latency_di_03a1d302_v1,
  title = {Redundancy Strategies for Low-Latency Distributed Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/redundancy-strategies-for-low-latency-distributed-systems/rdr_03a1d302f55e4e22bdfc303af9fd89fb/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}