Practical Functional Regenerating Codes for Broadcast Repair of Multiple Nodes

TL;DR

This paper introduces a practical coding scheme for efficient repair of multiple node failures in wireless distributed storage, optimizing bandwidth and storage with low complexity.

Contribution

It presents a new code construction for functional regeneration using linearized polynomials, achieving optimal points with low subpacketization and computational cost.

Findings

Achieves minimum-bandwidth regenerating point.

Supports repair of multiple node failures efficiently.

Provides insights into the properties of functional regenerating codes.

Abstract

A code construction and repair scheme for optimal functional regeneration of multiple node failures is presented, which is based on stitching together short MDS codes on carefully chosen sets of points lying on a linearized polynomial. The nodes are connected wirelessly, hence all transmissions by helper nodes during a repair round are available to all the nodes being repaired. The scheme is simple and practical because of low subpacketization, low I/O cost and low computational cost. Achievability of the minimum-bandwidth regenerating (MBR) point, as well as an interior point, on the optimal storage-repair bandwidth tradeoff curve is shown. The subspace properties derived in the paper provide insight into the general properties of functional regenerating codes.

Figures

Equations

$$H(W_A)$$

$$H(W_1,\dots ,W_l)$$

$$H(W_A|W_B)$$

$$I(W_A;W_B)$$

$$I(W_A;W_B;W_C)$$

$$f(x)=\sum _{i=1}^P{a}_i{x}^{q^{i-1}},a_i\in {\mathbb{F}}_{q^m}$$

$$f(ax+by)=af(x)+bf(y),a,b\in {\mathbb{F}}_q,x,y\in {\mathbb{F}}_{q^m},$$

$$f(x)=\sum _{i=1}^{\frac{k}{2}(2d-k+r)}{m}_i{x}^{q^{i-1}},m_i\in {\mathbb{F}}_{q^m}$$

$$\displaystyle\mathbf{Y}=\left[\begin{array}[]{cccc}1&1&\cdots&1\\ 2&2&\cdots&2\\ \vdots&\ddots&\ddots&\vdots\\ d&d&\cdots&d\end{array}\right]$$

$$\displaystyle\mathbf{Y}=\left[\begin{array}[]{cccc}1&2&\cdots&r\\ 2&3&\cdots&r+1\\ \vdots&\ddots&\ddots&\vdots\\ d&1&\cdots&r-1\end{array}\right].$$

$$\dim (W_A\cap \sum _{i=1}^l{W}_i)=\sum _{i=1}^{\text{nicefrac}lr}\dim (W_A\cap W_{{\mathcal{R}}_i})$$

$$\dim (W_A\cap \sum _{i=1}^l{W}_i)=I(W_A;W_1,\dots ,W_l)$$

$$=I(W_A;W_{{\mathcal{R}}_1},\dots ,W_{{\mathcal{R}}_{\text{nicefrac}lr}},W_{{\mathcal{R}}^{\prime }})$$

$$=I(W_A;W_{{\mathcal{R}}_1})+I(W_A;W_{{\mathcal{R}}_2}\dots ,W_{{\mathcal{R}}^{\prime }}|W_{{\mathcal{R}}_1})$$

$$\stackrel{(a)}{=}I(W_A;W_{{\mathcal{R}}_1})+I(W_A;W_{{\mathcal{R}}_2}\dots ,W_{{\mathcal{R}}^{\prime }})$$

$$I(W_A;W_1,\dots ,W_l)$$

$$\stackrel{(b)}{=}\sum _{i=1}^{\text{nicefrac}lr}I(W_A;W_{{\mathcal{R}}_i})$$

$$=\sum _{i=1}^{\text{nicefrac}lr}\dim (W_A\cap W_{{\mathcal{R}}_i})$$

$$\dim (\sum _{i=1}^k{W}_i)$$

$$=\sum _{i=1}^{k}H(W_i|W_{i-1},\dots ,W_1)$$

$$=\sum _{i=1}^k\left[H(W_i)-I(W_i;W_{i-1},\dots ,W_1)\right]$$

$$\stackrel{(c)}{=}\sum _{i=1}^{k}H(W_i)-\sum _{i=1}^k\sum _{j=1}^{\text{nicefrac}(i-1)r}I(W_i;W_{{\mathcal{R}}_j})$$

$$\stackrel{(d)}{\ge }kd-\left(r(r)+r(2r)+\cdots +r(k-r)\right)$$

$$=\frac{k}{2}(2d-k+r)$$

$$\displaystyle\mathbf{Y}=\left[\begin{array}[]{c}\mathbf{S}_{(n-2r)\times r}\end{array}\begin{array}[]{|c}\mathbf{\phi}_{r\times r}\\ \hline\cr\vdots\\ \hline\cr\mathbf{\phi}_{r\times r}\end{array}\right]_{(n-2r)\times 2r}$$

$$I(W_A;W_{\mathcal{B}})$$

$$\stackrel{(e)}{=}\sum _{j\ge 2}I(W_A;W_{{\mathcal{R}}_j}|W_{{\mathcal{R}}_1})$$

$$\dim (\sum _{i=1}^k{W}_i)$$

$$=\sum _{i=1}^k\left[H(W_i)-I(W_i;W_{i-1},\dots ,W_1)\right]$$

$$\stackrel{(f)}{=}\sum _{i=1}^{k}H(W_i)-\sum _{i=1}^k\sum _{j=2}^{\text{nicefrac}(i-1)r}I(W_i;W_{{\mathcal{R}}_j}|W_{{\mathcal{R}}_1})$$

$$\stackrel{(g)}{\ge }k(n-2r)-\left(r(r)+\cdots +r(k-2r)\right)$$

$$=\frac{k}{2}\left(2(n-2r)-(k-r)\right)+r(k-r)$$

Full text

I Introduction

The content of a file is typically distributed among multiple access points such that accessing any $k$ distinct access points is sufficient to recover the original file. MDS codes provide high storage efficiency while satisfying the above property. When some nodes fail, their cache contents need to be regenerated to be able to continue serving users. An important objective of edge caching in wireless networks is to reduce the backhaul link loads; therefore, we will consider cache recovery at the edge; that is, rather than updating the failed cache contents from a central server through backhaul links, the failed cache contents are regenerated with the help of surviving cache nodes. The total amount of data transferred from the surviving nodes to repair the failed nodes is called the repair bandwidth. Traditional MDS codes have high storage efficiency, but their repair bandwidth is large [1]. The data of one node is repaired by accessing and transferring data from $k$ nodes, i.e., by recovering the whole content library.

Dimakis et al. showed in [1] that there is a fundamental trade-off between the storage and repair bandwidth by mapping the repair problem in a distributed storage system to a multicasting problem over an information flow graph. The analysis focuses on a single node repair; that is, losing one of the nodes triggers the repair process. Regenerating codes achieve any point on the optimal trade-off curve, while minimum-storage regenerating (MSR) codes and minimum-bandwidth regenerating (MBR) codes operate on the two extremes of this trade-off curve.

It was observed in [2] that multiple node repair; that is, the repair process starts only after $r$ nodes fail, is more efficient in terms of the repair bandwidth per node, compared to repairing each node as it fails. In [3] and [4], the authors introduce cooperative regenerating codes, which repair multiple failures cooperatively by allowing each of the $r$ nodes being repaired to collect data from $d$ non-failed nodes, called helper nodes, and then to cooperate with the other $r-1$ nodes being repaired, called newcomers. Cooperative repair allows each newcomer to contact any set of helper nodes independently. An explicit construction of regenerating codes that achieve minimum repair bandwidth under cooperative repair is given in [5].

Another model studied in the literature is the centralized repair model [6, 7], in which all the helper nodes transmit the repairing symbols to a centralized node, which then repairs the failed nodes. There being a centralized entity repairing the failed nodes, there is no need for the newcomers to exchange data between themselves like in cooperative repair, thus making the system simpler.

Instead, similarly to [8], we will consider broadcast repair; that is, transmissions from each helper node are received in an error-free manner by all the newcomers. In summary, we will study the broadcast repair of multiple failed cache nodes. The storage-repair bandwidth trade-off for the repair of multiple fully failed nodes is investigated in [9],[10].

The broadcast repair model is theoretically equivalent to the centralized multi-node repair model studied in [6, 7]. Hence, the results that we derive, and codes that we construct for broadcast repair are directly applicable to the centralized repair model. The broadcast repair is different from centralized repair in that, while centralized repair involves a centralized entity which then repairs the failed nodes, thus involving two rounds, broadcast repair involves only one round, and thus, is simpler and faster.

In [7], it is shown that the functional MBR point for repair of multiple nodes is not achievable under exact repair. Similarly, it is shown that under exact repair, the functional repair tradeoff interior points are also not achievable. In [6, 11], it is shown that cooperative repair achieves the minimum bandwidth of centralized repair (and broadcast repair), under exact repair, albeit at a slightly higher storage cost.

In this paper, our contribution is to give an explicit code construction to achieve the optimal storage-repair bandwidth tradeoff under functional repair, first for the MBR point for all admissible parameters, and then for an interior point, thus potentially providing us with a general framework to construct functional repair codes to achieve any point on the tradeoff curve. The broadcast nature of the system allows all the newcomers to receive the same data, which simplifies the coding scheme. Reference [12] studies the functional repair problem from a projective geometry viewpoint. The subspace/projective geometry view makes it hard to visualize how a set of nodes look like, and how one might approach the construction of a code. There have been attempts to derive the conditions necessary for a functional repair code in [12, 13]. Our code construction strives to address this problem by proposing a simple scheme and simple conditions to guarantee optimality.

Our code construction has the property that for most failure patterns, the helper nodes do not have to perform computations in a repair round; instead they just read and send the data to the newcomers. This property is called repair-by-transfer, which is desirable for a low I/O cost. Functional repair-by-transfer MDS codes were constructed in [14] for some parameters.

Other than these, in our knowledge, there has not been much progress in providing simple, explicit code constructions for functional repair. The network coding literature usually employs random coding, which is not the most practically feasible scheme for distributed storage because of large overheads.

II System Model

Consider a wireless caching system where $n$ nodes, each with storage capacity $\alpha$ bits, store a file of size $M$ bits. We index these storage nodes by the set $\cal N$ $\triangleq\{1,\ldots,n\}$. The nodes are fully connected by a wireless broadcast medium and use orthogonal channels for data transmission.

We refer to the nodes that fail as the failed nodes and the nodes that do not experience any losses as the surviving nodes. We assume that the repair occurs in rounds, where a repair round gets initiated when $r$ nodes experience failures. Thus, a single repair round repairs $r$ failed nodes. There is no loss during a repair round. During a repair round, the failed nodes are repaired with the help of bits transmitted from $d$ surviving nodes, called the helper nodes.

A data collector (DC) corresponds to a request to reconstruct the file. Data collectors connect to any subset of $k$ active nodes and retrieve all the stored data in these nodes. This is called the reconstructability property. In general, the repair is functional, i.e., the repaired content of the node may not be the same as the original content, but it satisfies the reconstructability property.

Definition 1**.**

The repair bandwidth $\gamma=d\beta$ is defined as the total number of bits the helper nodes broadcast in a repair round.

II-A Subspace view

Consider a node storing $\alpha$ linearly independent elements $y_{1},\ldots,y_{\alpha}$ from $GF(q^{m})$ (possible only if $\alpha\leq m$), then any linear operations performed on these finite field elements, which can be viewed as $m-$dimensional vectors over $GF(q)$, lie in the same subspace. Hence, the node is said to store the subspace of dimension $\alpha$, denoted by $W_{i}\equiv\operatorname{span}\{y_{i}\},i=1,\ldots,\alpha$. For a set of nodes denoted by $\mathcal{A}$, the subspace stored by $\mathcal{A}$ is denoted by $W_{\mathcal{A}}=\sum_{i\in\mathcal{A}}W_{i}$, where the addition operation on subspaces denotes the direct sum of subspaces. By abuse of notation, $W_{i}$ can also denote the random variables of the stored information in the nodes. The Shannon entropic measures on random variables can be redefined as a measure $``\dim(.)"$ (subspace dimension) on intersection, union and set difference of subspaces. The following identities hold [15]:

[TABLE]

For each set of parameters, a $(n,k,\gamma,d,\alpha,r)$ tuple is feasible, if a code with storage $\alpha$ and repair bandwidth $\gamma$ exists.

III MBR point construction for multiple node failures

Theorem 1**.**

[16]** For any $\alpha\geq\alpha^{*}(n,k,\gamma,d,r)$, the points $(n,k,\gamma,d,\alpha,r)$ are feasible, and linear network codes suffice to achieve them. If $r$ divides $k$, the minimum repair bandwidth point is achieved by the pair $(\alpha_{MBR},\gamma_{MBR}^{*})=\frac{2M}{k(2d-k+r)}(d,rd)$.

We provide a construction of a functional repair code for the broadcast setting using linearized polynomials, which were first used by Gabidulin for the construction of rank-metric codes [17].

III-A Linearized Polynomials

An important component of our construction is linearized polynomial and their special properties.

A linearized polynomial

[TABLE]

can be uniquely identified from evaluations at any $P$ points $x=\theta_{i}\in\mathbb{F}_{q^{m}},i=1,2,\ldots,P$, that are linearly independent over $\mathbb{F}_{q}$.

Another relevant property of linearized polynomials is that they satisfy the following condition

[TABLE]

that is, given a set of points on a linearized polynomial, any linear combination of the points also lies on the polynomial.

III-B Code construction

Consider a file of $M$ bits. We split the file into $\frac{k}{2}(2d-k+r)$ packets, denoted by $\{m_{1},\ldots,m_{\frac{k}{2}(2d-k+r)}\}$. Thus each packet is of size $\frac{2M}{k(2d-k+r)}$ bits. Define the linearized polynomial

[TABLE]

in a field $GF(q^{m})$. If a DC receives any $\frac{k}{2}(2d-k+r)$ linearly independent points on the polynomial $f(x)$, it can reconstruct $f(x)$ by interpolation, and thus reconstruct the file.

Pick $d$ linearly independent points on $f(x)$, denoted by $(x_{1},y_{1}),\ldots,(x_{d},y_{d})$, where $y_{i}=f(x_{i})$ for all $i=1,\ldots,d$. Store these points at node $1$. Pick another $d$ linearly independent points that are also linearly independent from the points stored at node $1$, denoted by $(x_{d+1},y_{d+1}),\ldots,(x_{2d},y_{2d})$, on $f(x)$, and store them at node $2$, and so on, till $d$ nodes are filled with linearly independent points. For the remaining $n-d$ nodes, fill them as if they are being repaired by the $d$ nodes already filled. The scheme for repair is detailed in the Section III-C.

At each node, encode the points with a $(n-1,d)$ systematic MDS code to obtain $n-1$ coded symbols. The symbols at node $i$ are denoted by $\{w_{ij}\}$, where $j\in[n]\setminus\{i\}$.

III-C Repair

Suppose the first repair round repairs the nodes $n-r+1$ to $n$ with the helper nodes $1,\ldots,d$. Each node $i\in[d]$ transmits the points $w_{ij},j\in[n-r+1:n]$. The total number of points broadcasted by $d$ helper nodes is $rd$. The broadcasted points must be linearly independent, which will become evident that it holds as the repair scheme is explained. Arrange these received points in a $d\times r$ matrix, where row $i$ contains the points transmitted by node $i$. In the following matrix representation of the received points, we denote the points with the node from which it was transmitted only. It must be noted that all elements in the following matrix actually represent distinct points.

[TABLE]

We then permute the columns of the above matrix in such a way that no row has two points transmitted by the same node. A circular permutation achieving this condition looks like the following

[TABLE]

Now, assume that each node is given a $(2r,r)$ systematic MDS code generator matrix $\mathbf{G}=[\mathbf{I}\ \ \mathbf{M}]$. $\mathbf{G}$ has rank $r$, implying that any $r$ columns are linearly independent. Let each newcomer multiply the permuted point-matrix $\mathbf{Y}$ with the local $r\times r$ invertible encoding matrix $\mathbf{M}$ to get $\mathbf{Y}^{\prime}=\mathbf{YM}$. The points in column $i$ of $\mathbf{Y}^{\prime}$ are stored on the $i^{th}$ newcomer, and encoded with the local $(n-1,d)$ systematic MDS code.

The above scheme ensures the following properties to hold:

L1:

For $i\neq j$, $\dim(W_{i}\cap W_{j})=0$, or, $I(W_{i};W_{j})=0$.

L2:

For any set of nodes $\mathcal{A}$, $\lvert\mathcal{A}\rvert\leq r$, the following holds : $\dim(\sum_{i\in\mathcal{A}}W_{i})=\sum_{i\in\mathcal{A}}\dim(W_{i})$.

This is equivalent to the condition - $H(W_{\mathcal{A}})=\sum_{i\in\mathcal{A}}H(W_{i})$. This property is the consequence of permuting the $\mathbf{Y}$ matrix so that packets from the same node are not repeated in the same row. Encoding each row with the full rank matrix $\mathbf{M}$, extracted from an MDS code, ensures the independence of any $r$ nodes.

L3:

Given a node $A$, and a set of nodes denoted by $\mathcal{B}$, $\lvert\mathcal{B}\rvert\leq d$, partition $\mathcal{B}$ into two disjoint subsets $\mathcal{B}_{1}$ and $\mathcal{B}_{2}$. Then the following holds - $\dim(W_{A}\cap W_{\mathcal{B}_{1}}\cap W_{\mathcal{B}_{2}})=0$, or, $I(W_{A};W_{\mathcal{B}_{1}};W_{\mathcal{B}_{2}})=0$. This is because each node transmits a distinct point to repair any node, of which any $d$ of them are linearly independent because of the rank $d$ MDS encoding in each node. Since $d\geq k$, this allows for all admissible parameters.

L4:

Given a node $A$, and a set of different $r$ nodes denoted by $\mathcal{R}$, then $I(W_{A};W_{\mathcal{R}})\leq r$, where equality holds iff $1)$ the set $\mathcal{R}$ were helper nodes while repairing node $A$, and a particular row of $\mathbf{Y}$ consisted of the nodes in $\mathcal{R}$; or, $2)$ node $A$ was a helper node while repairing the set $\mathcal{R}$ which failed together.

III-D Reconstruction

Suppose a DC accesses the nodes $1,\ldots,k$, denoted by $\mathcal{A}_{dc}$. The points available at the $k$ nodes should be enough to interpolate the polynomial $f(x)$; hence, the necessary and sufficient condition for successful reconstruction is $\dim(W_{\mathcal{A}_{dc}})\geq\frac{k}{2}(2d-k+r)$. The following lemma will be helpful in showing that the reconstructability property is satisfied.

Lemma 1**.**

Consider a node $A$, and a set of other $l\leq d$ nodes. Partition the $l$ nodes into sets of $r$ nodes denoted by $\mathcal{R}_{1},\ldots,\mathcal{R}_{\lfloor\nicefrac{{l}}{{r}}\rfloor}$, and the remaining set of nodes denoted by $\mathcal{R}^{\prime}$. Then,

[TABLE]

Proof.

[TABLE]

where $(a)$ holds due to L3, which applied to a well known identity from multivariate mutual information, gives $I(W_{A};W_{\mathcal{R}_{2}},\ldots,W_{\mathcal{R}^{\prime}};W_{\mathcal{R}_{1}})=I(W_{A};W_{\mathcal{R}_{2}},\ldots,W_{\mathcal{R}^{\prime}})-I(W_{A};W_{\mathcal{R}_{2}},\ldots,W_{\mathcal{R}^{\prime}}|W_{\mathcal{R}_{1}})=0$. Using this result inductively, we get

[TABLE]

where $(b)$ follows from L2. ∎

Theorem 2**.**

If a DC accesses $k$ nodes, the dimension of the space obtained from those nodes is $\frac{k}{2}(2d-k+r)$. Thus, the DC can reconstruct the file.

Proof.

Without loss of generality, assume that the DC accesses nodes $1,\ldots,k$. We have

[TABLE]

where $(c)$ follows from Lemma 1, and $(d)$ holds due to L4. ∎

IV Code construction for interior point, $d=n-r$

Theorem 3**.**

[10]** The pair $(\alpha,\gamma^{*})=\frac{2M}{k((2(n-2r)-(k-r))+2r(k-r))}((n-2r),r(n-r))$ is an interior point on the tradeoff curve, and is achievable with our coding framework.

We consider $d=n-r$ in this section. Each file is divided into $\nicefrac{{1}}{{2}}k((2(n-2r)-(k-r))+2r(k-r))$ subpackets, and the polynomial $f(x)$ is constructed accordingly. The storage and repair scheme is the same as in Section III-C, except that the matrix $\mathbf{Y}$ is of dimensions $(n-2r)\times 2r$, and $\mathbf{M}$ is a $2r\times r$ local encoding matrix, such that there is a $(3r,2r)$ MDS systematic generator matrix of the form $[\mathbf{I}\ \ \mathbf{M}]$. Each node stores $n-2r$ linearly independent points, which are then encoded with a local systematic $(n-1,n-2r)$ MDS code. The matrix $\mathbf{Y}$ is constructed by arranging the points received from $n-2r$ helper nodes in the first $r$ columns, like in Equation (8), and the points received from the remaining $r$ helper nodes in the next $r$ columns. The elements of $\mathbf{Y}$ are rearranged so that no two points from a helper node lie in the same row, similar to Equation (13), to obtain the following form,

[TABLE]

where the matrix $\mathbf{\phi}$ consists of the $r^{2}$ points from the last $r$ helper nodes. Then, the columns of $\mathbf{Y}^{\prime}=\mathbf{Y}\mathbf{M}$, which is a $(n-2r)\times r$ matrix, are stored on the $r$ nodes respectively.

The property L1 is satisfied. Properties L2,L3 and $\mathbf{L4}$ are modified as follows:

L2:

For any set of nodes $\mathcal{A}$, $\lvert\mathcal{A}\rvert\leq 2r$, the following holds : $\dim(\sum_{i\in\mathcal{A}}W_{i})=\sum_{i\in\mathcal{A}}\dim(W_{i})$.

This is equivalent to the condition - $H(W_{\mathcal{A}})=\sum_{i\in\mathcal{A}}H(W_{i})$.

L3:

Given a node $A$, and a set of nodes denoted by $\mathcal{B}$ such that $\lvert\mathcal{B}\rvert\leq n-r$. Partition $\mathcal{B}$ into three disjoint sets $\mathcal{B}_{1}.\mathcal{B}_{2}$ and $\mathcal{B}_{3}$, such that $\lvert\mathcal{B}_{3}\rvert=r$, or in other words, $\lvert\mathcal{B}_{1}\cup\mathcal{B}_{2}\rvert\leq n-2r$. Then the following holds - $I(W_{A};W_{\mathcal{B}_{1}};W_{\mathcal{B}_{2}}|W_{\mathcal{B}_{3}})=0$. This is a consequence of the fact that each node encodes its stored symbols with a rank $n-2r$ MDS code.

L4:

Given a node $A$, and a set of different $2r$ nodes denoted by $\mathcal{B}$, the following holds- $I(W_{A};W_{\mathcal{B}})\leq 2r$.

Modified Lemma 1: For any node $A$, and a set of different nodes denoted by $\mathcal{B}$, $|\mathcal{B}|\leq n-r$, which is partitioned into sets $\mathcal{R}_{1},\ldots,\mathcal{R}^{\prime}$, as in Lemma 1, the following holds due to properties $\mathbf{L2,L3}$ and $\mathbf{L4}$:

[TABLE]

where $(e)$ follows similarly to Equation (15) with the slight difference of conditioning. Thus, the dimension of the space obtained by a DC accessing any $k$ nodes is

[TABLE]

where $(f)$ follows from the modified Lemma 1 above, and $(g)$ holds due to $\mathbf{L4}$.

IV-A Complexity analysis

Each node must store a local $r\times r$ encoding matrix, and $n-r$ domain points of the polynomial. The subpacketization level of the scheme for the MBR point is $k(2d-k+r)$. Thus functional MBR codes can have a reasonable subpacketization while achieving the optimal repair bandwidth and low I/O cost. The finite field operations are in $GF(q^{m}),m\geq d^{2}$. This is because while initially storing points in the nodes, the first $d$ nodes must be filled with $d$ linearly independent points, while the content of the remaining nodes can be generated as if they were being repaired by the first $d$ nodes. Addition and subtraction can be done in $\mathbb{O}(m)$, while multiplication and division can be done in $\mathbb{O}(m^{\log_{2}3})$ using Karatsuba’s algorithm [18]. State of the art polynomial interpolation can be done in $\mathbb{O}(n\log n)$.

The scheme in this paper is partially repair-by-transfer, when the systematic symbols from the stored points are transmitted. When the non-systematic symbols are transmitted, more than one systematic symbol must be read to form the required linear combination. A sparse systematic MDS generator matrix is ideal for this application [19]. Another advantage of the scheme is that it stitches together short MDS codes to form a larger code, thus each encoding operation can be done sequentially on a small number of elements.

V Conclusions

We presented a practical code construction and repair scheme for functional repair of multiple node failures in a broadcast setting, achieving the MBR point as well as an interior point, as indicated in Fig. 2. We leave for future work to use the construction in this paper for achieving other interior points. The conditions on the stored subspaces provide an insight into the general properties of functional regenerating codes.