Distributed Matrix-Vector Multiplication: A Convolutional Coding Approach

TL;DR

This paper introduces a convolutional coding approach for distributed matrix-vector multiplication that effectively mitigates stragglers, offers low-complexity decoding, and is well-suited for sparse matrices, outperforming Reed-Solomon based methods.

Contribution

The paper presents a novel convolutional coding scheme for distributed matrix-vector multiplication with low-complexity decoding and improved numerical stability over Reed-Solomon codes.

Findings

Peeling decoder enables efficient recovery.

Scheme is numerically more stable.

Performs well with sparse matrices.

Abstract

Distributed computing systems are well-known to suffer from the problem of slow or failed nodes; these are referred to as stragglers. Straggler mitigation (for distributed matrix computations) has recently been investigated from the standpoint of erasure coding in several works. In this work we present a strategy for distributed matrix-vector multiplication based on convolutional coding. Our scheme can be decoded using a low-complexity peeling decoder. The recovery process enjoys excellent numerical stability as compared to Reed-Solomon coding based approaches (which exhibit significant problems owing their badly conditioned decoding matrices). Finally, our schemes are better matched to the practically important case of sparse matrix-vector multiplication as compared to many previous schemes. Extensive simulation results corroborate our findings.

Equations

$$C_j(D)=\sum _{i=0}^{\infty }{c}_{i,j}{D}^i$$

$$\sum _{j=0}^{n-1}{c}_{i-mj,j}=0\text{leavevmodenobreak leavevmodenobreak forleavevmodenobreak }i\ge 0,$$

$$\sum _{j=0}^{n-1}{C}_j(D)D^{mj}=0$$

$$\underline{C}(D)=\left(C_0(D),C_1(D),C_2(D)\dots ,C_{n-1}(D)\right).$$

$$\underline{C}(D){\mathbf{H}}_{n,k}^T(D)=0,$$

$${\mathbf{H}}_{n,k}(D)=\left[\begin{array}{ccccc}1& 1& 1& \dots & 1\\ 1& D& D^2& \dots & D^{(n-1)}\\ \text{vbox}...& \text{vbox}...& \text{vbox}...& & \text{vbox}...\\ 1& D^{(s-1)}& D^{2(s-1)}& \dots & D^{(n-1)(s-1)}\end{array}\right].$$

$${\mathbf{Y}}_{a,b}(i,j)=D^{ij};0\le i\le a-1,0\le j\le b-1;$$

$${\Psi }_w=\text{diag}\left[\begin{array}{ccccc}1& D& D^2& \dots & D^{w-1}\end{array}\right].$$

$$\displaystyle\mathbf{H}_{n,k}^{T}(D)=\begin{bmatrix}\mathbf{Y}_{s,s}\\ ----\\ \mathbf{Y}_{k,s}\Psi_{s}^{s}\end{bmatrix}.\$$

$${\mathbf{G}}_{n,k}(D)=\left[\begin{array}{c}\mathbf{Z}{\mathbf{I}}_k\end{array}\right],$$

$$\mathbf{Z}=-{\mathbf{Y}}_{k,s}{\Psi }_s^s{\mathbf{Y}}_{s,s}^{-1}.$$

$$\displaystyle\mathbf{W}_{k,s}=\begin{bmatrix}1&D^{s}&D^{2s}&\dots&D^{(s-1)s}\\ 1&D^{s+1}&D^{2(s+1)}&\dots&D^{(s-1)(s+1)}\\ \vbox{\hbox{.}\hbox{.}\hbox{.}}&\vbox{\hbox{.}\hbox{.}\hbox{.}}&\vbox{\hbox{.}\hbox{.}\hbox{.}}&&\vbox{\hbox{.}\hbox{.}\hbox{.}}\\ 1&D^{(s+k-1)}&D^{2(s+k-1)}&\dots&D^{(s-1)(s+k-1)}\end{bmatrix}.\$$

$$y_j(\sigma )=\sum _{\ell =0}^{s-1}{y}_{\ell j}{\sigma }^{\ell }$$

$$y_j(D^{\ell })=0,\text{for}\ell \ne j,$$

$$y_j(\sigma )=\sum _{\ell =0}^{s-1}{y}_{\ell j}{\sigma }^{\ell }=\prod _{\ell =0,\ell \ne j}^{s-1}\frac{\sigma -D^{\ell }}{D^j-D^{\ell }}.$$

$$Z_{ij}=-\prod _{\ell =0,\ell \ne j}^{s-1}\frac{D^{s+i}-D^{\ell }}{D^j-D^{\ell }}.$$

$$Z_{ij}=-\left[\frac{\left(D^{s+i}-D^0\right)\left(D^{s+i}-D^1\right)\dots \left(D^{s+i}-D^{j-1}\right)}{\left(D^j-D^0\right)\left(D^j-D^1\right)\dots \left(D^j-D^{j-1}\right)}\right]$$

$$\times$$

$$A_{ij}$$

$$B_{ij}$$

$$W=\frac{\left(D^{x+1}-1\right)\left(D^{x+2}-1\right)\dots \left(D^{x+y}-1\right)}{\left(D^1-1\right)\left(D^2-1\right)\dots \left(D^y-1\right)}.$$

$$D^q-1=\prod _{d|q}{\Phi }_d(D)$$

$$\text{den}(W)={\left[{\Phi }_1(D)\right]}^{i_1}\times {\left[{\Phi }_2(D)\right]}^{i_2}\times \cdots \times {\left[{\Phi }_y(D)\right]}^{i_y}$$

$$\displaystyle\mathbf{G}_{4,2}(D)\;=\;\begin{bmatrix}D&-D-1&1&0\\ D^{2}+D&-D^{2}-D-1&0&1\end{bmatrix}\$$

$${\tilde{u}}_i(D)=u_{iq}+u_{iq+1}D+\cdots +u_{(i+1)q-1}{D}^{q-1}$$

$$U(D)=\left[\begin{array}{cccc}{\tilde{u}}_0(D)& {\tilde{u}}_1(D)& \dots & {\tilde{u}}_{k-1}(D)\end{array}\right]{\mathbf{G}}_{n,k}(D).$$

$$\frac{\Delta }{k}+\lambda \le \gamma \Delta \text{which leads to}\Delta \ge \frac{\lambda }{\gamma -\frac{1}{k}}.$$

$${\tilde{u}}_0(D)=u_0+u_{1}D+u_2{D}^2+u_3{D}^3,\text{leavevmodenobreak and}$$

$${\tilde{u}}_1(D)=u_4+u_{5}D+u_6{D}^2+u_7{D}^3.$$

$$\sum _{j=0}^{n-1}{c}_{i-(s-1)j,j}=0$$

$$\sum _{j=0}^{n-1}{c}_{(s-1)(t_0-j)+\alpha ,j}=0$$

$$\alpha +(s-1)(t_0-j)=-1.$$

Full text

I Introduction

Distributed computation plays a major role in several problems in optimization and machine learning. For example, large scale gradient descent often requires us to repeatedly calculate matrix-vector products. In high-dimensional problems, time and storage constraints necessitate the splitting of these computations across multiple nodes.

Distributed systems are well known to suffer from the issue of slow or faulty processors, which are referred to as stragglers. Several methods have been developed recently for straggler mitigation by using ideas from erasure coding [1, 2, 3]. For example, suppose that we want to compute the product of matrix $\textbf{A}\in\mathbb{R}^{r\times t}$ and $\textbf{x}\in\mathbb{R}^{t}$ in a distributed fashion. As proposed by [4], we can first split matrix $\mathbf{A}$ into submatrices with equal number of rows as $\mathbf{A}^{T}=\left[\mathbf{A}_{0}^{T}\;\;\mathbf{A}_{1}^{T}\right]$, and assign three different worker nodes the jobs of computing $\textbf{A}_{0}\textbf{x}$, $\textbf{A}_{1}\textbf{x}$ and $\left(\textbf{A}_{0}+\textbf{A}_{1}\right)\textbf{x}$ so that the computational load on each of them is half of the original. It is evident that the master node can recover $\mathbf{A}\mathbf{x}$, as soon as it receives results from any two workers, i.e., the system is resilient to one straggler. This can be generalized by using Reed-Solomon (RS) code-like ideas. Reference [2] incorporates similar ideas also for matrix-matrix multiplication. In both these cases, the proposed solutions have the property that the master node can recover the final result as soon as it receives the results from any $\tau$ workers; $\tau$ is called the recovery threshold.

While these solutions for distributed matrix-vector multiplication are optimal with respect to the recovery threshold, they neglect certain important issues that exist in practical scenarios. For instance, in many machine learning problems, the matrix $\mathbf{A}$ is sparse. RS based aproaches require dense linear combinations of the submatrices of $\mathbf{A}$. This may cause the computation time of the submatrix-vector products to go up. RS based approaches also suffer from numerical stability issues owing to the high condition number of the corresponding Vandermonde matrices. A high condition number results in the decoded value changing by a large amount even if the computed submatrix-vector products change by a small amount. This is especially relevant in the machine learning context where gradient computations can often be approximate. We note here that this issue with respect to polynomial interpolation is well recognized in the numerical analysis literature [5] and several papers discuss appropriate choices of interpolation points for numerical robustness [6]. However, in the straggler mitigation context, we need to be able to perform recovery from any large enough subset of interpolation points. This causes the worst case condition number to be quite bad.

In this work, we present a class of distributed matrix-vector multiplication schemes by leveraging (binary) cross parity check convolutional codes [7], that were originally proposed for distributed storage systems. In our context, the generator matrices specify the assignment of jobs to the worker nodes.

I-A Main Contributions

• •

While the codes in [7] can result in generator matrices that are recursive, we show that our schemes always result in feed-forward encoders. This is important in our setting, because our underlying field of operation is $\mathbb{R}$. Furthermore, we show that in the setting when the number of stragglers is two, then our encoder only has coefficients in $\{-1,0,1\}$. When the number of stragglers is three, we show an upper bound on the absolute value of the coefficients.

• •

We demonstrate that our schemes can be decoded at the master node by a low-complexity peeling decoder. This implies that the master node can operate in iterations such that in each iteration, it solves an equation where there is only one unknown.

• •

Our experimental results indicate the numerical robustness of our scheme, and also shows its advantage in computation speed when $\mathbf{A}$ is sparse.

II Cross Parity Check Convolutional Codes

Consider the set of real infinite sequences $\{c_{r},c_{r+1},\dots\}$ for $r\in\mathbb{Z}$ that start at some finite integer index and continue thereafter. These sequences can be treated as elements of the formal Laurent series [7] in indeterminate $D$ with coefficients from $\mathbb{R}$, i.e. $\sum\limits_{i=r}^{\infty}c_{i}D^{i}$. Let us denote the ring of formal Laurent series over $\mathbb{R}$ as $\mathbb{R}((x))$ under the normal addition and multiplication of formal power series. It can be shown that $\mathbb{R}((x))$ forms a field, i.e., each non-zero element of $\mathbb{R}((x))$ has a corresponding inverse.

In this work, we will consider $n$ infinite strips that can be visualized as columns that start at index $r=0$ and continue indefinitely downward. We denote the infinite sequence as $\{c_{0,j},c_{1,j},c_{2,j},\dots\}$ for each column $j$, and so, we can represent the $j$-th strip by the formal series as

[TABLE]

for $0\leq j\leq n-1$. These sequences obey the “geometric” constraint

[TABLE]

which indicates the lines of slope $m$. For each value of $m=0,1,\dots,(n-k-1)$, the sequences sum to zero along the lines of the corresponding slope. The value $c_{i,j}=0$ if $i<0$ for any $j$.

Let $CP(n,k)$ denote the set of all sequences111We will refer to this as the $CP(n,k)$ code that satisfy the constraints in (1). This can equivalently be expressed as

[TABLE]

for $m=0,1,\dots,(n-k-1)$. Let

[TABLE]

Then, we can express the condition succinctly as

[TABLE]

where $\mathbf{H}_{n,k}(D)$ is the $(n-k)\times\,n$ matrix (analogous to a parity-check matrix), which can be obtained from (2) and written as

[TABLE]

Since every $(n-k)\times(n-k)$ submatrix of $H_{n,k}(D)$ is a Vandermonde matrix evaluated at distinct powers of the indeterminate $D$, its determinant will be a non-zero polynomial in $D$ and hence invertible over $\mathbb{R}((x))$. Thus, $\underline{C}(D)$ can be recovered even if any $n-k$ columns are lost.

The key idea underlying our work is that distributed matrix vector multiplication can be embedded into the class of $CP(n,k)$ codes, where a given column $i$ represents (upon appropriate interpretation) the computation assigned to worker node $W_{i}$, which sequentially processes its assigned jobs from top to bottom. The result $\mathbf{A}\mathbf{x}$ can be recovered even if any $n-k$ worker nodes fail. Crucially, $\mathbf{A}\mathbf{x}$ can be decoded using a peeling decoder. This significantly reduces the overall computation load at the master node and provides for a scheme that enjoys excellent numerical stability.

Example 1**.**

Let $\mathbf{A}$ be a large matrix that is split into eight block-rows, $\mathbf{A}_{0},\mathbf{A}_{1},\dots,\mathbf{A}_{7}$. Fig. 1 shows an example where the distributed computation of $\mathbf{A}\mathbf{x}$ is embedded into a $CP(4,2)$ code. Each cell in the figure shows the responsibility assigned to the corresponding worker node (from top to bottom). It can be observed that the geometric condition in (1) is satisfied by the cell contents and that $\mathbf{A}\mathbf{x}$ can be recovered even if any two of the worker nodes fail. Furthermore, this can be achieved by a peeling decoder with only addition/subtraction operations.

III Embedding Matrix-Vector Multiplication into a $CP(n,k)$ code

In this section, we outline the details of our proposed scheme. Towards this end, we first derive the corresponding generator matrix for the $CP(n,k)$ code and show that it can be expressed in feed-forward form. And then we discuss how the distributed computation of $\mathbf{A}\mathbf{x}$ can be mapped onto a system with $n$ worker nodes using the $CP(n,k)$ code.

Let $s=n-k$ and $\mathbf{Y}_{a,b}$ be a $a\times b$ matrix such that

[TABLE]

and $\Psi_{w}$ be a $w\times w$ diagonal matrix such that

[TABLE]

Thus, we have

[TABLE]

Let the systematic generator matrix be

[TABLE]

where $\mathbf{I}_{k}$ is the $k\times k$ identity matrix. Now satisfying $\mathbf{G}_{n,k}(D)\;\mathbf{H}_{n,k}^{T}(D)=\textbf{0}$, we obtain

[TABLE]

We can express $\mathbf{W}_{k,s}=\mathbf{Y}_{k,s}\;\Psi_{s}^{s}$ as

[TABLE]

Suppose that $\{y_{\ell j}\}$ are the elements of $\mathbf{Y}_{s,s}^{-1}$ and we define $s$ different polynomials in the indeterminate $\sigma$ as

[TABLE]

for $0\leq j\leq s$. Since $\mathbf{Y}_{s,s}\mathbf{Y}_{s,s}^{-1}=\textbf{I}$, we can write for any $j$,

[TABLE]

which indicates that any $D^{\ell}$ will be a root of the polynomial $y_{j}(\sigma)$ if $\ell\neq j$. On the other hand, $y_{j}(D^{j})=1$ so that

[TABLE]

Now taking the product $\mathbf{W}_{k,s}\;\mathbf{Y}_{s,s}^{-1}$ involves evaluating these polynomials at $D^{s+i}$ where $i=0,\dots,k-1$, and thus we get

[TABLE]

It is unclear whether the above expression leads to a recursive or a non-recursive $\mathbf{G}_{n,k}$. The following theorem shows that $Z_{ij}$ can be simplified to express it as a polynomial, i.e., $\mathbf{G}_{n,k}$ can be put in feed-forward form.

Theorem 1**.**

Any term $Z_{ij}$, with $0\leq i<k$ and $0\leq j<s$, can be written as a finite polynomial in $D$ with integer coefficients. When $s=2$, the coefficients of $Z_{ij}\in\{-1,0,1\}$ and when $s=3$ the coefficients of $Z_{ij}$ have absolute value at most $k$.

Proof.

From (4), we can write

[TABLE]

which can be written as $Z_{ij}=-\;A_{ij}B_{ij}$. Here

[TABLE]

where $x_{ij}=s+i-j$, $y_{ij}=s-j-1$, $e_{ij}=s-j-1$ and $f_{ij}\geq 0$ as $j<s$. Now consider a term $W$ such that

[TABLE]

A polynomial of the form $D^{q}-1$ can be written as a product of some cyclotomic polynomials [8], as

[TABLE]

where $\Phi_{d}(D)$ is the $d^{th}$ cyclotomic polynomial. Thus, we can expand the denominator of $W$ as

[TABLE]

where $i_{j}=\lfloor y/j\rfloor$ for $j=1,2,\dots,y$. The numerator of $W$ is a product of $y$ different polynomials, and the maximum exponent of $D$ in those $y$ polynomials are consecutive $y$ numbers. This indicates that we must have $\prod\limits_{v=1}^{y}\left[\Phi_{v}(D)\right]^{i_{v}}$ as a factor of the numerator. But the numerator is, in fact, a product of different cyclotomic polynomials, according to its definition. Thus, after the cancellation by the denominator and expansion, all the exponents and corresponding coefficients of $D$ in $W$ would be integers. It indicates that the terms $A_{ij}$ and $B_{ij}$ are also finite polynomials of $D$ with integer coefficients, and thus the first part of the proof is complete. The proof regarding the corresponding coefficients of the assigned submatrix-vector block products is given in Appendix A. ∎

Example 2**.**

When $n=4,k=2$, we can obtain $\mathbf{G}_{4,2}(D)$ as

[TABLE]

where we note that all coefficients of the polynomials in $\mathbf{G}_{4,2}(D)$ belong to the set $\{-1,0,1\}$.

Next, we discuss the usage of $\mathbf{G}_{n,k}$ in a distributed matrix-vector multiplication context. First we partition $\mathbf{A}$ row-wise into $\Delta$ (we assume that $k$ divides $\Delta$) equal sized block-rows. These are denoted $\mathbf{A}_{0},\mathbf{A}_{1},\mathbf{A}_{2},\dots,\mathbf{A}_{\Delta-1}$. Let $u_{j}=\mathbf{A}_{j}\mathbf{x}$ where $(0\leq j\leq\Delta-1)$. The next step is to form $k$ different polynomials with coefficients from the $u_{j}$’s. These are given by

[TABLE]

for $0\leq i\leq k-1$ where $q=\frac{\Delta}{k}$. Now the submatrices assigned to all the workers are determined by

[TABLE]

Suppose that each worker node can store at most the equivalent of $\gamma$ fraction of the rows of $\mathbf{A}$. Thus, if we assign $\ell_{j}$ jobs to worker $W_{j}$, then it needs to satisfy $\frac{\ell_{i}}{\Delta}\leq\gamma$. The number of jobs assigned to worker node $W_{i}$, $(0\leq i\leq n-1)$, depends on the entries of the corresponding column of $\mathbf{G}_{n,k}(D)$. Let $d_{i}$ denote the difference between the maximum and the minimum exponent of $D$ in the $i$-th column of $\mathbf{G}_{n,k}(D)$, and let $\lambda=\underset{i}{\text{max}}\;d_{i}$. Then, for satisfying the storage constraint we require

[TABLE]

Example 3**.**

We consider the same scenario as mentioned in Example 2 with $n=4$ workers, and we need to develop a scheme that is resilient to $s=2$ stragglers, so $k=n-s=2$. If $\gamma=\frac{3}{4}$, then we can set $\Delta=\frac{2}{\frac{3}{4}-\frac{1}{2}}=8$, as it is divisible $k$. The relevant polynomials are

[TABLE]

Forming $U(D)=\begin{bmatrix}\overset{\sim}{u_{0}}(D)&\overset{\sim}{u_{1}}(D)\end{bmatrix}\mathbf{G}_{4,2}(D)$, we obtain the scheme shown in Fig. 1.

Remark 1**.**

The above procedure demonstrates the importance of a feed-forward $\mathbf{G}_{n,k}$. Indeed, if $\mathbf{G}_{n,k}$ had been recursive, the number of terms in the output would have been infinite.

IV Decoding of a $CP(n,k)$-scheme

A major advantage of our proposed scheme is a low-complexity decoding procedure. Note that our scheme is in one-to-one correspondence with the $CP(n,k)$ code. Hence, we describe the decoding procedure for the $CP(n,k)$ code; the adaptation to recovering $\mathbf{A}\mathbf{x}$ follows naturally.

Recall that the symbols are denoted by $c_{i,j}$ where $0\leq i\leq\ell_{j}-1$ and $0\leq j\leq n-1$. Let the indices of the straggler nodes be $0\leq t_{0}<t_{1}<t_{2}<\dots<t_{s-1}\leq n-1$.

At each step, our decoding process in Algorithm 1 exploits the geometric constraints in (1) to identify an equation where there is one unknown; it continues in a systematic fashion until all the unknowns are decoded. In the sequel, we refer to this as decoding in a peeling decoder fashion. For instance, to start decoding symbols from straggler $t_{0}$, we can use (1) and obtain the constraint for the line with slope $s-1$ as

[TABLE]

which can pass through a symbol $c_{\alpha,t_{0}}$ in straggler $t_{0}$. So we have the constraint as

[TABLE]

In (7), if $j<t_{0}$, we assumed that these symbols are known. Now if $j>t_{0}$, the elements $c_{\alpha,j}$’s are also known until a constraint line passes through $c_{0,t_{1}}$ with the increase of $j$. Thus, in the extreme case, the line can pass through $c_{-1,t_{1}}$, so we can set $j=t_{1}$ and

[TABLE]

Thus if $0\leq\alpha\leq(s-1)(t_{1}-t_{0})-1$, we can say that the only unknown in (7) is $c_{\alpha,t_{0}}$. In this manner, we can obtain the first $(s-1)(t_{1}-t_{0})$ symbols of straggler $t_{0}$ in a peeling decoding fashion.

To better understand the behavior of the algorithm, we divide it into phases. We say that the algorithm has finished phase $p$, where $0\leq p\leq s-2$, if it has only recovered as many symbols as possible in a peeling decoding fashion from the stragglers $t_{i}$, $i\leq p$, without recovering any symbol from stragglers $t_{j}$, $j>p$. Let us denote $\eta_{p,y}$ as the number of recovered symbols in a peeling decoding fashion from straggler $t_{y}$ after finishing phase $p$.

Lemma 1**.**

[TABLE]

for $p<s-1$.

Proof.

We are going to prove this by induction.

Base case: After finishing the phase $p=0$, we recover as many symbols as possible from straggler $t_{0}$. Thus we have proved earlier in this Section that

[TABLE]

Inductive step: Now we assume that after finishing phase $p$, the number of recovered symbols by the stragglers can be represented by

[TABLE]

where $0\leq p<s-2$. Then after finishing phase $p+1$, to recover symbols from the straggler $t_{p+1}$, we obtain the constraint for the line with slope $(s-p-2)$ as

[TABLE]

which can pass through $c_{0,t_{p+1}}$. So we obtain

[TABLE]

For $j<t_{p+1}$, if the line passes through the straggler $t_{q}$ where $0\leq q\leq p$, it will pass through the points $c_{(s-p-2)(t_{p+1}-t_{q}),t_{q}}$, but from the hypothesis we assumed $\eta_{p,q}$ symbols are known from worker $t_{q}$ after phase $p$, and

[TABLE]

which indicates that all necessary symbols of the stragglers are already known. And, if $j>t_{p+1}$, then the row index is negative which means that those corresponding elements are zero. So, we can recover $c_{0,t_{p+1}}$ in a peeling decoding fashion.

Now, we move to straggler $t_{p}$ and want to recover one more symbol, where already we recovered $\eta_{p,p}$ symbols. So, we can find the constraint line with slope $(s-p-1)$,

[TABLE]

and to recover one additional symbol from straggler $t_{p}$, this line needs to pass through $c_{(s-p-1)(t_{p+1}-t_{p}),t_{p}}$, so we obtain

[TABLE]

In this equation, the terms with $j>t_{p+1}$ are actually zero, and the term with $j=t_{p+1}$ is $c_{0,t_{p+1}}$ which is decoded before. Now if $j=t_{q}<t_{p}$, the values are already known after finishing phase $p$ because

[TABLE]

So we can obtain $c_{\eta_{p,p},t_{p}}$ in a peeling decoding fashion.

Thus we need previously decoded $c_{0,t_{p+1}}$ to decode $c_{\eta_{p,p},t_{p}}$. Now in a similar way, we can decode all $c_{\eta_{p,q},t_{q}}$, where $q<p$, each of which would need the previously decoded $c_{\eta_{p,q+1},t_{q+1}}$. It should be noted that we do not need any symbols from straggler $t_{i}$ to decode $c_{0,t_{p+1}}$, where $i>p+1$. Thus we do not need them to decode $c_{\eta_{p,q},t_{q}}$ too, $(q\leq p+1)$, because of the constraint lines with increasing slopes. This argument is sketched in Appendix B.

Now we repeat the whole process until we require any symbol from straggler $t_{p+2}$ to decode a symbol from the straggler $t_{p+1}$. We assume that we can recover maximum $\nu$ symbols from $t_{p+1}$ without decoding any symbol from the straggler $t_{q}$, $q>p+1$. So, the constraint line in (9) passes through $c_{\nu,t_{p+1}}$ and $c_{-1,t_{p+2}}$, and then, we can write

[TABLE]

which leads to $\nu=(s-p-2)(t_{p+2}-t_{p+1})-1$. So we can recover $(s-p-2)(t_{p+2}-t_{p+1})$ symbols from each of the stragglers, $t_{0},t_{1},\dots,t_{p+1}$. So, we can say

[TABLE]

which proves the inductive step. ∎

Theorem 2**.**

The decoding procedure in Algorithm 1 allows the recovery of all $c_{i,j}$ where $0\leq i\leq\ell_{j}-1$ and $0\leq j\leq n-1$ in a peeling decoding fashion, as long as there are at most $s$ node failures.

Proof.

From Lemma 1, we have proved that we can decode $\eta_{s-2,q}$ elements from a straggler $t_{q}$ after finishing phase $s-2$, for $q<s-1$. Now if we apply the constraint line with slope zero, then we can recover $\eta_{s-2,s-2}=(t_{s-1}-t_{s-2})$ elements from straggler $t_{s-1}$, and similar to the proof of inductive step, applying the other slopes we can recover additional $(t_{s-1}-t_{s-2})$ elements from other stragglers, until all the symbols from a straggler are recovered. If we just continue this process, we can recover all symbols from all the workers in a peeling decoding fashion. ∎

Example 4**.**

In this example, we demonstrate how we can recover $\mathbf{A}\mathbf{x}$ in a peeling decoding fashion for the same scenario in Fig. 1. In this example, we have four workers, $W_{0},W_{1},W_{2}$ and $W_{3}$, among which we assume that $W_{2}$ and $W_{3}$ are stragglers. According to Algorithm 1, we utilize the slope $1$ constraint lines to recover the block products of $W_{2}$ and slope [math] constraint lines to recover the block products of $W_{3}$. For example, if we utilize the slope $1$ constraint line through the blue dotted blocks in Fig. 1, then we can recover the first block of of $W_{2}$, which is $\mathbf{A}_{0}\mathbf{x}$. Similarly, if we utilize the slope [math] constraint line through the red dotted blocks, then we can also recover the first block of $W_{3}$, which is $\mathbf{A}_{4}\mathbf{x}$. Using this same fashion, we can decode all the submatrix-vector block products from workers $W_{2}$ and $W_{3}$, which completes the job.

V Numerical Results

We consider a scenario where $\mathbf{A}$ has dimension $8,000\times 10,000$ and $\mathbf{x}$ is of length $10,000$. Suppose that we have $n=7$ workers, $\gamma=\frac{3}{10}$ (storage fraction). We require the system to be resilient to $s=3$ stragglers.

For the RS based approach we can partition $\mathbf{A}$ in $\Delta=10$ parts, and assign three submatrix-vector products to each worker. The evaluation points for the RS code are chosen as real numbers equally spaced in $[-1,1]$; this is a better choice than integers [9]. On the other hand, we can embed this problem into a $CP(7,4)$ using our proposed approach. The value of $\lambda$ (cf. Section III) in this case is $8$ and $\Delta=\frac{\lambda}{\gamma-\frac{1}{k}}=\frac{8}{\frac{3}{10}-\frac{1}{4}}=160$. The assignment of jobs to each worker node can be determined by the procedure in Section III

In order to test the numerical stability of recovery at the master node, we add white Gaussian noise to each submatrix-vector product computed by the workers. Fig. 2 presents a comparison of the RS based approach and our proposed approach. The error percentage values at the output are shown for different noise levels. If the correct output is $y$ and the recovered output by the master is $\hat{y}$, then the error percentage is measured as $\frac{||y-\hat{y}||}{||y||}\times 100\%$. We can see that the error percentage for our proposed method is nearly zero, whereas the RS based method has around $5\%$ error even at an SNR = $70$ dB. This is due to the high condition number of the associated real Vandermonde matrix of the RS based method.

Next, we compare the computation times of the two schemes when the matrix $\mathbf{A}$ is sparse. Consider a system with $n=5$ workers with $\gamma=\frac{3}{5}$. We choose $\mathbf{A}$ (of dimension $12,000\times 12,000$) to be of limited bandwidth [10], i.e., it has non-zero values only in the $\beta$- diagonals (diagonals from top-left to bottom-right) and $\beta=-b,-b+1,\dots,-1,0,1,\dots,b-1,b$, where $b<12,000$. Thus the sparsity of the matrix decreases if $b$ increases.

In the RS based approach, we choose $\Delta=5$ and assign $3$ jobs to each of the workers. For our scheme we embed the computation into a $CP(5,2)$ code. The parameter $\lambda=4$, and $\Delta=\frac{\lambda}{\gamma-\frac{1}{k}}=40$. Note that both of the schemes are resilient to three stragglers.

Fig. 3 shows the maximum time needed by any worker for different approaches at different sparsity levels. It is evident that the workers take significantly less amount of time in the proposed method in comparison to the RS based approach. This is attributed to the fact that the sparsity level in the coded jobs can be preserved more in our proposed scheme than RS approach. For example, in our experiment, when matrix $\mathbf{A}$ has $90\%$ sparsity, the submatrices assigned to any worker in RS coding approach has around $51\%$ sparsity, whereas in our proposed scheme, even in the worst case, a parity worker can enjoy, on average $70\%$ sparsity. It should be noted that the message workers take further less time since they preserve the same level of sparsity as matrix $\mathbf{A}$.

VI Conclusion

In this paper, we present an approach for embedding distributed matrix-vector multiplication into the class of cross-parity check convolutional codes towards the goal of straggler mitigation. Our proposed scheme has significant advantages over RS based approaches. The recovery of the intended product is performed using a low-complexity peeling decoder in our scheme as compared to polynomial interpolation in RS based approaches. Unlike RS based approaches which suffer from ill-conditioned recovery matrices, our recovery is numerically quite stable. Finally, for the case of sparse $\mathbf{A}$ matrices, our scheme requires much sparser combinations of the block-rows of $\mathbf{A}$, leading to faster computation at the worker nodes. Numerical examples have confirmed these results.

Appendix A

Now we are going to discuss about the coefficients in the $CP(n,k)$ schemes for $s=2$ or $3$.

Case $s=2$: In this case, from (4) we can write

[TABLE]

If $j=0$, then we get

[TABLE]

And if $j=1$, then we get

[TABLE]

So, we can say the coefficients are [math] or $\pm 1$.

Case $s=3$: In this case, from (4) we can write

[TABLE]

If $j=0$, then we can write

[TABLE]

Here, we can have two different cases. If $i$ is even, then

[TABLE]

On the other hand, if $i$ is odd, then

[TABLE]

Thus after multiplication, in terms of absolute value, the highest coefficient would be \Bigl{\lfloor}\dfrac{i}{2}\Bigr{\rfloor}+1 in both cases. It will also be maximum when $i$ is maximum, $k-1$, and that coefficient would \Bigl{\lfloor}\dfrac{k-1}{2}\Bigr{\rfloor}+1. Next, if $j=1$, then we can write

[TABLE]

which leads to

[TABLE]

Thus after multiplication, the maximum coefficient would be $i+1$, and so, the maximum coefficient is $k$. Finally, if $j=2$, then we can write

[TABLE]

Here, we can have two different cases again. If $i$ is even, then

[TABLE]

On the other hand, if $i$ is odd, then

[TABLE]

Thus after multiplication, in terms of absolute value, the highest coefficient would be \Bigl{\lfloor}\dfrac{i+1}{2}\Bigr{\rfloor}+1 in both cases. It will also be maximum when $i$ is maximum, $k-1$, and that coefficient would \Bigl{\lfloor}\dfrac{k}{2}\Bigr{\rfloor}+1. Thus the result follows.

Appendix B

Lemma 2**.**

We assume two stragglers having index $t_{u}$ and $t_{v}$, where $u<v$. We assume that two constraint lines with slopes $(s-1-u)$ and $(s-1-w)$ pass through the same point $c_{\alpha,t_{u}}$, where $w<u$. But, these two lines will pass through two different points, $c_{\beta,t_{v}}$ and $c_{\gamma,t_{v}}$ in worker $t_{v}$, since the slopes are not equal. Then it can be shown that

[TABLE]

Proof.

We can find the equation for the constraint line with slope $(s-1-u)$ from (1) as

[TABLE]

which passes through $c_{\alpha,t_{u}}$ and $c_{\beta,t_{v}}$, so we get

[TABLE]

And the constraint line with slope $(s-1-w)$ is given by

[TABLE]

which passes through $c_{\alpha,t_{u}}$ and $c_{\gamma,t_{v}}$, so we get

[TABLE]

which leads to

[TABLE]

∎

From this lemma, we can say, if we have different constraint lines with different slopes passing through a particular point $\alpha$, in a straggler $t_{u}$, then the constraint line with a larger slope will pass through a prior point of a straggler $t_{v}$, if $u<v$, and vice versa.

We can see an example with five stragglers in Fig. 4, where the green and red blocks indicate that they are decoded and undecoded, respectively. The slopes of the constraint lines are higher for decoding the straggler $t_{0}$ than for $t_{1}$. We assume that two different constraint lines from these two workers (blue for $t_{0}$ and red for $t_{1}$) intersect at a point in $t_{1}$. Then from the lemma we can say, the blue line will always intersect with the next stragglers prior to the red line does. And in a similar way, we can say that because of the larger slope, the red line will intersect with $t_{3}$ or $t_{4}$ before the black line; since these two lines have already intersected at a point in straggler $t_{2}$.