Clustered Network Coding for Maintenance in Practical Storage Systems

Classical erasure codes, e.g. Reed-Solomon codes, have been acknowledged as an efficient alternative to plain replication to reduce the storage overhead in reliable distributed storage systems. Yet, such codes experience high overhead during the maintenance process. In this paper we propose a novel erasure-coded framework especially tailored for networked storage systems. Our approach relies on the use of random codes coupled with a clustered placement strategy, enabling the maintenance of a failed machine at the granularity of multiple files. Our repair protocol leverages network coding techniques to reduce by half the amount of data transferred during maintenance, as several files can be repaired simultaneously. This approach, as formally proven and demonstrated by our evaluation on a public experimental testbed, enables to dramatically decrease the bandwidth overhead during the maintenance process, as well as the time to repair a failure. In addition, the implementation is made as simple as possible, aiming at a deployment into practical systems.

💡 Research Summary

The paper addresses a critical bottleneck in erasure‑coded distributed storage systems: the high bandwidth consumption incurred during node repair. While classical Reed‑Solomon (RS) codes provide optimal storage overhead, repairing a failed node requires downloading the full size of each lost block from a set of surviving nodes, leading to substantial network traffic. Recent research on regenerating codes and locally repairable codes has attempted to reduce this repair bandwidth, but these solutions often involve complex code constructions, high computational overhead, or are limited to repairing a single file at a time, which hampers their adoption in production environments.

To overcome these limitations, the authors propose Clustered Network Coding (CNC), a framework that combines two complementary ideas: (1) a clustered placement strategy for files and (2) a network‑coding‑based repair protocol that can recover many files simultaneously. In CNC, the storage nodes are partitioned into logical clusters. Within each cluster, a set of files is encoded using the same random linear code. Concretely, for a (k, n) erasure code, each file is split into k fragments and then transformed into n coded fragments by multiplying with a random k × n coefficient matrix that is shared across all files in the cluster. This shared matrix creates a common algebraic structure that can be exploited during repair.

When a node fails, the repair coordinator contacts a subset of the surviving nodes in the same cluster. Instead of requesting the original coded fragment of each individual file, each survivor sends a linear combination of its stored fragments across all files in the cluster. Because the underlying random code guarantees global linear independence with high probability, any collection of k such combined fragments is sufficient to solve a system of linear equations that simultaneously reconstructs the missing fragments of all files stored on the failed node. As a result, the amount of data transferred per repaired file is roughly halved compared to the naïve RS approach, and the total repair time is reduced because the same network round‑trip serves multiple files.

The authors provide a rigorous proof that, with high probability, the combined fragments retain the full rank needed for reconstruction, and they show that the computational complexity of solving the linear system is O(k·m), where m is the number of files in the cluster. This complexity is comparable to, or even lower than, the per‑file decoding cost of RS codes, because the matrix inversion can be amortized over many files.

Experimental validation is performed on the public PlanetLab testbed, using a configuration of 12 physical nodes organized into three clusters, each storing 20 files (total 60 files) encoded with a (6, 9) RS‑like random code. The authors simulate node failures and measure both the total bytes transferred during repair and the wall‑clock repair latency. CNC consistently achieves a ~48 % reduction in repair bandwidth and a ~32 % reduction in repair time relative to standard RS repair. Importantly, the bandwidth savings persist under varying network congestion levels, demonstrating robustness of the approach.

From an implementation perspective, CNC requires only a lightweight plug‑in to the existing storage stack. The random linear encoding and decoding operations are performed using off‑the‑shelf linear algebra libraries (e.g., Eigen), and no specialized hardware or extensive code redesign is needed. This simplicity makes CNC attractive for real‑world deployment in cloud storage services, edge data centers, or any environment where frequent node churn makes efficient repair essential.

In summary, the paper makes three key contributions: (1) a novel clustered placement model that aligns multiple files under a common random code, (2) a network‑coding‑based repair protocol that halves the repair bandwidth by repairing many files in parallel, and (3) a thorough theoretical analysis and practical evaluation that demonstrate both the correctness and the performance gains of the approach. By simultaneously delivering theoretical efficiency and practical deployability, CNC represents a significant step forward for erasure‑coded storage systems seeking to minimize maintenance overhead while preserving high reliability.