Repair Duality with Locally Repairable and Locally Regenerating Codes

TL;DR

This paper introduces an explicit family of locally repairable and regenerating codes based on HashTag codes, demonstrating their construction, field size reduction, and the practical advantages of dual repair methods in distributed storage systems.

Contribution

The paper provides the first explicit construction of locally repairable and regenerating codes with dual repair options, based on HashTag codes, and discusses their practical benefits.

Findings

Explicit code construction based on HashTag codes.

Reduced finite field size requirements.

Practical benefits demonstrated in Hadoop experiments.

Abstract

We construct an explicit family of locally repairable and locally regenerating codes whose existence was proven in a recent work by Kamath et al. about codes with local regeneration but no explicit construction was given. This explicit family of codes is based on HashTag codes. HashTag codes are recently defined vector codes with different vector length $\alpha$ (also called a sub-packetization level) that achieve the optimal repair bandwidth of MSR codes or near-optimal repair bandwidth depending on the sub-packetization level. We applied the technique of parity-splitting code construction. We show that the lower bound on the size of the finite field for the presented explicit code constructions can be lower than the one given in the work of Kamath et al. Finally, we discuss the importance of having two ways for node repair with locally regenerating HashTag codes: repair only with local parity nodes or repair with both local and global parity nodes. To the best of the authors' knowledge, this is the first work where this duality in repair process is discussed. We give a practical example and experimental results in Hadoop where we show the benefits of having this repair duality.

Equations

$$\mathcal{C}=\{\mathbf{c}=({\mathbf{c}}_1,{\mathbf{c}}_2,\dots ,{\mathbf{c}}_n),{\mathbf{c}}_i\in {\mathbb{F}}_q^{\alpha }\text{ for all }i\in [n]\},$$

$$a\mathbf{c}+b{\mathbf{c}}^{\prime }=(a{\mathbf{c}}_1+b{\mathbf{c}}_1^{\prime },a{\mathbf{c}}_2+b{\mathbf{c}}_2^{\prime },\dots ,a{\mathbf{c}}_n+b{\mathbf{c}}_n^{\prime })$$

$$d_{\min }\le n-\kappa +1.$$

$$\gamma \ge \frac{M}{k}\frac{d}{d-k+1},$$

$${\gamma }_{MSR}^{min}=\frac{M}{k}\frac{n-1}{n-k}.$$

$$\mathbf{P}=\left[\begin{array}{cccc}{G}_{1,1}& G_{1,2}& \dots & G_{1,\kappa }\\ G_{2,1}& G_{2,2}& \dots & G_{2,\kappa }\\ \text{mathmakebox}[\text{widthof}1][c]⋮& \text{mathmakebox}[\text{widthof}{\alpha }_n][c]⋮& \ddots & \text{mathmakebox}[\text{widthof}{{\alpha }_n}^{k-1}][c]⋮\\ G_{\kappa ,1}& G_{\kappa ,2}& \dots & G_{\kappa ,n-\kappa }\end{array}\right],$$

$$d_{\min }\le n-k-\lceil \frac{k}{l}\rceil +2.$$

$$d_{\min }\le n-k+1-\left(\lceil \frac{k}{l}\rceil -1\right)(\delta -1).$$

$$c_{j,i}=\sum f_{\nu ,j,i}{x}_{j_1,j_2},$$

$${\mathbf{P}}_1=\left[\begin{array}{cccc}(1,1)& (1,2)& \dots & (1,k)\\ (2,1)& (2,2)& \dots & (2,k)\\ \text{mathmakebox}[\text{widthof}1][c]⋮& \text{mathmakebox}[\text{widthof}{\alpha }_n][c]⋮& \ddots & \text{mathmakebox}[\text{widthof}{{\alpha }_n}^{k-1}][c]⋮\\ (\alpha ,1)& (\alpha ,2)& \dots & (\alpha ,k)\end{array}\right],$$

$$\stackrel{\lceil \frac{k}{r}\rceil }{\overbrace{}}$$

$${\mathbf{P}}_i=\left[\begin{array}{ccccccc}(1,1)& (1,2)& \dots & (1,k)& (?,?)& \dots & (?,?)\\ (2,1)& (2,2)& \dots & (2,k)& (?,?)& \dots & (?,?)\\ \text{mathmakebox}[\text{widthof}1][c]⋮& \text{mathmakebox}[\text{widthof}{\alpha }_n][c]⋮& \ddots & \text{mathmakebox}[\text{widthof}{{\alpha }_n}^{k-1}][c]⋮& & & \\ (\alpha ,1)& (\alpha ,2)& \dots & (\alpha ,k)& (?,?)& \dots & (?,?)\end{array}\right].$$

$$d_{\min }=n-k+1-\left(\frac{k}{l}-1\right)(\delta -1).$$

$${\gamma }_{Local}^{min}=\min (\frac{M}{k}\frac{\frac{k}{l}+\delta -2}{\delta -1},\frac{M}{k}\frac{n-1}{n-k}).$$

$$\frac{\frac{M}{l}}{\frac{k}{l}}\cdot \frac{\frac{k}{l}+(\delta -1)-1}{\delta -1}=\frac{M}{k}\frac{\frac{k}{l}+\delta -2}{\delta -1}.$$

Full text

Keywords: Vector codes, Repair bandwidth, Repair locality, Exact repair, Parity-splitting, Hadoop.

I Introduction

The repair efficiency of erasure coding in distributed storage systems is measured with two main metrics: the amount of transferred data during a repair process (repair bandwidth) and the number of accessed nodes in a repair process (repair locality). Two types of erasure codes that are optimal with respect to these two metrics have emerged: Regenerating Codes (RCs) [1] and Locally Repairable Codes (LRCs) [2, 3, 4].

Minimum Storage Regenerating (MSR) codes are an important class of RCs that minimize the amount of data stored per node and the repair bandwidth. Explicit constructions of MSR codes can be found in [5, 6]. LRCs relax the maximum distance separable (MDS) requirement in order to minimize the number of nodes accessed during a repair. Studies on implementation and performance evaluation of LRCs can be found in [7, 8, 9, 10]. Combining the benefits of RCs and LRCs in one storage system can bring huge savings in practical implementations. For instance, repair bandwidth savings by RCs are important when repairing huge amounts of data, while a fast recovery and an access to small number of nodes enabled by LRCs are desirable for repair of frequently accessed data.

Several works present code constructions that combine the benefits of RCs and LRCs [11, 12, 13]. Rawat et al. in [11] and Kamath et al. in [12] have independently investigated codes with locality in the context of vector codes, and they call them locally repairable codes with local minimum storage regeneration (MSR-LRCs) and codes with local regeneration, respectively. Rawat et al. [11] provided an explicit construction, based on Gabidulin maximum rank-distance codes, of vector linear codes with all-symbol locality for the case when the local codes are MSR codes. However, the complexity of these codes increases exponentially with the number of nodes due to the two-stage encoding. In [12], Kamath et al. gave an existential proof without presenting an explicit construction. Another direction of combining RCs and LRCs is to use repair locality for selecting the accessed nodes in a RC [13], while an interpretation of LRCs as exact RCs was presented in [14]. Two different erasure codes, product and LRC codes, are used to optimize for recovery performance and reduce the storage overhead in [15].

Our Contribution: We construct an explicit family of locally repairable and locally regenerating codes whose existence was proven in a recent work by Kamath et al. [12] about codes with local regeneration. In that work, an existential proof was given, but no explicit construction was given. Our explicit family of codes is based on HashTag codes [5, 6]. HashTag codes are MDS vector codes with different vector length $\alpha$ (also called a sub-packetization level) that achieve the optimal repair bandwidth of MSR codes or near-optimal repair bandwidth depending on the sub-packetization level. We apply the technique of parity-splitting of HashTag codes in order to construct codes with locality in which the local codes are regenerating codes and which hence, enjoy both advantages of locally repairable codes as well as regenerating codes.

We also show (although just with a concrete example) that the lower bound on the size of the finite field where these codes are constructed, given in the work by Kamath et al. [12], can be lower. The presented explicit code construction has a practical significance in distributed storage systems as it provides system designers with greater flexibility in terms of selecting various system and code parameters due to the flexibility of HashTag code constructions.

Last but not least, we discuss the repair duality and its importance. Repair duality is a situation of having two ways to repair a node: to repair it only with local parity nodes or repair it with both local and global parity nodes. To the best of the authors’ knowledge, this is the first work that discusses the repair duality and how it can be applied based on concrete system and code parameters.

The paper is organized as follows. Section II presents mathematical preliminaries. In Section III, we describe a framework for explicit constructions of locally repairable and locally regenerating codes. The repair process is analyzed in Section IV where we explain the repair duality. Experimental results of measurements in Hadoop are given in Section V. Conclusions are summarized in Section VI.

II Mathematical Preliminaries and Related Work

Inspired by the work of Gopalan et al. about locally repairable codes [2], Kamath et al. extended and generalized the concept of locality in [12]. In this paper, we use notation that is mostly influenced (and adapted) from those two papers.

Definition 1** ([12])**

A $\mathbb{F}_{q}$-linear vector code of block length $n$ is a code \mathcal{C}\in\big{(}\mathbb{F}_{q}^{\alpha}\big{)}^{n} having a symbol alphabet $\mathbb{F}_{q}^{\alpha}$ for some $\alpha\geq 1$, i.e.

[TABLE]

and satisfies the additional property that for given $\mathbf{c},\mathbf{c}^{\prime}\in\mathcal{C}$ and $a,b\in\mathbb{F}_{q}$,

[TABLE]

also belongs to $\mathcal{C}$ where $a\mathbf{c}_{i}$ is a scalar multiplication of the vector $\mathbf{c}_{i}$. $\blacksquare$

Throughout the paper, we refer to the vectors $\mathbf{c}_{i}$ as vector symbols or nodes. Working with systematic codes, it holds that for the systematic nodes $\mathbf{c}_{i}=\mathbf{d}_{i}$ for $1\leq i\leq k$ and for the parity nodes $\mathbf{c}_{k+i}=\mathbf{p}_{i}$ for $1\leq i\leq r$. For every vector code \mathcal{C}\in\big{(}\mathbb{F}_{q}^{\alpha}\big{)}^{n} there is an associated scalar linear code $\mathcal{C}^{(s)}$ over $\mathbb{F}_{q}$ of length $N=\alpha n$. Accordingly, the dimension of the associated scalar code $\mathcal{C}^{(s)}$ is $K=\alpha k$. For a convenient notation, the generator matrix $G$ of size ${K\times N}$ of the scalar code $\mathcal{C}^{(s)}$ is such that each of the $\alpha$ consecutive columns corresponds to one code symbol $\mathbf{c}_{i},i\in[n]$, and they are considered as $n$ thick columns $\mathbf{W}_{i},i\in[n]$. For a subset $\mathcal{I}\subset[n]$ we say that it is an information set for $\mathcal{C}$ if the restriction $G|_{\mathcal{I}}$ of $G$ to the set of thick columns with indexes lying in $\mathcal{I}$ has a full rank, i.e. $\text{rank}(G|_{\mathcal{I}})=K$.

The minimum cardinality of an information set is referred as quasi-dimension $\kappa$ of the vector code $\mathcal{C}$. As the vector code $\mathcal{C}$ is $\mathbb{F}_{q}$-linear, the minimum distance $d_{\min}$ of $\mathcal{C}$ is equal to the minimum Hamming weight of a non-zero codeword in $\mathcal{C}$. Finally, a vector code of block length $n$, scalar dimension $K$, minimum distance $d_{\min}$, vector-length parameter $\alpha$ and quasi-dimension $\kappa$ is shortly denoted with $[n,K,d_{\min},\alpha,\kappa]$. While in the general definition of vector codes in [12] the quasi-dimension $\kappa$ does not necessarily divide the dimension $K$ of the associated scalar, for much simpler and convenient description of the codes in this paper we take that $k=\kappa$, i.e. $K=\alpha\kappa$. In that case the erasure and the Singleton bounds are given by:

[TABLE]

In [1], Dimakis et al. studied the repair problem in a distributed storage system where a file of $M$ symbols from a finite field $\mathbf{F}_{q}$ is stored across $n$ nodes, each node stores $\frac{M}{k}$ symbols. They introduced the metric repair bandwidth $\gamma$, and proved that the repair bandwidth of a MDS code is lower bounded by

[TABLE]

where $d$ is the number of accessed available nodes (helpers).

Lemma 1** ([1])**

The repair bandwidth of a $(n,k)$ MDS code is minimized for $d=n-1$. MSR codes achieve the lower bound of the repair bandwidth equal to

[TABLE]

A $(n,k)$ MSR code has the maximum possible distance $d_{min}=n-k+1$ in addition to minimizing the repair bandwidth, but it has the worst possible locality.

Corollary 1

The locality of a $(n,k)$ MSR code is equal to $n-1$.

Any $[n,K,d_{\min},\alpha,\kappa]$ vector code $\mathcal{C}$ is MDS if and only if its generator matrix can be represented in the form $G=[I|P]$, where the $K\times(N-K)$ parity matrix

[TABLE]

possesses the property that every square block submatrix of $P$ is invertible. The $G_{i,j}$ entries are square sub-matrices of size $\alpha\times\alpha$, and a block submatrix is composed by different entries of $G_{i,j}$.

In order to analyze codes with local regeneration, Kamath et al. introduced a new family of vector codes called uniform rank-accumulation (URA) codes in [12]. They showed that exact-repair MSR codes belong to the class of URA codes.

Definition 2

[12*, Def. 2]**

Let $\mathcal{C}$ be a $[n,K,d_{\min},\alpha,\kappa]$ vector code with a generator matrix $G$. The code $\mathcal{C}$ is said to have $(l,\delta)$ information locality if there exists a set of punctured codes $\{\mathcal{C}_{i}\}_{i\in\mathcal{L}}$ of $\mathcal{C}$ with respective supports $\{S_{i}\}_{i\in\mathcal{L}}$ such that*

• •

$|S_{i}|\leq l+\delta-1,$**

• •

$d_{\min}(\mathcal{C}_{i})\geq\delta,$* and*

• •

$\text{rank}(G|_{\bigcup_{i\in\mathcal{L}}})=K.$**

If we put $\delta=2$ in Def.2, then we get the definition of information locality introduced by Gopalan et al. [2]. They derived the upper bound for the minimum distance of a $(n,k,d)_{q}$ code with information locality $l$ for $\delta=2$ as

[TABLE]

A general upper bound was derived in [12] as

[TABLE]

Huang et al. showed the existence of Pyramid codes that achieve the minimum distance given in (5) when the field size is big enough [7]. Finally, based on the work by Gopalan et al. [2] and Pyramid codes by Huang et al. [7], Kamath et al. proposed a construction of codes with local regeneration based on a parity-splitting strategy in [12].

III Codes with Local Regeneration from HashTag Codes by Parity-Splitting

In [5, 6], a new class of vector MDS codes called HashTag codes is defined. HashTag codes achieve the lower bound of the repair bandwidth given in (3) for $\alpha=r^{\lceil\frac{k}{r}\rceil}$, while they have near-optimal repair bandwidth for small sub-packetization levels. HashTag codes are of a great practical importance due to their properties: flexible sub-packetization level, small repair bandwidth, and optimized number of I/O operations. We briefly give the basic definition of HashTag codes before we construct codes with local regeneration from them by using the framework of parity-splitting discussed in [12].

Definition 3

A $(n,k,d)_{q}$ HashTag linear code is a vector systematic code defined over an alphabet $\mathbb{F}_{q}^{\alpha}$ for some $\alpha\geq 1$. It encodes a vector $\mathbf{x}=(\mathbf{x}_{1},\ldots,\mathbf{x}_{k})$, where $\mathbf{x}_{i}=(x_{1,i},x_{2,i},\ldots,x_{\alpha,i})^{T}\in\mathbf{F}_{q}^{\alpha}$ for $i\in[k]$, to a codeword $\mathcal{C}(\mathbf{x})=\mathbf{c}=(\mathbf{c}_{1},\mathbf{c}_{2},\ldots,\mathbf{c}_{n})$ where the systematic parts $\mathbf{c}_{i}=\mathbf{x}_{i}$ for $i\in[k]$ and the parity parts $\mathbf{c}_{i}=(c_{1,i},c_{2,i},\ldots,c_{\alpha,i})^{T}$ for $i\in\{k+1,\ldots,n\}$ are computed by the linear expressions that have a general form as follows:

[TABLE]

where $f_{\nu,j,i}\in\mathbb{F}_{q}$ and the index pair $(j_{1},j_{2})$ is defined in the $j$-th row of the index array $\mathbf{P}_{i-r}$. The $r$ index arrays $\mathbf{P}_{1},\ldots,\mathbf{P}_{r}$ are defined as follows:

[TABLE]

[TABLE]

[TABLE]

where the values of the indexes $(?,?)$ are determined by a scheduling algorithm that guarantees the code is MDS, i.e. the entire information $\mathbf{x}$ can be recovered from any $k$ out of the $n$ vectors $\mathbf{c}_{i}$. $\blacksquare$

One scheduling algorithm for Def. 3 is defined in [5, 6].

Example 1

The linear expressions for the parity parts for a $(9,6)$ HashTag code with $\alpha=9$ are given here. The way how we obtain them is explained in Section 4.1 in [6]. We give one set of coefficients $f_{\nu,j,i}$ for equation (7) from the finite field $\mathbf{F}_{32}$ with irreducible polynomial $x^{5}+x^{3}+1$. This code achieves the lower bound of repair bandwidth in (3), i.e. the repair bandwidth is $\gamma=\frac{8}{3}=2.67$ for repair of any systematic node.

[TABLE]

We adapt the parity-splitting code construction for designing codes with local regeneration described in [12] for the specifics of HashTag codes. The construction is described in Construction 1. For simplifying the description, we take some of the parameters to have specific relations, although it is possible to define a similar construction with general values of the parameters. Namely, we take that $r|k$ and $r|\alpha$. We also take that the parameters for the information locality $(l,\delta)$ are such that $l|k$ and $\delta\leq r$.

Construction 1

An input to the construction is a $(n,k)$ HashTag MDS code with a sub-packetization level $\alpha$. This input comes with the associated linear parity equations (7), i.e. with the associated systematic generator matrix $G$. The MDS code can be, but it does not necessarily have to be a MSR code. Another input is the information locality $(l,\delta)$ that the constructed code with local regeneration will have. The following steps are performed:

Step 1.

Split $k$ systematic nodes into $l$ disjunctive subsets $S_{i},i\in[l]$, where every set has $\frac{k}{l}$ nodes. While this splitting can be arbitrary, take the canonical splitting where $S_{1}=\{1,\ldots,\frac{k}{l}\}$, $S_{2}=\{\frac{k}{l}+1,\ldots,\frac{2k}{l}\}$, $\ldots$, $S_{l}=\{\frac{(l-1)k}{l}+1,\ldots,k\}$.

Step 2.

Split each of the $\alpha$ linear equations for the first $\delta-1$ parity expressions (7) into $l$ sub-summands where the variables in each equation correspond to the elements from the disjunctive subsets.

Step 3.

Associate the obtained $\alpha\times l\times(\delta-1)$ sub-summands to $l\times(\delta-1)$ new local parity nodes.

Step 4.

Rename the remaining $r-\delta+1$ parity nodes that were not split in Step 1 - Step 3 as new global parity nodes.

Step 5.

Obtain a new systematic generator matrix $G^{\prime}$ from the local and global parity nodes.

Step 6.

Return $G^{\prime}$ as a generator matrix of a $[n,K=k\alpha,d_{\min},\alpha,k]$ vector code with information locality $(l,\delta)$.

A graphical presentation of the parity-splitting procedure is given in Fig. 1.

Theorem 1

If the used $(n,k)$ MDS HashTag code in Construction 1 is MSR, then the obtained $[n,K=k\alpha,d_{\min},\alpha,k]$ code with information locality $(l,\delta)$ is a MSR-Local code, where

[TABLE]

Proof:

(Sketch) Since in Construction 1 we took that $r|k$ and $r|\alpha$, it means that the scalar dimension of the code is $K=ml\alpha$ for some integer $m$. Then the proof continues basically as a technical adaptation of the proof of Theorem 5.5 that Kamath et al. gave for the pyramid-like MSR-Local codes constructed with the parity-splitting strategy in [12]. ∎

Note that if $\alpha<r^{\frac{k}{r}}$, then HashTag codes are sub-optimal in terms of the repair bandwidth. Consequently, the produced codes with Construction 1 are locally repairable, but they are not MSR-Local codes.

Example 2

*Let us split the MSR code given in Example 1 into a code with local regeneration and with information locality $(l=2,\delta=2)$. In Step 1 we split 6 systematic nodes $\{\mathbf{c}_{1},\ldots,\mathbf{c}_{6}\}$ into $l=2$ disjunctive subsets $S_{1}=\{\mathbf{c}_{1},\mathbf{c}_{2},\mathbf{c}_{3}\}$ and $S_{2}=\{\mathbf{c}_{4},\mathbf{c}_{5},\mathbf{c}_{6}\}$. According to Step 2 of Construction 1, the first global parity $\mathbf{c}_{7}$ in Example 1 is split into two local parities $\mathbf{l}_{1}=(l_{1,1},\ldots,l_{9,1})^{T}$ and $\mathbf{l}_{2}=(l_{1,2},\ldots,l_{9,2})^{T}$ as follows:

$l_{1,1}=$ $\textbf{\ 7}x_{1,1}$ + $\textbf{10}x_{1,2}$ + $\textbf{18}x_{1,3}$

$l_{2,1}=$ $\textbf{26}x_{2,1}$ + $\textbf{17}x_{2,2}$ + $\textbf{25}x_{2,3}$

$l_{3,1}=$ $\textbf{22}x_{3,1}$ + $\textbf{12}x_{3,2}$ + $\textbf{27}x_{3,3}$

$l_{4,1}=$ $\textbf{17}x_{4,1}$ + $\textbf{\ 9}x_{4,2}$ + $\textbf{14}x_{4,3}$

$l_{5,1}=$ $\textbf{20}x_{5,1}$ + $\textbf{\ 5}x_{5,2}$ + $\textbf{\ 5}x_{5,3}$

$l_{6,1}=$ $\textbf{25}x_{6,1}$ + $\textbf{16}x_{6,2}$ + $\textbf{30}x_{6,3}$

$l_{7,1}=$ $\textbf{20}x_{7,1}$ + $\textbf{\ 8}x_{7,2}$ + $\textbf{21}x_{7,3}$

$l_{8,1}=$ $\textbf{23}x_{8,1}$ + $\textbf{\ 4}x_{8,2}$ + $\textbf{12}x_{8,3}$

$l_{9,1}=$ $\textbf{\ 2}x_{9,1}$ + $\textbf{21}x_{9,2}$ + $\textbf{\ 8}x_{9,3}$

$l_{1,2}=$ $\textbf{11}x_{1,4}$ + $\textbf{17}x_{1,5}$ + $\textbf{\ 6}x_{1,6}$

$l_{2,2}=$ $\textbf{27}x_{2,4}$ + $\textbf{31}x_{2,5}$ + $\textbf{\ 4}x_{2,6}$

$l_{3,2}=$ $\textbf{31}x_{3,4}$ + $\textbf{31}x_{3,5}$ + $\textbf{23}x_{3,6}$

$l_{4,2}=$ $\textbf{\ 4}x_{4,4}$ + $\textbf{21}x_{4,5}$ + $\textbf{25}x_{4,6}$

$l_{5,2}=$ $\textbf{13}x_{5,4}$ + $\textbf{11}x_{5,5}$ + $\textbf{16}x_{5,6}$

$l_{6,2}=$ $\textbf{28}x_{6,4}$ + $\textbf{10}x_{6,5}$ + $\textbf{24}x_{6,6}$

$l_{7,2}=$ $\textbf{\ 9}x_{7,4}$ + $\textbf{\ 3}x_{7,5}$ + $\textbf{25}x_{7,6}$

$l_{8,2}=$ $\textbf{16}x_{8,4}$ + $\textbf{\ 8}x_{8,5}$ + $\textbf{17}x_{8,6}$

$l_{9,2}=$ $\textbf{16}x_{9,4}$ + $\textbf{\ 7}x_{9,5}$ + $\textbf{25}x_{9,6}$

The remaining two global parities are kept as they are given in Example 1, they are only renamed as $\mathbf{g}_{1}=(c_{1,8},c_{2,8},\ldots,c_{9,8})^{T}$ and $\mathbf{g}_{2}=(c_{1,9},c_{2,9},\ldots,c_{9,9})^{T}$. The overall code is a $(10,6)$ code or with the terminology from [8] it is a $(6,2,2)$ code. $\blacksquare$*

Example 3

*Let us split the same MSR code now with parameters $(l=3,\delta=2)$. In Step 1 we split 6 systematic nodes $\{\mathbf{c}_{1},\ldots,\mathbf{c}_{6}\}$ into $l=3$ disjunctive subsets $S_{1}=\{\mathbf{c}_{1},\mathbf{c}_{2}\}$, $S_{2}=\{\mathbf{c}_{3},\mathbf{c}_{4}\}$ and $S_{3}=\{\mathbf{c}_{5},\mathbf{c}_{6}\}$. In Step 2 of Construction 1, the first global parity $\mathbf{c}_{7}$ is split into three local parities: $\mathbf{l}_{1}=(l_{1,1},\ldots,l_{9,1})^{T}$, $\mathbf{l}_{2}=(l_{1,2},\ldots,l_{9,2})^{T}$ and $\mathbf{l}_{3}=(l_{1,3},\ldots,l_{9,3})^{T}$ as follows:

$l_{1,1}=$ $\textbf{\ 7}x_{1,1}$ + $\textbf{10}x_{1,2}$

$l_{2,1}=$ $\textbf{26}x_{2,1}$ + $\textbf{17}x_{2,2}$

$l_{3,1}=$ $\textbf{22}x_{3,1}$ + $\textbf{12}x_{3,2}$

$l_{4,1}=$ $\textbf{17}x_{4,1}$ + $\textbf{\ 9}x_{4,2}$

$l_{5,1}=$ $\textbf{20}x_{5,1}$ + $\textbf{\ 5}x_{5,2}$

$l_{6,1}=$ $\textbf{25}x_{6,1}$ + $\textbf{16}x_{6,2}$

$l_{7,1}=$ $\textbf{20}x_{7,1}$ + $\textbf{\ 8}x_{7,2}$

$l_{8,1}=$ $\textbf{23}x_{8,1}$ + $\textbf{\ 4}x_{8,2}$

$l_{9,1}=$ $\textbf{\ 2}x_{9,1}$ + $\textbf{21}x_{9,2}$

$l_{1,2}=$ $\textbf{18}x_{1,3}$ + $\textbf{11}x_{1,4}$

$l_{2,2}=$ $\textbf{25}x_{2,3}$ + $\textbf{27}x_{2,4}$

$l_{3,2}=$ $\textbf{27}x_{3,3}$ + $\textbf{31}x_{3,4}$

$l_{4,2}=$ $\textbf{14}x_{4,3}$ + $\textbf{\ 4}x_{4,4}$

$l_{5,2}=$ $\textbf{\ 5}x_{5,3}$ + $\textbf{13}x_{5,4}$

$l_{6,2}=$ $\textbf{30}x_{6,3}$ + $\textbf{28}x_{6,4}$

$l_{7,2}=$ $\textbf{21}x_{7,3}$ + $\textbf{\ 9}x_{7,4}$

$l_{8,2}=$ $\textbf{12}x_{8,3}$ + $\textbf{16}x_{8,4}$

$l_{9,2}=$ $\textbf{\ 8}x_{9,3}$ + $\textbf{16}x_{9,4}$

$l_{1,3}=$ $\textbf{17}x_{1,5}$ + $\textbf{\ 6}x_{1,6}$

$l_{2,3}=$ $\textbf{31}x_{2,5}$ + $\textbf{\ 4}x_{2,6}$

$l_{3,3}=$ $\textbf{31}x_{3,5}$ + $\textbf{23}x_{3,6}$

$l_{4,3}=$ $\textbf{21}x_{4,5}$ + $\textbf{25}x_{4,6}$

$l_{5,3}=$ $\textbf{11}x_{5,5}$ + $\textbf{16}x_{5,6}$

$l_{6,3}=$ $\textbf{10}x_{6,5}$ + $\textbf{24}x_{6,6}$

$l_{7,3}=$ $\textbf{\ 3}x_{7,5}$ + $\textbf{25}x_{7,6}$

$l_{8,3}=$ $\textbf{\ 8}x_{8,5}$ + $\textbf{17}x_{8,6}$

$l_{9,3}=$ $\textbf{\ 7}x_{9,5}$ + $\textbf{25}x_{9,6}$

The remaining two global parities are kept as they are given in Example 1, but they are just renamed as $\mathbf{g}_{1}=(c_{1,8},c_{2,8},\ldots,c_{9,8})^{T}$ and $\mathbf{g}_{2}=(c_{1,9},c_{2,9},\ldots,c_{9,9})^{T}$. The overall code is a $(11,6)$ code or with the terminology from [8] it is a $(6,3,2)$ code. $\blacksquare$*

There are two interesting aspects of Theorem 1 that should be emphasized: 1. We give an explicit construction of an MSR-Local code (note that in [12] the construction is existential), and 2. Examples 2 and 3 show that the size of the finite field can be slightly lower than the size proposed in [12]. Namely, the MSR HashTag code used in our example is defined over $\mathbf{F}_{32}$, while the lower bound in [12] suggests the field size to be bigger than $\binom{9}{6}=84$. We consider this as a minor contribution and an indication that a deeper theoretical analysis can further lower the field size bound given in [12].

IV Repair Duality

Theorem 2

Let $\mathcal{C}$ be a $(n,k)$ MSR HashTag code with $\gamma_{MSR}^{min}=\frac{M}{k}\frac{n-1}{n-k}$. Further, let $\mathcal{C}^{\prime}$ be a $[n,K=k\alpha,d_{\min},\alpha,k]$ code with local regeneration and with information locality $(l,\delta)$ obtained by Construction 1. If we denote with $\gamma_{Local}^{min}$ the minimum repair bandwidth for single systematic node repair with $\mathcal{C}^{\prime}$, then

[TABLE]

Proof:

When repairing one systematic node, we can always treat local nodes as virtual global nodes from which they have been constructed by splitting. Then with the use of other global nodes we have a situation of repairing one systematic node in the original MSR code for which the repair bandwidth is $\frac{M}{k}\frac{n-1}{n-k}$. On the other hand, if we use the MSR-Local code, then we have the following situation. There are $\frac{k}{l}$ systematic nodes in the MSR-Local code, and the total length of the MSR-Local code is $\frac{k}{l}+\delta-1$. The file size for the MSR-Local code is decreased by a factor $l$, i.e. it is $\frac{M}{l}$. If we apply the MSR repair bandwidth for these values we get:

[TABLE]

∎

Theorem 2 is one of the main contributions of this work: It emphasizes the repair duality for repairing one systematic node: by the local and global parity nodes or only by the local parity nodes. We want to emphasize the practical importance of Theorem 2. Namely, in practical implementations regardless of the theoretical value of $\gamma_{Local}^{min}$, the number of I/O operations and the access time for the contacted parts can be either crucial or insignificant. In those cases an intelligent repair strategy implemented in the distributed storage system can decide which repair procedure should be used: the one with global parity nodes or the one with the local parity nodes. We illustrate this by the following example.

Example 4

Let us consider the $(9,6)$ MSR HashTag code given in Example 1 and its corresponding local variant from Construction 1 with information locality $(l=2,\delta=2)$ given in Example 2. That means that the code with local regeneration has 6 systematic nodes, 2 local and 2 global parity nodes.

Let us analyze the number of reads when we recover one unavailable systematic node. If we recover with the local nodes, then we have to perform 3 sequential reads, reading the whole data in a contiguous manner from 3 nodes. If we repair the unavailable data with the help of both local and global parity nodes, it reduces to the case of recovery with a MSR code, where the number of sequential reads is between 8 and 24 (average 16 reads) but the amount of transferred data is equivalent to 2.67 nodes.

More concretely, let us assume that we want to recover the node $\mathbf{x}_{1}=(x_{1,1},x_{2,1},\ldots,x_{9,1})^{T}$.

For a recovery only with the local parity $\mathbf{l}_{1}$, 3 sequential reads of $\mathbf{l}_{1}$, $\mathbf{x}_{2}$ and $\mathbf{x}_{3}$ are performed. 2. 2.

For a recovery with the local and global parities:

1. (a)

First, read $l_{1,1}$, $l_{2,1}$ and $l_{3,1}$ from $\mathbf{l}_{1}$, and $x_{1,2}$, $x_{2,2}$ and $x_{3,2}$ from $\mathbf{x}_{2}$ and $x_{1,3}$, $x_{2,3}$ and $x_{3,3}$ from $\mathbf{x}_{3}$ to recover $x_{1,1}$, $x_{2,1}$ and $x_{3,1}$. 2. (b)

Additionally, read $x_{1,4}$, $x_{2,4}$ and $x_{3,4}$ from $\mathbf{x}_{4}$ and $x_{1,5}$, $x_{2,5}$ and $x_{3,5}$ from $\mathbf{x}_{5}$ and $x_{1,6}$, $x_{2,6}$ and $x_{3,6}$ from $\mathbf{x}_{6}$. 3. (c)

Then, read $c_{1,8}$, $c_{2,8}$ and $c_{3,8}$ from the global parity $\mathbf{g}_{1}$ to recover $x_{4,1}$, $x_{5,1}$ and $x_{6,1}$. 4. (d)

Finally, read $c_{1,9}$, $c_{2,9}$ and $c_{3,9}$ from the global parity $\mathbf{g}_{2}$ to recover $x_{7,1}$, $x_{8,1}$ and $x_{9,1}$.

Now, let a small file of 54 KB be stored across 6 systematic, 2 local and 2 global parity nodes. The sub-packetization level is $\alpha=9$, thus every node stores 9 KB, sub-packetized in 9 parts, each of size 1 KB. If the access time for starting a read operation is approximately the same as transferring 9 KB, then repairing with local and global parity nodes is more expensive since we have to perform in average 12 reads, although the amount of transferred data is equivalent to 2.67 nodes.

On the other hand, let us have a big file of 540 MB stored across 6 systematic nodes and 2 local and 2 global parity nodes. The sub-packetization level is again $\alpha=9$, thus every node stores 90 MB, sub-packetized in 9 parts, each of size 10 MB. The access time for starting a read operation is again approximately the same as transferring 9 KB, which is insignificant in comparison with the total amount of transferred data in the process of repairing of a node. In this case, it is better to repair a failed node with local and global parity nodes since it requires a transfer of 240 MB versus the repair just with local nodes that requires a transfer of 270 MB.

V Experiments in Hadoop

The repair duality discussed in Example 4 of previous section was mainly influenced by one system characteristic: the access time for starting a read operation. In different environments of distributed storage systems there are several similar system characteristics that can affect the repair duality and its final optimal procedure. We next discuss this matter for Hadoop.

Hadoop is an open-source software framework used for distributed storage and processing of big data sets [16]. From release 3.0.0-alpha2 Hadoop offers several erasure codes such as $(9,6)$ and $(14,10)$ Reed-Solomon (RS) codes. Hadoop Distributed File System (HDFS) has the concepts of Splits and Blocks. A Split is a logical representation of the data while a Block describes the physical alignment of data. Splits and Blocks in Hadoop are user defined: a logical split can be composed of multiple blocks and one block can have multiple splits. All these choices determine in a more complex way the access time for I/O operations.

To verify the performance of HashTag codes and their locally repairable and locally regenerating variants we implemented them in C/C++ and used them in HDFS.

For the code $(9,6)$ we used one NameNode, nine DataNodes, and one client node. All nodes had a size of 50 GB and were connected with a local network of 10 Gbps. The nodes were running on Linux machines equipped with Intel Xeon E5-2676 v3 running on 2.4 GHz. We have experimented with different block sizes (90 MB and 360 MB), different split sizes (512 KB, 1 MB and 4 MB) and different sub-packetization levels ($\alpha=1,3,6,$ and $9$) in order to check how they affect the repair time of one lost node. The measured times to recover one node are presented in Fig. 2. Note that the sub-packetization level $\alpha=1$ represents the RS code that is available in HDFS, while for every other $\alpha=3,6,9$ the codes are HashTag codes. In all measurements HashTag codes outperform RS. The cost of having significant number of I/O operations for the sub-packetization level $\alpha=9$ is the highest for the smallest block and split size (Block size of 90 MB and Split size of 512 KB). This is shown by yellow bars. As the split sizes increase, the disadvantage of bigger number of I/Os due to the increased sub-packetization diminishes, and the repair time decreases further (red and blue bars).

In Fig. 3, we compare the repair times for one lost node of 50 GB with the codes from Examples 2 and 3. The cost of bigger redundancy with the locally repairable code $(10,6)$ (which is also a locally regenerative code since the sub-packetization level is $\alpha=9$) with $(l=2,\delta=2)$ (the red bar) is still not enough to outperform the ordinary $(9,6)$ HashTag MSR code (the blue bar). However, paying even higher cost by increasing the redundancy for the other locally regenerative code $(11,6)$ with $(l=3,\delta=2)$ (the yellow bar) finally manages to outperform the repairing time for the ordinary $(9,6)$ HashTag MSR code.

The situation of comparing the slightly less optimal $(9,6)$ HashTag code with $\alpha=6$ with its locally repairable variants with $(l=2,\delta=2)$ and $(l=3,\delta=2)$ is different, and this is presented in Fig. 4. In this case, all variants of locally repairable codes outperform the original HashTag code, i.e. they repair a failed node in shorter time than the original HashTag code from which they were constructed.

VI Conclusions

We constructed an explicit family of locally repairable and locally regenerating codes. We applied the technique of parity-splitting on HashTag codes and constructed codes with locality. For these codes we showed that there are two ways to repair a node (repair duality), and in practice which way is applied depends on optimization metrics such as the repair bandwidth, the number of I/O operations, the access time for the contacted parts and the size of the stored file. Additionally, we showed that the size of the finite field can be slightly lower than the theoretically obtained lower bound on the size in the literature. We hope that this work will inspire a further theoretical analysis for obtaining new lower bound.