Exact-repair Codes Research Articles

Graftage Coding for Distributed Storage Systems

To achieve various tradeoffs between storage and repair bandwidth, this article proposes to construct exact repair codes by grafting two codes ${\mathcal{ C}}_{1}$ and ${\mathcal{ C}}_{2}$ . By replacing certain nonzero entries in the generator matrix of ${\mathcal{ C}}_{1}$ by zero, the repair bandwidth of the resulting grafting part decreases. However, it may no longer keep the maximum-distance-separable (MDS) property. As a result, the grafted code ${\mathcal{ C}}_{2}$ takes these nonzero entries into account such that the entire graftage code can keep the MDS property. The relationship between the bandwidth reduction of ${\mathcal{ C}}_{1}$ and the file size of ${\mathcal{ C}}_{2}$ is derived to optimize graftage codes. Our analysis indicates that these graftage codes may provide better tradeoffs than space-sharing.

An Outer Bound for Linear Multi-Node Exact Repair Regenerating Codes

In distributed storage, erasure codes provide fault-tolerance while reducing the storage overhead compared to replication. The network traffic cost during the repair of node failures, called repair bandwidth, is an important metric in code design. Regenerating codes are a class of erasure codes developed with the aim of reducing the repair bandwidth while maintaining a high level of fault-tolerance. They exhibit a tradeoff between the storage overhead per node and the repair bandwidth. However, a fundamental understanding of the storage-repair bandwidth tradeoff under exact repair is open in general. In this work, we consider the exact repair problem of multiple failures in a centralized way. Building upon techniques from the literature, we first provide an alternative proof of the functional repair bound. Then, we derive a new outer bound for linear centralized multi-node exact repair codes and illustrate its performance under various parameter settings. The derived outer bound shows that, in general, the centralized multi-node functional repair tradeoff is not achievable under linear exact repair.

Exact-Repair Codes With Partial Collaboration in Distributed Storage Systems

The partially collaborative repair of multiple node failures in distributed storage systems is investigated. An exact-repair code is constructed using a bilinear form, which achieves the minimum-bandwidth partially collaborative repair (MBPCR) point. When the storage capacity is minimum, the problem of repairing multi-node failures using a Maximum Distance Separable (MDS) array code is also investigated. The minimum-storage partially collaborative repair (MSPCR) problem with same number of repairing and reconstruction nodes has been studied before. In this paper, the scenario where the number of repairing nodes is greater than that of reconstruction nodes and the storage capacity is already minimal for partial collaboration is considered. An MDS array code is constructed, which asymptotically achieves the MSPCR point. Further, we show that the given code construction could not always have a regular collaborative structure.

Centralized Multi-Node Repair Regenerating Codes

In a distributed storage system, recovering from multiple failures is a critical and frequent task that is crucial for maintaining the system's reliability and fault-tolerance. In this work, we focus on the problem of repairing multiple failures in a centralized way, which can be desirable in many data storage configurations, and we show that a significant repair traffic reduction is possible. First, the fundamental tradeoff between the repair bandwidth and the storage size for functional repair is established. Using a graph-theoretic formulation, the optimal tradeoff is identified as the solution to an integer optimization problem, for which a closed-form expression is derived. Expressions of the extreme points, namely the minimum storage multi-node repair (MSMR) and minimum bandwidth multi-node repair (MBMR) points, are obtained. Second, we describe a general framework for converting single erasure minimum storage regenerating codes to MSMR codes. The repair strategy for $e$ failures is similar to that for single failure, however certain extra requirements need to be satisfied by the repairing functions for single failure. For illustration, the framework is applied to product-matrix codes and interference alignment codes. Furthermore, we prove that the functional MBMR point is not achievable for linear exact repair codes. We also show that exact-repair minimum bandwidth cooperative repair (MBCR) codes achieve an interior point, that lies near the MBMR point, when $k \equiv 1 \mod e$, $k$ being the minimum number of nodes needed to reconstruct the entire data. Finally, for $k> 2e, e\mid k$ and $e \mid d$, where $d$ is the number of helper nodes during repair, we show that the functional repair tradeoff is not achievable under exact repair, except for maybe a small portion near the MSMR point, which parallels the results for single erasure repair by Shah et al.

Centralized Repair of Multiple Node Failures With Applications to Communication Efficient Secret Sharing

This paper considers a distributed storage system, where multiple storage nodes can be reconstructed simultaneously at a centralized location. This centralized multi-node repair (CMR) model is a generalization of regenerating codes that allow for bandwidth efficient repair of a single-failed node. This paper focuses on the tradeoff between the amount of data stored and repair bandwidth in the CMR model. In particular, repair bandwidth bounds are derived for the minimum storage multi-node repair (MSMR) and the minimum bandwidth multi-node repair (MBMR) operating points. The tightness of these bounds is analyzed via code constructions. The MSMR point is characterized by codes achieving this point under functional repair for the general set of CMR parameters, as well as with codes enabling exact repair for certain CMR parameters. The MBMR point, on the other hand, is characterized with exact repair codes for all CMR parameters for systems that satisfy a certain entropy accumulation property. Finally, the model proposed here is utilized for the secret sharing problem, where the codes for the multi-node repair problem are used to construct communication efficient secret sharing schemes with the property of bandwidth efficient share repair.

The Storage Versus Repair-Bandwidth Trade-off for Clustered Storage Systems

We study a generalization of the setting of regenerating codes, motivated by applications to storage systems consisting of clusters of storage nodes. There are $n$ clusters in total, with $m$ nodes per cluster. A data file is coded and stored across the $mn$ nodes, with each node storing $\alpha$ symbols. For availability of data, we require that the file be retrievable by downloading the entire content from any subset of $k$ clusters. Nodes represent entities that can fail. We distinguish between intra-cluster and inter-cluster bandwidth (BW) costs during node repair. Node-repair in a cluster is accomplished by downloading $\beta$ symbols each from any set of $d$ other clusters, dubbed remote helper clusters, and also up to $\alpha$ symbols each from any set of $\ell$ surviving nodes, dubbed local helper nodes, in the host cluster. We first identify the optimal trade-off between storage-overhead and inter-cluster repair-bandwidth under functional repair, and also present optimal exact-repair code constructions for a class of parameters. The new trade-off is strictly better than what is achievable via space-sharing existing coding solutions, whenever $\ell > 0$. We then obtain sharp lower bounds on the necessary intra-cluster repair BW to achieve optimal trade-off. Our bounds reveal the interesting fact that, while it is beneficial to increase the number of local helper nodes $\ell$ in order to improve the storage-vs-inter-cluster-repair-BW trade-off, increasing $\ell$ not only increases intra-cluster BW in the host-cluster, but also increases the intra-cluster BW in the remote helper clusters. We also analyze resilience of the clustered storage system against passive eavesdropping by providing file-size bounds and optimal code constructions.

An Outer Bound on the Storage-Bandwidth Tradeoff of Exact-Repair Cooperative Regenerating Codes

Cooperative regenerating codes are a kind of erasure codes, which are optimal in terms of minimizing the repair bandwidth. An $(n,k,d,r)$ -cooperative regenerating code has $n$ storage nodes, where $k$ arbitrary nodes are enough to reconstruct original data, and $r$ failed nodes can be repaired cooperatively with the help of $d$ arbitrary surviving nodes. In the regenerating-code framework, there exists a tradeoff between the storage capacity of each node $\alpha $ and the repair bandwidth $\gamma $ , but the problem of specifying the optimal storage-bandwidth tradeoff of the exact-repair cooperative regenerating codes remains open. A key contribution of this paper is that an outer bound on the storage-bandwidth tradeoff of exact-repair linear cooperative regenerating codes is proposed. This result can be regarded as a generalization of the outer bound proposed by Prakash et al. , which specifies the optimal tradeoff of exact-repair regenerating codes for the case of $d=k=n-1$ . The proposed outer bound suggests the $(\alpha ,\gamma )$ pairs that no exact-repair codes can achieve but only functional-repair codes can. By observing the size of the set of such $(\alpha ,\gamma )$ pairs, the performance of the proposed outer bound is evaluated under various parameter settings.

Linear Exact-Repair Construction of Hybrid MSR Codes in Distributed Storage Systems

An [n, k, d]-hybrid minimum storage regenerating (HMSR) codes is one class of minimum storage regenerating (MSR) codes where each storage node stores two symbols in a distributed storage system (DSS). Due to the ability of reducing repair bandwidth and minimizing disk I/O cost, HMSR codes are proper to be used in practice. In this letter, we prove that there exists no linear exact-repair HMSR codes when k ≥ 5. A construction of [6,3,4]-HMSR codes is devised in F 2 . Focused on [4,2,3]-HMSR codes, a repair-by-transfer construction and the corresponding regenerating algorithm are proposed.

Distributed Storage Codes With Repair-by-Transfer and Nonachievability of Interior Points on the Storage-Bandwidth Tradeoff

Regenerating codes are a class of recently developed codes for distributed storage that, like Reed-Solomon codes, permit data recovery from any subset of k nodes within the n-node network. However, regenerating codes possess in addition, the ability to repair a failed node by connecting to an arbitrary subset of d nodes. It has been shown that for the case of functional-repair, there is a tradeoff between the amount of data stored per node and the bandwidth required to repair a failed node. A special case of functional-repair is exact-repair where the replacement node is required to store data identical to that in the failed node. Exact-repair is of interest as it greatly simplifies system implementation. The first result of the paper is an explicit, exact-repair code for the point on the storage-bandwidth tradeoff corresponding to the minimum possible repair bandwidth, for the case when d=n-1. This code has a particularly simple graphical description and most interestingly, has the ability to carry out exact-repair through mere transfer of data and without any need to perform arithmetic operations. Hence the term `repair-by-transfer'. The second result of this paper shows that the interior points on the storage-bandwidth tradeoff cannot be achieved under exact-repair, thus pointing to the existence of a separate tradeoff under exact-repair. Specifically, we identify a set of scenarios, termed `helper node pooling', and show that it is the necessity to satisfy such scenarios that over-constrains the system.