Uncoded Repair by Transfer for Distributed Storage

This direction is merged into another direction: repair bandwidth overhead, repair-by-transfer. Its last version stays readable and citable here.

Version 1 of 121 papers30 conceptsfrozen 2026-10-04

In massive data centers, hardware failure is a statistical certainty rather than a rare accident. To protect data against these failures, distributed storage systems use erasure codes—mathematical schemes like Reed-Solomon codes that split data into fragments and add redundancy. If a storage node fails, the system must "repair" it by downloading data from surviving "helper" nodes to reconstruct the lost information.

Traditionally, this repair process is expensive. It consumes significant network bandwidth and, crucially, imposes a heavy computational "tax" on the healthy helper nodes. These nodes must read data from disk and perform complex arithmetic (often in large finite fields) to generate the specific packets needed for recovery.

A growing body of research focuses on Uncoded Repair (also known as Repair-by-Transfer), a strategy that eliminates this computational burden. Instead of computing new packets, helper nodes simply identify and transmit raw data segments they already store.

The Computational Bottleneck of Repair

In a standard regenerating code framework, the goal is to minimize the "repair bandwidth"—the total amount of data sent over the network. However, as Nihar B Shah, K. V. Rashmi, and P. Vijay Kumar observed in Distributed Storage Codes With Repair-by-Transfer, minimizing bandwidth often comes at the cost of high CPU usage. Helper nodes must perform intensive Galois Field arithmetic to "mix" their data before sending it.

In high-speed networks, this CPU overhead becomes the primary bottleneck. If a helper node is busy calculating parity symbols for a repair, its ability to serve regular user requests drops. The intuition behind Repair-by-Transfer is to shift the entire computational burden away from the healthy nodes. By designing the code structure such that the lost data is a simple combination of existing, unmodified chunks, the helper nodes act as simple data pipes.

Designing for Zero-Computation Helpers

Achieving uncoded repair requires sophisticated code constructions. The challenge is to maintain the Maximum Distance Separable (MDS) property—which ensures the highest possible reliability for a given amount of storage—while allowing for simple data copying during repair.

Combinatorial and Layered Designs

One approach involves "stitching" together smaller codes using combinatorial patterns. Chao Tian, Birenjith Sasidharan, and P. Vijay Kumar introduced Layered Exact-Repair Regenerating Codes, which use combinatorial block designs to ensure that any failed node can be reconstructed by simply collecting specific symbols from its neighbors. In this model, the helper nodes do zero math; the replacement node performs all necessary decoding locally after receiving the raw symbols.

Binary Array Codes and XOR Operations

Another path to efficiency is moving away from complex finite fields toward binary operations. Hanxu Hou has demonstrated that Binary MDS Array Codes can achieve optimal repair using only bitwise XOR operations. By applying transformations to these binary codes, as explored by Hanxu Hou and Yunghsiang S. Han in Multi-Layer Transformed MDS Codes, researchers can reach theoretical limits of repair traffic while keeping the math simple enough for hardware-constrained environments.

Balancing Complexity and Practicality

While theoretical "minimum bandwidth" codes exist, they often suffer from "exponential sub-packetization"—meaning a file must be split into a massive number of tiny chunks, which is impractical for real file systems.

Ankit Singh Rawat and Venkatesan Guruswami addressed this in New MDS codes with small sub-packetization and near-optimal repair bandwidth. They showed that by slightly relaxing the requirement for absolute minimum bandwidth, one can design codes that still support uncoded repair-by-transfer but with much more manageable data chunking (polynomial rather than exponential).

Beyond Single Failures: Sequential and Clustered Repair

Real-world systems often face multiple simultaneous failures or need to repair nodes in sequence. Ganesh Ramachandra Kini and P. Vijay Kumar established bounds for Sequential Recovery from Multiple Erasures, showing how XOR-based parity checks can efficiently handle "one-by-one" recovery.

Similarly, Anne-Marie Kermarrec and colleagues proposed Clustered Network Coding, which organizes nodes into clusters to allow for the simultaneous repair of multiple files. This clustering, also explored by Saeid Sahraei in Increasing Availability in Distributed Storage Systems via Clustering, further reduces the network and computational overhead by localizing the repair-by-transfer traffic within specific groups of servers.

By prioritizing the "transfer" of existing data over the "computation" of new parity, this research direction makes the maintenance of massive distributed systems faster, cheaper, and more resilient to the bottlenecks of modern hardware.

Papers in this version

History & citationVersion 1 · 2026-10-04

Merged into another direction · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_uncoded_repair_by_transfer_for_distribut_c57a69ae,
  title = {Uncoded Repair by Transfer for Distributed Storage},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/uncoded-repair-by-transfer-for-distributed-storage/rdr_c57a69ae6cb8411ca193f04dc422aad7},
  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_uncoded_repair_by_transfer_for_distribut_c57a69ae_v1,
  title = {Uncoded Repair by Transfer for Distributed Storage},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/uncoded-repair-by-transfer-for-distributed-storage/rdr_c57a69ae6cb8411ca193f04dc422aad7/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}