On the minimum storage overhead of distributed storage codes with a

On the minimum storage overhead of distributed storage codes with a given repair locality. Henk D. L. Hollmann Division of Mathematical Sciences, School of Physical and Mathematical Sciences, Nanyang Technological University, Singapore Email: [email protected]

Abstract—The repair locality of a storage code is the maximum number of nodes that may be contacted during the repair of a failed node. Having small repair locality is desirable since it is proportional to the number of disk accesses required during a node repair, which for certain applications seems to be the main bottleneck. However, recent publications show that small repair locality comes with a penalty in terms of code distance or storage overhead, at least if exact repair is required. Here, we first review some of the recent work on possible (information-theoretical) trade-offs between repair locality and other code parameters like storage overhead (or, equivalently, coding rate) and code distance, which all assume the exact repair regime. Then, we present some new information theoretical lower bounds on the storage overhead as a function of the repair locality, valid for most common coding and repair models.

I. I NTRODUCTION The ever-increasing need for additional storage capacity makes economically viable and efficient data storage techniques of paramount importance. A distributed storage system (DSS) typically store data objects in encoded form on multiple storage units or storage nodes. These storage nodes are inherently unreliable and may fail and leave the system, for example due to hardware failures or system updates in data centers, or due to peer churning in peer-to-peer systems. To combat this problem a DSS employs redundancy, thus affording the possibility to replace a lost data block by an identical copy (called exact repair) or by a functionally equivalent copy (this repair modus is called functional repair) in order to maintain data integrity over time. Traditionally, simple replication was the preferred form of redundancy, but in modern DSS we see the emerging of more sophisticated encoding techniques. For example, the Windows Azure storage system employs a Pyramid Code [1], and for archiving purposes, Facebook uses a Reed-Solomon code on top of their Hadoop File System [2]. One of the main challenges in data storage is the design of storage codes that allow efficient and low-cost repair of lost nodes. Various performance measures for repair efficiency have been considered. An important parameter is the repair bandwidth [3], the total amount of data traffic involved in the repair of a lost data block. In certain applications like cloud storage and deep archival, minimizing disk I/O seems to be of more concern [4]. Since the disk I/O is proportional to the number of nodes that are contacted to repair a failed node [5], recently another parameter called the repair locality (or sometimes the fan-in) has come under attention. Here, the

repair locality is the maximum number of other nodes that may be contacted during repair of a data block on a lost node. Recently there has been much interest in the influence of the repair locality of a storage code on the maximum possible coding rate (or, equivalently, on the minimum excess storage overhead). We extend some of the present results for storage codes under exact repair to arbitrary codes under functional repair. We offer a general conjecture on the maximal possible coding rate, depending only on the repair locality r, the storage capacity per node α, and the amount of data β that can be transported from a node contacted during repair, and we prove that this bound holds in a number of important cases. In particular, we show that the rate is upper-bounded by r/(r+1) if α = β and by 1/2 if α = rβ. Some of these results were announced earlier in [6]. II. R EPAIR LOCALITY IN STORAGE CODES In applications such as cloud storage systems and deep archival storage, a low disk I/O overhead is a main concern [4]. The disk I/O is proportional to the number of nodes involved in a repair, which makes the repair locality an important performance criteria [7], [8], [9]. Some families of codes specifically designed for small repair locality are Pyramid codes [10], Homomorphic codes [7] and Spread codes [11], some codes from [9], and LRC codes [12]. Also certain repairby-transfer codes [13] can be considered as being especially designed for this purpose. It is therefore of interest to investigate rate bounds in terms of the repair locality. Already in [3], where another type of rate bound was presented, a footnote explicitly states interest in this problem, and possible trade-offs between recovery I/O and storage efficiency were conjectured in [4]. In the case of exact repair, recently bounds have been discovered relating rate, repair locality, and code distance. For example, in [14] it was shown that for linear [n, k, d]-codes, necessarily n − k ≥ dk/re + d − 2 (attainable for d ≥ 2), which implies that the rate R = k/n satisfies R ≤ r/(r + 1). In [5], a more general information-theoretical bound has been derived in terms of the total amount m of stored information, the “informationtheoretical distance” d of the code (defined as the maximum number such that any k = n − d + 1 nodes can reconstruct the stored information), and the storage capacity per node α , stating that d ≤ n − dm/αe − dm/(rα)e + 2. Now if a failed node can be repaired at all, then necessarily d ≥ 2 and this

bound again implies that the rate R satisfies R = m/(nα) ≤ r/(r + 1). For other recent work in this direction, see for example [15] and [16]. All of the publications mentioned above assume that a certain node and all of its reincarnations have the same, fixed repair set of size r; here each newcomer node inherits its identity from the node that it replaces. In this paper, our aim is to investigate the trade-off in the most general setting where no such assumption is made and similar to that of the information flow network setting used to derive the cutset bound in [3]. In the next section, we describe our model and the relation with the work in [3]. III. M ODEL AND BACKGROUND In this paper, we will find it convenient to think of the data management in a DSS as taking place according to the following model. Assume that a DSS stores a data object, consisting of m data symbols, in encoded form across n storage nodes, with each node storing one data block of size α; here, typically m < nα, so that the data object is stored in redundant form. Furthermore, upon failure of one of the storage nodes, we assume that the DSS performs a repair action by first contacting a set of r other nodes, downloading β symbols (possibly computed at the nodes) from each of them, and then employs the data thus collected to create a replacement block, again containing α symbols, which is then stored on some newcomer node. We do not require that always the same set of r nodes is contacted to repair a given node, that is, the repair set that is used to construct the replacement block is allowed to depend on the state of the DSS. Note that obviously β ≤ α ≤ rβ in this model. We will refer to α and β as the storage node capacity and the transport capacity, respectively. Finally, assume that at any moment, the original data object can be recovered from the data blocks stored on some subset of size k of the storage nodes. Here we assume that the number k is the smallest number with this property, so note that we may assume r ≤ k ≤ n−1. We do not require that this recovering subset is time-invariant, so again, different sets of k nodes may be used depending on the state of the DSS. In this paper, the parameter k will hardly be considered. We will refer to the above assumptions as saying that the DSS employs a storage code with parameters (m; n, k, r; α, β), with the code dictating how the encoding, storing, repair, and recovery is actually implemented. The parameter r is called the repair locality. The rate and the storage overhead of the code both measure how efficient the data is stored: here the rate of the code is R = m/(nα), the fraction of the stored data actually carrying information, and the storage overhead is given by E = −1 + 1/R. We can represent the evolution over time of the repair process by means of a directed capacitated network N that we will refer to as the associated information flow graph, in the following way. Initially, each of the n storage nodes vi , having storage capacity α, is represented by a capacitated edge α viin −→ viout , connected to a data source S by a capacitated ∞ edge S −→ viin . For later use, let us refer to this initial network

as Ninit . Then, each time when a newcomer node v with storage capacity α enters the system due to a repair, we add a α corresponding capacitated edge v in −→ v out to the network, β together with a further r capacitated edges wiout −→ v in representing the data flow from each of the r (live) storage nodes wi that were contacted during repair to the newcomer node. The significance of the information flow network is that the requirements on the code imply that, irrespective of how the network develops, the amount m of data initially brought into the network by the source S should be able to flow to the set of n currently alive nodes (in fact, even to a subset of the nodes forming a recovery set). From network flow theory, we know that the bottleneck necessarily takes the form of a cut between the source S and the set of n current live nodes. Here, such a cut is represented by a subset V of the nodes containing the source S but none of the live nodes, thus representing a barrier that the data must pass on its way from the source to the live nodes. The capacity of the cut is the sum of the capacities of edges from a node in V to a node not in V , and thus represents an upper bound on the maximum amount of data that can flow from the source to the live nodes, hence on the amount m of data that can be permanently stored using this code. In fact, from the famous Ford-Fulkerson network theorem (sometimes called the max-flow min-cut theorem), we know that, at any moment in time, the maximum size of such a flow in the current network N is in fact equal to the minimum capacity γ(N ) of such a cut in N , see e.g. [17]. The above information flow graph was first introduced in the breakthrough paper [3] in order to determine the maximal possible rate of a class of storage codes called regenerating codes, codes possessing the extra properties that (i) every set of r live nodes can serve as the repair set for a lost node and (ii) every set of k nodes can serve as a recovery set. Note that our assumptions then imply that k ≤ r. With these additional assumptions, it is possible to explicitly determine an (attainable) lower bound for the capacity γ(N ) of the minimum cut. As a consequence, it was shown in [3] that the maximal amount of information m that can be stored and maintained in such a code satisfies m≤

k−1 X

min(α, (r − j)β),

(1)

j=0

which obviously implies a bound on the rate. We remark that inspection of the proof of this result reveals that the above result is still valid provided that there exists a timeinvariant recovery set of size k ≥ r. (Here, newcomer nodes are supposed to inherit the identity of the node they replace.) Since the ideas behind the proof are relevant to this paper, we briefly sketch the proof here. The idea is to consider the nodes in a recovery set of size k, and to kill these nodes one by one, while choosing each repair set to include all the newcomer nodes. It is not difficult to see that the amount of information that can flow to the k newcomer nodes is bounded by the right-hand side of (1). The functioning of the above proof crucially depends on the

property that every set of r nodes should be able to serve as a repair set. Already in a footnote in [3], the authors wondered if the min-cut value could not become bigger if the the newcomer could choose the r live nodes to connect to. It this precisely this question that we will investigate in this paper, in the general setting as sketched in the beginning of this section. IV. A GAME ON THE INFORMATION FLOW GRAPH The problem that we consider can conveniently be described in terms of a game played by two players, KILLER and BUILDER, on the information flow graph N as defined in the previous section. At the start of the game, N = Ninit , so consist of the source S connected to each of n isolated edges representing the n storage nodes. So the network Ninit represents the DSS having stored the data on n storage nodes, before any repair has taken place. Now, the two players move in turn. KILLER moves by choosing a node and killing it, then BUILDER moves by creating a newcomer node and connecting it to a set of r live nodes according to his choice. In detail, the network N is adapted as follows: the killed node is marked α “dead”, and a capacitated edge v in −→ v out representing the newcomer node is added, together with r capacitated edges β wiout −→ v in representing the connections from the repair set {w1 , . . . , wr } to this newcomer node v. The player KILLER represents the worst case scenario for the DSS, so will try to create a graph N for which the min-cut value γ(N ) is as small as possible, while the player BUILDER tries to keep the min-cut value as large as possible whatever the future moves of KILLER. Let γ ∗ represents the equilibrium value of this game: so KILLER can always choose a series of storage node killings that lowers the min-cut value to γ ∗ , whatever the moves of BUILDER, but BUILDER can always prevent the min-cut from getting smaller than γ ∗ by a careful choice of the repair sets. From the discussion in the previous section, it should be clear that the value γ ∗ = γ ∗ (n, r, α, β) represents an upper bound to the achievable amount of information m that can be permanently stored by the DSS, and hence, also any upper bound on γ ∗ will provide an upper bound on m, and therefore also on the rate of a storage code with these parameters. Remark 4.1: In the formulation as given above, γ ∗ does not depend on the size k of a recovery set; in this paper, such a dependency is not considered. This dependency could be taken into account by defining γ(N ) as the minimum, over all subsets K of size k of the live nodes, of the maximal flow from the source S to the nodes in K and then letting γ ∗ be the equilibrium value of this γ(N ). In other words, here we investigate only the situation where k = n−1. It is not difficult to see how to adapt the subsequent analysis to incorporate the more general case. This will be the subject of a future paper. Remark 4.2: At each moment in time, we may consider a special cut, between the live nodes and the currently dead nodes at that moment; here, for each live node v, the corresponding node v in is either grouped with the dead nodes or with the live nodes, depending on what gives the smallest cut value. We believe that under optimal play, the min-cut value γ ∗

will always be attained on one of these special cuts. Intuitively, this seems evident, but we have not been able to come up with a convincing proof. Fortunately, we do not need such a proof, since in all cases where we can determine an upper bound on γ ∗ by considering these special cuts, the obtained upper bound turns out to coincide with the actual value of γ ∗ . In view of the conjecture in Remark 4.2, we will concentrate on the minimum value of the capacity of a cut occurring on the border between the currently live nodes and the other nodes. To that end, it is sufficient to analyze the restriction of the graph N to the live nodes. Indeed, assume that at a certain moment in time, the live nodes are v1 , . . . , vn , and let A denote the adjacency matrix of this restriction, that is, ( β 1, if there is an edge viout −→ vjin ; Ai,j = 0, otherwise. + We will write d− i and di to denote the in-degree and outdegree of the node vi , that is, d− i is the number of live nodes connected to vi and d+ i is the number of live nodes that vi − connects to. Note that d+ i and di count the number of 1’s in row i and column i of the matrix A, respectively. Now let γ(A) denote the corresponding value of the capacity of the cut between the current live nodes {v1 , . . . , vn } and the other, dead nodes. At the moment that node vi was created, there were exactly r live nodes connected to vi . Hence, the number of dead nodes currently connected to vi equals r − d− i . So, the contribution to the capacity of the minimal cut is given in by min(α, (r − d− i )β), where we include vi among the dead nodes (for a contribution of α) or among the live nodes (for a contribution of (r − d− i )β), depending on which value is the smallest. As a consequence, we see that on the border between the live nodes and the other nodes, we find a cut with capacity

γ(A) =

n X

min(α, (r − d− i )β).

(2)

i=1

(Remark that the value of the contribution min(α, (r − d− i )β) by node vi should be replaced by α in the case where vi is one of the original nodes in the network Ninit .) Next, the effect on the matrix A of KILLER killing node vi and BUILDER creating a newcomer node vi0 and having r live nodes connecting to vi0 is that the ith row of A is replaced by the all-zero row (newcomer node vi0 is not yet connected to any other node), and the ith column of A is replaced by a new 0 − 1 column containing exactly r 1’s, with a 0 in position (i, i) (representing the r new connections to newcomer node vi0 . We will refer to this setting as the matrix game. In the next section we will use these observations to derive the exact value of γ ∗ in the important extreme cases where α = β and α = rβ. V. A NALYSIS OF THE MATRIX GAME We will now use the matrix game from the previous section to obtain some of the values γ ∗ (n, r, α, β). First, we introduce some notation. In the remainder of this paper, we let the integer s be such that sβ ≤ α ≤ (s + 1)β. Since

β ≤ α ≤ rβ, we have 0 ≤ s ≤ r. Write Γ− (vi ) and Γ+ (vi ) to denote the collection of live nodes connected to or from vi , respectively. Also, for t = 0, 1, . . . , r, we let Vt = {i ∈ {1, . . . , n} | d− i = t} and nt = |Vt |. Note that n0 + · · · + nr = n. Then we can write n X γ(A) = min(α, (r − d− i )β) i=1

=

r X

nr will increase by 1. KILLER can repeat this type of move until nr (r + 1) ≥ n. As a consequence, we obtain the following. Theorem 5.4: We have that γ ∗ (n, r, β, β) ≤ nαr/(r + 1), with equality if r + 1 divides n. Hence the maximum rate R∗ (r, β, β) of any storage code with repair locality r, transport capacity β, and storage node capacity α = β is given by R∗ (r, rβ, β) = r/(r + 1).

nt min(α, (r − t)β)

t=0

= α(n0 + · · · + nr−s−1 ) + β

r X

(r − t)nt . (3)

t=r−s

With all the machinery in place, the next results are now easy. Proposition 5.1: In the matrix game, KILLER can achieve Pn that i=1 d− i ≥ nr/2. Proof: Counting theP number of 1’s first by rows, then Pnin A + n by columns, we see that i=1 d− = d i i . So to prove the i=1 P n − proposition, it is sufficient to show that σ = i=1 (d+ i +di ) ≥ nr is achievable. Indeed, if σ < nr, then there is a node vi − such that δ = d+ i + di < r; in that case, KILLER kills this node, which let σ decrease by δ; then after BUILDER ’s move, the replacement node adds exactly r to σ, so that after these two moves, σ has increased by r −δ, so by at least 1. KILLER repeats such moves until σ ≥ nr. As a result, we can show the following. Theorem 5.2: We have that γ ∗ (n, r, rβ, β) ≤ nα/2, with equality if r + 1 divides n. Hence the maximum rate R∗ (r, rβ, β) of any storage code with repair locality r, transport capacity β, and storage node capacity α = rβ is given by R∗ (r, rβ, β) = 1/2. Proof: ByPProposition 5.1, KILLER can achieve a man trix A where i=1P d− i ≥ nr/2. Now if α = rβ, Pnthen−by (2) r − we have γ(A) = i=1 (r − di )β = (nr − i=1 di )β ≤ βnr/2 = nα/2. There are various ways to show that we have equality when n is a multiple of r + 1; the easiest is perhaps for BUILDER to group the nodes into groups of size r + 1 each, and to repair every killed nodes “within its own group”; the corresponding (exact-repair) code within each group is the code in Example 3.2 from [6]: each node vi stores the symbols x{i,j} with j 6= i. To see the last claim, note that the amount of information m in such a code satisfies m ≤ γ ∗ (n, r, rβ, β) ≤ nα/2, so for the rate R, we have R = m/(nα) ≤ 1/2. Proposition 5.3: In the matrix game, KILLER can achieve nr ≥ n/(r + 1). Proof: Suppose that nr (r + 1) < n. By definition, if d− = r , then Γ− (vi ) has size r. Since there are nr such nodes i vi , there necessarily exists a node vj not contained in any of the nr sets Γ− (vi )∪{vi } with d− i = r. Suppose KILLER kills such a vj . Then after BUILDER has moved, the newcomer node vj0 replacing vj will have r connections to it, hence d− j = r and vj0 ∈ Vr , while none of the nodes that were already in Vr will have lost one of its connections. Hence, as a result,

Proof: By Proposition 5.3, KILLER can achieve a matrix A for which nr ≥ n/(r + 1). Then, since α = β, we may take s = 0, so from (3), we obtain that γ ∗ ≤ γ(A) = α(n − nr ) ≤ nαr/(r + 1). There are various ways to show that we have equality when n is a multiple of r + 1; the easiest is perhaps for BUILDER to group the nodes into groups of size r + 1 each, and to repair every killed nodes “within its own group”; the corresponding (exact-repair) code in each group is the [r + 1, r] binary MDS code. The second claim is an immediate consequence. We remark that in the proofs of both Theorem 5.2 and 5.4 we recognize the repair groups from [5]. For the general case, we offer the following conjecture. Conjecture 5.5: With sβ ≤ α ≤ (s + 1)β, we have that   r−1 γ ∗ (n, r, α, β) X s+1 ≤ min(α, (r−j)β) = (r−s)α+ β; (n/(r + 1)) 2 j=0 hence the maximal rate R∗ (r, α, β) of any storage code with repair locality r, storage node capacity α, and transport capacity β, is given by     s+1 R∗ (r, α, β) = (r − s)α + β /((r + 1)α), (4) 2 with equality if and only if n is a multiple of r + 1. Note that by Theorems 5.2 and 5.4, this conjecture holds for s = 0 and s = r; so exact repair is optimal for α = β and α = rβ. We will now show that it also holds when r = 2. In fact, we will show something slightly stronger. To this end, we first strengthen Proposition 5.3 in the case where r = 2. Proposition 5.6: In the matrix game with r = 2, KILLER can achieve that both 3n2 ≥ n and n1 + 2n2 ≥ n. Proof: Let Vt denote the set of nodes vi for which d− i = t. As in the proof of Proposition 5.3, KILLER tries to increase n2 ; if that is not possible, then each node outside V2 connects to a node in V2 , which implies that 2n2 ≥ n − n2 , that is, 3n2 ≥ n. In that case, KILLER tries to increase n1 without lowering n2 . This is possible if there is a node vi outside V1 ∪ V2 that connects to only one node in V2 and to no node in V1 (since in that case, killing node vi moves a node from V2 to V1 and adds vi to V2 . Since at least n − n2 of the edges to nodes in V2 are already used to connect to V2 from nodes outside V2 , we have at most 2n2 −(n−n2 )+n1 edges available to connect the n−n2 −n1 nodes outside V1 ∪V2 a second time to V1 ∪ V2 . So if every node outside V2 is connected to a node in V2 and if, in addition, every node outside V1 ∪V2 has another connection to V1 ∪V2 , then 2n2 −(n−n2 )+n1 ≥ n−n1 −n2 , or,equivalently, 4n2 + 2n1 ≥ 2n, that is, 2n2 + n1 ≥ n.

From this result, we can obtain the following. Theorem 5.7: For r = 2, writing n = 3q − e with q, e integer, 0 ≤ e < 3, we have that γ ∗ (n, 2, α, β) = qα+(q−e)β. As a consequence, we have that ∗

R (n, α, β) ≤ (qα + (q − e)β)/(nα) ≤ (α + β)/(3α), with equality if and only if n is a multiple of 3. Proof: With r = 2, we have β ≤ α ≤ 2β, so s = 1; so for the corresponding matrix A, we see from (3) that the desired inequality holds if γ(A) = αn0 +βn1 ≤ qα+(q −e)β for all α in [β, 2β]. By convexity, this holds if and only if it holds for α = β and for α = 2β, that is, if and only if both (n − n1 − n2 ) + n1 ≤ 2q − e, or, equivalently n2 ≥ q = dn/3e, and 2(n − n1 − n2 ) + n1 ≤ 2q + (q − e) = n, or, equivalently, n1 + 2n2 ≥ n hold. According to Proposition 5.6, KILLER can indeed achieve this. To see that equality holds for γ ∗ , let BUILDER partition the nodes into groups of three each, with one group of size 4 or 5 if n is not divisible by 3. Now each time that KILLER kills a node, BUILDER repairs within the group to which that node belongs. It is easily checked that BUILDER can defend a min-cut α + β on each group of size 3, and min-cuts of size 2α or 2α + β on a group of size 4 or 5, respectively. In a future paper [18], we will provide further results on this problem. VI. C ODES ATTAINING THE BOUND By comparing the bound in Conjecture 5.5 with the cutset bound (1) from [3], we see that they coincide if k = r. As remarked in [3], there exist linear (functional-repair) storage codes over a sufficiently large field attaining the cutset bound at least asymptotically. In fact, in another paper [19], we have constructed linear functional-repair codes with parameters
(m = (r − s)(s + 1) + s+1 ; n = r + 1, k = r, r, α = 2 s + 1, β = 1) over every finite field Fq with q ≥ r − 1, so we have explicit constructions for codes attaining the bound in conjecture 5.5 whenever r + 1|n, even when in addition we require that k = r. (Note that the conjectured bound and all our results hold without any assumptions on k.) It can be shown that, except for a few cases, exact-repair codes with these parameters do not exist. In [5], MDS codes of large lengths n are constructed that almost attain the rate bound (4). VII. C ONCLUSIONS The repair locality of a storage code, the maximum number of nodes that need to be contacted during repair of a failed note, is an important performance measure. It is therefore of interest to investigate the possible trade-offs between the repair locality r and the maximum rate R, or, equivalently, the minimum storage overhead E, of a storage code. We have obtained some tight bounds relating R, r, the storage node capacity α, and the transport capacity β between nodes during repair, for the case of a functional-repair regime, in an information flow network setting, thus demonstrating the potential of our methods; in addition we offer a general conjecture that, if true, would be tight. In particular, for the

two extreme cases where α = β or α = rβ, we have shown that R ≤ r/(r + 1) and R ≤ 1/2, or E ≥ 1/r and E ≥ 1, respectively. ACKNOWLEDGMENT The authors would like to thank Lluis Pamies-Juarez and Frederique Oggier for proofreading and for providing some helpful feedback. The research of Henk D.L. Hollmann is supported by Nanyang Technological University, Division of Mathematical Sciences. R EFERENCES [1] H. C. Huang, Y. X. Simitci, A. Ogus, B. Calder, P. Gopalan, J. Li, and S. Yekhanin, “Erasure coding in windows azure storage,” in Proceedings of the USENIX Annual Technical Conference (ATC). USENIX ATC, Boston, MA, June 2012, best Paper Award. [2] A. Thusoo, Z. Shao, S. Anthony, D. Borthakur, N. Jain, J. Sen Sarma, R. Murthy, and H. Liu, “Data warehousing and analytics infrastructure at facebook,” in Proceedings of the 2010 ACM SIGMOD International Conference on Management of data, SIGMOD 10, 2010. [3] A. G. Dimakis, P. B. Godfrey, Y. Wu, M. Wainwright, and K. Ramchandran, “Network coding for distributed storage systems,” IEEE Trans. Inf. Theory, vol. 56, no. 9, 2010. [4] O. Khan, R. Burns, J. S. Plank, and C. Huang, “In search of I/O-optimal recovery from disk failures,” in HotStorage ’11: 3rd Workshop on Hot Topics in Storage and File Systems. Portland: USENIX, June 2011. [5] D. Papailiopoulos and A. Dimakis, “Locally repairable codes,” in Proceedings ISIT 2012, July 2012, pp. 2771 –2775, full version available at http:\\tinyurl.com/82cucvd. [6] H. D. Hollmann, “Storage codes – coding rate and repair locality,” in 2013 International Conference on Computing, Networking and Communications, Invited Position Papers (ICNC’13 - Invited), San Diego, USA, Jan. 2013, available at http://arxiv.org/abs/1301.4300. [7] F. E. Oggier and A. Datta, “Self-repairing homomorphic codes for distributed storage systems,” in INFOCOM. IEEE, 2011, pp. 1215– 1223, extended version at http://arxiv.org/abs/1107.3129. [8] P. Gopalan, C. Huang, H. Simitci, and S. Yekhanin, “On the locality of codeword symbols,” Information Theory, IEEE Transactions on, vol. 58, no. 11, pp. 6925 –6934, nov. 2012. [9] D. S. Papailiopoulos, J. Luo, A. G. Dimakis, C. Huang, and J. Li, “Simple regenerating codes: Network coding for cloud storage,” in INFOCOM, A. G. Greenberg and K. Sohraby, Eds. IEEE, 2012, pp. 2801–2805. [10] C. Huang, M. Chen, and J. Li, “Pyramid codes: Flexible schemes to trade space for access efficiency in reliable data storage systems,” in Sixth IEEE International Symposium on Network Computing and Applications (NCA 2007), July 2007, pp. 79 –86. [11] F. Oggier and A. Datta, “Self-repairing codes for distributed storage – a projective geometric construction,” in Information Theory Workshop (ITW), 2011 IEEE, oct. 2011, pp. 30 –34. [12] A. S. Rawat and S. Vishwanath, “On locality in distributed storage systems,” CoRR, vol. abs/1204.6098, 2012. [13] N. B. Shah, K. V. Rashmi, P. V. Kumar, and K. Ramchandran, “Distributed storage codes with repair-by-transfer and nonachievability of interior points on the storage-bandwidth tradeoff,” IEEE Trans. Inf. Theory, vol. 58, no. 3, pp. 1837–1852, 2012. [14] P. Gopalan, C. Huang, H. Simitci, and S. Yekhanin, “On the locality of codeword symbols,” IEEE Trans. Inf. Theory, vol. PP, no. 99, p. 1, 2012. [15] N. Prakash, G. M. Kamath, V. Lalitha, and P. V. Kumar, “Optimal linear codes with a local-error-correction property,” CoRR, vol. abs/1202.2414, 2012. [16] G. M. Kamath, N. Prakash, V. Lalitha, and P. V. Kumar, “Codes with local regeneration,” in Proceedings ISIT 2013, Istanbul, Turkey, July 712, 2013, pp. 1606–1610. [17] D. West, Introduction to graph theory. Prentice Hall, 2001. [18] H. D. Hollmann, “On the maximum rate of distibuted storage codes with a given repair locality,” in preparation. [19] H. D. Hollmann and W. Poh, “Characterizations and construction methods for linear functional-repair storage codes,” in Proceedings ISIT 2013, Istanbul, Turkey, July 7-12, 2013, pp. 336–340.