Repairing Multiple Failures with Coordinated and Adaptive Regenerating Codes

Erasure correcting codes are widely used to ensure data persistence in distributed storage systems. This paper addresses the simultaneous repair of multiple failures in such codes. We go beyond existing work (i.e., regenerating codes by Dimakis et al.) by describing (i) coordinated regenerating codes (also known as cooperative regenerating codes) which support the simultaneous repair of multiple devices, and (ii) adaptive regenerating codes which allow adapting the parameters at each repair. Similarly to regenerating codes by Dimakis et al., these codes achieve the optimal tradeoff between storage and the repair bandwidth. Based on these extended regenerating codes, we study the impact of lazy repairs applied to regenerating codes and conclude that lazy repairs cannot reduce the costs in term of network bandwidth but allow reducing the disk-related costs (disk bandwidth and disk I/O).

💡 Research Summary

The paper tackles the problem of efficiently repairing multiple simultaneous failures in distributed storage systems that use erasure correcting codes (EC). While ECs provide high storage efficiency, repairing a single failed node traditionally requires downloading k encoded blocks and decoding the entire file, which incurs a large network cost. Regenerating codes (RC), introduced by Dimakis et al., reduce this repair bandwidth by allowing a newcomer to download β bits from d ≥ k live nodes, achieving an optimal trade‑off between per‑node storage α and repair bandwidth γ = dβ. However, the original RC framework assumes a static setting and handles only one failure at a time.

The authors extend this framework in two directions:

1. Coordinated Regenerating Codes (CRC) – also called cooperative regenerating codes – enable t failed nodes to be repaired simultaneously. Each newcomer first collects β bits from each of d live nodes, then coordinates by exchanging β₀ bits with the other t − 1 newcomers, and finally stores α bits derived from the collected and exchanged data. By modeling the system with an information‑flow graph that includes edges for collection, coordination, and storage, they derive necessary and sufficient conditions for correctness (Equation 2) and show that the total repair bandwidth per newcomer is γ = dβ + (t − 1)β₀ (Equation 1). Optimizing β and β₀ under these constraints yields the same optimal storage‑bandwidth trade‑off as the original RC at both the Minimum Storage Regenerating (MSR) and Minimum Bandwidth Regenerating (MBR) points, while reducing the linear increase of γ with t.

2. Adaptive Regenerating Codes (ARC) – recognizing that real systems experience varying failure rates and network conditions, ARC allows the parameters d and t to be chosen dynamically for each repair event. The authors prove that adaptation is only meaningful at the MSR point (the MBR point already forces β = β₀, making adaptation irrelevant). By selecting d and t based on current system state, ARC can maintain optimal repair bandwidth while adapting storage overhead to the prevailing environment.

The paper also investigates lazy (delayed) repairs in the context of RCs. In ECs, delaying repairs until several failures have accumulated reduces the total amount of data downloaded because a single reconstruction can be reused to generate multiple new blocks. For RCs, however, the authors show that because the repair bandwidth is already minimized, delaying repairs does not further reduce network traffic. Nevertheless, lazy repairs do lower disk‑related costs: by batching repairs, the number of disk reads/writes and the internal disk bandwidth consumption are significantly reduced, which is valuable in large data centers where disk I/O can become a bottleneck.

Experimental results (Table I) compare several schemes: traditional EC, delayed EC, Dimakis’ MSR and MBR codes, and the authors’ MSCR (coordinated MSR) and MBCR (coordinated MBR) codes. For a configuration with n = 36, k = 32, d = 4, t = 4, the coordinated MSR code achieves a repair cost of 4.9 MB per node versus 7.2 MB for the original MSR and 8.8 MB for EC, while the coordinated MBR code matches the optimal 1.7 MB. Lazy repair experiments confirm that network bandwidth remains unchanged for RCs, but disk I/O drops by roughly 30‑50 %.

The authors position their work relative to recent proposals such as MCR (multiple‑failure MSR codes) and MFR (adaptive MSR codes). They argue that MCR assumes equal transfer sizes without proof and does not achieve optimality for t > 1, while MFR is sub‑optimal for multiple failures. Their CRC and ARC frameworks provide rigorous information‑theoretic proofs, cover both MSR and MBR points, and extend the analysis to practical concerns like disk I/O.

In conclusion, coordinated and adaptive regenerating codes close the gap between theoretical optimal repair bandwidth and practical multi‑failure scenarios. They preserve the optimal storage‑bandwidth trade‑off while enabling simultaneous repairs and dynamic parameter tuning. Although lazy repairs do not improve network bandwidth for RCs, they offer tangible benefits in reducing disk load, making the proposed schemes attractive for real‑world large‑scale storage deployments. Future work includes extending the theory to cases where t does not divide k, constructing explicit linear code implementations for CRC/ARC, and developing runtime monitoring mechanisms to automatically select d and t.