A Fast Repair Code Based on Regular Graphs for Distributed Storage Systems

1. A Fast Repair Code Based on Regular Graphs for Distributed Storage Systems Yan Wang, East China Jiao Tong University Xin Wang,Fudan University

2. Outline • Introduction • Related work • The code framework • Performance analysis • Conclusion

3. Introduction • Introducing a class of distributed storage codes, the fast repair codes (FRC). • Based on regular graphs. • Simple lookup and exact repair. • minimum repair bandwidth and low disk I/O overhead.

4. Outline • Introduction • Related work • The code framework • Performance analysis • Conclusion

5. Related work • Minimum storage regenerating (MSR). • Minimumbandwidth regenerating (MBR). • (n, k, f)-SRCcode. • Twin-MDS codes. • Uncoded repairproperty and fractional repetition codes. • Self-repairing code.

6. Related work─ Regular graph

7. Related work─ Twin-MDS codes • Partition the n storage nodes into two categories. • Consisting of and nodes respectivelyand encode themusing two different MDS codes. • Minimization of storage space. • Repair-bandwidth. • Low complexity of operation. • Fewerdisk reads. • But in the worstcaseanalysis. • Handle failure of anyn − (2k − 1) nodes with respect to data-construction.

8. Related work─ Uncoded repairproperty and fractional repetition codes • Using an outer MDScode followed by an inner repetition code. • Exact repair for the minimum bandwidth regime. • Can totally tolerate ρ − 1 node failures. • ρ = 2, achieved based on regulargraph. • ρ > 2, achieved based on Steiner system.

9. Related work─ Self-repairing code • Low complexity and bandwidth consumption. • Repair one block, often two blocks are enough. • Only encoding operation is XOR. • However, their code does not satisfy the (n, k)-MDS property. • Not any k storage node can reconstruct the data file.

10. Related work─References • [1]“Network coding for distributed storage system,” inProc.IEEEInt. Conf. on Computer Commun, May 2007 • [5]“Simple regenerating codes,” in arXiV, Aug 2011, Aug. 2011. • [6]“Enabling node repair in any erasure codefor distributed storage,” in ISIT, Sep. 2011. • [7]“Fractional repetitioncodes for repair in distributed storage systems,” in Proc.Allerton Conf., Sep. 2010. • [9]“Self-repairing homomorphic codes fordistributed storage systems,” in INFOCOM, 2011 ProceedingsIEEE, april 2011, pp. 1215 –1223.

11. Outline • Introduction • Related work • The code framework • Code construction • Construction of regular graph • Example • Performance analysis • Conclusion

12. The code framework─Code construction • The data file to be stored in n distributed storage nodes. • A series of 0-1 bits of length M. • (n’, k’)-MDScode. • Partitionthe file into k’blocks of equal size. • Encode the file into n’codedblocks. • Choose a d-regular graph G(V,E). • Deploy the n’coded blocksto n storage nodes. • n nodes, each node corresponds to a storage node and has dneighbors. • Each edge as a coded block, each node stores d coded blocks. • n’ = nd/2.

13. The code framework─Code construction • When a node fails, we select a newcomer to perform exact repair. • As each block is stored in two nodes. • Can be done by retrieving coded block one from each neighbor node in the regular graph. • Need to access several storage nodes to get no less than k’distinct coded blocks. • The numberof distinct coded blocks stored in k storage nodes equalsto the number of edges covered by the k nodes in the regular graph.

14. The code framework─Code construction • Let Rc(G, k) denote theminimum number of edges covered by any k nodes in aregular graph G. • k’ ≤ Rc(G, k). • Can often get k’distinct blocks from accessing less than k storage nodes. • Becausewe choose the storage nodes randomly while Rc(G, k)considers the minimum distinct blocks we can get from kstorage nodes.

15. The code framework─Construction of regular graph • Show that how to construct aclass of regular graphs for any values of (n, k, d) that n isdivisible by (d − 1). • n = (d − 1)m, the regular graph is formed by d − 1 cycles of length m. • Label each node of each cycle from 1 tom. • Connect any two nodes having the same label. • Thereby, any d − 1 nodes having the same label forms acomplete graph −1. • Each node is of degree d. • d − 2 edges from thecomplete graph Kd−1.

16. The code framework─Example

17. The code framework─Example • Consider a DSS with (n = 10, k = 4, d = 3). • choose n’= 15, asthere are 15 edges in the regular graph. • K’= 8, as any 4 nodes can cover 8 distinct edges at least. • Use a (15, 8)-MDS code to encode the file into 15 coded blocks. • Eachstorage node stores 3 blocks corresponding the 3 adjacentedges in graph.

18. Outline • Introduction • Related work • The code framework • Performance analysis • Coding rate • Other aspects • Trade strict MDS property for better average performance • Conclusion

19. Performance analysis─Coding rate • Store 2n’ = ndblocks in all, while the file is of size k’blocks. • choose an (nd/2, k’)-MDS code. • K’is no more than Rc(G, k). • Maximizing the coding rate = maximizing Rc(G, k). • However, it is a challenging problem.

20. Performance analysis─Coding rate • Proposition 1: For general d-regular graph, Rc(G, k) ≥ dk/2. • Proof: As each node has d neighbors and each edge is counted in dkat most twice. • Therefore, let k’= Rc(G, k), and the coding rate of theFRC code is no less than k/2n.

21. Performance analysis─Other aspects When a node fails: • We retrieve one block from each of its d neighbor nodes to exactly restore the data. • The total repair bandwidth is the same as the storage per node • The number of disk access is d. • Only look-up and replications are performed. • the lowest coding complexity for repairing. • the lowest repair bandwidth as well.

22. Performance analysis─Trade strict MDS property for better average performance • Not access a fixed number of storage nodes. • Keep accessing new storage nodes until we collect enough distinct coded blocks. • no constraint on k’and thus can start with any given coding rate.

23. Performance analysis─Trade strict MDS property for better average performance • Proposition 2: For any d-regular graph, the expected number of edges covered by k nodes is dk(1 - ). • Proof: Let denote the expected number of edges covered twice by the k nodes. • i.e., both its ends belong to the k selected nodes. • Then the total number of covered edges is dk − .

24. Performance analysis─Trade strict MDS property for better average performance • Select the k nodes one by one. • When selecting the last node, its d neighbors are independently selected with probability . • = + d・ = 0. • = = dk.

25. Performance analysis─Trade strict MDS property for better average performance • We can conclude the results. • When k ≤ n/2, the expected number of edges covered by k storage nodes is greater than dk. • Thus, we can set k’= dk, achieving coding rate . • File can be reconstructed from no more than k storage nodes on average.

26. Performance analysis─Trade strict MDS property for better average performance

27. Outline • Introduction • Related work • The code framework • Performance analysis • Conclusion

28. Conclusion • FRC codes minimizes bandwidth consumption and coding complexity in the repairing process. • Analytical results show that the FRC codes outperform the others in terms of low repair complexity and disk I/O overhead

29. Conclusion • The challenging issue is the relatively small coding rates • Considering acceptable as a trade-off for the simple repairing process • As future research • It is challenging to find a class of regular graphs with large coding rates