Decoding and Repair Schemes for Shift-XOR Regenerating Codes

TL;DR

This paper introduces efficient decoding and repair schemes for shift-XOR regenerating codes that reduce communication and computation costs, featuring an in-place algorithm called shift-XOR elimination with broad applicability.

Contribution

The paper presents a novel in-place shift-XOR elimination algorithm for decoding and repairing shift-XOR PM regenerating codes, improving efficiency and extending to other code types.

Findings

Optimal transmission bandwidth for shift-XOR MBR codes.

Lower computational complexity compared to previous zigzag algorithms.

Schemes can be extended to other PM-based MBR/MSR codes.

Abstract

Decoding and repair schemes are proposed for shift-exclusive-or (shift-XOR) product-matrix (PM) regenerating codes, which outperform the existing schemes in terms of both communication and computation costs. In particular, for the shift-XOR minimum bandwidth regenerating (MBR) codes, our decoding and repair schemes have the optimal transmission bandwidth and can be implemented in-place without extra storage space for intermediate XOR results. Technically, our schemes involve an in-place algorithm for solving a system of shift-XOR equations, called \emph{shift-XOR elimination}, which does not have the bandwidth overhead generated by shift operations as in the previous zigzag algorithm and has lower computation complexities compared with the zigzag algorithm. The decoding and repair of shift-XOR MBR/MSR codes are decomposed into a sequence of systems of shift-XOR equations, and hence can be solved by a sequence of calls to the shift-XOR elimination. As the decompositions of the decoding and repair depend only on the PM construction, but not the specific shift and XOR operations, our decoding and repair schemes can be extended to other MBR/MSR codes using the PM construction. Due to its fundamental role, the shift-XOR elimination is of independent interest.

Tables

Table 1. TABLE I: Comparison of the algorithms for decoding a shift-XOR storage code in terms of bandwidth overhead, decoding auxiliary space, and decoding complexities. Here L 𝐿 L is the message sequence length, and k 𝑘 k is the number of message sequences. A Vandermonde generator matrix is assumed.

Decoding Algorithm	Bandwidth Overhead	Decoding	Decoding	Decoding
		Auxiliary Space	XOR Operation	Integer Operation
shift-XOR elimination (Section III)	$0$	$O\left(1\right)$ integers		$O\left(k^{2}L\right)$
zigzag decoding [12]	$i\left(k-1\right)$ bits for node $i$	$O\left(kL\right)$ integers and $kL$ bits	$k\left(k+1\right)L$	$O\left(k^{2}L\right)$

Table 2. TABLE II: Comparison among Decoding and Repair Schemes of (cyclic-)shift-XOR MBR/MSR Codes. Here B 𝐵 B is the number of message sequences, L 𝐿 L is the message sequence length, k 𝑘 k is the number of nodes for decoding, n 𝑛 n is the number of storage nodes, d 𝑑 d is the number of helper nodes for repair, and i 𝑖 i is the node to repair. For MSR codes, d = 2 ​ k − 2 𝑑 2 𝑘 2 d=2k-2 . A Vandermonde generator matrix is assumed.

Algorithm		Bandwidth	Auxiliary Space for XOR results	XOR Operation
MBR Decoding	this paper (Section IV-A)	$BL$	$0$	$O\left(d{k}^{2}L\right)$
	[17]	$>BL+\frac{k\left(k-1\right)}{2}L$	$>BL+\frac{k\left(k-1\right)}{2}L$	$>d^2{k}^{3}nL$
	[27]	$>BL+\frac{k\left(k-1\right)}{2}L$	$>BL+\frac{k\left(k-1\right)}{2}L$	$O\left(d{k}^{3}L\right)$
MBR Repair	this paper (Section IV-B)	$d\left(L+\left(i-1\right)\left(d-1\right)\right)$	$0$	$2d\left(d-1\right)L+O\left(n{d}^3\right)$
	[17]	$d\left(L+\left(i-1\right)\left(d-1\right)\right)+O\left(n{d}^2\right)$	$>dL$	$>d^{4}nL$
	[27]	$dL$	$dL$	$\left(\frac{15}{4}d-\frac{3}{4}\right)dL$
MSR Decoding	this paper (Section V-A2)	$k\left(k-1\right)L+O\left(n{k}^{2}d\right)$	$\left(k-1\right)\left(k-2\right)L+O\left(n{k}^{2}d\right)$	$O\left(k^{3}L+n{k}^{3}d\right)$
	[17]	$k\left(k-1\right)L+O\left(n{k}^{2}d\right)$	$k\left(k-1\right)L+O\left(n{k}^{2}d\right)$	$>d{k}^{4}nL$
	[27]	$k\left(k-1\right)L$	$k\left(k-1\right)L$	$O\left(k^{4}L\right)$
MSR Repair	this paper (Section V-B)	$dL+O\left(n{d}^2\right)$	$\frac{1}{2}dL+O\left(n{d}^2\right)$	$\frac{3}{2}\left(d-1\right)dL+O\left(n{d}^3\right)$
	[17]	$dL+O\left(n{d}^2\right)$	$dL+O\left(n{d}^2\right)$	$>d^{4}nL$
	[27]	$dL$	$dL$	$\left(\frac{23}{16}d+\frac{5}{8}\right)dL$

Table 3. TABLE III: The three tables illustrate how 𝐲 1 , 𝐲 2 , 𝐲 3 subscript 𝐲 1 subscript 𝐲 2 subscript 𝐲 3 \mathbf{y}_{1},\mathbf{y}_{2},\mathbf{y}_{3} are formed by 𝐱 1 subscript 𝐱 1 \mathbf{x}_{1} , 𝐱 2 subscript 𝐱 2 \mathbf{x}_{2} and 𝐱 3 subscript 𝐱 3 \mathbf{x}_{3} . For number l 𝑙 l in the row of 𝐲 i subscript 𝐲 𝑖 \mathbf{y}_{i} , let l j subscript 𝑙 𝑗 l_{j} be the number in the same column of l 𝑙 l and in the row of 𝐱 j subscript 𝐱 𝑗 \mathbf{x}_{j} . Then the table tells that 𝐲 i ​ [ l ] = 𝐱 1 ​ [ l 1 ] + 𝐱 2 ​ [ l 2 ] + 𝐱 3 ​ [ l 3 ] subscript 𝐲 𝑖 delimited-[] 𝑙 subscript 𝐱 1 delimited-[] subscript 𝑙 1 subscript 𝐱 2 delimited-[] subscript 𝑙 2 subscript 𝐱 3 delimited-[] subscript 𝑙 3 \mathbf{y}_{i}[l]=\mathbf{x}_{1}[l_{1}]+\mathbf{x}_{2}[l_{2}]+\mathbf{x}_{3}[l_{3}] . For example, the 2nd, 3rd and 4th columns of Table IIIa mean 𝐲 1 ​ [ 1 ] = 𝐱 1 ​ [ 1 ] subscript 𝐲 1 delimited-[] 1 subscript 𝐱 1 delimited-[] 1 \mathbf{y}_{1}[1]=\mathbf{x}_{1}[1] , 𝐲 1 ​ [ 2 ] = 𝐱 1 ​ [ 2 ] + 𝐱 2 ​ [ 1 ] subscript 𝐲 1 delimited-[] 2 subscript 𝐱 1 delimited-[] 2 subscript 𝐱 2 delimited-[] 1 \mathbf{y}_{1}[2]=\mathbf{x}_{1}[2]+\mathbf{x}_{2}[1] and 𝐲 1 ​ [ 3 ] = 𝐱 1 ​ [ 3 ] + 𝐱 2 ​ [ 2 ] + 𝐱 3 ​ [ 1 ] subscript 𝐲 1 delimited-[] 3 subscript 𝐱 1 delimited-[] 3 subscript 𝐱 2 delimited-[] 2 subscript 𝐱 3 delimited-[] 1 \mathbf{y}_{1}[3]=\mathbf{x}_{1}[3]+\mathbf{x}_{2}[2]+\mathbf{x}_{3}[1] , respectively.

${𝐲}_1$	1	2	3	4	5	$\cdots$	$L$	$L+1$	$L+2$
${𝐱}_1$	1	2	3	4	5	$\cdots$	$L$
${𝐱}_2$		1	2	3	4	$\cdots$	$L-1$	$L$
${𝐱}_3$			1	2	3	$\cdots$	$L-2$	$L-1$	$L$

Table 4. (a)

${𝐲}_1$	1	2	3	4	5	$\cdots$	$L$	$L+1$	$L+2$
${𝐱}_1$	1	2	3	4	5	$\cdots$	$L$
${𝐱}_2$		1	2	3	4	$\cdots$	$L-1$	$L$
${𝐱}_3$			1	2	3	$\cdots$	$L-2$	$L-1$	$L$

Table 5. (b)

${𝐲}_2$	1	2	3	4	5	$\cdots$	$L$	$L+1$	$L+2$	$L+3$	$L+4$
${𝐱}_1$	1	2	3	4	5	$\cdots$	$L$
${𝐱}_2$			1	2	3	$\cdots$	$L-2$	$L-1$	$L$
${𝐱}_3$					1	$\cdots$	$L-4$	$L-3$	$L-2$	$L-1$	$L$

Table 6. (c)

${𝐲}_3$	1	2	3	4	5	6	7	$\cdots$	$L$	$L+1$	$L+2$	$L+3$	$\cdots$
${𝐱}_1$	1	2	3	4	5	6	7	$\cdots$	$L$
${𝐱}_2$				1	2	3	4	$\cdots$	$L-3$	$L-2$	$L-1$	$L$
${𝐱}_3$							1	$\cdots$	$L-6$	$L-5$	$L-4$	$L-3$	$\cdots$

Table 7. TABLE IV: Solving system ( 7 ) by the Shift-XOR Elimination for the first 10 10 10 iterations. The first row gives the three phases of the iterations, and the second row gives the iterations s 𝑠 s . The three rows following 𝐱 ^ i subscript ^ 𝐱 𝑖 \hat{\mathbf{x}}_{i} ( i = 1 , 2 , 3 𝑖 1 2 3 i=1,2,3 ) show how 𝐱 ^ i subscript ^ 𝐱 𝑖 \hat{\mathbf{x}}_{i} is formed by 𝐱 j subscript 𝐱 𝑗 \mathbf{x}_{j} , j = 1 , 2 , 3 𝑗 1 2 3 j=1,2,3 . For number l 𝑙 l in the row of 𝐱 ^ i subscript ^ 𝐱 𝑖 \hat{\mathbf{x}}_{i} , let l j subscript 𝑙 𝑗 l_{j} be the number in the same column of l 𝑙 l and in the row of 𝐱 j subscript 𝐱 𝑗 \mathbf{x}_{j} following 𝐱 ^ i subscript ^ 𝐱 𝑖 \hat{\mathbf{x}}_{i} . Then the table tells that 𝐱 ^ i ​ [ l ] = 𝐱 1 ​ [ l 1 ] + 𝐱 2 ​ [ l 2 ] + 𝐱 3 ​ [ l 3 ] subscript ^ 𝐱 𝑖 delimited-[] 𝑙 subscript 𝐱 1 delimited-[] subscript 𝑙 1 subscript 𝐱 2 delimited-[] subscript 𝑙 2 subscript 𝐱 3 delimited-[] subscript 𝑙 3 \hat{\mathbf{x}}_{i}[l]=\mathbf{x}_{1}[l_{1}]+\mathbf{x}_{2}[l_{2}]+\mathbf{x}_{3}[l_{3}] . For each iteration, the bits decoded are specified by the entries in the same column and in the gray rows. For example, from the column indexed by s = 4 𝑠 4 s=4 , the three gray entries are 4 4 4 , 2 2 2 and 1 1 1 , where the entry 4 4 4 in the row of 𝐱 ^ 1 subscript ^ 𝐱 1 \hat{\mathbf{x}}_{1} means that 𝐱 1 ​ [ 4 ] subscript 𝐱 1 delimited-[] 4 \mathbf{x}_{1}[4] can be solved by substituting the previous solved bits into 𝐱 ^ 1 ​ [ 4 ] subscript ^ 𝐱 1 delimited-[] 4 \hat{\mathbf{x}}_{1}[4] .

phase	1		2	3
iteration $s$	1	2	3	4	5	6	7	8	9	10	$\cdots$
${\widehat{𝐱}}_1$	1	2	3	4	5	6	7	8	9	10	$\cdots$
${𝐱}_1$	1	2	3	4	5	6	7	8	9	10	$\cdots$
${𝐱}_2$				1	2	3	4	5	6	7	$\cdots$
${𝐱}_3$							1	2	3	4	$\cdots$
${\widehat{𝐱}}_2$			1	2	3	4	5	6	7	8	$\cdots$
${𝐱}_1$			3	4	5	6	7	8	9	10	$\cdots$
${𝐱}_2$			1	2	3	4	5	6	7	8	$\cdots$
${𝐱}_3$					1	2	3	4	5	6	$\cdots$
${\widehat{𝐱}}_3$				1	2	3	4	5	6	7	$\cdots$
${𝐱}_1$				3	4	5	6	7	8	9	$\cdots$
${𝐱}_2$				2	3	4	5	6	7	8	$\cdots$
${𝐱}_3$				1	2	3	4	5	6	7	$\cdots$

Equations

$$\left(z^t\mathbf{a}\right)\left[l\right]=\{\begin{array}{ll}0,& 1\le l\le t,\\ \mathbf{a}\left[l-t\right],& t<l\le L+t.\end{array}$$

$$(z^t\mathbf{a})[l]=\mathbf{a}[l-t],l=1,\dots ,L+t.$$

$$\left(\mathbf{a}+{\mathbf{a}}^{\prime }\right)\left[l\right]=\mathbf{a}\left[l\right]\oplus {\mathbf{a}}^{\prime }\left[l\right],$$

$${\mathbf{y}}_{i,j}=\sum _{u=1}^d{z}^{t_{i,u}}{\mathbf{m}}_{u,j},$$

$$\mathbf{Y}=\mathbf{\Psi M}.$$

$$0\le t_{i,j^{\prime }}-t_{i,j}<t_{i^{\prime },j^{\prime }}-t_{i^{\prime },j},$$

$$\mathbf{\Psi }=(z^{(i-1)(j-1)}),$$

$$B=\frac{1}{2}(k+1)k+k(d-k).$$

$$\mathbf{M}=\left[\begin{array}{cc}\mathbf{S}& \mathbf{T}\\ {\mathbf{T}}^{\top }& \mathbf{O}\end{array}\right],$$

$$\mathbf{M}=\left[\begin{array}{cccc}{\mathbf{x}}_1& {\mathbf{x}}_2& {\mathbf{x}}_3& {\mathbf{x}}_7\\ {\mathbf{x}}_2& {\mathbf{x}}_4& {\mathbf{x}}_5& {\mathbf{x}}_8\\ {\mathbf{x}}_3& {\mathbf{x}}_5& {\mathbf{x}}_6& {\mathbf{x}}_9\\ {\mathbf{x}}_7& {\mathbf{x}}_8& {\mathbf{x}}_9& 0\end{array}\right],$$

$$\mathbf{\Psi }=\left[\begin{array}{cccc}1& 1& 1& 1\\ 1& z& z^2& z^3\\ 1& z^2& z^4& z^6\\ 1& z^3& z^6& z^9\\ 1& z^4& z^8& z^{12}\\ 1& z^5& z^{10}& z^{15}\end{array}\right],$$

$$\left\{\begin{IEEEeqnarraybox}[]{[}][c]{r.C.l}\mathbf{y}_{i,1}\!&\!=\!&\!\mathbf{x}_{1}+z^{i-1}\mathbf{x}_{2}+z^{2(i-1)}\mathbf{x}_{3}+z^{3(i-1)}\mathbf{x}_{7},\\ \mathbf{y}_{i,2}\!&\!=\!&\!\mathbf{x}_{2}+z^{i-1}\mathbf{x}_{4}+z^{2(i-1)}\mathbf{x}_{5}+z^{3(i-1)}\mathbf{x}_{8},\\ \mathbf{y}_{i,3}\!&\!=\!&\!\mathbf{x}_{3}+z^{i-1}\mathbf{x}_{5}+z^{2(i-1)}\mathbf{x}_{6}+z^{3(i-1)}\mathbf{x}_{9},\\ \mathbf{y}_{i,4}\!&\!=\!&\!\mathbf{x}_{7}+z^{i-1}\mathbf{x}_{8}+z^{2(i-1)}\mathbf{x}_{9}.\end{IEEEeqnarraybox}\right.$$

$$\mathbf{M}=\left[\begin{array}{c}\mathbf{S}\\ \mathbf{T}\end{array}\right],$$

$$\mathbf{\Psi }=\left[\begin{array}{cc}\mathbf{\Phi }& \mathbf{\Lambda \Phi }\end{array}\right],$$

$$\mathbf{M}=\left[\begin{array}{cc}{\mathbf{x}}_1& {\mathbf{x}}_2\\ {\mathbf{x}}_2& {\mathbf{x}}_3\\ {\mathbf{x}}_4& {\mathbf{x}}_5\\ {\mathbf{x}}_5& {\mathbf{x}}_6\end{array}\right],$$

$$\mathbf{\Phi }=\left[\begin{array}{cc}1& 1\\ 1& z\\ 1& z^2\\ 1& z^3\\ 1& z^4\\ 1& z^5\end{array}\right].$$

$$\mathbf{\Psi }=\left[\begin{array}{cccc}1& 1& 1& 1\\ 1& z& z^2& z^3\\ 1& z^2& z^4& z^6\\ 1& z^3& z^6& z^9\\ 1& z^4& z^8& z^{12}\\ 1& z^5& z^{10}& z^{15}\end{array}\right].$$

$$\left\{\begin{IEEEeqnarraybox}[]{[}][c]{r.C.l}\mathbf{y}_{i,1}\!&\!=\!&\!\mathbf{x}_{1}+z^{i-1}\mathbf{x}_{2}+z^{2\left(i-1\right)}\mathbf{x}_{4}+z^{3\left(i-1\right)}\mathbf{x}_{5},\\ \mathbf{y}_{i,2}\!&\!=\!&\!\mathbf{x}_{2}+z^{i-1}\mathbf{x}_{3}+z^{2\left(i-1\right)}\mathbf{x}_{5}+z^{3\left(i-1\right)}\mathbf{x}_{6}.\end{IEEEeqnarraybox}\right.$$

$$\left[\begin{array}{c}{\mathbf{y}}_1\\ {\mathbf{y}}_2\\ ⋮\\ {\mathbf{y}}_k\end{array}\right]=\mathbf{\Psi }\left[\begin{array}{c}{\mathbf{x}}_1\\ {\mathbf{x}}_2\\ ⋮\\ {\mathbf{x}}_k\end{array}\right],$$

$$\left[\begin{array}{c}{\mathbf{y}}_1\\ {\mathbf{y}}_2\\ {\mathbf{y}}_3\end{array}\right]=\left[\begin{array}{ccc}1& z& z^2\\ 1& z^2& z^4\\ 1& z^3& z^6\end{array}\right]\left[\begin{array}{c}{\mathbf{x}}_1\\ {\mathbf{x}}_2\\ {\mathbf{x}}_3\end{array}\right].$$

$${\hat{\mathbf{x}}}_1$$

$${\hat{\mathbf{x}}}_2$$

$${\hat{\mathbf{x}}}_3$$

$${\hat{\mathbf{x}}}_1[l]$$

$${\hat{\mathbf{x}}}_2[l]$$

$${\hat{\mathbf{x}}}_3[l]$$

$${\hat{\mathbf{x}}}_i={\mathbf{y}}_{k+1-i}\left[t_{k+1-i,i}+(1:L)\right],$$

$${\hat{\mathbf{x}}}_i[l]={\mathbf{x}}_i[l]+\sum _{j\ne i}{\mathbf{x}}_j[l-t_{k+1-i,j}+t_{k+1-i,i}],$$

$$L_b=\{\begin{array}{ll}{t}_{k-b,b+1}-t_{k-b,b},& 1\le b<k,\\ L,& b=k,\end{array}$$

$${\hat{\mathbf{x}}}_i={\mathbf{y}}_{k+1-i}\left[t_{k+1-i,i}+(1:L)\right],i=1,\dots ,k.$$

$$\mathbf{Y}=\mathbf{\Psi }\left[\begin{array}{cc}\mathbf{S}& \mathbf{T}\\ {\mathbf{T}}^{\top }& \mathbf{O}\end{array}\right],$$

$${\mathbf{y}}_{v,u}[l]=\{\begin{array}{ll}\sum _{j=1}^u{\mathbf{m}}_{j,u}[l-t_{v,j}]+\sum _{j=u+1}^d{\mathbf{m}}_{u,j}[l-t_{v,j}],& 1\le u\le k\\ \sum _{j=1}^k{\mathbf{m}}_{j,u}[l-t_{v,j}],& k<u\le d\end{array}$$

Full text

I Introduction

Distributed storage systems with potential node failures usually use redundancy to ensure the reliability of the stored data. Compared with repetition, erasure coding is a more efficient approach to introduce redundancy. Using an $\left[n,k\right]$ maximum-distance separable (MDS) erasure code, a data file of $kL$ bits is divided into $k$ sequences, each of $L$ bits. The $k$ sequences are encoded into $n$ coded sequences and stored in $n$ nodes, each storing one coded sequence. A decoder can decode the data file from any $k$ out of the $n$ coded sequences. An $\left[n,k\right]$ MDS erasure code can tolerate at most $n-k$ node failures. Reed-Solomon codes [1] are widely used MDS erasure codes, where the encoding and decoding operations are over finite fields, and have high computation costs.

Towards low complexity codes, exclusive-or (XOR) and cyclic-shift operations have been employed to replace finite-field operations. One family of such MDS storage codes includes EVENODD codes [2] and RDP codes [3] for tolerating double node failures, and their extensions [4, 5, 6] for tolerating triple or more node failures. These codes share a common cyclic-shift Vandermonde generator matrix and the decoding complexity of these codes has been improved by LU factorization of Vandermonde matrix [7]. Another family of MDS storage codes using XOR and cyclic-shift is based on Cauchy generator matrices, including Cauchy Reed-Solomon [8, 9] and Rabin-like codes [10], where the decoding method is improved in [11].

In this paper, we focus on a class of storage codes based on (non-cyclic) shift and XOR operations, called shift-XOR codes. Sung and Gong [12] presented a class of storage codes for any valid pair $\left[n,k\right]$ using shift and XOR operations, where the generator matrix satisfies the increasing difference property. Using an $[n,k]$ shift-XOR storage code, the $kL$ bits of the data file can be decoded from any $k$ out of the $n$ coded sequences using the zigzag decoding algorithm [12]. Due to shift operations, the coded sequences are usually longer than $L$ bits so that the shift-XOR storage codes are not strictly MDS, where the extra bits are called the storage overhead. An $[n,k]$ shift-XOR storage code is asymptotic MDS when $L$ is large. Moreover, the total number of bits retrieved by the zigzag decoder is more than $kL$ bits, where the extra bits are called the (decoding) bandwidth overhead.

Shift-XOR codes have attracted more research interests recently due to the potential low encoding/decoding computation costs. The shift-XOR storage codes with zigzag decoding have lower encoding and decoding complexities than Cauchy Reed-Solomon codes in a wide range of coding parameters [13]. A fountain code based on shift and XOR outperforms Raptor code in terms of the transmission overhead [14]. Efficient repair schemes for shift-XOR storage codes have been studied in [15]. Moreover, shift and XOR operations can also be used to construct network codes [16] and regenerating codes [17].

For distributed storage system, it is also worthwhile to consider the repair of failed nodes. Dimakis et al. formulated regenerating codes to address this issue [18]. In an $\left[n,k,d\right]$ regenerating code, a data file of $BL$ bits is divided into $B$ sequences, each containing $L$ bits. The sequences are encoded into $n\alpha$ sequences each of $L$ bits and distributed to $n$ storage nodes, each storing $\alpha$ sequences of $L$ bits. The data file can be decoded from any $k$ storage nodes, and a failed node can be repaired from any other $d$ surviving nodes. There are two kinds of repair [18]: exact repair and functional repair. In exact repair, the sequences stored in the failed node can be exactly reconstructed in the new node. In functional repair, the sequences reconstructed in the new node may be different from those in the failed node as long as the new node and the other nodes form an $[n,k,d]$ regenerating code.

The tradeoff between the storage in a node and the repair bandwidth is characterized in [18]. Two classes of codes that achieve the optimal storage-repair-bandwidth tradeoff are of particular interests, i.e., the minimum bandwidth regenerating (MBR) codes and minimum storage regenerating (MSR) codes. Rashmi, Shah and Kumar [19] proposed product-matrix (PM) constructions of MBR codes for all valid tuples $\left[n,k,d\right]$ and MSR codes for $d\geq 2k-2$ with exact repair algorithms. In [19], PM MSR codes with $d>2k-2$ are constructed based on the construction of the $d=2k-2$ case. Two unified constructions of MSR codes for $d\geq 2k-2$ were proposed in [20, 21]. Based on special parameterized codes such as determinant codes with $k=d$ [22], Cascade codes were proposed to achieve the MSR tradeoff point with arbitrary feasible combinations of $n,k,d$ [23]. Some MDS codes with sub-packetization were proposed to construct MSR codes [24, 25, 26].

The PM MBR/MSR codes require matrix operations over finite fields for encoding, decoding and repair, which have the high computation cost as Reed-Solomon codes. To achieve lower complexity, Hou et al. [17] proposed the regenerating codes using shift and XOR operations based on the PM construction. The shift-XOR MBR/MSR codes have the storage overhead the decoding/repair bandwidth overhead. For example, for the shift-XOR MBR codes, extra $\frac{1}{2}k(k-1)$ sequences are retrieved for decoding, where the sequence length is at least $L$. Hou et al. [27] proposed another class of regenerating codes using cyclic-shift and XOR based on the PM construction, called BASIC codes, and demonstrated the lower computation costs than the finite-field PM regenerating codes. The BASIC MBR codes have the similar decoding bandwidth issue as the shift-XOR regenerating codes.

In [17], a general sufficient condition is provided such that a system of shift-XOR equations is uniquely solvable, which induces an adjoint matrix based approach to solve a system of shift-XOR equations. However, the adjoint matrix based approach has a high computation cost so that the decoding and repair computation costs of the shift-XOR regenerating codes in [17] are higher than those of the BASIC codes in [27] (see the comparison in Table II). In this paper, we will show that it is possible to reduce the decoding/repair complexities of the shift-XOR regenerating codes to be better than or similar to those of BASIC codes.

I-A Our Contributions

In this paper, we first study solving a system of shift-XOR equations, where the generator matrix satisfies a refined version of the increasing difference property (see Section II). The refined increasing difference (RID) property relaxes the original one in [12] so that the storage overheads can be smaller. The RID property is satisfied by, for example, Vandermonde matrices. We propose an algorithm, called shift-XOR elimination, for solving such a system of shift-XOR equations (see Section III). Our algorithm has the following properties:

• •

Bandwidth overhead free: using the shift-XOR elimination to decode a shift-XOR storage code, only subsequences stored in a storage node are needed, and the number of bits retrieved from the storage nodes is equal to the number of bits to decode. In other words, the bandwidth costs of the shift-XOR elimination is optimal.

• •

Lower computational space and time complexities: the shift-XOR elimination has a smaller number of XOR operations and smaller auxiliary space compared with the zigzag algorithm. The number of XOR operations used by the shift-XOR elimination is the same as the number of XOR operations used to generate the input subsequences from the message sequences. The shift-XOR elimination only needs a constant number of auxiliary variables, and can be implemented in-place: the results of the intermediate XOR operations and the output bits are all stored at the same storage space of the input binary sequences. In other words, the algorithm uses an auxiliary space of $O(1)$ integers per $kL$ bits to solve, and hence has an asymptotically optimal space cost as $kL$ is large.

In Table I, the shift-XOR elimination and the zigzag algorithm are compared for decoding a shift-XOR storage code. The shift-XOR elimination can be used in other shift-XOR codes, e.g., [14, 15]. In this paper, we focus on its application in regenerating codes.

In Section IV and V, we study decoding and repair of the shift-XOR PM regenerating codes proposed in [17]. Our decoding/repair schemes transform the decoding/repair problem to a sequence of subproblems of shift-XOR equations, which can be solved using the shift-XOR elimination. Benefit from the advantages of the shift-XOR elimination, our schemes in general have lower computation and bandwidth costs than those in [17] (see Table II).

In particular, for the shift-XOR MBR codes, our decoding and repair schemes retrieve the same number of bits as the sequences to decode or repair. The decoding and repair schemes can be implemented in-place with only $O(1)$ integer auxiliary variables, but without any auxiliary variables to store the intermediate XOR results. Moreover, for decoding, the number of XOR operations is the same as the number of XOR operations for generating the input subsequences from the message sequences. For the shift-XOR MSR codes, our decoding and repair schemes have the same bandwidth cost, smaller auxiliary space for intermediate XOR results, and lower order of the number of XOR operations than those of [17].

With our decoding and repair schemes, shift-XOR regenerating codes can have better or similar performance compared with the BASIC codes [27], which use cyclic-shift and XOR. In particular, for MBR decoding and repair and MSR repair, our schemes have lower auxiliary spaces; for MBR decoding, our scheme has a smaller number of XOR operations. When $L$ is sufficiently larger than $nd$, for MBR repair and MSR decoding and repair, our schemes have a similar or smaller number of XOR operations. See the comparison in Table II.

In Section VI, we discuss how to extend our decoding and repair schemes to some other MBR/MSR codes based on the PM construction, so that these codes can gain certain advantages we have for shift-XOR codes. For codes based on the PM construction in [19, 27], the decoding and repair schemes are the same except that the shift-XOR elimination is replaced by certain sub-processes for finite fields and cyclic-shift respectively.

II Shift-XOR Storage Codes

In this section, we formulate shift-XOR storage codes [12, 17] after introducing some notations.

II-A Notations

A range of integers from $i$ to $j$ is denoted by $i:j$. When $i>j$, $i:j$ is the empty set. A (binary) sequence is denoted by a bold lowercase letter, e.g., $\mathbf{a}$. The $i$-th entry of a sequence $\mathbf{a}$ is denoted by $\mathbf{a}[i]$. The subsequence of $\mathbf{a}$ from the $i$-th entry to the $j$-th entry is denoted by $\mathbf{a}[i:j]$.

For a sequence $\mathbf{a}$ of $L$ bits and a natural number $t$, the shift operator $z^{t}$ pads $t$ zeros in front of $\mathbf{a}$, so that $z^{t}\mathbf{a}$ has $L+t$ bits and

[TABLE]

We use the convention that $\mathbf{a}[l]=0$ for $l\notin 1:L$, with which we can write

[TABLE]

Let $\mathbf{a}$ and $\mathbf{a}^{\prime}$ be two sequences of length $L$ and $L^{\prime}$, respectively. The addition of $\mathbf{a}$ and $\mathbf{a}^{\prime}$, denoted by $\mathbf{a}+\mathbf{a}^{\prime}$, is a sequence of $\max\{L,L^{\prime}\}$ bits obtained by bit-wise exclusive-or (XOR), i.e., for $l\in 1:\max\{L,L^{\prime}\}$,

[TABLE]

where we also use the convention that $\mathbf{a}[l]=0$ for $l>L$ and $\mathbf{a}^{\prime}[l]=0$ for $l>L^{\prime}$.

II-B General Shift-XOR Storage Codes

We describe a general shift-XOR storage code and discuss special instances in the next subsection. The code has parameters $B$, $L$, $d$, $n$ and $\alpha$, which are positive integers. Consider a storage system of $n$ storage nodes employing a shift-XOR storage code. A message is formed by $B$ binary sequences, each of $L$ bits. These $B$ message sequences are organized as a $d\times\alpha$ message matrix $\mathbf{M}=(\mathbf{m}_{i,j})$ in certain way to be described subsequently, where two entries may share the same message sequence, and certain entries may be the all-zero sequences. The generator matrix used for encoding the message is an $n\times d$ matrix $\mathbf{\Psi}=(z^{t_{i,j}})$, where $t_{i,j}$ are nonnegative integers to be explained further soon. For $1\leq i\leq n,1\leq j\leq\alpha$, let

[TABLE]

called the coded sequence. Denote $\mathbf{Y}=(\mathbf{y}_{i,j})$ as the $n\times\alpha$ coded matrix of sequences $\mathbf{y}_{i,j}$, which can be written in the matrix form

[TABLE]

The $\alpha$ sequences in the $i$-th row of $\mathbf{Y}$ are stored at the $i$-th node (also called node $i$) of the storage system.

Definition 1** (Refined Increasing Difference (RID) Property).**

Matrix $\mathbf{\Psi}=(z^{t_{i,j}})_{1\leq i\leq n,1\leq j\leq d}$ is said to satisfy the refined increasing difference (RID) property if the following conditions hold: For any $i,{i}^{\prime},j$, and ${j}^{\prime}$ such that $i<{i}^{\prime}$ and $j<{j}^{\prime}$,

[TABLE]

where equality in the first inequality holds only when $i=1$. We also say the numbers ${{t}_{i,j}}$, $1\leq i\leq n$, $1\leq j\leq d$ satisfy the RID property when they satisfy the above inequalities.

To guarantee certain efficient decoding algorithms, in this paper, we require the generator matrix $\mathbf{\Psi}$ of a shift-XOR code satisfying the RID property. Different from the increasing difference property in [12], the RID property allows ${t}_{1,{j}^{\prime}}-{t}_{1,j}=0$ such that less storage at each node is required. Suppose $\alpha=1$ and $B=d$, i.e., the $d$ entries of $\mathbf{M}$ are independent message sequences. The shift-XOR storage codes of this case have been studied in [12], and the zigzag algorithm can decode the $d$ message sequences from any $d$ rows of $\mathbf{Y}$.

Due to shift operations, the length of a coded sequence can be more than $L$ bits. In particular, the length of $\mathbf{y}_{i,j}$ is $L+t_{i,d}$. So the total number of bits stored at node $i$ is $\alpha(L+t_{i,d})$. The extra $\alpha t_{i,d}$ bits stored at node $i$ using a shift-XOR storage code is called the storage overhead. Under the constraint of the RID property, it can be argued that the generator matrix minimizing the storage overhead is [28]

[TABLE]

which is a Vandermonde matrix. In our analysis, we suppose $t_{i,j}=O(nd)$, which is feasible as we have a choice of $t_{i,j}=(i-1)(j-1)<nd$.

II-C Shift-XOR Regenerating Codes

We discuss two classes of shift-XOR product-matrix (PM) regenerating codes [17]. The two constructions of the message matrix $\mathbf{M}$ are the same as those of the (finite-field) PM MBR and MSR codes [19]. According to the storage overhead discussed in the preceding section, these codes achieve the MBR/MSR tradeoff asymptotically when $L\rightarrow\infty$, so the constructed codes are called shift-XOR MBR codes and shift-XOR MSR codes, respectively.

In contrast, regenerating codes using cyclic-shift-and-XOR operations [27] and finite-field operations [19] do not have storage overhead. Though with the storage overhead, the shift-XOR codes have the potential of low encoding/decoding complexity, to be demonstrated by the schemes of this paper.

II-C1 Shift-XOR MBR Codes

Fix an integer $k$ with $k\leq d$. Consider $\alpha=d$ and

[TABLE]

The message matrix $\mathbf{M}$ is of the form

[TABLE]

where $\mathbf{S}$ is a $k\times k$ symmetric matrix of the first $\frac{1}{2}\left(k+1\right)k$ message sequences, $\mathbf{T}$ is a $k\times\left(d-k\right)$ matrix of the remaining $k\left(d-k\right)$ message sequences, $\mathbf{O}$ is a $\left(d-k\right)\times\left(d-k\right)$ matrix of the zero sequence $\mathbf{0}$, and $\mathbf{T}^{\top}$ is the transpose of $\mathbf{T}$. By (2), all the $B$ message sequences are used in $\mathbf{M}$.

The shift-XOR MBR code has the coded sequences $\mathbf{Y}=\mathbf{\Psi}\mathbf{M}$, where $\mathbf{\Psi}=(z^{t_{i,j}})$ is an $n\times d$ matrix satisfying the RID property. A shift-XOR MBR code has the parameters $n$, $k$, $d$ and $L$, and is usually referred to as an $[n,k,d]$ code.

Example 1** ($[6,3,4]$ shift-XOR MBR Code).**

For a shift-XOR MBR code with $n=6$, $k=3$, $d=4$, the message matrix is of the form

[TABLE]

where $\mathbf{x}_{i}$ is a binary sequence of $L$ bits. Using the Vandermonde generator matrix

[TABLE]

the coded sequences stored at node $i$ ($1\leq i\leq 6$) are

[TABLE]

II-C2 Shift-XOR MSR Codes

Here we only discuss shift-XOR MSR codes with $d=2k-2$ and $\alpha=k-1$. Codes with $d\geq 2k-1$ can be constructed using the method in [19] based on the codes with $d=2k-2$ and $\alpha=k-1$. Let $B=k\alpha=(\alpha+1)\alpha$. The message matrix $\mathbf{M}$ is of the form

[TABLE]

where ${{\mathbf{S}}}$ is an $\alpha\times\alpha$ symmetric matrix of the first $\frac{1}{2}\alpha\left(\alpha+1\right)$ message sequences, and ${{\mathbf{T}}}$ is another $\alpha\times\alpha$ symmetric matrix of the remaining $\frac{1}{2}\alpha\left(\alpha+1\right)$ message sequences.

The generator matrix $\mathbf{\Psi}$ is of the form

[TABLE]

where $\mathbf{\Phi}=(z^{{t}_{i,j}})$ is an $n\times\alpha$ matrix satisfying the RID property, and $\mathbf{\Lambda}$ is an $n\times n$ diagonal matrix with diagonal entries $z^{{\lambda}_{1}},z^{{\lambda}_{2}},\ldots,z^{{\lambda}_{n}}$ such that $\mathbf{\Psi}$ satisfies the RID property. When $\mathbf{\Phi}=\left(z^{(i-1)(j-1)}\right)$ and ${\lambda}_{i}=(i-1)\alpha$, $\mathbf{\Psi}$ is a Vandermonde matrix, for which the storage overheads are minimal as we have discussed.

The shift-XOR MSR code described above has the coded sequences $\mathbf{Y}=\mathbf{\Psi}\mathbf{M}$, and is usually referred to as an $[n,k,d]$ code.

Example 2** ($[6,3,4]$ shift-XOR MSR Code).**

For a shift-XOR MSR code with $n=6$, $k=3$, $d=4$ and $\alpha=k-1=2$, the message matrix is

[TABLE]

where $\mathbf{x}_{i}$ is a binary sequence of $L$ bits. Let

[TABLE]

and $\mathbf{\Lambda}=\text{diag}\left\{1,z^{2},z^{4},z^{6},z^{8},z^{10}\right\}$. Then the generator matrix $\mathbf{\Psi}$ is

[TABLE]

The coded sequences stored at node $i$ ($1\leq i\leq 6$) are

[TABLE]

III Solving a System of Shift-XOR Equations

Before introducing the decoding and repair schemes of the shift-XOR regenerating codes, we give an algorithm for solving a system of shift-XOR equations, called shift-XOR elimination. This algorithm will be used as a sub-process of our subsequent decoding and repair schemes, and is of independent interest due to its fundamental role.

A $k\times k$ system of shift-XOR equations is given by

[TABLE]

where ${{\mathbf{x}}_{1}},{{\mathbf{x}}_{2}},\ldots,{{\mathbf{x}}_{k}}$ are binary sequences of $L$ bits, and matrix $\mathbf{\Psi}=(z^{t_{i,j}})$ satisfies the RID property given in Definition 1. The problem of solving a system of shift-XOR equations (6) is to calculate $\mathbf{x}_{i}$, $i=1,\ldots,k$ for given $\mathbf{y}_{i}$, $i=1,\ldots,k$ and $\mathbf{\Psi}$.

III-A Zigzag Algorithm

One approach to solve the system is the zigzag algorithm [12], which performs successive cancellation. We use an example to illustrate the idea of the zigzag algorithm.

Example 3**.**

Consider the $3\times 3$ system

[TABLE]

Table III illustrates how the bits in $\mathbf{y}_{i}$ are aligned with bits in $\mathbf{x}_{1}$, $\mathbf{x}_{2}$ and $\mathbf{x}_{3}$. We see that $\mathbf{x}_{1}[1]=\mathbf{y}_{i}[1]$, for $i=1,2,3$, and hence $\mathbf{x}_{1}[1]$ is solvable. Next, we see that $\mathbf{x}_{1}[2]=\mathbf{y}_{i}[2]$, for $i=2,3$ and hence $\mathbf{x}_{1}[2]$ is solvable. Substituting $\mathbf{x}_{1}[2]$ back into $\mathbf{y}_{1}$, we further obtain $\mathbf{x}_{2}[1]=\mathbf{y}_{1}[2]-\mathbf{x}_{1}[2]$. This process can be repeated to solve all the bits in $\mathbf{x}_{1}$, $\mathbf{x}_{2}$ and $\mathbf{x}_{3}$: in every iteration, a solvable bit is found and is substituted back to all the equations it involves in. When there are more than one solvable bits in an iteration, one of them is chosen for substitution.

The zigzag algorithm in [12] implements the above idea to solve any $k\times k$ system of shift-XOR equations as defined in (6). The zigzag algorithm, however, is not optimal in several aspects. First, the zigzag algorithm needs all the $kL+\sum_{i=1}^{k}t_{i,k}$ bits of $\mathbf{y}_{1},\mathbf{y}_{2},\ldots,\mathbf{y}_{k}$ to solve the $kL$ bits of ${{\mathbf{x}}_{1}},{{\mathbf{x}}_{2}},\ldots,{{\mathbf{x}}_{k}}$. The extra $\sum_{i=1}^{k}t_{i,k}$ bits consumed by the algorithm is called the communication overhead or bandwidth overhead. The ideal case is to have zero bandwidth overhead, same as solving a full-rank $k\times k$ system of linear equations over a finite field.

Second, the space and time computation complexities of the zigzag algorithm have room to improve. The zigzag algorithm [12] runs in $kL$ iterations to solve all the $kL$ bits. In each iteration, a solvable bit is found to back substitute into all the related equations. In [12], two approaches for searching the solvable bit are discussed. The first approach takes $O(k^{2})$ comparisons to find a solvable bit and results in totally $O(k^{3}L)$ time complexity. To reduce the time complexity, the second approach uses a pre-calculated array of $O(kL)$ integers to assist the searching process. Searching and updating the array takes $O(k)$ integer operations in each iteration, so that the time complexity is $O(k^{2}L)$. In addition to the input and output sequences, the second approach requires $O(kL)$ auxiliary space to store the integer array. Without otherwise specified, we refer to the second approach as the zigzag algorithm.

III-B Shift-XOR Elimination

Here we propose an algorithm to solve systems of shift-XOR equations, called shift-XOR elimination, which improves the zigzag algorithm in terms of both bandwidth overhead and computation complexities. First, only a subsequence of $L$ bits of $\mathbf{y}_{i}$ ($i=1,\ldots,k$) is used so that the shift-XOR elimination has no bandwidth overhead. Second, the order of the bits to solve follows a regular pattern so that the shift-XOR elimination has lower computation time and space costs than the zigzag algorithm. We use an example to illustrate our algorithm.

Example 4**.**

Consider the system in (7). As illustrated in Table III, $\mathbf{y}_{1}[1]$, $\mathbf{y}_{2}[1]$ and $\mathbf{y}_{3}[1]$ are all equal to $\mathbf{x}_{1}[1]$ and hence one of them is sufficient for solving $\mathbf{x}_{1}[1]$ and other two are redundant. Similarly, $\mathbf{y}_{2}[2]$ and $\mathbf{y}_{3}[2]$ are the same, and one of them is redundant. Define subsequences

[TABLE]

Table IV illustrates how $\hat{\mathbf{x}}_{i}$ is formed by $\mathbf{x}_{1},\mathbf{x}_{2},\mathbf{x}_{3}$. In particular, for $l\in 1:L$,

[TABLE]

We see that $\hat{\mathbf{x}}_{i}$ involves all the bits in $\mathbf{x}_{i}$.

Let’s illustrate how to solve the system using $\hat{\mathbf{x}}_{i}$, $i=1,2,3$. The system is solved in multiple iterations indexed by $s=1,2,\ldots$, which can be further separated into three phases:

For each iteration $s=1,2$, one bit in $\mathbf{x}_{1}$ is solved. 2. 2.

For the iteration $s=3$, one bit is solved in $\mathbf{x}_{1}$ and one bit is solved in $\mathbf{x}_{2}$ sequentially. 3. 3.

For each iteration $s\geq 4$, one bit is solved from each of $\mathbf{x}_{1},\mathbf{x}_{2}$ and $\mathbf{x}_{3}$ sequentially. (When $l>L$, $\mathbf{x}_{i}[l]$ is supposed to be solvable.)

Here, a bit is solved implies that it is also back substituted into the equations it involves. Table IV illustrates this order of bit solving. The first two iterations form the first phase, where $\mathbf{x}_{1}[1]$ and $\mathbf{x}_{1}[2]$ are solved. The third iteration forms the second phase, where $\mathbf{x}_{1}[3]$ is solved first and then $\mathbf{x}_{2}[1]$ is solved by substituting $\mathbf{x}_{1}[3]$. Other iterations form the third phase. At iteration $4$, for example, $\mathbf{x}_{1}[4]$ is first solved by substituting $\mathbf{x}_{2}[1]$; $\mathbf{x}_{2}[2]$ is then solved by substituting $\mathbf{x}_{1}[4]$; last, $\mathbf{x}_{3}[1]$ is solved by substituting $\mathbf{x}_{1}[3]$ and $\mathbf{x}_{2}[2]$.

Now we introduce the general shift-XOR elimination for solving (6). The algorithm uses the subsequence $\hat{\mathbf{x}}_{i}$, $i=1,\ldots,k$ defined as

[TABLE]

where $t_{k+1-i,i}+(1:L)$ denotes $(t_{k+1-i,i}+1):(t_{k+1-i,i}+L)$. As $\hat{\mathbf{x}}_{i}$ has exactly $L$ bits, our algorithm needs exactly $kL$ input bits and hence achieves zero bandwidth overhead. Substituting (6) into (8), we have for $1\leq l\leq L$,

[TABLE]

where we use the convention that $\mathbf{x}_{i}[l]=0$ for $l\leq 0$ and $l>L$.

The shift-XOR elimination solves $\hat{\mathbf{x}}_{i}$, $i=1,\ldots,k$ as follows. The algorithm runs in a number of iterations indexed by $s=1,2\ldots$, which are partitioned into $k$ phases. For $b=1,2,\ldots,k$, define

[TABLE]

and define $L_{1:b}=\sum_{b^{\prime}=1}^{b}L_{b^{\prime}}$. The $b$-th phase ($b\in 1:k$) has $L_{b}$ iterations. The operations in each iteration are specified as follows:

• •

For each iteration $s$ in phase $1$ (i.e., $s\in 1:L_{1}$), $\mathbf{x}_{1}[s]$ is solved (using $\hat{\mathbf{x}}_{1}[s]$).

• •

For each iteration $s$ in phase $b=2,\ldots,k$ (i.e., $s\in L_{1:(b-1)}+(1:L_{b})$), $\mathbf{x}_{i}[s-L_{1:(i-1)}]$ is solved (using $\hat{\mathbf{x}}_{i}[s-L_{1:(i-1)}]$ and the previously solved bits) sequentially for $i=1,\ldots,b$.

In the above process, i) a bit is solved implies that it is also back substituted into the equations it involves in; ii) for $\mathbf{x}_{i}[l]$ with $l>L$, $\mathbf{x}_{i}[l]$ is supposed to be solvable as [math], and hence do not need to be substituted; iii) the total number of iterations is $L_{1:k}$.

A pseudocode of the shift-XOR elimination is given in Algorithm 1, which also demonstrates an in-place implementation of the shift-XOR elimination. The loop started at Line 2 enumerates all the phases $b=1,\ldots,k$. The operations in each iteration are given from Line 3 to 9: In Line 6, one more bit is marked to be solved, and the following three lines perform back substitution. For in-place implementation, the back substitution result $\hat{\mathbf{x}}_{v}[l+t_{{k+1-v},i}-t_{{k+1-v},v}]\oplus\mathbf{x}_{i}[l]$ is stored at the same place of $\hat{\mathbf{x}}_{v}[l+t_{{k+1-v},i}-t_{{k+1-v},v}]$. After the execution of the algorithm, the value $\mathbf{x}_{i}[l]$ is stored at the same storage space as $\hat{\mathbf{x}}_{i}[l]$.

To prove the correctness of the shift-XOR elimination, we only need to show that each bit chosen to solve during the execution of the algorithm can be expressed as $\hat{\mathbf{x}}_{i}$, $i=1,\ldots,k$ and the previously solved bits. Theorem 1, proved in Appendix, justifies the shift-XOR elimination.

Theorem 1**.**

Consider a $k\times k$ system of shift-XOR equations $(\mathbf{y}_{1}\ \cdots\ \mathbf{y}_{k})^{\top}=\mathbf{\Psi}(\mathbf{x}_{1}\ \cdots\ \mathbf{x}_{k})^{\top}$ with $\mathbf{\Psi}$ satisfying the RID property. The shift-XOR elimination can successfully solve $\mathbf{x}_{i}$, $i=1,\ldots,k$ using

[TABLE]

We summarize the bandwidth and computation costs of the shift-XOR elimination:

• •

First, the algorithm has no bandwidth overhead as the number of input bits is the same as the number of bits to solve. In contrast, the bandwidth overhead of the zigzag algorithm has $\sum_{i=1}^{k}t_{i,k}$ bits.

• •

Second, as the algorithm can be implemented in-place, no extra storage space is required to store the intermediate XOR results. The algorithm only needs a small constant number (independent of $k$ and $L$) of intermediate integer variables. (The values $t_{i,j}$, $L_{b}$ and $L_{1:b}$ are constants that included as a part of the program that implements the algorithm.) Therefore, the shift-XOR elimination uses $O(1)$ auxiliary integer variables. In contrast, the zigzag algorithm needs $O(kL)$ auxiliary integer variables, and $kL$ bits to store the intermediate XOR results.

• •

Third, the number of XOR operations used by Algorithm 1 is the same as the number of XOR operations used to generate $\hat{\mathbf{x}}_{1},\ldots,\hat{\mathbf{x}}_{k}$ from $\mathbf{x}_{1},\ldots,\mathbf{x}_{k}$, and is less than $k(k-1)L$. The number of integer operations used in the algorithm (for calculating back substitution positions) is $O(k^{2}L)$. Similarly, the zigzag algorithm needs $k(k+1)L$ XOR operations and $O(k^{2}L)$ integer operations.

To conclude this section, we remark that there are other choices of the subsequences that can guarantee the solvability. But different subsequences may result in different order of the bits to solve, which we would not explore in this paper. For example, if we use $\textbf{y}_{u}[t_{u,u}+(1:L)]$, $u=1,\ldots,k$, each sequence $\mathbf{x}_{i}$ can be solved from the last bit to the first bit.

IV Decoding and Repair Schemes of Shift-XOR MBR Codes

In this section, we discuss the decoding and repair schemes for the shift-XOR MBR codes described in Section II-C1. Our schemes decompose the decoding/repair problem into a sequence of systems of shift-XOR equations, each of which can be solved efficiently using the shift-XOR elimination discussed in the last section.

Let $m,n$ be positive integers, and let $\mathbf{A}=(a_{i,j})$ be an $m\times n$ matrix. We define some notations to represent submatrices of $\mathbf{A}$. For two subsets $I\subset\{1,\ldots,n\}$ and $J\subset\{1,\ldots,m\}$, let $\mathbf{A}_{I}$ (resp. $\mathbf{A}^{J}$) be the submatrix of $\mathbf{A}$ formed by all the columns (resp. rows) with indices in $I$ (resp. $J$). Following these notations, $\mathbf{A}^{J}_{I}$ is the submatrix of $\mathbf{A}$ formed by the entries on the rows in $J$ and columns in $I$. When $I=\{i\}$ (resp. $J=\{j\}$), we also write $\mathbf{A}_{i}$ (resp. $\mathbf{A}^{j}$) for convenience. These submatrix notations should not be confused with the matrix entries (e.g., $a_{i,j}$), which are specified case by case before using.

IV-A Decoding Scheme of Shift-XOR MBR Codes

Consider an $[n,k,d]$ shift-XOR MBR codes. According to the encoding (1) with the symmetric matrix $\mathbf{M}=(\mathbf{m}_{i,j})$ in (3), we get

[TABLE]

where $\mathbf{\Psi}=(z^{t_{i,j}})$ is an $n\times d$ matrix satisfying the RID property. We see that for $1\leq i\leq j\leq k$, the $(i,j)$ entry of the symmetric matrix $\mathbf{S}$ is $\mathbf{m}_{i,j}$ and for $1\leq i\leq k,1\leq j\leq d-k$, the $(i,j)$ entry of $\mathbf{T}$ is $\mathbf{m}_{i,j+k}$. Due to the symmetry of $\mathbf{S}$, there are totally $B=\frac{1}{2}(k+1)k+k(d-k)$ message sequences to decode. Substituting the entries $\mathbf{m}_{i,j}$ into (11), the $(i,j)$ entry of $\mathbf{Y}$ is

[TABLE]

where $1\leq l\leq L+t_{v,d}$.

IV-A1 Decomposition of Decoding Problem

Our scheme decodes the message matrix $\mathbf{M}$ by first decoding the $k\times(d-k)$ submatrix $\mathbf{T}$ and then decoding the $k\times k$ symmetric submatrix $\mathbf{S}$. For each $j=1,\ldots,d-k$, we have the system of shift-XOR equations

[TABLE]

where $\mathbf{\Psi}_{1:k}$ satisfies the RID property. Using the shift-XOR elimination, $\mathbf{T}_{j}$ can be decoded from any $k$ rows of (13). The $d-k$ columns of $\mathbf{T}$ can be decoded one-by-one or in parallel.

After decoding $\mathbf{T}$, we continue to decode the $k$ columns of $\mathbf{S}$ sequentially with the column indices in descending order. Fix $u$ with $1\leq u\leq k$. We have, according to (11),

[TABLE]

Then we have

[TABLE]

As $\mathbf{\Psi}_{1:u}$ satisfies the RID property, (14) can be viewed as a system of shift-XOR equations generated by $\mathbf{\Psi}_{1:u}$ of the input $\mathbf{S}_{u}^{1:u}$. When $u=k$, $\mathbf{S}_{k}$ can be decoded using the shift-XOR elimination on any $k$ rows of $\mathbf{Y}_{u}-\mathbf{\Psi}_{(k+1):d}(\mathbf{T}^{u})^{\top}$. When $u<k$, suppose that the columns of $\mathbf{S}$ with indices larger than $u$ have all been decoded. Then $\mathbf{S}_{u}^{1:u}$ can be decoded using the shift-XOR elimination on any $u$ rows of (14), where $\mathbf{S}_{u}^{(u+1):k}=\left(\mathbf{S}_{(u+1):k}^{u}\right)^{\top}$ have been decoded.

IV-A2 Decoding Scheme

Our decoding scheme is able to decode the message sequences by retrieving data from any $k$ out of the $n$ nodes. Now we give the details of our decoding scheme, which consists of two stages: the transmission stage and the decoding stage. In the transmission stage, $k$ storage nodes are chosen. Let the indices of the $k$ nodes be $i_{1},i_{2},\ldots,i_{k}$, where $i_{1}>i_{2}>\cdots>i_{k}$. For $v\in 1:k$ and $u\in v:d$, define subsequence

[TABLE]

which is of $L$ bits. For $v\in 1:k$, node $i_{v}$ transmits the subsequences $\hat{\mathbf{m}}_{v,u}$, $u=v,\ldots,d$ to the decoder. Substituting (12) into (15), we have for $1\leq l\leq L$,

[TABLE]

where we see that $\hat{\mathbf{m}}_{v,u}$ involves all the bits in $\mathbf{m}_{v,u}$.

The decoding stage consists of two steps. In the first step, matrix $\mathbf{T}$ is decoded using $\hat{\mathbf{m}}_{v,u}$, $1\leq v\leq k,k+1\leq u\leq d$. In the second step, matrix $\mathbf{S}$ is decoded using $\hat{\mathbf{m}}_{v,u}$, $1\leq v\leq u\leq k$. A pseudocode of the decoding scheme is shown in Algorithm 2, which also demonstrates an in-place implementation of the decoding algorithm.

• Step 1:

This step contains $d-k$ iterations. For each $u\in(k+1):d$, performing the shift-XOR elimination on $\hat{\mathbf{m}}_{1,u},\hat{\mathbf{m}}_{2,u},\ldots,\hat{\mathbf{m}}_{k,u}$, we can decode $\mathbf{m}_{1,u},\mathbf{m}_{2,u},\ldots,\mathbf{m}_{k,u}$ (ref. Line 2 in Algorithm 2). For in-place implementation, $\mathbf{m}_{v,u}$ is stored at the same storage place of storing $\hat{\mathbf{m}}_{v,u}$. For any $v$ with $1\leq v\leq k$, $\mathbf{m}_{v,u}$ is involved in generating $\hat{\mathbf{m}}_{w,v}$, $1\leq w\leq v$ as in (16). So the value of $\mathbf{m}_{v,u}$ is substituted in $\hat{\mathbf{m}}_{w,v}$ (ref. Line 3–5 in Algorithm 2). After the substitution, ${{\hat{\mathbf{m}}}_{w,v}}$ with $1\leq w\leq v\leq k$ is only related to ${{\mathbf{{m}}}_{v^{\prime},u^{\prime}}},1\leq v^{\prime}\leq u^{\prime}\leq k$.

• Step 2:

This step contains $k-1$ iterations. For iteration $u$ from $k$ down to $2$, performing the shift-XOR elimination of $\hat{\mathbf{m}}_{1,u},\hat{\mathbf{m}}_{2,u},\ldots,\hat{\mathbf{m}}_{u,u}$ to decode $\mathbf{m}_{1,u},\mathbf{m}_{2,u},\ldots,\mathbf{m}_{u,u}$ (ref. Line 7 in Algorithm 2). Since $\mathbf{m}_{v,u}$ $(1\leq v\leq u-1)$ is involved in generating the bits in $\hat{\mathbf{m}}_{w,v}$ $(1\leq w\leq v)$, the sequence $\mathbf{m}_{v,u}$ $(1\leq v\leq u-1)$ is then substituted into $\hat{\mathbf{m}}_{w,v}$ $(1\leq w\leq v)$, according to (16) (ref. Line 8–10 in Algorithm 2). After the substitution, ${{\hat{\mathbf{m}}}_{w,v}}$ ($1\leq w\leq v\leq u-1$) is only related to ${\mathbf{{m}}_{v^{\prime},u^{\prime}}},1\leq v^{\prime}\leq u^{\prime}\leq u-1$.

After Step 2, $\mathbf{m}_{v,u}$ ($1\leq v\leq k,v\leq u\leq d$) is decoded and stored at the same storage place as $\hat{\mathbf{m}}_{v,u}$.

Example 5**.**

Consider the $\left[6,3,4\right]$ shift-XOR MBR code in Example 1. Suppose the transmission stage chooses nodes $1$, $3$ and $4$, i.e., $i_{1}=4$, $i_{2}=3$, and $i_{3}=1$. Node $i_{1}=4$ transmits $\hat{\mathbf{m}}_{1,i}=\mathbf{y}_{4,i}[1:L]$, $i=1,\ldots,4$ to the decoder. Node $i_{2}=3$ transmits $\hat{\mathbf{m}}_{2,i}=\mathbf{y}_{3,i}[3:(L+2)]$, $i=2,3,4$ to the decoder. Node $i_{3}=1$ transmits $\hat{\mathbf{m}}_{3,i}=\mathbf{y}_{1,i}[1:L]$, $i=3,4$ to the decoder.

Since $d=k+1$, Step 1 of Algorithm 2 has only one iteration. According to (16), we have for $1\leq l\leq L$

[TABLE]

Performing the shift-XOR elimination on $\hat{\mathbf{m}}_{1,4}$, $\hat{\mathbf{m}}_{2,4}$ and $\hat{\mathbf{m}}_{3,4}$ we obtain $\mathbf{m}_{1,4}$, $\mathbf{m}_{2,4}$ and $\mathbf{m}_{3,4}$. For $1\leq l\leq L$,

[TABLE]

The decoder further substitutes $\mathbf{m}_{1,4}$ into $\hat{\mathbf{m}}_{1,1}$, substitutes $\mathbf{m}_{2,4}$ into $\hat{\mathbf{m}}_{1,2}$ and $\hat{\mathbf{m}}_{2,2}$, and substitutes $\mathbf{m}_{3,4}$ into $\hat{\mathbf{m}}_{1,3}$, $\hat{\mathbf{m}}_{2,3}$ and $\hat{\mathbf{m}}_{3,3}$ correspondingly. We use the same notation to denote the sequences after substitution.

Step 2 of Algorithm 2 has two iterations with $u=3$ and $u=2$ respectively. In the $u=3$ iteration, we have for $1\leq l\leq L$

[TABLE]

which can be solved by shift-XOR elimination to obtain $\mathbf{m}_{1,3}$, $\mathbf{m}_{2,3}$ and $\mathbf{m}_{3,3}$. Similarly, the decoder substitutes $\mathbf{m}_{1,3}$ into $\hat{\mathbf{m}}_{1,1}$, substitutes $\mathbf{m}_{2,3}$ into $\hat{\mathbf{m}}_{1,2}$ and $\hat{\mathbf{m}}_{2,2}$. In the $u=2$ iteration, the shift-XOR elimination is performed on $\hat{\mathbf{m}}_{1,2}$ and $\hat{\mathbf{m}}_{2,2}$ to decode $\mathbf{m}_{1,2}$ and $\mathbf{m}_{2,2}$. The decoder then substitutes $\mathbf{m}_{1,2}$ into $\hat{\mathbf{m}}_{1,1}$, which becomes ${\mathbf{m}}_{1,1}$.

IV-A3 Complexity Analysis

Time Complexity: In Step 1, decoding each column of $\mathbf{T}$ costs $k(k-1)L$ XOR operations by the shift-XOR elimination (Line 2 in Algorithm 2). Noting that in Line 5 of Algorithm 2, the sequences for back substitution are shorter than $L$, and hence substituting each column of $\mathbf{T}$ into other retrieved sequences takes less than $\frac{1}{2}k(k+1)L$ XOR operations (Line 3 – 5 in Algorithm 2). There are $\left(d-k\right)$ iterations in this step, so the number of XOR operations $T_{1}$ required in Step 1 satisfies

[TABLE]

In Step 2, similarly, an iteration $u\in 2:k$ needs $u(u-1)L$ XOR operations to execute Algorithm 1 and less than $\frac{1}{2}u\left(u-1\right)L$ XOR operations to substitute the decoded sequences. Therefore, the number of XOR operations $T_{2}$ in the second step satisfies

[TABLE]

Therefore, the total number of XOR operations is

[TABLE]

So the time complexity is $O(dk^{2}L)$.

Space Complexity: Same as the shift-XOR elimination, Algorithm 2 can be implemented in-place, so that the output sequences take the same storage space as the input sequences. No extra space is required to store the intermediate XOR results. Only $O(1)$ integer auxiliary variables are required by Algorithm 2.

Bandwidth Overhead: Our algorithm consumes exactly $BL$ bits from the storage nodes to decode the $BL$ bits of the message sequences. Therefore, our decoding algorithm has zero bandwidth overhead.

IV-B Repair Scheme for Shift-XOR MBR Codes

This section introduces the repair scheme for the $[n,k,d]$ shift-XOR MBR code described in Section II-C1. Suppose that node $i$ fails. Our repair scheme generates a new storage node that stores $d$ sequences

[TABLE]

same as the $d$ sequences stored at node $i$. Note that a sequence in $\mathbf{Y}^{i}$ has $L+t_{i,d}$ bits. Recall that each storage node $j\in 1:n$ stores the sequences $\mathbf{\Psi}^{j}\mathbf{M}$, and hence can compute locally the sequence

[TABLE]

which is a shift-XOR equation of $\mathbf{Y}^{i}$. Therefore, using the shift-XOR elimination, $\mathbf{Y}^{i}$ can be decoded from $\mathbf{r}_{j}$ of any $d$ nodes $j$.

Specifically, the repair scheme includes two stages: the transmission stage and the decoding stage. In the transmission stage, $d$ helper nodes are chosen to repair node $i$, which have the indices $i_{1},i_{2},\ldots,i_{d}$ where $i_{1}>i_{2}>\cdots>i_{d}$. Each node $i_{v}$ ($1\leq v\leq d$) transmits a subsequence of $\mathbf{r}_{i_{v}}$ (defined in (18))

[TABLE]

to the new node $i$ for repairing. Note that $\hat{\mathbf{m}}_{v}$ has exactly the same number of bits as the sequences to repair. In the decoding stage, the new node $i$ has received sequences $\hat{\mathbf{m}}_{v}$, $v=1,\ldots,d$, and performs the shift-XOR elimination to decode $\mathbf{Y}^{i}$.

Example 6**.**

Consider again $\left[6,3,4\right]$ MBR code in Example 1, where the message matrix and generator matrix can be found. This example will show the transmission stage and decoding stage to repair node $3$ by connecting helper nodes $1$, $2$, $4$ and $5$, i.e., $i_{1}=5$, $i_{2}=4$, $i_{3}=2$, $i_{4}=1$. So

[TABLE]

Then the sequences transmitted to the new node $3$ are

[TABLE]

Applying Algorithm 1 on $\hat{\mathbf{m}}_{1}$, $\hat{\mathbf{m}}_{2}$, $\hat{\mathbf{m}}_{3}$ and $\hat{\mathbf{m}}_{4}$, we repair $\mathbf{y}_{3,1}$, $\mathbf{y}_{3,2}$, $\mathbf{y}_{3,3}$ and $\mathbf{y}_{3,4}$ at the new node $3$.

Time Complexity: The repair computation cost involves two parts: The first part is the computation at the $d$ helper nodes, and the second part is the computation at the repaired node. At each helper node, $(d-1)\left(L+t_{i,d}\right)$ XOR operations are used. So the total number of XOR operations at all the helper nodes is $d\left(d-1\right)(L+t_{i,d})$. The number of XOR operations of the second part is $d(d-1)\left(L+t_{i,d}\right)$, according to the analysis of Algorithm 1. Totally, the number of XOR operations of MBR codes repair is $2d(d-1)(L+t_{i,d})=2d(d-1)L+O(nd^{3})$.

Space Complexity: In the repaired node, one shift-XOR elimination is performed and $O(1)$ auxiliary integer variables are required.

Bandwidth: Our algorithm consumes exactly $L+t_{i,d}$ bits from $d$ helper nodes to repair the $d(L+t_{i,d})$ bits of node $i$, and hence has zero bandwidth overhead.

V Decoding and Repair Schemes of Shift-XOR MSR Codes

In this section, we discuss the decoding and repair schemes for the shift-XOR MSR codes described in Section II-C2. Similar to those of the shift-XOR MBR codes, our schemes decompose the decoding/repair problem into a sequence of systems of shift-XOR equations, each of which can be solved efficiently using the shift-XOR elimination.

V-A Decoding Scheme of Shift-XOR MSR Codes

Consider an $\left[n,k,d\right]$ shift-XOR MSR code, where $d=2k-2$ and $\alpha=k-1$. Substituting the message matrix $\mathbf{M}$ in (4) and the generator matrix $\mathbf{\Psi}$ in (5) into the general encoding formula (1), we obtain

[TABLE]

which is the $i$-th row of $\mathbf{Y}$ stored at storage node $i$. Denote the $(v,u)$ entry of $\mathbf{S}$ and $\mathbf{T}$ as $\mathbf{s}_{v,u}$ and $\mathbf{t}_{v,u}$, respectively. Due to symmetry, the decoding problem is to solve the message sequences $\mathbf{s}_{v,u}$, $\mathbf{t}_{v,u}$, $1\leq v\leq u\leq\alpha$, totally $B=\alpha(\alpha+1)=(k-1)k$ sequences.

V-A1 Decomposition of Decoding Problem

Suppose the indices of the $k$ nodes chosen for decoding are $i_{1},i_{2},\ldots,i_{k}$, where $i_{1}>i_{2}>\cdots>i_{k}$, so that the decoder can retrieve $\mathbf{Y}^{i_{u}}$, $u=1,\ldots,k$. Denote for $1\leq u\neq v\leq k$,

[TABLE]

Here $\mathbf{c}_{u,v}$ can be computed by the decoder using the sequences it retrieved. Due to the symmetry of $\mathbf{S}$ and $\mathbf{T}$, we have $\mathbf{p}_{u,v}=\mathbf{p}_{v,u}$ and $\mathbf{q}_{u,v}=\mathbf{p}_{v,u}$. Briefly, the decoding problem is decomposed into the following two steps:

• •

First, $\mathbf{p}_{u,v}$, $\mathbf{q}_{u,v}$, $1\leq u<v\leq k$ are solved using $\mathbf{c}_{u,v}$, $1\leq u\neq v\leq k$.

• •

Second, $\mathbf{S}$ is solved using $\mathbf{p}_{u,v}$, $1\leq u<v\leq k$, and $\mathbf{T}$ is solved using $\mathbf{q}_{u,v}$, $1\leq u<v\leq k$.

Let us elaborate these two steps.

Step 1: For $1\leq v<u\leq k$, we have the shift-XOR equations (obtained by (20) – (23))

[TABLE]

Due to the RID property of $\left[\mathbf{\Phi}\ \mathbf{\Lambda}\mathbf{\Phi}\right]$, we have $\lambda_{i_{u}}t_{i_{u},1}-t_{i_{u},a}<\lambda_{i_{v}}t_{i_{v},1}-t_{i_{v},a}$ and $t_{i_{u},a}-t_{i_{u},1}<t_{i_{v},a}-t_{i_{v},1}$, which implies $\lambda_{i_{u}}\neq\lambda_{i_{v}}$. Hence, the shift-XOR elimination can be performed on $\mathbf{c}_{u,v}$ and $\mathbf{c}_{v,u}$ to solve $\mathbf{p}_{u,v}$ and $\mathbf{q}_{u,v}$, which are of $L+t_{i_{u},\alpha}+t_{i_{v},\alpha}$ bits. According to the discussion in Section III, only the subsequences

[TABLE]

are needed for the shift-XOR elimination.

Step 2: Define an $\alpha\times\alpha$ matrix $\tilde{\mathbf{S}}=(\tilde{\mathbf{s}}_{v,u})$ as

[TABLE]

Due to the symmetry of $\mathbf{S}$, $(\tilde{\mathbf{S}}^{v})^{\top}=\mathbf{S}(\mathbf{\Phi}^{i_{v}})^{\top}$. For each $v\in 1:\alpha$, form the $\alpha\times\alpha$ system of shift-XOR equations (by (22) and (27))

[TABLE]

so that $(\tilde{\mathbf{S}}^{v})^{\top}$ can be solved by performing the shift-XOR elimination on the LHS of (28). By (27), we see the maximum length of sequences in $\tilde{\mathbf{S}}^{v}$ is $L^{\prime}_{v}=L+t_{i_{v},\alpha}$. So the shift-XOR elimination only needs the subsequences

[TABLE]

After solving $\tilde{\mathbf{S}}$, we further solve the system of shift-XOR equations (27), so that $\mathbf{S}_{u}$ can be decoded by the shift-XOR elimination on

[TABLE]

The procedure for solving $\mathbf{T}$ is the same and hence is omitted.

V-A2 Decoding Scheme

Our decoding scheme is able to decode the message sequences by retrieving data from any $k$ out of the $n$ nodes. Now we give the details of our decoding scheme, which consists of two stages: the transmission stage and the decoding stage. In the transmission stage, $k$ storage nodes are chosen. Let the indices of the $k$ nodes be $i_{1},i_{2},\ldots,i_{k}$, where $i_{1}>i_{2}>\cdots>i_{k}$. For $u\in 1:k$, node $i_{u}$ transmits $\mathbf{Y}^{i_{u}}$ to the decoder.

The decoding stage includes the two steps described above, with the pseudocode in Algorithm 3. The algorithm inputs $\mathbf{Y}^{i_{u}}$, $u=1,\ldots,k$ (totally $B$ sequences) and outputs the $B$ message sequences. But different from the decoding of shift-XOR MBR codes, this algorithm needs extra storage space for the intermediate XOR results.

In Step 1, the algorithm first calculates $\hat{\mathbf{c}}_{u,v}$ and $\hat{\mathbf{c}}_{v,u}$, $1\leq u<v\leq k$. From (25) and (26), we see the length of $\hat{\mathbf{c}}_{u,v}$ and $\hat{\mathbf{c}}_{v,u}$ is $L+O(nd)$. To storage $\hat{\mathbf{c}}_{u,v}$ and $\hat{\mathbf{c}}_{v,u}$, $1\leq u<v\leq k$, a space of $\alpha(\alpha+1)(L+O(nd))$ bits is needed. In Line 4, the shift-XOR elimination is applied on $\hat{\mathbf{c}}_{u,v}$ and $\hat{\mathbf{c}}_{v,u}$ to solve $\mathbf{p}_{u,v}$ and $\mathbf{q}_{u,v}$ for $1\leq v<u\leq k$. As the shift-XOR elimination is in-place, $\mathbf{p}_{u,v}$ and $\mathbf{q}_{u,v}$ can take exactly the same storage space as $\hat{\mathbf{c}}_{u,v}$ and $\hat{\mathbf{c}}_{v,u}$ for $1\leq v<u\leq k$, respectively. Then another space of $\alpha(\alpha-1)$ sequences is needed to store $\mathbf{p}_{u,v}$ and $\mathbf{q}_{u,v}$, $1\leq u<v\leq\alpha$. Therefore, after Line 7, totally $2\alpha^{2}(L+O(nd))$ bits space is needed.

In Step 2, from Line 8 to 9, the shift-XOR elimination is applied on $\hat{\mathbf{p}}_{u,v}$, $u=1,\ldots,v-1,v+1,\ldots,k$ to solve $\tilde{\mathbf{S}}^{v}$ for $v=1,\ldots,\alpha$. From Line 10 to 11, the shift-XOR elimination is applied on $\hat{\mathbf{s}}_{u,v}$, $v=1,2,\ldots,\alpha$ to solve $\mathbf{S}_{u}$ for $u=1,\ldots,\alpha$. Due to the in-place property of the shift-XOR elimination, no additional space is needed.

Last, $\mathbf{T}$ is solved by repeating the above process on $\hat{\mathbf{q}}_{u,v}$ instead of $\hat{\mathbf{p}}_{u,v}$.

Example 7**.**

Consider the example of $\left[6,3,4\right]$ MSR code in Example 2, where $\alpha=2$. Consider decoding from nodes $1$, $3$ and $4$, i.e., $i_{1}=4$, $i_{2}=3$ and $i_{3}=1$. The decoder retrieves the sequences $\mathbf{Y}^{4}=\left[\mathbf{y}_{4,1},\mathbf{y}_{4,2}\right]$, $\mathbf{Y}^{3}=\left[\mathbf{y}_{3,1},\mathbf{y}_{3,2}\right]$ and $\mathbf{Y}^{1}=\left[\mathbf{y}_{1,1},\mathbf{y}_{1,2}\right]$, and obtains the shift-XOR equations

[TABLE]

The above system cannot be solved directly using the shift-XOR elimination as it does not satisfy the RID property. We apply Algorithm 3 to solve the system.

First, the decoder uses the above sequences to calculate $\hat{\mathbf{c}}_{u,v}$ ($1\leq u\neq v\leq 3$), where

[TABLE]

By (24), we have the system of shift-XOR equations

[TABLE]

Performing the shift-XOR elimination on $\hat{\mathbf{c}}_{2,1}$ and $\hat{\mathbf{c}}_{1,2}$, we obtain $\mathbf{p}_{2,1}$ and $\mathbf{q}_{2,1}$. Similarly, we obtain $\mathbf{p}_{3,1}$ and $\mathbf{q}_{3,1}$ from $\hat{\mathbf{c}}_{1,3}$ and $\hat{\mathbf{c}}_{3,1}$, and obtain $\mathbf{p}_{3,2}$ and $\mathbf{q}_{3,2}$ from $\hat{\mathbf{c}}_{2,3}$ and $\hat{\mathbf{c}}_{3,2}$. We further generate $\mathbf{p}_{v,u}$ and $\mathbf{q}_{v,u}$ for $1\leq v<u\leq 3$ by symmetry.

By (28), we can form two systems

[TABLE]

and

[TABLE]

solving of which give us $\tilde{\mathbf{s}}_{v,u}$, $1\leq v,u\leq 2$. Then by (27), we have the system

[TABLE]

Applying the shift-XOR elimination on $\hat{\mathbf{s}}_{1,1}$ and $\hat{\mathbf{s}}_{2,1}$, we obtain $\mathbf{x}_{1}$ and $\mathbf{x}_{2}$. Applying the shift-XOR elimination on $\hat{\mathbf{s}}_{1,2}$ and $\hat{\mathbf{s}}_{2,2}$, we obtain $\mathbf{x}_{2}$ and $\mathbf{x}_{3}$.

Executing the same process above using ${\mathbf{q}}_{u,v}$ in place of $\mathbf{p}_{u,v}$, we can solve $\mathbf{x}_{4},\mathbf{x}_{5},\mathbf{x}_{6}$.

V-A3 Complexity Analysis

Time Complexity: The time complexity of Algorithm 3 can be calculated based on the time complexity of shift-XOR eliminations performed in the algorithm. First, $k\alpha(\alpha-1)(L+O(nd))=k(k-1)(k-2)(L+O(nd))$ XOR operations are needed for computing $\hat{\mathbf{c}}_{u,v}$ and $\hat{\mathbf{c}}_{v,u}$ for $1\leq u<v\leq k$. Solving $\mathbf{p}_{u,v}$ and $\mathbf{q}_{u,v}$ for $u=2,\ldots,k$ and $v=1,\ldots,u-1$ costs $\alpha(\alpha+1)(L+O(nd))=k(k-1)(L+O(nd))$ XOR operations. Then solving $\mathbf{S}$ and $\mathbf{T}$ costs $4\alpha^{2}(\alpha-1)(L+O(nd))=4(k-1)^{2}(k-2)(L+O(nd))$ XOR operations. Totally, the time complexity $T$ for decoding of MSR codes is

[TABLE]

Space Complexity: In Algorithm 3, the $2\alpha^{2}$ sequences $\mathbf{p}_{u,v}$, $\mathbf{p}_{v,u}$ take $2\alpha^{2}(L+O(nd))$ bits storage, which is the largest space cost of the algorithm during an execution. The message sequences has $\alpha(\alpha+1)L$ bits, so the auxiliary space is $\alpha(\alpha-1)L+O(nd^{3})$ bits.

Bandwidth: As the number of bits transmitted to the decoder from node $i_{j}$ is $\alpha(L+t_{i_{j},\alpha}+\lambda_{i_{j}})$, the total number of transmitted bits is $k\alpha L+\alpha\sum_{j=1}^{k}(t_{i_{j},\alpha}+\lambda_{i_{j}})$. There are $k\alpha L$ bits in the message sequences, and hence the bandwidth overhead is $\alpha\sum_{j=1}^{k}(t_{i_{j},\alpha}+\lambda_{i_{j}})=O(nk^{2}d)$.

V-B Repair Scheme of Shift-XOR MSR Codes

This section introduces our repair scheme for an $[n,k,d]$ shift-XOR MBR code, where $d=2k-2$ and $\alpha=k-1$. Define an $\alpha\times d$ matrix $\mathbf{X}=(\mathbf{x}_{i,j})$ with $\mathbf{x}_{i,j}=\mathbf{\Phi}^{i}\mathbf{S}_{j}$ and $\mathbf{x}_{i,j+\alpha}=\mathbf{\Phi}^{i}\mathbf{T}_{j}$ for $1\leq i,j\leq\alpha$. Suppose that node $i$ fails. Our repair scheme generates a new storage node that stores the same $\alpha$ sequences at node $i$:

[TABLE]

Recall that each storage node $j\in 1:n$ stores the sequences $\mathbf{\Psi}^{j}\mathbf{M}$, and hence can compute locally the sequence

[TABLE]

which is a shift-XOR equation of $\mathbf{X}^{i}$. By $\mathbf{r}_{j}$ from any $d$ nodes $j\neq i$, we can solve $\mathbf{X}^{i}$ using the shift-XOR elimination, and then calculate $\mathbf{Y}^{i}$ by (29).

Specifically, the repair scheme includes two stages: the transmission stage and the decoding stage. In the transmission stage, $d$ helper nodes are chosen to repair node $i$, which have the indices $i_{1},i_{2},\ldots,i_{d}$ where $i_{1}>i_{2}>\cdots>i_{d}$. Each helper node $i_{v}$ ($1\leq v\leq d$) transmits

[TABLE]

to the new node $i$ for repairing, where the sequence $\mathbf{r}_{i_{v}}$ is defined in (30). In the decoding stage, the new node $i$ performs the shift-XOR elimination on $\hat{\mathbf{r}}_{v}$, $v=1,\ldots,d$ to decode $\mathbf{X}^{i}$, and then calculate $\mathbf{Y}^{i}$ by (29).

Example 8**.**

Consider the $\left[6,3,4\right]$ MSR Code studied in Example 2. This example will show the transmission and decoding stages to repair node $3$ from helper nodes $1$, $2$, $4$ and $5$, i.e., $i_{1}=5$, $i_{2}=4$, $i_{3}=2$, $i_{4}=1$ and $i=3$. The sequences transmitted to node $i$ from the $4$ helper nodes are

[TABLE]

By (30), we have the system

[TABLE]

Applying the shift-XOR elimination on $\hat{\mathbf{r}}_{1}$, $\hat{\mathbf{r}}_{2}$, $\hat{\mathbf{r}}_{3}$ and $\hat{\mathbf{r}}_{4}$, we can obtain ${\mathbf{X}}^{3}$, and hence solve $\mathbf{Y}^{3}$ by (29).

Time Complexity: At each helper node $i_{v}$ ($v=1,\ldots,d$), computing $\hat{\mathbf{r}}_{i_{v}}$ costs $(\alpha-1)(L+O(nd))$ XOR operations. So there are totally $d\left(\alpha-1\right)(L+O(nd))=d(\frac{d}{2}-1)(L+O(nd))$ XOR operations at all the helper nodes. At the new node $i$, solving $\mathbf{X}^{i}$ costs $d(d-1)(L+O(nd))$ XOR operations by the shift-XOR elimination. Computing $\mathbf{Y}^{i}$ costs $\alpha(L+O(n\alpha))=\frac{d}{2}(L+O(n\alpha))$ XOR operations. So the total time complexity at the new node $i$ is $d(d-1/2)(L+O(nd))$. The overall time complexity among all the involved nodes is $\frac{3}{2}(d-1)dL+O(nd^{3})$.

Bandwidth: As the number of bits transmitted from node $i_{v}$ is $L+t_{i,\alpha}$, so the total number of bits transmitted is $d(L+t_{i,\alpha})=dL+O(nd^{2})$.

Space Complexity: The storage space of $d(L+t_{i,\alpha})=d(L+O(nd))$ bits is required to store the bits retrieved from the helper nodes. As the shift-XOR elimination can be implemented in-place, no extra storage space is required to store the intermediate results $\mathbf{X}^{i}$. The total length of the repaired sequences is $\alpha(L+\lambda_{i}+t_{i,\alpha})=\frac{d}{2}(L+O(nd))$. So the auxiliary space required for intermediate XOR results is $\frac{d}{2}(L+O(nd))$.

VI Extensions to other PM-Constructed Codes

The decompositions of our decoding and repair schemes discussed in the previous two sections depend mostly on the PM construction, and have little correlation to the shift and XOR operations. Therefore, similar decomposition may be possible for the decoding and repair of other regenerating codes based on the PM construction. In this section, we study the extensions of our decoding and repair schemes to the finite-field PM codes [19, 20] and the cyclic-shift PM codes [27].

VI-A Extension to Finite-Field PM Codes

The finite-field PM codes in [19] use finite field operations. Suppose the entries of a sequence are elements from a finite field $\mathbb{F}$. Same as the setting in Section II-B, using finite field operations, we define

[TABLE]

where $\psi_{i,u}\in\mathbb{F}$, and $\mathbf{y}_{i,j}$ and $\mathbf{m}_{u,j}$ are sequences of $L$ bits, or $L$ symbols from $\mathbb{F}$. Denoting $\mathbf{\Psi}=(\psi_{i,j})$, called the generator matrix, the encoding follows the same form of (1):

[TABLE]

As Gaussian elimination can solve systems of linear equations over finite fields, we can use Gaussian elimination in place of shift-XOR elimination to build decode/repair schemes for the finite-field PM codes.

VI-A1 Decoding Scheme of Finite-Field MBR Codes

For the finite-field MBR codes in [19], $\mathbf{\Psi}$ in (36) is of the form

[TABLE]

where $\mathbf{\Phi}=\left(\phi_{i,j}\right)$ and $\mathbf{\Delta}$ are $n\times k$ and $n\times(d-k)$ matrices respectively and satisfy: 1) any $d$ rows of $\mathbf{\Psi}$ are linearly independent; 2) any $k$ rows of $\mathbf{\Phi}$ are linearly independent. Specifically, the Vandermonde matrix and Cauchy matrix satisfy the above two conditions [19]. The message matrix is of the form

[TABLE]

where $\mathbf{S}$ is a $k\times k$ symmetric matrix and $\mathbf{T}$ is a $k\times(d-k)$ matrix. There are totally $\frac{1}{2}(k+1)k+k(d-k)$ message sequences. In the decoding algorithm of [19], the $dk$ sequences stored at $k$ nodes are retrieved for decoding, so that the decoding bandwidth overhead is $\frac{1}{2}k(k-1)$ sequences.

Due to the same matrix form as the shift-XOR MBR codes, we may wonder whether it is possible to derive a similar decoding algorithm as in Section IV-A with zero bandwidth overhead. We show it is possible when $\mathbf{\Phi}$ satisfies the further requirement that for any $k$ rows of $\mathbf{\Phi}$, all the leading principal submatrices are full rank. It is noted that the Vandermonde matrix and Cauchy matrix used in [19] also satisfy the requirement.

To illustrate the algorithm, suppose the first $k$ storage nodes are used for decoding. The decoding using other choice of nodes is similar. The decoder first retrieves

[TABLE]

As any $k$ rows of $\mathbf{\Phi}$ are linearly independent, $\mathbf{T}$ can be decoded using Gaussian elimination. After decoding $\mathbf{T}$, we continue to decode the $k$ columns of $\mathbf{S}$ sequentially with the column indices in descending order. For $u=k,k-1,\ldots,1$,

[TABLE]

i.e.,

[TABLE]

After substituting $\mathbf{T}$ and $\mathbf{S}^{(u+1):k}_{u}=\mathbf{S}^{u}_{(u+1):k}$, the LHS of the above equation is known and $\mathbf{S}^{1:u}_{u}$ can be decoded by Gaussian elimination as $\mathbf{\Phi}^{1:u}_{1:u}$ has rank $u$. Hence, $\mathbf{S}$ can be decoded column by column.

The above decoding scheme has the same asymptotic time/space/bandwidth complexity as the scheme for the shift-XOR MBR codes, and the decoder retrieves exactly the same number of bits as the message sequences.

VI-A2 Decoding Scheme of Finite-Field MSR Codes

For finite-field MSR codes with $d=2k-2$ and $\alpha=k-1$ in [19], the generator matrix $\mathbf{\Psi}$ is of the form

[TABLE]

where $\mathbf{\Phi}$ is an $n\times\alpha$ matrix and $\mathbf{\Lambda}=\text{diag}(\lambda_{1},\ldots,\lambda_{n})$ is an $n\times n$ diagonal matrix and satisfy: 1) any $d$ rows of $\mathbf{\Psi}$ are linearly independent; 2) any $\alpha$ rows of $\mathbf{\Phi}$ are linearly independent; (3) the $n$ diagonal elements in $\mathbf{\Lambda}$ are distinct. The message matrix is of the form

[TABLE]

The coded sequences stored are obtained by

[TABLE]

The $i$-th row of $\mathbf{Y}$ are stored at node $i$, i.e., $\mathbf{Y}^{i}=\mathbf{\Phi}^{i}\mathbf{S}+\lambda_{i}\mathbf{\Phi}^{i}\mathbf{T}$.

Assume that the decoder has access to $k$ nodes $i_{u}$ for $1\leq u\leq k$. For decoding, node $i_{u}$ transmits $\mathbf{Y}^{i_{u}}$ to the decoder. As discussed in Section V-A2, denote for $1\leq u\neq v\leq k$,

[TABLE]

$\mathbf{S}$ and $\mathbf{T}$ can be solved by the following two steps.

Step 1: For $1\leq v<u\leq k$, we have the linear systems

[TABLE]

Gaussian elimination is performed on $\mathbf{c}_{u,v}$ and $\mathbf{c}_{v,u}$ to solve $\mathbf{p}_{u,v}$ and $\mathbf{q}_{u,v}$.

Step 2: Define an $\alpha\times\alpha$ matrix $\tilde{\mathbf{S}}=(\tilde{\mathbf{s}}_{v,u})$ as

[TABLE]

Due to the symmetry of $\mathbf{S}$, $(\tilde{\mathbf{S}}^{v})^{\top}=\mathbf{S}(\mathbf{\Phi}^{i_{v}})^{\top}$. For each $v\in 1:\alpha$, form the $\alpha\times\alpha$ linear system

[TABLE]

so that $(\tilde{\mathbf{S}}^{v})^{\top}$ can be solved by performing Gaussian elimination. After solving $\tilde{\mathbf{S}}$, we further solve the linear system (37). Hence, $\mathbf{S}_{u}$ can be decoded by Gaussian elimination on $\tilde{\mathbf{s}}_{v,u},v=1,\ldots,\alpha$.

$\mathbf{T}$ can be solved by the same procedure and hence is omitted.

For our method, storage space of $2\alpha\times\alpha L=2(k-1)^{2}L$ symbols are needed; while in [19] the decoding needs space of $2k(k-1)L$ symbols. Hence, we can reduce space of $2(k-1)L$ symbols. In addition, the computation of $\mathbf{Y}^{i_{u}}(\mathbf{\Phi}^{i_{u}})^{\top}$ are omitted in our method, such that $\alpha$ multiplications of a vector and a sequence can be reduced.

In [20], finite-field MSR codes for $d\geq 2k-2$ are constructed, where the decoding procedure involves the decoding of the finite-field PM MSR codes with $d=2k-2$. Therefore, our decoding scheme mentioned above can also be substituted into the decoding of these MSR codes for $d\geq 2k-2$, and reduce the corresponding decoding complexity.

VI-B Extension to Cyclic-shift Regenerating Codes

The cyclic-shift regenerating codes in [27] employ a cyclic-shift operation defined as

[TABLE]

Same as the setting in Section II-B, let

[TABLE]

where $t_{i,u}\geq 0$ are integers. Denoting $\mathbf{\Psi}=(z_{c}^{t_{i,j}})$, the encoding follows the same form as (1).

A system of cyclic-shift equations can be expressed as

[TABLE]

where $\det(\mathbf{\Psi})$ has an inverse element in $\mathbb{F}_{2}[z]/(1+z+\cdots+z^{L-1})$. When $\mathbf{\Psi}$ is a Vandermonde matrix with $k-1$ strictly less than all divisors of $L$ which are not equal to $1$, the system can be solved using the LU method [27].

Similar to shift-XOR codes in Section IV and Section V, the decoding and repair of the cyclic-shift codes can be decomposed into a sequence of systems of cyclic-shift equations. When $n-1$ (where $n$ is the number of storage nodes) is strictly less than all divisors of $L$ which are not equal to $1$, the sequence of systems can be solved by the LU method. The decoding and repair schemes built in this way have the same asymptotic complexity as that of our shift-XOR codes.

VII Concluding Remarks

One technical contribution of this paper is an efficient algorithm called shift-XOR elimination to solve a system of shift-XOR equations satisfying the RID property. Our algorithm consumes the exactly same number of XOR operations for decoding as encoding the input subsequences, and can be implemented in-place with only a small constant number of auxiliary integer variables. The shift-XOR elimination has the potential to be applied to and simplified the decoding costs of a range of codes based on shift-XOR operations.

For shift-XOR regenerating codes, the decoding/repair schemes are decomposed into a sequence of systems of shift-XOR equations. Our decoding/require schemes have much lower computation costs than the existing schemes for the shift-XOR regenerating codes, and demonstrate better or similar computation costs compared with the regenerating codes based on cyclic-shift and XOR operations. Our results provide a further evidence that shift and XOR operations can help to design codes with low computation costs.

Though we only studied the bit-wise shifts in this paper, our algorithms can be extended to byte-wise or word-wise shifts to utilize multi-bit computation devices in parallel.

We are motivated to further explore the potential of shift-XOR codes. In one direction, we may extend the code constructions based on finite-field/cyclic-shift operations (e.g., [20, 21, 22, 23, 25, 24, 26]) to ones using shift and XOR. In another direction, we may investigate non-RID generator matrices, which may have lower storage overhead.

[Proof of Theorem 1]

Here we prove Theorem 1, which concerns a $k\times k$ system of shift-XOR equations (6), where $\mathbf{\Psi}=(z^{t_{i,j}})$ satisfies the RID property in Definition 1. Recall $L_{b}$ defined in (10).

Lemma 1**.**

For integers $1\leq u<v<k$,

[TABLE]

Proof:

The lemma can be proved by applying the RID property. On the one hand,

[TABLE]

On the other hand,

[TABLE]

∎

Now we start to prove Theorem 1. We inductively show that all the bits to solve in each iteration depend on only the previous solved bits. We use $l_{i}$ to denote the number of bits solved in $\mathbf{x}_{i}$, which are zero initially. For $k=1$, the shift-XOR elimination is successful without using back substitution. We consider $k>1$ in the following proof.

Firstly, for an iteration $s$ in $1:L_{1}$, we see that

[TABLE]

As $s\leq L_{1}=t_{k-1,2}-t_{k-1,1}$, we have $s+t_{k,1}-t_{k,u}<t_{k,2}-t_{k,1}+t_{k,1}-t_{k,u}=t_{k,2}-t_{k,u}\leq 0$ for $u\geq 2$ due to the RID property. Hence $\mathbf{x}_{1}[s]=\hat{\mathbf{x}}_{1}[s]$ so that $\mathbf{x}_{1}[s]$ can be solved. After iteration $L_{1}$, we have $l_{1}=L_{1}$ and $l_{i}=0$ for $i>1$.

For certain $2\leq b\leq k$, fix an iteration $s$ in $\sum_{b^{\prime}=1}^{b-1}L_{b^{\prime}}+(1:L_{b})$ and an index $i$ in $1:b$. We assume that the algorithm runs successfully to iteration $s$ with $\mathbf{x}_{u}[s-\sum_{b^{\prime}=1}^{u-1}L_{b^{\prime}}]$, for all $u<i$ solved, i.e.,

[TABLE]

To check whether $\mathbf{x}_{i}[l_{i}+1]$ can be solved or not, we write by (9)

[TABLE]

We can check the second term on the RHS is solved as follows:

For $1\leq u\leq i-1$, $\mathbf{x}_{u}[l_{i}+1+t_{k-i+1,i}-t_{k-i+1,u}]$ has been solved as

[TABLE]

where the first two equalities are obtained by substituting the formula in (38), and the inequality is obtained by Lemma 1. 2. 2.

For $i+1\leq u\leq b$, $\mathbf{x}_{u}[l_{i}+1+t_{k-i+1,i}-t_{k-i+1,u}]$ has been solved as

[TABLE]

where the first two equalities are obtained by substituting the formula in (38), the first inequality is obtained by Lemma 1, and the last inequality follows from the RID property. 3. 3.

For $b<u\leq k$, $\mathbf{x}_{u}[l_{i}+1+t_{k-i+1,i}-t_{k-i+1,u}]=0$ as

[TABLE]

where the first equality follows from (38), the first inequality follows from $s\leq\sum_{b^{\prime}=1}^{b}L_{b^{\prime}}\leq\sum_{b^{\prime}=1}^{u-1}L_{b^{\prime}}$, and the second inequality is obtained by Lemma 1 and the RID property.

Therefore, all terms on the RHS of (39) are known and hence $\mathbf{x}_{i}[l_{i}+1]$ can be solved. The proof of the theorem is completed.