Determinant Codes with Helper-Independent Repair for Single and Multiple Failures
Mehran Elyasi, Soheil Mohajer

TL;DR
This paper introduces a new helper-independent repair mechanism for determinant codes in distributed storage, enabling efficient repair of single and multiple failures while maintaining the code's properties.
Contribution
It proposes a helper-independent repair method for determinant codes and demonstrates their capability to repair multiple failures with sub-linear repair bandwidth.
Findings
Helper-independent repair mechanism achieved for determinant codes.
Determinant codes can repair multiple failures with sub-linear bandwidth.
Preserves all original properties of determinant codes.
Abstract
Determinant codes are a class of exact-repair regenerating codes for distributed storage systems with parameters (n, k = d, d). These codes cover the entire trade-off between per-node storage and repair-bandwidth. In an earlier work of the authors, the repair data of the determinant code sent by a helper node to repair a failed node depends on the identity of the other helper nodes participating in the process, which is practically undesired. In this work, a new repair mechanism is proposed for determinant codes, which relaxes this dependency, while preserving all other properties of the code. Moreover, it is shown that the determinant codes are capable of repairing multiple failures, with a per-node repair-bandwidth which scales sub-linearly with the number of failures.
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Determinant Codes with Helper-Independent Repair for Single and Multiple Failures
Mehran Elyasi, and Soheil Mohajer M. Elyasi and S. Mohajer are with the Department of Electrical and Computer Engineering, University of Minnesota, Twin Cities, MN 55455, USA, (email: {melyasi, soheil}@umn.edu).
Abstract
Determinant codes are a class of exact-repair regenerating codes for distributed storage systems with parameters . These codes cover the entire trade-off between per-node storage and repair-bandwidth. In an earlier work of the authors, the repair data of the determinant code sent by a helper node to repair a failed node depends on the identity of the other helper nodes participating in the process, which is practically undesired. In this work, a new repair mechanism is proposed for determinant codes, which relaxes this dependency, while preserving all other properties of the code. Moreover, it is shown that the determinant codes are capable of repairing multiple failures, with a per-node repair-bandwidth which scales sub-linearly with the number of failures.
I Introduction
While individual storage units in distributed storage systems (DSS) are subject to temporal or permanent failure, the entire system should be designed to avoid losing the stored data. Coding and storing redundant data is a standard approach to guarantee durability in such systems. Moreover, these systems are equipped with a repair mechanism that allows for a replacement of a failed node. Such replacement can be performed in the functional or exact sense. In functional repair, a failed node will be replaced by another one, so that the consequent family of nodes maintains the data recovery and node-repair properties. In an exact repair process, the content of a failed node will be exactly replicated by the helpers.
Regeneration codes are introduced to manage data recovery and node repair mechanism in DSS. Formally, an regeneration code with parameters encodes a file comprised of symbols (from a finite field ) into segments (nodes) each of size , such that two important properties are fulfilled: (1) the entire file can be recovered from every subset of nodes, and (2) whenever a node fails (become inaccessible), it can be repaired by accessing remaining nodes and downloading symbols from each.
It turns out that there is a fundamental trade-off between the minimum required per-node storage and the repair-bandwidth , to store a given amount of data in a DSS. This tradeoff is fully characterized for functional repair in the seminal work of Dimakis et. al [1], where it is shown to be achievable by random network coding. However, for the exact-repair problem, which is notably important from the practical perspective, characterization of the trade-off and design of optimum codes are widely open, except for some special cases. Construction of exact-repair regenerating codes for a system with arbitrary parameters is a complex task due to several combinatorial constraints to be satisfied. The number of such constraints dramatically increases with , the total number of nodes in the system.
There are known code constructions for the two extreme points on the tradeoff, namely, minimum bandwidth regeneration (MBR) [2] and minimum storage regeneration (MSR) [2, 3, 4, 5, 6, 7] points.
A lower bound for the trade-off of the exact-repair regenerating codes with parameters is presented independently by [8, 9, 10], under the assumption that the underlying code is linear. This lower bound could be achieved for the special case of (i.e., the DSS can only tolerate one failure) by code constructions proposed in [11] and [12]. While the lower bound does not depend on (the total number of nodes in the system), the performance (storage capacity) of both code constructions in [11] and [12] degrades as exceeds (see Fig. 1).
I-A Determinant Codes and Helper-Independent Repair
Determinant codes are a family of exact repair regenerating codes, which are introduced in [14, 13] for a DSS with parameters . The main property of these codes is to maintain a constant trade-off between and , regardless of the number of the nodes. In particular, these codes can achieve the lower bound [8, 9, 10], and hence they are optimum. The determinant codes have a linear structure and can be obtained from the inner product between an encoder matrix and the message matrix. Especially, product-matrix codes introduced in [2] for MBR and MSR points can be subsumed from the general construction of the determinant codes.
The repair mechanism proposed for the determinant codes in the original paper [13] requires a rather heavy computation at the helper nodes in order to prepare their repair symbols to send to the failed node. More importantly, each helper node needs to know the identity of all the other helper nodes participating in the repair process. The assumption of knowing the set of helpers in advance is a limitation of the determinant codes, and it is undesired in real-world systems. In practice, it is preferable that once a request for a repair of a failed node is made, each node can independently decide to whether or not to participate in the repair process and generate the repair data from its content, regardless of the other helper nodes.
On the other hand, besides the repair bandwidth, one of the crucial bottlenecks in the performance of the storage systems is the I/O load, which refers to the amount of data to be read by a helper node to encode for a repair process. While the native constructions for exact repair generating code require a heavy I/O read, the repair-by-transfer (RBT) codes [15] offer an optimum I/O. In [16] an elegant modification is proposed to improve the I/O cost of product-matrix MSR codes, by pre-processing the content of the nodes and storing the repair data on non-systematic nodes instead of the original node content. This results in a semi-RBT code: whenever such modified nodes contribute in a repair process, they merely transfer some of their stored symbols without any computation. Such modification could not be applied on the original determinant codes since the repair symbols from a helper node to a failed node could be computed only when the set of other helper nodes is identified.
In this paper, we propose a novel repair mechanism for the determinant codes introduced in [13]. In the new repair procedure, data repair symbols from helper node to a failed node solely depend on the content of the helper node and the identity of the failed node . The failed node collects a total of repair symbols from the helper nodes and can reconstruct all of its missing symbols by simple addition and subtraction of some of the received symbols. This simple repair scheme further allows for modifications proposed in [16], to further improve the I/O overhead of the code.
I-B Multiple Failures Repair
The second contribution of this work is the simultaneous repair for multiple failures. Although single failures are the dominant type of failures in distributed storage systems [17], multiple simultaneous failures occur rather frequently and need to be handled in order to maintain the system’s reliability and fault-tolerance. The naive approach to deal with such failures is to repair each failed node individually and independently from the others. This requires a repair bandwidth from each helper node that scales linearly with the number of failures. There are two types of repair for multiple failures studied in the literature [18]: (i) centralized regenerating codes and (ii) cooperative regenerating codes. In centralized regenerating codes, a single data center is responsible for the repair of all failed nodes. More precisely, once a set of nodes in the system fail, an arbitrary set of nodes are chosen, and repair symbols will be downloaded from each helper node. This leads to a total of symbols which will be used to repair the content of all the failed nodes. The storage-bandwidth trade-off of these codes are studied for two extreme points, namely the minimum storage multi-node repair (MSMR) and the minimum bandwidth multi-node repair (MBMR) points. In particular, in [4] a class of MSMR code is introduced, that are capable of repairing any number of failed nodes from any number of helper nodes , using an optimal repair bandwidth. In cooperative regenerating codes upon failure of a node, the replacement node downloads repair data from a subset of helper nodes. In the case of multiple failures, the replacement nodes not only download repair data from the helper nodes, but also exchange information among themselves before regenerating the lost data, and this exchanged data between them is included in the repair bandwidth. Similar to the centralized case, the trade-off for these codes for the two extreme points, namely the minimum bandwidth cooperative regeneration (MBCR) codes [19] and the minimum storage cooperative regenerating (MSCR) codes [20, 21, 22] are studied. In particular, in [22] authors introduced explicit constructions of MDS codes with optimal cooperative repair for all possible parameters. Also, they have shown that any MDS code with optimal repair bandwidth under the cooperative model also has optimal bandwidth under the centralized model.
In this work we show that the repair bandwidth required for multiple failures repair in determinant codes can be reduced by exploiting two facts: (i) the overlap between the repair space (linear dependency between the repair symbols) that each helper node sends to the set of failed nodes, and (ii) in the centralized repair, the data center (responsible for the repair process) can perform the repair of the nodes in a sequential manner, and utilize already repaired nodes as helpers for the repair of the remaining failed nodes. Interestingly, using these properties we can limit the maximum (normalized) repair-bandwidth of the helper nodes to a certain fraction of , regardless of the number of failures. The structure of the code allows us to analyze this overlap, and obtain a closed-form expression for the repair bandwidth. Our codes are not restricted only to the extreme points of the trade-off and can operate at any intermediate point on the optimum trade-off. A similar problem is studied in [18], where a class of codes is introduced to operate at the intermediate points of the trade-off, with an improved repair bandwidth for multiple failures. However, this improvement is obtained at the price of degradation of the system’s storage capacity as (the total number of nodes) increases. Consequently, the resulting codes designed for two or more simultaneous failures are sub-optimum, and cannot achieve the optimum trade-off between the per-node capacity, repair bandwidth, and the overall storage capacity. One of the main advantages of our proposed code and repair mechanism is to offer a universal code, which provides a significant reduction in the repair bandwidth for multiple failures, without compromising the system performance.
The rest of this paper is organized as follows: For the sake of completeness, we first review the achievable trade-off and the construction of the determinant codes [13] in Sections II and Section III. The new encoding and decoding for the node repair are presented in Section III-B. An illustrative example is provided in Section IV, in which the core idea of data recovery and node repair are demonstrated. The formal proofs of the properties of the proposed code are presented in Section V. Finally, in Section VI we discuss the improved repair-bandwidth for multiple failures in a centralized repair setting.
II Main Result
We start by introducing a few symbols and notations, which are frequently used in this paper.
Notation: We use to denote the set of integer numbers , and to represent the set . For a set and a member , we define . We use boldface symbols to refer to matrices, and for a matrix , we denote its -th row by . We also use the notation to refer to the -th column of . Moreover, we use to denote a sub-matrix of obtained by rows and columns . Accordingly, denotes the sub-matrix of by stacking rows . Moreover, we may use sets to label rows and/or columns of a matrix, and hence refers to an entry of matrix at the row indexed by and the column labeled by . Finally, for a set , we denote the maximum entry of by .
The optimum storage repair-bandwidth of the exact-repair regenerating codes for an system is a piece-wise linear function [13, 14], which is fully characterized by its corner (intersection) points [8, 10, 9]. The determinant codes provide a universal construction for all corner points on the optimum trade-off curve. We assign a mode (denoted by ) to each corner point, which is an integer in (from for MBR to for MSR point). The main distinction between the result of this work and that of [13, 14] is the fact that the repair data sent by one helper node does not depend on the identity of all the other helper nodes participating the repair process. The following definition formalizes this distinction.
Definition 1**.**
Consider the repair process of a failed node using a set of helper nodes . The repair process is called helper-independent if the repair data sent by each helper node to the failed node only depends on and the content of node (but not the other helpers participating in the repair process).
The following theorem formally states the trade-off achievable by determinant codes.
Theorem 1**.**
For an distributed storage system and any mode , the triple with
[TABLE]
can be achieved under helper-independent exact repair by the code construction proposed in this paper.
It is worth mentioning that this theorem and the achievable points on the trade-off curve are identical to those of [13]. However, the novel repair process presented here has the advantage that the repair data sent by a helper node does not depend on the identity of other helpers participating in the repair process. Moreover, we present a repair mechanism for multiple simultaneous failures. The proposed scheme exploits the overlap between the repair data sent for different failed nodes and offers a reduced repair-bandwidth compared to naively repairing the failed nodes independent of each other.
The code construction is reviewed in Section III for completeness. In order to prove Theorem 1, it suffices to show that the proposed code satisfies the two fundamental properties, namely data recovery and exact node repair. The proof data recovery property is similar to that of [13, Proposition 1], and hence omitted here. The exact-repair property is formally stated in Proposition 2, and proved in Section V. Moreover, Proposition 1 shows that the repair bandwidth of the proposed code does not exceed . This is also proved in Section V.
In Fig. 2 the linear trade-off for a system together with achievable corner points of this paper are depicted.
Remark 1**.**
Theorem 1 offers an achievable trade-off for the normalized parameters given by
[TABLE]
It is shown in [8, 9, 10] that for any linear exact-repair regenerating code with parameters that is capable of storing symbols, should satisfy
[TABLE]
where takes values in . This establishes a piece-wise linear lower bound curve, with (normalized) corner points obtained at integer values of . For these corner points, the (normalized) operating points are given
[TABLE]
These operating points are matching with the achievable (normalized) pairs given in (2). Therefore, determinant codes are optimal, and together with the lower bound of [8, 9, 10] fully characterize the optimum trade-off for exact-repair regenerating codes with parameters .
The next result of this paper provides an achievable bandwidth for multiple repairs.
Theorem 2**.**
In an determinant codes operating at mode , the content of any set of simultaneously failed nodes can be exactly repaired by accessing an arbitrary set of nodes and downloading
[TABLE]
repair symbols from each helper node.
The repair mechanism for multiple failures is similar to that of single failure presented in Proposition 2. In order to prove Theorem 2, it suffices to show that the repair bandwidth required for multiple failures does not exceed . This is formally stated in Proposition 3 and proved in Section V.
Remark 2**.**
Note that the repair bandwidth proposed for multiple repairs in Theorem 2 subsumes the one in Theorem 1 for single failure for setting :
[TABLE]
Remark 3**.**
It is worth mentioning that the repair-bandwidth proposed in Theorem 2 is universally and simultaneously achievable. That is, the same determinant code can simultaneously achieve for every .
The next theorem shows that the repair bandwidth for multiple failures can be further reduced in the centralized repair setting [4, 18], by a sequential repair mechanism, and exploiting the repair symbols contributed by already repaired failed nodes which can act as helpers.
Theorem 3**.**
In an determinant code with (up to a scalar factor) parameters and , any set of simultaneously failed nodes can be centrally repaired by accessing an arbitrary set of helper nodes and downloading a total of
[TABLE]
repair symbols from each helper node.
Remark 4**.**
It is worth noting that for we have (independent of ), and
[TABLE]
which is strictly less than as shown in Fig. 3 (for all corner points except the MSR point, ). The fact that implies that the helper nodes contribute just enough number of repair symbols to be able to recover the entire file, without sending any redundant data. It is clear that this repair-bandwidth is optimum for , since such a set of failed nodes should be able to recover the entire file after being repaired.
This theorem is built on the result of Theorem 2, by exploiting the repair data can be exchanged among the failed nodes. Note that in the centralized repair setting, the information exchanged among the failed nodes at the repair center are not counted against the repair bandwidth. We prove this theorem in Section VI.
III Construction of determinant codes
The code construction described in this section is identical to that of [13], except the repair process which is different and simpler. However, for the sake of completeness, we start with the details of code construction.
III-A Code Construction
For a distributed storage system with parameters and corresponding to a mode , our construction provides an exact-repair regenerating code with per-node storage capacity and per-node repair-bandwidth . This code can store up to symbols.
We represent the coded symbols in a matrix , in which the -th row corresponds to the encoded data to be stored in -th node of DSS. The proposed code is linear, i.e., the encoded matrix is obtained by multiplying an encoder matrix and a message matrix111The number of entries in this matrix is more than , the size of the file to be coded. Indeed, there are some redundancies among the entries of this matrix as will be explained later. , whose construction will be explained later. All entries of the encoder matrix and the message matrix222In general elements of the message matrix can be chosen from a Galois field for some prime number and an integer . are assumed to be from a finite field , which has at least distinct elements. Moreover, all the arithmetic operations are performed with respect to the underlying finite field. The structures of the encoder and message matrices are given below.
Encoder Matrix: The matrix is a fixed matrix which is shared among all the nodes in the system. The main property required for matrix is being Maximum-Distance-Separable (MDS), that is, any sub-matrix of is full-rank. Examples of MDS matrices include Vandermonde or Cauchy matrices. We can always convert an MDS matrix to a systematic MDS matrix, by multiplying it by the inverse of its top sub-matrix (see the example in Section IV). We refer to the first nodes by systematic nodes if a systematic MDS matrix is used for encoding.
Message Matrix: The message matrix is filled with raw (source) symbols and parity symbols. Recall that is a matrix, that has entries, while we wish to store only source symbols. Hence, there are redundant entries in , which are filled with parity symbols. More precisely, we divide the set of data symbols into two groups, namely, and , whose elements are indexed by sets as follows
[TABLE]
Note that each element of is indexed by a set of length and an integer number . Hence, . Similarly, symbols in are indexed by a pair , where is a subset of with entries, and can take any value in except the largest one. So, there are symbols in set . Note that .
For the sake of completeness, we define parity symbols indexed by pairs , where and . Such symbols are constructed such that parity equations
[TABLE]
hold for any with . In other words, such missing symbols are given by333Note that for an underlying Galois field with characteristic , the parity equation reduces to . .
The rows of matrix are labeled by numbers , and the columns are labeled by subsets of of size . The entries of matrix are given by
[TABLE]
It is shown in [13, Proposition 1] that the entire data encoded by this code can be recovered from the content of any nodes. Next, we show the exact-repair properties for single and multiple failures.
III-B Single Failure Exact Repair
The second important property of the proposed code is its ability to exactly repair the content of a failed node using the repair data sent by the helper nodes. Let node fails, and a set of helper nodes with wishes to repair node . We first determine the repair data sent from each helper node in order to repair node .
Repair Encoder Matrix at the Helper Nodes: For a determinant code operating in mode and a failed node , the repair-encoder matrix is defined as a matrix, whose rows are labeled by -element subsets of and columns are labeled by -element subsets of . The entry in row and column is given by
[TABLE]
where is the entry of the encoder matrix at position . An example of the matrix is given in (24) in Section IV.
In order to repair node , each helper node multiplies its content by the repair-encoder matrix of node to obtain , and sends it to node . Note that matrix has columns, and hence the length of the repair data is , which is greater than . However, the following proposition states that out of columns of matrix at most are linearly independent. Thus, the entire vector can be sent by communicating at most symbols (corresponding to the linearly independent columns of ) to the failed node, and other symbols can be reconstructed using the linear dependencies among the repair symbols. This is formally stated in the following proposition, which is proved in Section V.
Proposition 1**.**
The rank of matrix is at most .
Decoding at the Failed Node: Upon receiving repair-data vectors , the failed node stacks them to form a matrix , where in the sub-matrix of obtained from nodes . This matrix is full-rank by the definition of the matrix. Multiplying by , the failed node retrieves
[TABLE]
This is a matrix. These linear combinations of the data symbols span a linear subspace, which we refer to by repair space of node . The following proposition shows that all of the missing symbols of node can be recovered from its repair space.
Proposition 2**.**
In the proposed codes with parameters , for every failed node and set of helpers with , the content of node can be exactly regenerated by downloading symbols from each of nodes in . More precisely, the -th entry of the node can be recovered using
[TABLE]
The proof of this proposition is presented in Section V.
Remark 1**.**
Note that for a code defined on the Galois field with characteristic , we have , and hence, all the positive and negative signs disappear. In particular, the parity equation in (5) will simply reduce to , the non-zero entries of the repair encoder matrix in (11) will be , and the repair equation in (13) will be replaced by .
III-C Multiple Failure Exact Repair
The repair mechanism proposed for multiple failure scenario is similar to that of the single failure case. We consider a set of failed nodes with failures. Each helper node sends its repair data to all failed nodes simultaneously. Each failed node can recover the repair data , and the repair mechanism is similar to that explained in Proposition 2.
A naive approach is to simply concatenate all the required repair data at the helper node and send it to the failed nodes. More precisely, for a set of failed nodes and a helper node , we define its repair data as , where
[TABLE]
This is simply a concatenation of the repair data for individual repair of , and the content of each failed node can be exactly reconstructed according to Proposition 2. The repair bandwidth required for naive concatenation scheme is . Instead, we show that the bandwidth can be opportunistically utilized by exploiting the intersection between the repair space of the different failed nodes. The following proposition shows that the repair data can be delivered to the failed nodes by communicating only repair symbols.
Proposition 3**.**
Assume that a family of nodes are failed. Then the rank of matrix defined in (15) is at most .
IV An Illustrative Example for codes
Before presenting the formal proof of the main properties of the proposed code, we show the code construction and the repair mechanism through an example in this section. This example is similar to that of [13], and will be helpful to understand the notation and the details of the code construction, as well as to provide an intuitive justification for its underlying properties.
Let’s consider a distributed storage system with parameters and an operating mode . The parameters of the proposed regeneration code for this point of the trade-off are given by
[TABLE]
We first label and partition the information symbols into two groups, and , with and . Note that .
[TABLE]
Moreover, for each subset with , we define parity symbols as
[TABLE]
Next, the message matrix will be formed by placing and symbols as specified in (8). The resulting message matrix is given by
The next step for encoding the data is multiplying by an encoder matrix . To this end, we choose a finite field (with at least distinct non-zero entries), and pick an Vandermonde matrix generated by . We convert this matrix to a systematic MDS matrix by multiplying it from the right by the inverse of its top matrix. That is,
[TABLE]
Note that every rows of matrix are linearly independent, and form an invertible matrix. Then the content of node is formed by row in the matrix product , which we denote by .
Data recovery from the content of any node is immediately implied by the MDS property of the encoder matrix. For further details, we refer to Section IV in [13]. Next, we describe the repair process for single and multiple failures.
IV-A Single Failure Repair
First, suppose that a non-systematic node fails, and we wish to repair it by the help of the systematic nodes , by downloading from each. The content of node is given by , which includes symbols. Note that the content of this node is a row vector whose elements has the same labeling as the columns of , i.e all elements subsets of . The symbols of this node are given by:
[TABLE]
In the repair procedure using the systematic nodes as helpers, every symbol will be repaired by nodes. Recall that helper nodes contribute in the repair process by sending symbols each, in order to repair missing symbols. Hence, the number of repair equations per missing symbol is , which matches with the proposed repair mechanism.
The helpers for each missing encoded symbol are those who have a copy of the corresponding -symbols, e.g., for the symbol indexed by which has and , the contributing helpers are nodes (who has a copy of ) and node (who stores a copy of ). To this end, node can send which node sends to perform the repair.
It can be seen that the -th missing symbols has also two other terms depending on and , which are stored at nodes and , respectively. A naive repair mechanism requires these two nodes also to contribute in this repair procedure, which yields in a full data recovery in order to repair a failed node. Alternatively, we can reconstruct these -symbols using the parity equations, and the content of the the first two helper nodes. Recall from (5) that
[TABLE]
where and are stored in node and and are stored in node . Hence, the content of nodes and are sufficient to reconstruct the -th symbol at the failed node . To this end, node computes (a linear combination of its first, forth, and fifth entries), and sends to . Similarly, node sends (a linear combination of its first, second, and third coded symbols). Upon receiving these symbols, the -th missing symbols of node can be recovered from
[TABLE]
In general, symbols are repaired directly by communicating an identical copy of them, while symbols are repaired indirectly, using their parity equations. This is the general rule that we use for repair of all other missing symbols of node . It can be seen that each helper node participates in the repair of missing symbols, by sending one repair symbol for each. For instance, node contributes in the repair of symbols indexed by , , and . The repair equation sent by node for each these repair scenarios are listed below:
[TABLE]
Similarly, the repair symbols sent from helper nodes , , and are given by
[TABLE]
The repair symbols of helper node in (20)-(23) could be obtain from , which is the content of the helper nodes (i.e., ) times the repair encoder matrix for (i.e., ) defined in (11):
[TABLE]
Note that, even though this matrix has columns, and hence, is a vector of length , it suffices to communicate only444Indeed the entire repair process can be expressed in terms of the repair symbols sent by the helper nodes. However, the recovery equations for the missing symbols are mathematically more symmetric and compact if we allow the fourth symbol to appear in the repair equations. symbols from the helper node to the failed node and the fourth symbol can be reconstructed from the other symbols at the failed node. This is due to the fact that the rank of matrix equals to . More precisely, a non-zero linear combination of the columns of is zero, that is,
[TABLE]
Therefore, (if ) the helper node only sends the first symbols of the vector , namely, , , and , and the forth symbol can be appended to it at node from
[TABLE]
Upon receiving the repair data from helper nodes , namely , the failed can stack them to obtain a matrix
[TABLE]
where the last identity is due to the fact that is the identity matrix. We refer to this matrix by the repair space matrix of node , and denote it by , as presented at the top of the next page.
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] A. G. Dimakis, P. Godfrey, Y. Wu, M. J. Wainwright, and K. Ramchandran, “Network coding for distributed storage systems,” Information Theory, IEEE Transactions on , vol. 56, no. 9, pp. 4539–4551, 2010.
- 2[2] K. V. Rashmi, N. B. Shah, and P. V. Kumar, “Optimal exact-regenerating codes for distributed storage at the msr and mbr points via a product-matrix construction,” Information Theory, IEEE Transactions on , vol. 57, no. 8, pp. 5227–5239, 2011.
- 3[3] S.-J. Lin, W.-H. Chung, Y. S. Han, and T. Y. Al-Naffouri, “A unified form of exact-msr codes via product-matrix frameworks,” Information Theory, IEEE Transactions on , vol. 61, no. 2, pp. 873–886, 2015.
- 4[4] M. Ye and A. Barg, “Explicit constructions of high-rate mds array codes with optimal repair bandwidth,” IEEE Transactions on Information Theory , vol. 63, no. 4, pp. 2001–2014, 2017.
- 5[5] B. Sasidharan, M. Vajha, and P. V. Kumar, “An explicit, coupled-layer construction of a high-rate msr code with low sub-packetization level, small field size and all-node repair,” ar Xiv preprint ar Xiv:1607.07335 , 2016.
- 6[6] C. Tian, J. Li, and X. Tang, “A generic transformation for optimal repair bandwidth and rebuilding access in mds codes,” in Information Theory (ISIT), 2017 IEEE International Symposium on , 2017, pp. 1623–1627.
- 7[7] M. Ye and A. Barg, “Explicit constructions of optimal-access mds codes with nearly optimal sub-packetization,” IEEE Transactions on Information Theory , vol. 63, no. 10, pp. 6307–6317, 2017.
- 8[8] M. Elyasi, S. Mohajer, and R. Tandon, “Linear exact repair rate region of ( k + 1 , k , k ) 𝑘 1 𝑘 𝑘 (k+1,k,k) distributed storage systems: A new approach,” in Information Theory Proceedings (ISIT), 2015 IEEE International Symposium on . IEEE, 2015, pp. 2061–2065.
