[Paper] Making Wide Stripes Practical: Cascaded Parity LRCs for Efficient Repair and High Reliability

Source: arXiv - 2512.10425v1

Overview

Erasure coding is the workhorse behind the massive storage pools that power cloud services, but traditional locally repairable codes (LRCs) struggle when the stripe width grows to hundreds of data blocks. The paper Making Wide Stripes Practical: Cascaded Parity LRCs for Efficient Repair and High Reliability proposes a new class of LRCs—Cascaded Parity LRCs (CP‑LRCs)—that let local and global parity cooperate, slashing repair traffic while keeping the strong fault‑tolerance guarantees of MDS codes.

Key Contributions

• Cascaded parity construction: Introduces a systematic way to split a global parity block across all local parity blocks, forming a “cascaded” parity group that preserves MDS‑level reliability.
• General coefficient‑generation framework: Provides an algorithmic recipe for picking encoding coefficients that guarantee the required linear independence for both local and global repairs.
• Repair algorithms that exploit cascading: Designs low‑bandwidth procedures for single‑node and multi‑node failures, avoiding the costly full‑stripe decoding typical of existing wide‑stripe LRCs.
• Two concrete instantiations: CP‑Azure (tuned for Azure‑style 12‑data‑block stripes) and CP‑Uniform (a more generic, uniform‑stripe version).
• Real‑world evaluation: Deploys the codes on Alibaba Cloud storage clusters, showing up to 41 % faster single‑node repairs and 26 % faster two‑node repairs compared with state‑of‑the‑art LRCs.

Methodology

1. Problem analysis: The authors first dissect why conventional wide‑stripe LRCs suffer high repair cost—local groups become large, and global parity is isolated, so a multi‑node failure often forces a full‑stripe decode.
2. Cascading idea: They propose to embed the global parity into the local parity blocks. Concretely, a global parity symbol (g) is expressed as a linear combination of all local parity symbols (p_1, p_2, \dots, p_L). This creates a dependency chain: when a local node fails, the missing local parity can be reconstructed using the other locals and the global parity, dramatically reducing the amount of data that must be read.
3. Coefficient generation: To keep the code MDS (i.e., any (k) out of (n) blocks suffice to reconstruct the data), the paper presents a systematic method for selecting the encoding coefficients from a finite field. The method guarantees that every set of (k) symbols remains linearly independent, even after cascading.
4. Repair procedures:
   • Single‑node repair: Pull a small subset of local data plus the global parity, solve a tiny linear system, and rebuild the missing block.
   • Two‑node repair: If the failures belong to the same local group, the cascade lets the system use the remaining locals plus the global parity; if they belong to different groups, each can be repaired independently using its own cascade, avoiding a full‑stripe decode.
5. Prototype implementation: The authors integrate CP‑LRCs into a production‑grade erasure‑coding library used by Alibaba Cloud, instrumenting the repair path to collect latency and network‑traffic metrics.

Results & Findings

• Repair latency drops consistently across all tested stripe widths (from 8 to 24 data blocks).
• Network traffic saved per repair is roughly proportional to the reduction in latency, easing pressure on intra‑datacenter links.
• Reliability (MTTDL) improves because the cascaded parity retains the full MDS fault‑tolerance while still offering fast local repairs.

Practical Implications

• Lower operational cost: Faster repairs mean less time spent in degraded mode, reducing the risk of cascading failures and the need for over‑provisioned spare capacity.
• Higher throughput for hot data: Applications that experience frequent small‑scale node churn (e.g., container‑orchestrated storage, edge caching) can benefit from the reduced repair bandwidth, keeping the storage cluster at peak performance.
• Simplified tiered storage: CP‑LRCs work well with existing tiering strategies (e.g., hot‑cold separation) because the same code can be used for both narrow and wide stripes, eliminating the need to maintain multiple code families.
• Ease of integration: The coefficient‑generation framework is deterministic and can be baked into existing erasure‑coding libraries (e.g., Jerasure, Intel ISA‑L), making migration straightforward for cloud providers.
• Potential for SSD/NVMe arrays: The reduced read‑amplification during repair aligns with the wear‑leveling concerns of flash‑based storage, extending device lifespan.

Limitations & Future Work

• Finite‑field size constraints: The construction relies on a sufficiently large Galois field to guarantee coefficient independence; for extremely wide stripes (hundreds of blocks) the field size may become a bottleneck.
• Complexity of coefficient management: While the paper provides an algorithm, generating and storing the coefficient matrix for many different stripe configurations adds metadata overhead.
• Evaluation scope: Experiments were performed on a single cloud provider’s infrastructure; cross‑cloud or geo‑distributed scenarios (where latency dominates) remain untested.
• Future directions suggested by the authors:
  1. Extending the cascade concept to hierarchical parity (multiple layers of global parity) for even larger stripes.
  2. Exploring adaptive coefficient selection that reacts to real‑time failure patterns.
  3. Integrating CP‑LRCs with emerging storage‑class memory technologies to assess latency‑critical repair benefits.

Authors

• Fan Yu
• Guodong Li
• Si Wu
• Weijun Fang
• Sihuang Hu

Paper Information

• arXiv ID: 2512.10425v1
• Categories: cs.DC
• Published: December 11, 2025
• PDF: Download PDF