Pith. sign in

REVIEW 6 minor 53 references

Repair Pipelining for Erasure-Coded Storage: Algorithms and Evaluation

T0 review · 0 major / 6 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Repair pipelining reduces the time to rebuild a lost erasure-coded block to almost the same as reading an available block, independent of coding parameters.

desk verdict Solid systems paper: clean O(1) repair-time analysis with honest scope, backed by extensive experiments; worth serious refereeing despite minor reproducibility gaps. read the letter →

arxiv 1908.01527 v3 pith:YM2FXZWC submitted 2019-08-05 cs.DC

Xiaolu Li , Zuoru Yang , Jinhong Li , Runhui Li , Patrick P. C. Lee , Qun Huang , Yuchong Hu This is my paper · ORCID
classification cs.DC
keywords erasurecodingrepairpipeliningdegradedreadsfull-noderecoverydistributedstorageReed-SolomoncodesheterogeneousnetworksECPipe
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Repair pipelining is a scheduling technique for erasure-coded storage that makes rebuilding a failed block nearly as fast as reading a healthy one. It splits each block into many small slices and pipes partial repaired slices along a linear chain of helper nodes, so that no network link becomes a bottleneck. In a homogeneous, network-bound environment the single-block repair time is $\frac{s-1+k}{s}$ timeslots, approaching one timeslot as the slice count $s$ grows; for multi-block repair the time approaches $f$ timeslots for $f$ failed blocks. The paper also extends the idea to heterogeneous links, limited edge bandwidth, rack-aware topologies, and full-node recovery, and demonstrates it in a middleware prototype integrated into three open-source storage systems.

What carries the argument

The load-bearing mechanism is slice-level repair pipelining along a linear helper path. A block is divided into $s$ fixed-size slices; helper $N_i$ receives a partially combined slice, adds its own locally stored block contribution (possible because erasure-code decoding is a linear, associative combination), and sends the new partial sum to $N_{i+1}$, while the upstream helper simultaneously starts the next slice. This keeps every link equally busy and eliminates the requestor-downlink bottleneck, converting the $k$-fold repair traffic of conventional Reed-Solomon repair into a pipeline whose makespan is $1+(k-1)/s$ timeslots. Named extensions include a cyclic version for limited edge bandwidth, rack-aware path selection that minimizes cross-rack transmissions, and a weighted path-selection algorithm that finds the path maximizing the minimum link bandwidth in heterogeneous networks.

What would settle it

Run a single-block repair of a 64 MiB block with 32 KiB slices in a homogeneous cluster at both 1 Gb/s and 10 Gb/s links and measure the ratio of repair time to direct-read time of one 64 MiB block; if the ratio does not stay close to 1 under the 10 Gb/s setting, the assumption that computation and disk I/O are hidden behind transmission is violated. A second check is to hold block size fixed while sweeping slice size: if repair time grows with $k$ even for large $s$, the claimed independence from coding parameters fails.

Watch

Extended reading notes

Core claim

The paper's central claim is that repair time in erasure-coded storage need not grow with the coding parameter $k$. By decomposing a failed block into $s$ slices and arranging $k$ helpers plus the requestor as a linear path, each helper contributes one partial linear combination per slice and forwards it, so traffic spreads evenly across all links. The resulting single-block repair time is $(s-1+k)/s = 1+(k-1)/s$ timeslots, which tends to $1$ for large $s$, meaning the rebuilt block arrives almost as quickly as a directly read available block. For $f$ simultaneously failed blocks in one stripe, the same schedule gives $f(1+(k-1)/s)$ timeslots, approaching $f$ timeslots, which is strictly below the $k+f-1$ timeslots of conventional repair. The paper supports this with a working middleware prototype and testbed and cloud measurements showing large reductions in degraded-read latency and full-node recovery time.

Load-bearing premise

The strong $O(1)$ result assumes the repair is dominated by network transmission: computation and disk I/O are negligible and can be overlapped with sending, and every link on the path has equal, dedicated bandwidth.

Editorial extensions

If this is right

  • Single-block repair time in homogeneous, network-bound settings becomes $O(1)$, independent of $k$, once slices are small enough; conventional repair is $O(k)$ and partial-parallel repair is $O(\log^2 k)$.
  • Multi-block repair of $f$ failed blocks approaches $f$ timeslots, compared with $k+f-1$ for conventional repair, so the advantage grows with $k$.
  • The rack-aware extension preserves the minimum cross-rack repair traffic of cluster-aware repair while also shortening the repair path, which should shorten the vulnerability window after a failure.
  • The cyclic and weighted-path extensions shift repair traffic away from a limited requestor edge link or slow links, making fast repair possible in hierarchical and heterogeneous deployments.
  • Because the technique applies to any linear erasure code, it can be combined with repair-friendly codes such as local reconstruction codes, gaining both reduced repair traffic and reduced repair time.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Inference: if the $O(1)$ bound survives in production-like settings, erasure coding could plausibly replace replication for hot, frequently read data, since the read-latency penalty that motivated replication is removed.
  • Inference: at network speeds where disk I/O or CPU is no longer hidden behind transmission, repair time will floor at the per-slice local processing cost; the practical speedup is therefore bounded by how much faster forwarding is than local read and encode, and the paper's own 10 Gb/s results already show shrinking gains.
  • Inference: the same slice-pipeline schedule could be composed with regenerating codes, which minimize repair traffic, to attack both dimensions at once; the paper leaves this as future work.
  • Inference: a direct test of the bound's limit is to fix block size and sweep slice size while measuring repair time; the optimum at intermediate slice sizes (small enough for parallelism, large enough to avoid request overhead) is itself a signature of the pipelining mechanism.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

0 major / 6 minor

Summary. This paper proposes repair pipelining for erasure-coded storage, a scheduling technique that splits each block into s slices and pipelines partial repair operations along a linear path of k helpers and a requestor. Under an explicit network-bound model with equal, dedicated links, the paper derives a makespan of (s−1+k)/s timeslots, which approaches one timeslot as s grows, so that single-block repair time approaches the time to read one available block. It extends the basic scheme to cyclic parallel reads for limited edge bandwidth, rack-aware path selection for hierarchical data centers, weighted path selection that minimizes the maximum link weight for arbitrary heterogeneous link bandwidths, and multi-block repair. The paper implements the scheme in the ECPipe middleware and integrates it into HDFS-RAID, HDFS-3, and QFS. Experiments on a local cluster and on two Amazon EC2 deployments show substantial reductions in degraded-read latency and full-node recovery time compared with conventional repair and PPR.

Significance. If the result holds, the paper makes a significant practical and conceptual contribution: it shows that repair scheduling, rather than code design, can bring single-block repair time close to normal read time for general erasure codes. The central time-complexity derivation is self-contained and does not fit constants to measurements; the only free parameter is the slice size s, and the predicted near-direct-send behavior is confirmed experimentally (8.8% above direct send at 1 Gb/s with 32 KiB slices). The paper is unusually candid about limitations: it explicitly states that computation and disk I/O are neglected, shows that the gain shrinks at 10 Gb/s and with small slice sizes, and reports a regime where block-level PUSH-style pipelining wins at small block sizes. The ECPipe prototype, the integrations into three real storage systems, and the fair comparison with prior pipelined-repair work are additional strengths of the paper.

minor comments (6)
  1. [§4.4] The sentence claiming that repair pipelining 'always incurs less repair time than conventional repair' is stronger than the derived formulas justify. Comparing the stated multi-block repair time f(1+(k−1)/s) with conventional repair time k+f−1 yields the condition f < s rather than an unconditional inequality. The claim should be qualified to the intended regime in which the block is split into more slices than the number of failed blocks.
  2. [§4.4 and Figure 6] The timeslot accounting for the final leg of the multi-block repair is ambiguous. If the f requestors are reached over f dedicated links with the assumed per-link bandwidth, the final transmission of one slice to each requestor can proceed in parallel and takes 1/s timeslots, not f/s timeslots; if the model instead assumes a single shared bottleneck link to the requestors, that assumption should be stated explicitly.
  3. [§3.2] The pipelined schedule requires each intermediate helper to receive from one neighbor and transmit to the next neighbor at the same time. The model description should state this concurrency assumption (for example, full-duplex links or independent network interfaces), since the (s−1+k)/s formula depends on it.
  4. [§6.1 and §6.3] The local-cluster plots in Figures 8 and 10 omit error bars, and the text merely states that the standard deviations are small; given that each point is averaged over only 10 runs, reporting the maximum standard deviation or adding error bars would make the variance visible.
  5. [§5] The source-code statement gives a URL but no version fingerprint such as a commit hash or DOI; since the stated URL is not independently versioned, the report should cite a concrete artifact identifier for reproducibility.
  6. [§4.3] Algorithm 2 is described as 'fast yet optimal'; its optimality is argued correctly, but the 'fast' claim is supported only by an average search time for a single (14,10) configuration, without a worst-case bound or a characterization of the explored search space.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the O(1) repair-time result is derived from the stated network-bound model and confirmed by experiments, not obtained by fitting.

full rationale

The central O(1) repair-time result in §3.2 is derived by counting timeslots under an explicitly stated network-bound model. The paper defines a timeslot as the transmission time of one block over one link, partitions each block into s slices, and observes that the repair of each slice traverses k links while the last slice starts after (s-1)/s timeslots, giving makespan (s-1+k)/s = 1 + (k-1)/s. This is arithmetic from the model, not a fit. The approximation to normal read time (1 timeslot) is a limiting statement of this same model; the paper separately validates it experimentally, e.g., Figure 8(a) reports repair time only 8.8% above direct-send time at 1 Gb/s. No parameter is fitted to data and then renamed as a prediction. The caveat that computation and disk I/O are neglected is stated in §3.2, and its limits are probed in §6.1, where the gain shrinks at 10 Gb/s but remains positive. Self-citations (e.g., [22], [29], [30]) are used for background, reliability analysis, and prior-work context; none is load-bearing for the central timeslot derivation. Hence no circularity.

Assumptions & free parameters 1 free parameters · 4 assumptions · 0 invented entities

The central analysis rests on a network-bound model with dedicated homogeneous links and negligible computation and I/O overhead. The slice size is a tunable parameter chosen empirically. No new physical entities are introduced.

free parameters (1)
  • slice size s = 32 KiB default (empirically chosen)
    The asymptotic result assumes s is sufficiently large; the practical repair time depends on slice size, which the paper tunes empirically (Figure 8(a)). It is not fitted to make the central claim true, but it is a hand-chosen parameter affecting performance.
assumptions (4)
  • domain assumption Network bandwidth is the dominant bottleneck during repair; computation and disk I/O can be overlapped and are negligible
    Stated in Sections 2.2 and 3.2; required for the timeslot analysis to translate to wall-clock repair time.
  • domain assumption All network links in the homogeneous model have equal bandwidth and are dedicated to the repair (no competing traffic)
    Used in Section 3.2 to claim no bottlenecked link; central to the O(1) result.
  • standard math Erasure codes are linear and additions are associative, so partial sums can be pipelined
    Invoked in Sections 2.1 and 3.2; standard property of Reed-Solomon and linear codes.
  • domain assumption A centralized coordinator can access block locations and schedule helpers
    Used in the design of ECPipe (Section 5.2); not proven for very large deployments, but common in such storage systems.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Repair Pipelining for Erasure-Coded Storage: Algorithms and Evaluation." pith.science (2026). https://pith.science/paper/YM2FXZWC

@misc{pith2026190801527,
  author       = {Pith},
  title        = {Pith review of: Repair Pipelining for Erasure-Coded Storage: Algorithms and Evaluation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YM2FXZWC}},
  note         = {Machine review of arXiv:1908.01527}
}
read the original abstract

We propose repair pipelining, a technique that speeds up the repair performance in general erasure-coded storage. By carefully scheduling the repair of failed data in small-size units across storage nodes in a pipelined manner, repair pipelining reduces the single-block repair time to approximately the same as the normal read time for a single block in homogeneous environments. We further design different extensions of repair pipelining algorithms for heterogeneous environments and multi-block repair operations. We implement a repair pipelining prototype, called ECPipe, and integrate it as a middleware system into two versions of Hadoop Distributed File System (HDFS) (namely HDFS-RAID and HDFS-3) as well as Quantcast File System (QFS). Experiments on a local testbed and Amazon EC2 show that repair pipelining significantly improves the performance of degraded reads and full-node recovery over existing repair techniques.

Figures

Figures reproduced from arXiv: 1908.01527 by the authors.

Figure 1
Figure 1. In erasure coding, blocks are partitioned into words, such that words at the same offset of each [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Examples of conventional repair and PPR in a single-block repair. [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Repair pipelining with k = 4 and s = 6. Thus, repair pipelining decomposes the repair of a block into the repair of a set of s small fixed-size units called slices S1, S2, · · · , Ss. It also partitions each block Bi (1 ≤ i ≤ k) into s slices Bi,1, Bi,2, · · · , Bi,s. It pipelines the repair of each slice through the linear path. To repair the first slice S1, N1 sends a1B1,1 to N2, N2 sends a1B1,1 + a2B2,1 to N3, an… view at source ↗
Figures from the paper (8 more)
Figure 4
Figure 4. Figure 4: Cyclic version of repair pipelining with [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]
Figure 5
Figure 5. Figure 5: Repair pipelining with rack-aware path selection. [PITH_FULL_IMAGE:figures/full_fig_p010_5.png]
Figure 6
Figure 6. Figure 6: Repair pipelining for a multi-block repair with [PITH_FULL_IMAGE:figures/full_fig_p014_6.png]
Figure 7
Figure 7. Figure 7: ECPipe architecture. multiple threads for performance speedup. Adding ECPipe into HDFS-RAID, HDFS-3, and QFS only requires changes of around 110, 245, and 180 lines of code, respectively. To provide fair comparisons (§6), we also implement conventional repair (§2.2) an…
Figure 8
Figure 8. Figure 8: Evaluation on a local cluster. • Multi-block repair time: the latency from issuing a request of repairing multiple failed blocks in a stripe until they are all reconstructed. All results are averaged over 10 runs. We find that the standard deviations are small and henc…
Figure 9
Figure 9. Figure 9: Evaluation on Amazon EC2. Note that the overhead of accessing the coordinator has negligible impact on the overall repair performance. We focus on evaluating the single-block repair time of a degraded read issued by a requestor. We host the requestor on an EC2 instance…
Figure 10
Figure 10. Figure 10: Evaluation on HDFS-RAID, HDFS-3, and QFS. [PITH_FULL_IMAGE:figures/full_fig_p022_10.png]
Figure 11
Figure 11. Figure 11: Evaluation on different repair pipelining implementations. [PITH_FULL_IMAGE:figures/full_fig_p023_11.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

53 extracted references · 53 canonical work pages

  1. [1]

    https://github.com/facebookarchive/hadoop-20, Retrieved in November 2020

    Facebook’s Hadoop. https://github.com/facebookarchive/hadoop-20, Retrieved in November 2020

    work page 2020

  2. [2]

    https://hadoop.apache.org/docs/r3.1.1/, Retrieved in Novem- ber 2020

    Hadoop 3.1.1 HDFS. https://hadoop.apache.org/docs/r3.1.1/, Retrieved in Novem- ber 2020

    work page 2020

  3. [3]

    https://iperf.fr/, Retrieved in November 2020

    Iperf. https://iperf.fr/, Retrieved in November 2020

    work page 2020

  4. [4]

    http://redis.io/, Retrieved in November 2020

    Redis. http://redis.io/, Retrieved in November 2020

    work page 2020

  5. [5]

    https://linux.die.net/man/8/tc, Retrieved in November 2020

    tc. https://linux.die.net/man/8/tc, Retrieved in November 2020

    work page 2020

  6. [6]

    M. K. Aguilera. Geo-distributed storage in data centers, 2013. Slides presented at International Conference on Principles of Distributed Systems (OPODIS’13)

    work page 2013

  7. [7]

    Ahmad, S

    F. Ahmad, S. T. Chakradhar, A. Raghunathan, and T. Vijaykumar. ShuffleWatcher: Shuffle-aware scheduling in multi-tenant Mapreduce clusters. In Proceedings of the 2014 USENIX Annual Technical Conference (USENIX ATC’14), pages 1--12, 2014

    work page 2014

  8. [8]

    Andr´e, A.-M

    F. Andr´e, A.-M. Kermarrec, E. L. Merrer, N. L. Souarnec, G. Straub, and A. van Kempen. Archiving cold data in warehouses with clustered network coding. In Proceedings of the Ninth European Conference on Computer Systems (EuroSys’14), pages 1--14, 2014

    work page 2014

Show all 53 references
  1. [9]

    Y. Bai, Z. Xu, H. Wang, and D. Wang. Fast recovery techniques for erasure-coded clusters in non- uniform traffic network. In Proceedings of the 48th International Conference on Parallel Processing (ICPP’19), pages 1--10, 2019

    2019

  2. [10]

    Bhagwan, K

    R. Bhagwan, K. Tati, Y. Cheng, S. Savage, and G. Voelker. Total Recall: System support for automated availability management. In Proceedings of the First Symposium on Networked Systems Design and Implementation (NSDI’04), page 25, 2004

    2004

  3. [11]

    Calder, J

    B. Calder, J. Wang, A. Ogus, N. Nilakantan, A. Skjolsvold, S. McKelvie, Y. Xu, S. Srivastav, J. Wu, H. Simitci, et al. Windows Azure Storage: A highly available cloud storage service with strong consistency. In Proceedings of the 23rd ACM Symposium on Operating Systems Princip...

    2011

  4. [12]

    Y. Chen, S. Mu, J. Li, C. Huang, J. Li, A. Ogus, and D. Phillips. Giza: Erasure coding objects across global data centers. In Proceedings of the 2017 USENIX Annual Technical Conference (USENIX ATC’17), pages 539--551, 2017

    2017

  5. [13]

    Chowdhury, S

    M. Chowdhury, S. Kandula, and I. Stoica. Leveraging endpoint flexibility in data-intensive clusters. In Proceedings of the ACM SIGCOMM 2013 conference (SIGCOMM’13) , pages 231--242, 2013

    2013

  6. [14]

    B. Chun, F. Dabek, A. Haeberlen, E. Sit, H. Weatherspoon, M. F. Kaashoek, J. Kubiatowicz, and R. Morris. Efficient replica maintenance for distributed storage systems. In Proceedings of the 3rd Symposium on Networked Systems Design & Implementation (NSDI’06) , pages 45--58, 2006

    2006

  7. [15]

    Dean and S

    J. Dean and S. Ghemawat. MapReduce: Simplified data processing on large clusters. In Proceedings of the 6th Symposium on Opearting Systems Design & Implementation (OSDI’04) , pages 137--149, 2004

    2004

  8. [16]

    A. G. Dimakis, P. B. Godfrey, Y. Wu, M. Wainwright, and K. Ramchandran. Network coding for distributed storage systems. IEEE Transactions on Information Theory , 56(9):4539--4551, Sep 2010

    2010

  9. [17]

    D. Ford, F. Labelle, F. I. Popovici, M. Stokel, V.-A. Truong, L. Barroso, C. Grimes, and S. Quinlan. Availability in globally distributed storage systems. In Proceedings of the 9th USENIX Symposium on Operating Systems Design and Implementation (OSDI’10), pages 61--74, 2010. 25

    2010

  10. [18]

    Ghemawat, H

    S. Ghemawat, H. Gobioff, and S. Leung. The Google File System. In Proceedings of the 19th ACM Symposium on Operating Systems Principles (SOSP’03), pages 29--43, 2003

    2003

  11. [19]

    C. A. R. Hoare. Algorithm 65: find. Communications of the ACM , 4(7):321--322, 1961

    1961

  12. [20]

    Holland and G

    M. Holland and G. A. Gibson. Parity declustering for continuous operation in redundant disk arrays. In Proceedings of the 5th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS’92), pages 23--35, 1992

    1992

  13. [21]

    H. Hou, P. P. C. Lee, K. W. Shum, and Y. Hu. Rack-aware regenerating codes for data centers. IEEE Transactions on Information Theory , 65(8):4730--4745, Aug 2019

    2019

  14. [22]

    Y. Hu, X. Li, M. Zhang, P. P. Lee, X. Zhang, P. Zhou, and D. Feng. Optimal repair layering for erasure-coded data centers: From theory to practice. ACM Transactions on Storage , 13(4):1--24, 2017

    2017

  15. [23]

    Huang, H

    C. Huang, H. Simitci, Y. Xu, A. Ogus, B. Calder, P. Gopalan, J. Li, and S. Yekhanin. Erasure coding in Windows Azure storage. In Proceedings of the 2012 USENIX Annual Technical Conference (USENIX ATC’12), pages 15--26, 2012

    2012

  16. [24]

    Huang, X

    J. Huang, X. Liang, X. Qin, Q. Cao, and C. Xie. PUSH: A pipelined reconstruction I/O for erasure-coded storage clusters. IEEE Transactions on Parallel and Distributed Systems , 26(2):516--526, 2015

    2015

  17. [25]

    Jalaparti, P

    V. Jalaparti, P. Bodik, I. Menache, S. Rao, K. Makarychev, and M. Caesar. Network-aware scheduling for data-parallel jobs: Plan when you can. In Proceedings of the ACM SIGCOMM 2015 conference (SIGCOMM’15), pages 407--420, 2015

    2015

  18. [26]

    O. Khan, R. Burns, J. Plank, W. Pierce, and C. Huang. Rethinking erasure codes for cloud file systems: Minimizing i/o for recovery and degraded reads. In Proceedings of the 10th USENIX conference on File and Storage Technologies (FAST’12), pages 251--264, 2012

    2012

  19. [27]

    J. Li, S. Yang, X. Wang, and B. Li. Tree-structured data regeneration in distributed and storage systems with regenerating codes. In Proceedings of the 29th IEEE Conference on Computer Communications (INFOCOM’10), pages 2892--2900, 2010

    2010

  20. [28]

    R. Li, P. P. C. Lee, and Y. Hu. Degraded-first scheduling for MapReduce in erasure-coded storage clusters. In Proceedings of the 44th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN’14), pages 419--430, 2014

    2014

  21. [29]

    R. Li, X. Li, P. P. C. Lee, and Q. Huang. Repair pipelining for erasure-coded storage. In Proceedings of the 2017 USENIX Annual Technical Conference (USENIX ATC’17) , pages 567--579, 2017

    2017

  22. [30]

    X. Li, R. Li, P. P. C. Lee, and Y. Hu. OpenEC: Toward unified and configurable erasure coding management in distributed storage systems. In Proceedings of the 17th USENIX conference on File and Storage Technologies (FAST’19), pages 331--344, 2019

    2019

  23. [31]

    Mitra, R

    S. Mitra, R. Panta, M.-R. Ra, and S. Bagchi. Partial-parallel-repair (PPR): A distributed technique for repairing erasure coded storage. In Proceedings of the 11th European Conference on Computer Systems (EuroSys’16), pages 1--16, 2016

    2016

  24. [32]

    Muralidhar, W

    S. Muralidhar, W. Lloyd, S. Roy, C. Hill, E. Lin, W. Liu, S. Pan, S. Shankar, V. Sivakumar, L. Tang, and S. Kumar. f4: Facebook’s warm BLOB storage system. In Proceedings of the 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI’14) , pages 383--398, 2014

    2014

  25. [33]

    L. M. Ni and P. K. McKinley. A survey of wormhole routing techniques in direct networks. IEEE Computer, 26(2):62--76, 1993

    1993

  26. [34]

    Ongaro, S

    D. Ongaro, S. M. Rumble, R. Stutsman, J. Ousterhout, and M. Rosenblum. Fast crash recovery in RAMCloud. In Proceedings of the 23rd ACM Symposium on Operating Systems Principles (SOSP’11) , pages 29--41, 2011. 26

    2011

  27. [35]

    Ovsiannikov, S

    M. Ovsiannikov, S. Rus, D. Reeves, P. Sutter, S. Rao, and J. Kelly. The Quantcast file system. Proceedings of the VLDB Endowment , 6(11):1092--1101, 2013

    2013

  28. [36]

    Pamies-Juarez, F

    L. Pamies-Juarez, F. Blagojevi ´c, R. Mateescu, C. Gyuot, E. E. Gad, and Z. Bandic. Opening the chrysalis: On the real repair performance of MSR codes. In Proceedings of the 14th Usenix Conference on File and Storage Technologies (FAST’16), pages 81--94, 2016

    2016

  29. [37]

    J. S. Plank. Erasure codes for storage systems: A brief primer. ;login: the Usenix magazine , 38(6):44-- 50, Dec 2013

    2013

  30. [38]

    J. S. Plank, J. Luo, C. D. Schuman, L. Xu, and Z. Wilcox-O’Hearn. A performance evaluation and examination of open-source erasure coding libraries for storage. In Proceedings of the 7th USENIX Conference on File and Storage Technologies (FAST’09), pages 253--265, 2009

    2009

  31. [39]

    Prakash, V

    N. Prakash, V. Abdrashitov, and M. M´edard. The storage versus repair-bandwidth trade-off for clustered storage systems. IEEE Transactions on Information Theory , 64(8):5783--5805, 2018

    2018

  32. [40]

    K. V. Rashmi, P. Nakkiran, J. Wang, N. B. Shah, and K. Ramchandran. Having your cake and eating it too: Jointly optimal erasure codes for I/O, storage, and network-bandwidth. In Proceedings of the 13th USENIX Conference on File and Storage Technologies (FAST’15) , pages 81--94, 2015

    2015

  33. [41]

    K. V. Rashmi, N. B. Shah, D. Gu, H. Kuang, D. Borthakur, and K. Ramchandran. A solution to the network challenges of data recovery in erasure-coded distributed storage systems: A study on the Facebook warehouse cluster. In Proceedings of the 5th USENIX conference on Hot Topics...

    2013

  34. [42]

    K. V. Rashmi, N. B. Shah, D. Gu, H. Kuang, D. Borthakur, and K. Ramchandran. A ”hitchhiker’s” guide to fast and efficient data reconstruction in erasure-coded data centers. In Proceedings of the ACM SIGCOMM 2014 conference (SIGCOMM’14), pages 331--342, 2014

    2014

  35. [43]

    Reed and G

    I. Reed and G. Solomon. Polynomial codes over certain finite fields.Journal of the Society for Industrial and Applied Mathematics, 8(2):300--304, 1960

    1960

  36. [44]

    J. K. Resch and J. S. Plank. AONT-RS: Blending security and performance in dispersed storage systems. In Proceedings of the 9th USENIX conference on File and Storage Technologies (FAST’11) , pages 191--202, 2011

    2011

  37. [45]

    Sathiamoorthy, M

    M. Sathiamoorthy, M. Asteris, D. Papailiopoulos, A. G. Dimakis, R. Vadali, S. Chen, and D. Borthakur. XORing elephants: Novel erasure codes for big data. Proceedings of the VLDB Endowment , 6(5):325-- 336, 2013

    2013

  38. [46]

    Z. Shen, X. Li, and P. P. C. Lee. Fast predictive repair in erasure-coded storage. In Proceedings of the 49th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN’19) , pages 556--567, 2019

    2019

  39. [47]

    Z. Shen, J. Shu, Z. Huang, and Y. Fu. Clustersr: Cluster-aware scattered repair in erasure-coded storage. In Proceedings of the 35th IEEE International Parallel & Distributed Processing Symposium (IPDPS’20), pages 42--51, 2020

    2020

  40. [48]

    Z. Shen, J. Shu, and P. P. C. Lee. Reconsidering single failure recovery in clustered file systems. In Proceedings of the 46th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN’16), pages 323--334, 2016

    2016

  41. [49]

    Shvachko, H

    K. Shvachko, H. Kuang, S. Radia, and R. Chansler. The Hadoop distributed file system. In Proceedings of the 2010 IEEE 26th Symposium on Mass Storage Systems and Technologies (MSST’10) , pages 1--10, 2010. 27

    2010

  42. [50]

    Silberstein, L

    M. Silberstein, L. Ganesh, Y. Wang, L. Alvizi, and M. Dahlin. Lazy means smart: Reducing repair bandwidth costs in erasure-coded distributed storage. In Proceedings of International Conference on Systems and Storage (SYSTOR’14), pages 1--7, 2014

    2014

  43. [51]

    Vajha, V

    M. Vajha, V. Ramkumar, B. Puranik, G. Kini, E. Lobo, B. Sasidharan, P. V. Kumar, A. Barg, M. Ye, S. Narayanamurthy, et al. Clay codes: Moulding MDS codes to yield an MSR code. In Proceedings of the 16th USENIX Conference on File and Storage Technologies (FAST’18) , pages 139--...

    2018

  44. [52]

    Weatherspoon and J

    H. Weatherspoon and J. D. Kubiatowicz. Erasure coding vs. replication: A quantitative comparison. In Proceedings of the first International Workshop on Peer-to-Peer Systems (IPTPS’02) , pages 328--337, 2002

    2002

  45. [53]

    F. Xu, Y. Wang, X. Pei, and X. Ma. LAR: Locality-aware reconstruction for erasure-coded distributed storage systems. Concurrency and Computation: Practice and Experience , 31(11):e5031, 2019. 28

    2019

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.