Analysis and Construction of Functional Regenerating Codes with Uncoded Repair for Distributed Storage Systems

Modern distributed storage systems apply redundancy coding techniques to stored data. One form of redundancy is based on regenerating codes, which can minimize the repair bandwidth, i.e., the amount of data transferred when repairing a failed storage node. Existing regenerating codes mainly require surviving storage nodes encode data during repair. In this paper, we study functional minimum storage regenerating (FMSR) codes, which enable uncoded repair without the encoding requirement in surviving nodes, while preserving the minimum repair bandwidth guarantees and also minimizing disk reads. Under double-fault tolerance settings, we formally prove the existence of FMSR codes, and provide a deterministic FMSR code construction that can significantly speed up the repair process. We further implement and evaluate our deterministic FMSR codes to show the benefits. Our work is built atop a practical cloud storage system that implements FMSR codes, and we provide theoretical validation to justify the practicality of FMSR codes.


I. INTRODUCTION
We have witnessed the wide deployment of storage systems in Internet-wide distributed settings, such as peer-to-peer storage (e.g., [14], [2], [5], [27]) and cloud storage (e.g., GFS [8] and Azure [4]), in which data is striped over multiple storage nodes in a networked environment. For data availability, a storage system must keep user data for a long period of time and allow users to access their data on demand. However, storage nodes are often deployed in commodity machines and prone to failures [8]. It is thus important for a storage system to ensure data availability in practical deployment.
One way to ensure data availability is to store redundant data over multiple storage nodes. Redundancy can be achieved via maximum distance separable (MDS) codes such as Reed-Solomon codes [18], whose idea is that even if any subset of nodes fail, the original data remains accessible from the remaining surviving nodes. In general, Reed-Solomon codes have significantly less redundancy overhead than simple replication of data under the same fault tolerance requirement.
When a storage node fails, it is necessary to recover the lost data of the failed node to preserve the required level of fault tolerance. Regenerating codes [7] have been proposed to minimize the repair bandwidth, which defines the amount of data traffic transferred in the repair process. Regenerating codes are built on network coding [1], such that to repair a failed node, existing surviving nodes encode their own stored data and send the encoded data to the new node, which then reconstructs the lost data. It is shown that regenerating codes use less repair bandwidth than Reed-Solomon codes, given the same storage overhead and fault tolerance requirements.
However, there are challenges of deploying regenerating codes in practice. First, most regenerating code constructions (e.g., [29], [6], [3], [23], [17], [21]) require storage nodes to encode stored data during repair. This may not be feasible for some storage devices that merely provide the basic I/O functionalities without any encoding capabilities. More importantly, even if storage nodes have encoding capabilities, they must first read all available data from disk and combine the data into encoded form before transmitting encoded data for repair. This leads to high disk reads, which may degrade the actual repair performance.
On the applied side, a cloud storage system NCCloud [10] proposes and implements functional minimum storage regenerating (FMSR) codes, which have several key properties: (i) FMSR codes preserve the fault tolerance of MDS codes and have the same redundancy overhead as MDS codes for a given fault tolerance; (ii) FMSR codes preserve the benefits of network coding as they minimize the repair bandwidth (e.g., the repair bandwidth saving compared to RAID-6 codes is up to 50% [10]); and (iii) FMSR codes use uncoded repair without requiring encoding of surviving nodes during repair, and this can minimize disk reads as the amount of data read from disk is the same as that being transferred. FMSR codes are designed as non-systematic codes as they do not keep the original uncoded data as their systematic counterparts, but instead store only linear combinations of original data called parity chunks. Each round of repair regenerates new parity chunks for the new node and ensures that the fault tolerance level is maintained. A trade-off of FMSR codes is that the whole encoded file must be decoded first if parts of a file are accessed. Nevertheless, FMSR codes are suited to long-term archival applications, since data backups are rarely read and it is common to restore the whole file rather than file parts.
While FMSR codes have been experimented on real-life cloud testbeds, there remain open issues regarding whether FMSR codes exist and how they are deterministically constructed. In particular, given that new parity chunks are regenerated in each round of repair, we need to ensure that such chunks preserve the fault tolerance of MDS codes after multiple rounds of repair. Thus, the key motivation of this work is to provide theoretical foundations for the practicality of FMSR codes.
In this paper, we conduct formal analysis on the existence of FMSR codes and provide a deterministic construction for FMSR codes, with an objective of theoretically validating the practicality of FMSR codes in distributed storage systems. We focus on the double-fault tolerance setting (i.e., at most two node failures can be tolerated) as in conventional RAID-6 codes [12]. Note that double-fault tolerance is by default used in practical cloud storage systems such as GFS [8] and Azure [4]. Our contributions are three-fold.
• We formally prove the existence of FMSR codes with uncoded repair, such that the fault tolerance of MDS codes is preserved after any number of rounds of repair. • We provide a deterministic FMSR code construction, such that the repair can deterministically specify (i) the chunks to be read from surviving nodes and (ii) the encoding coefficients used to regenerate new chunks. This significantly speeds up the repair time compared to the random FMSR code construction used in NCCloud [10]. • We build and evaluate our deterministic FMSR codes, and show that the chunk selection and regeneration during repair can be finished within less than one second. The rest of the paper proceeds as follows. Section II reviews related work. Section III characterizes the system model of FMSR codes and formulates the problems. Section IV formally proves the existence of FMSR codes. Section V provides a deterministic FMSR code construction. Section VI presents evaluation results. Section VII concludes the paper.

II. BACKGROUND AND RELATED WORK
Dimakis et al. [7] first propose regenerating codes based on network coding [1] for distributed storage systems. It is shown that when repairing a single failed storage node, regenerating codes use less repair bandwidth than conventional Reed-Solomon codes [18] by transmitting encoded data from the surviving nodes to a new node. Also, [7] gives an optimal tradeoff spectrum between storage cost and repair bandwidth and identifies two extreme points. One extreme point refers to the minimum storage regenerating (MSR) codes, in which each node stores the minimum amount of data as in Reed-Solomon codes. Another extreme point is the minimum bandwidth regenerating (MBR) codes, which allow each node to store more data than in conventional Reed-Solomon codes to minimize the repair bandwidth. In this work, we focus on the MSR codes, so that we can fairly compare with conventional Reed-Solomon codes under the same storage overhead.
As shown in [7], [28], [11], the MSR point is achievable under functional-repair, which means that the repaired data may not be the same as the lost data while still maintaining the same fault tolerance level. However, the corresponding coding schemes perform random linear coding in surviving nodes and do not provide explicit construction. Then there are extensive studies (e.g., [29], [6], [3], [23], [17], [21]) on the exactrepair MSR (EMSR) codes, in which the data reconstructed is identical to the lost data.
Most EMSR codes require storage nodes encode stored data during repair. Authors in [19], [20] propose regenerating codes that eliminate encoding of storage nodes during repair. We call it uncoded repair [19], or repair-by-transfer [20]. However, their constructions belong to MBR codes. EMSR code constructions based on uncoded repair have been proposed in [24], [26]. The EMSR code in [24] has the uncoded repair property for systematic nodes that store original data chunks but not for the parity nodes that store encoded chunks, while that in [26] has the uncoded repair property for both systematic and parity nodes. However, the code construction in [26] requires the total number of data chunks being stored increase exponentially with the number of systematic nodes. This increases the number of chunk accesses, and limits its application in practical storage systems.
Several studies (e.g., [25], [30], [13]) propose uncoded repair schemes that minimize disk reads for XOR-based erasure codes. Their solutions are built on existing code constructions. In general, they do not achieve the global minimum point.
A recent applied work [10] builds a network-coding-based cloud storage system called NCCloud. The authors build and evaluate functional MSR (FMSR) codes, which minimize the repair bandwidth using uncoded repair. Later in [22], the correctness of FMSR codes is analyzed for a special case of two systematic nodes. In this paper, we generalize the analysis, and also provide a deterministic code construction, for more systematic nodes.

A. Basics of FMSR Codes
We first describe the basics of FMSR codes, which are used by NCCloud [10] to store files over multiple independent storage nodes. Each node could be a disk device, a storage server, or a cloud storage provider. NCCloud motivates using FMSR codes to provide fault-tolerant, long-term archival storage using multiple clouds, so as to save the monetary cost in migrating data between cloud providers during repair. FMSR codes have three design properties, which we elaborate below.
Property 1: FMSR codes preserve the fault tolerance and storage efficiency of MDS codes. MDS codes are defined by two parameters n and k (k < n). An (n, k)-MDS code divides a file of size M into k pieces of size M/k each, and encodes them into n pieces such that any k out of n encoded pieces suffice to recover the original file. By storing the n encoded pieces over n nodes, a storage system can tolerate at most n − k node failures. An example of MDS codes is Reed-Solomon codes [18]. Figure 1 shows the FMSR codes for a special case n = 4 and k = 2. To store a file of size M units, an (n, k)-FMSR code splits the file evenly into k(n − k) native chunks, say F 1 , F 2 , . . . , F k(n−k) , and encodes them into n(n − k) parity chunks of size M k(n−k) each. Each l th parity chunk is formed by a linear combination of the k(n − k) native chunks, i.e., k(n−k) m=1 α l,m F m for some encoding coefficients α l,m . All encoding coefficients and arithmetic are operated over a finite field F q of size q. We store the n(n − k) parity chunks on n nodes, each keeping n − k parity chunks. Note that native chunks need not be stored. The original file can be restored by decoding k(n − k) parity chunks of any k nodes, where decoding can be done by inverting an encoding matrix [16]. Let P i,j be the j th parity chunk stored on node i, where i = 1, 2, . . . , n and j = 1, . . . , n − k. Property 2: FMSR codes minimize the repair bandwidth. If a node fails, we must reconstruct the lost data of the failed node to preserve fault tolerance. The conventional repair of Reed-Solomon codes reads k pieces from any k surviving nodes to restore the original file (by the design of MDS codes). Clearly, the amount of data read is the file size M . FMSR codes seek to read less than M units of data to reconstruct the lost data. We define repair bandwidth as the amount of data read from surviving nodes during repair. FMSR codes are designed to match the minimum storage point of regenerating codes when repairing a node failure [7], while having each node store M/k units of data as in Reed-Solomon codes. To repair a failed node in FMSR codes, each surviving node transfers data of size M k(n−k) units as in [7], or equivalently, a size of one parity chunk. In a special case of n = 4 and k = 2 (see Figure 1), the repair bandwidth is 0.75M , i.e., 25% less than that of conventional repair of Reed-Solomon codes. In general, the repair bandwidth of FMSR codes for k = n − 2 is M(n−1) 2(n−2) , and its saving compared to RAID-6 codes [12] (which are also double-fault tolerant) is up to 50% if n is large [10].
Property 3: FMSR codes use uncoded repair. During repair, each surviving node under FMSR codes transfers one parity chunk, without any encoding operations. This also minimizes the amount of data read from disk. Suppose we have a failed node l (e.g., l = 1 in Figure 1). Then we read one parity chunk denoted by P i,f (i) from each surviving node i, where 1 ≤ i ≤ n and i = l, and f (.) denotes some function that specifies which chunk to be read from a surviving node. Then we encode the n − 1 parity chunks into n − k linearly independent parity chunks P ′ l,1 , P ′ l,2 , . . . P ′ l,n−k , which will all be stored in a new node, which becomes the new node l (called the repaired node). Each new parity chunk is generated by: where γ i,j denotes some coefficient for encoding the collected parity chunks into new chunks. In Section V, we formally specify how we choose f (.) and γ i,j .

B. Formulation of Repair Problem in FMSR Codes
We formulate the repair problem in FMSR codes based on [10]. Note that [10] only gives a high-level description, without formal definitions and theoretical validations. Here, we provide a theoretical framework that formalizes the idea of [10].
FMSR codes satisfy the MDS property, as described below. Definition 1: MDS property. For any subset of k out of n nodes, if the k(n − k) parity chunks from the k nodes can be decoded to the k(n − k) native chunks of the original file, then the MDS property is satisfied.
Definition 2: Decodability. We say that a collection of k(n−k) parity chunks is decodable if the parity chunks can be decoded to the original file, which can be verified by checking if the associated k(n − k) vectors of encoding coefficients are linearly independent. Note that these k(n − k) chunks may be scattered among n nodes, and need not reside in k nodes.
Note that FMSR codes operate on parity chunks. For simplicity, when we use the term "chunk" in our discussion, we actually refer to a parity chunk.
Since FMSR codes regenerate different chunks in each repair, one design challenge of FMSR codes is to preserve the MDS property after multiple rounds of repairs. We illustrate with an example in Figure 1. Suppose that node 1 fails, and we construct new chunks P ′ 1,1 and P ′ 1,2 using P 2,1 , P 3,1 , and P 4,1 as in Figure 1. Next, suppose that node 2 fails. If we construct new chunks P ′ 2,1 and P ′ 2,2 using P ′ 1,1 , P 3,1 , and P 4,1 , then in the repaired nodes 1 and 2, the chunks {P ′ 1,1 , P ′ 1,2 , P ′ 2,1 , P ′ 2,2 } are the linear combinations of only three chunks P 2,1 , P 3,1 , and P 4,1 instead of four. So the chunks in the repaired nodes 1 and 2 are not decodable, and the MDS property is lost.
Thus, to preserve the MDS property over multiple rounds of repair, NCCloud uses a specific implementation of FMSR codes based on random chunk selection, which we call random FMSR codes. NCCloud seeks to completely avoid linear dependence in chunk regeneration and hence losing the MDS property. Specifically, NCCloud performs the r th (where r ≥ 1) round of repair as follows: (i) It randomly selects a chunk from each surviving node (i.e., f (.) returns a random value), and generates random encoding coefficients to encode the selected chunks into new chunks (i.e., γ i,j 's are randomly chosen). (ii) It then performs two-phase checking. In the first phase, it checks if the MDS property is satisfied with the new chunks generated (i.e., the chunks of any k out of n nodes remain decodable) after the current r th round of repair. In the second phase, it further checks if the MDS property is still satisfied after the (r + 1) th round of repair for any possible node failure, and this property is called the repair MDS property. (iii) If both phases are passed, then NCCloud writes the generated chunks to a new node; otherwise, it repeats (i) and (ii) with another set of random chunks and random encoding coefficients. We now formally define the repair MDS property. Definition 3: Repair-based collections (RBCs). An RBC of the r th round of repair is a collection of k(n − k) chunks that can be obtained after the r th round of repair by the following procedure. (Step 1) We select any n − 1 out of n nodes. (Step 2) We select k − 1 out of the n − 1 nodes found in Step 1 and collect n − k chunks from each selected node. (Step 3) We collect one chunk from each of the non-selected n − k nodes. Clearly, the number of collected chunks is We can easily verify that there are n n−1 Intuitively, an RBC refers to a collection of chunks of k nodes after the (r + 1) th round of repair for any possible node failure. For instance, after repairing node 1 in Figure 1, one example RBC is R = {P ′ 1,1 , P 3,1 , P 3,2 , P 4,1 }. This means that we assume: node 2 is the failed node in the next round of repair; the failed node 2 will be repaired by chunks P ′ 1,1 , P 3,1 (or P 3,2 ), and P 4,1 ; and we consider if the chunks of node 2 (after repair) and node 3 are decodable. Note that the chunks of node 2 and node 3 are linear combinations of this RBC R.
We assume that when a file is stored, it is first encoded using Reed-Solomon codes, such that any k(n − k) out of n(n − k) (parity) chunks are decodable. Note that these k(n−k) chunks may reside in more than k nodes (e.g., P 1,1 , P 2,1 , P 3,1 , P 4,1 in Figure 1). If no repair is carried out, then we ensure that every possible RBC is decodable.
However, after repairing a node failure, there exist some provably non-decodable RBCs. For example, in Figure 1, are linear combinations of P 2,1 , P 3,1 , P 4,1 . Note that these non-decodable RBCs all contain the chunks of the repaired node 1. Each of these RBCs is a linear combination of chunks P 2,1 , P 3,1 , P 4,1 (i.e., less than four chunks) in the repair. Accordingly, we define the following: Definition 4: Linear Dependent Collection (LDC). Suppose an RBC of the r th round of repair contains the n−k chunks of the repaired node that are collected in Step 2 (see Definition 3). If and only if every chunk of this RBC is a linear combination of a set of less than k(n−k) chunks of the r th round of repair, we call it an LDC of the r th round of repair.
Definition 5: Repair MDS (rMDS) property. If all RBCs, after excluding the LDCs, of the r th round of repair are decodable, then we say the rMDS property is satisfied. It means that if every RBC that is a linear combination of exactly k(n − k) chunks is always decodable, then we say that the rMDS property is satisfied.
Definition 6: (n,k)-FMSR codes. An original file is stored in n nodes in the form of n(n − k) chunks. If these n(n − k) chunks satisfy both the MDS and rMDS properties, then we say this file is FMSR-encoded.
Summary. Authors of NCCloud [10] show via simulations that by checking both the MDS and rMDS properties in each round of repair, FMSR codes can preserve the MDS property after hundreds of rounds of repair. Also, if we check only the MDS property but not the rMDS property, then after some rounds of repair we cannot regenerate the chunks that preserve the MDS property within a fixed number of iterations (this is called the bad repair [10]). On the other hand, there is no formal theoretical analysis showing the need of two-phase checking to preserve the MDS property after any number of rounds of repair. Also, random FSMR codes repeat two-phase checking until the valid chunks are regenerated. This could involve many iterations and significantly increase the repair time overhead (see Section VI). In the following sections, we formally provide the theoretical validation of existence of FMSR codes and the design of deterministic FMSR codes.

IV. EXISTENCE
We now prove the existence of FMSR codes. In this work, we focus on k = n−2, implying that FMSR codes are doublefault tolerant as conventional RAID-6 codes [12]. Double-fault tolerance has been assumed in practical cloud storage systems (e.g., GFS [8] and Azure [4]). Our goal is to show that FMSR codes always maintain double-fault tolerance (i.e., the MDS property is always satisfied with k = n − 2) after any number of rounds of uncoded repair, while the repair bandwidth is kept at the MSR point.
We first give three lemmas. Lemmas 1 and 2 provide a guideline of how to choose n − 1 chunks from n − 1 surviving nodes (one chunk from each node) to repair a failed node. Lemma 3 implies that if the finite field size is large enough, then we can always find a set of encoding coefficients to regenerate new chunks for a repaired node so as to maintain the MDS and rMDS properties after each round of repair. Finally, we prove Theorem 1 for the existence of FMSR codes.
Lemma 1: In repair, let F be the set of n − 1 chunks selected from n − 1 surviving nodes to regenerate the n − k chunks of the repaired node. Also, let Q be the set of chunks collected in Step 3 of RBC construction (see Definition 3). If an RBC (denoted by R) containing the n − k chunks of the repaired node is an LDC, then F and Q must have two or more common chunks.
Proof: Without loss of generality, let node 1 be the failed node. Let P be the set of chunks collected in Step 2 of Definition 3 excluding the n−k chunks of the repaired node 1. Thus, R = {P ′ 1,1 , . . . , P ′ 1,n−k } ∪ P ∪ Q. As P ′ 1,1 , . . . , P ′ 1,n−k are obtained by linearly combining the chunks in F , we infer that R contains linear combinations of chunks in F ∪ P ∪ Q.
Since F selects one chunk from each of n − 1 surviving nodes and P has all the chunks from k − 2 surviving nodes, F and P have k − 2 identical chunks, i.e., |F ∩ P| = k − 2.
Lemma 2: Suppose that the rMDS property is satisfied after every r th round of repair. Then for any n − 1 out of n nodes, we can always select one chunk from these n − 1 nodes (i.e., a total of n − 1 chunks) such that any RBC containing the selected n − 1 chunks is decodable.
Proof: Without loss of generality, suppose that we construct an RBC R by selecting the chunks from nodes 2, . . . , n (see Step 1 of Definition 3), and that G be the set of n − 1 chunks selected from nodes 2, . . . , n (one chunk from each nodes). We prove the existence of G such that if R contains G (i.e., G ⊂ R), then R is decodable.
If node 1 is the repaired node in the r th round of repair, then R is never an LDC (by Definition 4). Since the rMDS property is satisfied by our assumption, R is decodable (by Definition 5).
If node 1 is not the repaired node in the r th round of repair, then without loss of generality, let node 2 be the repaired node. By the FMSR design, the chunks of node 2 are linearly combined by one chunk in each of nodes 1, 3, . . . , n. We denote these chunks by F = {P 1,f (1) , P 3,f (3) , . . . , P n,f (n) }.
Since each node has n − k > 1 chunks, we can construct G = P 2,g(2) , . . . , P n,g(n) } such that g(i) = f (i) for i = 3, . . . , n (while g(2) can be randomly picked). If R contains G, then in Step 3 of RBC construction (see Definition 3), at least one chunk must be selected from G. However, G has no identical chunk with F . By Lemma 1, R is not an LDC. Since the rMDS property is satisfied, R is decodable.
Lemma 3: (Schwartz-Zippel Theorem) [15]. Consider a multivariate non-zero polynomial h(x 1 , . . . , x t ) of total degree ρ over a finite field F. Let S be a finite subset of F, and x 1 , . . . ,x t be the values randomly selected from S. Then the probability Pr[h(x 1 , . . . ,x t ) = 0] ≤ ρ |S| . Theorem 1: Consider a file encoded using FMSR codes with k = n − 2. In the r th (r ≥ 1) round of uncoded repair of some failed node j, the lost chunks are reconstructed by the random linear combination of n−1 chunks selected from n−1 surviving nodes (one chunk from each node). Then after the repair, the reconstructed file still satisfies both the MDS and rMDS properties with probability that can be driven arbitrarily to 1 by increasing the field size of F q .
Proof: We prove by induction on r. Initially, we use Reed-Solomon codes to encode a file into n(n−k) = 2n chunks that satisfy both the MDS and rMDS properties. Suppose that after the r th round of repair, both the MDS and rMDS properties are satisfied (this is our induction hypothesis).
Let U r = {P 1,1 , P 1,2 ; . . . ; P k+2,1 , P k+2,2 } be the current set of chunks after the r th round of repair. In the (r + 1) th round of repair, without loss of generality, let node 1 be the failed node to repair. Since U r satisfies the rMDS property, we have the following corollary by Lemma 2.
We use F to repair node 1. Suppose that the repaired node 1 has the new chunks {P ′ 1,1 , P ′ 1,2 }. Then: Next we prove that we can always tune γ i,j in F q in such a way that the set of chunks in the (r + 1) th round of repair U r+1 = {P ′ 1,1 , P ′ 1,2 ; . . . ; P k+2,1 , P k+2,2 } still satisfies both MDS and rMDS properties. The proof consists of two parts.
Part II: U r+1 satisfies the rMDS property. By Definition 5, we need to prove that all the RBCs of U r+1 except the LDCs are decodable. By Definition 3, we consider two cases of RBCs. Without loss of generality, we let node 1 be the repaired node.
Our goal is to show that if R 1 is not an LDC, then it is decodable. By Lemma 1, we know that if R 1 is an LDC, then there are at least two chunks selected in Step 3 that belong to F = {P 2,f (2) , . . . , P n,f (n) } (which are used to regenerate chunks for node 1), or equivalently, g(k) = f (k) and g(k + 1) = f (k +1). Therefore, to prove that R 1 except the LDCs is decodable, it is equivalent to prove that R 1 is decodable when (a) g(k) = f (k) and g(k + 1) = f (k + 1), (b) g(k) = f (k) and g(k + 1) = f (k + 1), or (c) g(k) = f (k) and g(k + 1) = f (k + 1).
The above collection is an RBC containing F . By our corollary, the collection is decodable. Therefore, R 1 is linear combination of a decodable collection. Then we can use the similar method in Part I to prove that there always exists an assignment of γ i,j in a sufficiently large field such that R 1 is decodable (by Lemma 3). The proof of (b) is similar to that of (a) and is thus omitted.
Lastly, let us consider (c). Now, X can be written as {P 2,1 , P 2,2 ; . . . ; P k−1,1 , P k−1,2 ; P k,1 , P k,2 ; P k+1,1 , P k+1,2 ; P k+2,f (k+2) }. Define X = X − {P k+2,f k+2 }. Note that the MDS property of X is satisfied by induction hypothesis. Thus, X is decodable, implying that P k+2,f (k+2) can be seen as a linear combination of X . Obviously, we can also say that X is formed by linear combinations of X . Therefore, R 1 is also formed by linear combinations of the decodable collection X . Based on the above argument, R 1 is decodable.
Denote the RBC by R 2 = {P 2,1 , P 2,2 ; . . . ; P k,1 , P k,2 ; P ′ 1,g(1) , P k+1,g(k+1) }. We need to show that if R 2 is not an LDC, it is decodable. Based on Lemma 1, there is no more than one identical chunk between F and the RBC's chunks collected in Step 3, so R 2 is never an LDC. We only need to prove that every possible R 2 is decodable.
Combining Case 1 and Case 2, we deduce that all RBCs excluding the LDCs are decodable. So U r+1 satisfies the rMDS property. Therefore, Theorem 1 concludes.

V. DETERMINISTIC FMSR CODES
In NCCloud [10], the repair operation under FMSR codes is accomplished based on two random processes: (i) using random chunk selection to read chunks from the surviving nodes and (ii) applying random linear combinations of the selected chunks to generate new chunks for the repaired node. Section IV has proved the correctness of the random-based repair operation by virtue of existence of FMSR codes. On the other hand, a drawback of the random approach is that it may need to try many iterations to generate the correct set of chunks that satisfies both the MDS and rMDS properties.
In this section, we propose a deterministic repair scheme under FMSR codes (k = n − 2), such that both the chunk selection and linear combination operations are deterministic. This enables us to significantly speed up the repair operation. In our deterministic scheme, we specify which particular chunk should be read from each surviving node in each round of repair. We also derive the sufficient conditions on which the encoding coefficients should satisfy. To design the deterministic scheme, we first introduce an evolved repair MDS property.
Definition 7: Evolved Repair MDS (erMDS) property. Let k = n−2. For any k+1 out of n nodes, if we can always select one specific chunk from each of the k + 1 nodes such that any RBC containing these selected k +1 chunks is decodable, then we say the code scheme has the erMDS property.
From Lemma 2, we can see that if the rMDS property is satisfied, then the erMDS property is also satisfied. Thus, any RBCs satisfying the rMDS property is a subset of the RBCs satisfying the erMDS property. We use the erMDS property to construct a deterministic FMSR code.
To construct deterministic FMSR codes for k = n − 2, we describe how we store a file and how we trigger the r th (r ≥ 1) round of repair for a node failure. The correctness of our deterministic FMSR codes is proved in Appendix.
The first round of repair. Suppose without loss of generality that node 1 fails and is then repaired by two steps.

VI. EVALUATION
In this section, we evaluate the repair performance of two implementations of FMSR codes: (i) random FMSR codes, which use random chunk selection in repair and is used in NCCloud [10] and (ii) deterministic FMSR codes, which use deterministic chunk selection proposed in Section V. We show that our proposed deterministic FMSR codes can significantly reduce the time required to regenerate parity chunks in repair.
We implement both versions of FMSR codes in C. We implement finite-field arithmetic operations over a Galois Field GF(2 8 ) based on the standard table lookup approach [9]. We conduct our evaluation on a server running on an Intel CPU at 2.4GHz. We consider different values of n (i.e., the number of nodes). For each n, we first apply Reed-Solomon codes to generate the encoding coefficients that will be used to encode a file into parity chunks before uploading. In each round of repair, we randomly pick a node to fail. We then repair the failed node using two-phase checking, based on either random or deterministic FMSR code implementations. The failed node that we choose is different from that of the previous round of repair, so as to ensure a different chunk selection in each round of repair. We conduct 50 rounds of repair in each evaluation run. We conduct a total of 30 runs over different seeds for each n.
The metric we are interested in is the checking time spent on determining if the chunks selected from surviving nodes can be used to regenerate the lost chunks. We do not measure the times of reading or writing chunks, as they are the same for both random and deterministic FMSR codes. Instead, we focus on measuring the processing time of two-phase checking in each round of repair. It is important to note that twophase checking only operates on encoding coefficients, and is independent of the size of the file being encoded. Note that we do not specifically optimize our encoding operations, but we believe our results provide fair comparison of both random and deterministic FMSR codes using our baseline implementations. Figure 2 first depicts the aggregate checking times for a total of 50 rounds of repair versus the number of nodes when using random and deterministic FMSR codes. The aggregate checking time of random FMSR codes is small when n is small (e.g., less than 1 second for n ≤ 6), but exponentially increases as n is large. On the other hand, the aggregate checking time of deterministic FMSR codes is significantly small (e.g., within 0.2 seconds for n ≤ 10).
Our investigation finds that the checking time of random FMSR codes increases dramatically as the value of n increases. For example, when n = 12 (not shown in our figures), we find that the repair operation of our random FMSR code implementation still cannot return a right set of regenerated chunks after running for two hours. In contrast, our deterministic FMSR codes can return a solution within 0.5 seconds.
To further examine the significant performance overhead of random FMSR codes, Figures 3 and 4 show the cumulative checking time and number of two-phase checkings performed for r rounds of repair, respectively, for n = 8, 9, 10. We note that random FMSR codes incur a fairly large but constant number of two-phase checkings in each round of repair. For example, for n = 10, each round of repair takes around 100 iterations of two-phase checkings (see Figure 4(a)). On the other hand, deterministic FMSR codes significantly reduce the number of iterations of two-phase checking (e.g., less than 2.5 on average for n = 10). In summary, our evaluation results show that deterministic FMSR codes significantly reduce the two-phase checking overhead of ensuring that the MDS property is preserved during repair.

VII. CONCLUSIONS
This paper formulates an uncoded repair problem based on functional minimum storage regenerating (FMSR) codes. We formally prove the existence of FMSR codes and provide a deterministic FMSR code construction. We also show via our evaluation that our deterministic FMSR codes significantly reduce the repair time overhead of random FMSR codes. Our theoretical results validate the correctness of existing practical FMSR code implementation [10]. We also demonstrate the feasibility of preserving the benefits of network coding in minimizing the repair bandwidth with uncoded repair.

APPENDIX
We now prove the correctness of the deterministic FMSR codes in Section V. Initiaially, the file is stored with Reed-Solomon codes, such that any 2k out of 2(k + 2) (parity) chunks are decodable to the original file. Therefore, the set of chunks being stored before any repair satisfies the MDS and erMDS properties. Now, we show that the MDS and erMDS properties are always satisfied after each round of repair, based on our chunk selection and coefficient construction.
The first round of repair. Let U 1 = {P ′ 1,1 , P ′ 1,2 ; P 2,1 , P 2,2 ; . . . ; P n,1 , P n,2 } be the set of all chunks after the first round of repair (for failed node 1). Next we prove that U 1 still satisfies both the MDS and erMDS properties.
(U 1 satisfies the erMDS property) Since the file is initially stored with Reed-Solomon Codes, the erMDS property is satisfied before the repair. Hence there already exist k + 1 chunks, say P 2,1 , . . . , P k+2,1 , such that any RBC containing them is decodable. Thus, we only need to check whether for the repaired node 1 and any k of nodes 2, . . . , k + 2, there always exist k + 1 chunks such that by collecting one chunk from each such node, any RBC containing them is decodable. Without loss of generality, we just consider the case for the repaired node 1 and nodes 2, . . . , k + 1 for simplicity.
Here, we select the k + 1 chunks in the way that they are distinct from those selected for the first round of repair. In this case, we collect F 1 = {P ′ 1,2 , P 2,2 , . . . , P k+1,2 } (note: either P ′ 1,1 or P ′ 1,2 is fine). Next we show that the constructed γ i,j can make any RBC containing F 1 decodable. Since the repaired node 1 may offer one or two chunks to an RBC, we consider two cases.
The r th repair (r > 1) Take r = 2 for instance. Suppose without loss of generality that node k + 2 fails. Then we select {P ′ 1,2 , P 2,2 , . . . , P k+1,2 } which are distinct from those in the first round of repair. We can observe that in fact this set is F 1 in the first round of repair. As mentioned above, any RBC containing F 1 is decodable. So F 1 can be used for the second round of repair. Then we can generate the coefficients that satisfy the similar inequalities as (4), (5), and (6). The proof of correctness is similar as r = 1 and thus omitted.