Block-Diagonal and LT Codes for Distributed Computing With Straggling Servers

I Introduction

Distributed computing systems have emerged as one of the most effective ways of solving increasingly complex computational problems, such as those in large-scale machine learning and data analytics . These systems, referred to as “warehouse-scale computers” (WSCs) , may be composed of thousands of relatively homogeneous hardware and software components. Achieving high availability and efficiency for applications running on WSCs is a major challenge. One of the main reasons is the large number of components that may experience transient or permanent failures . As a result, several distributed computing frameworks have been proposed . In particular, MapReduce has gained significant attention as a means of effectively utilizing large computing clusters. For example, Google routinely performs computations over several thousands of servers using MapReduce . Among the challenges brought on by distributed computing systems, the problems of straggling servers and bandwidth scarcity have recently received significant attention. The straggler problem is a synchronization problem characterized by the fact that a distributed computing task must wait for the slowest server to complete its computation, which may cause large delays . On the other hand, distributed computing tasks typically require that data is moved between servers during the computation, the so-called data shuffling, which is a challenge in bandwidth-constrained networks.

Coding for distributed computing to reduce the computational delay and the communication load between servers has recently been considered in . In , a structure of repeated computation tasks across servers was proposed, enabling coded multicast opportunities that significantly reduce the required bandwidth to shuffle the results. In , the authors showed that maximum distance separable (MDS) codes can be applied to a linear computation task (e.g., multiplying a vector with a matrix) to alleviate the effects of straggling servers and reduce the computational delay. In , a unified coding framework was presented and a fundamental tradeoff between computational delay and communication load was identified. The ideas of can be seen as particular instances of the framework in , corresponding to the minimization of the communication load and the computational delay, respectively. The code proposed in is an MDS code of code length proportional to the number of rows of the matrix to be multiplied, which may be very large in practice. For example, Google performs matrix-vector multiplications with matrices of dimension of the order of $10^{10}\times 10^{10}$ when ranking the importance of websites . In , the computational delay incurred by the encoding and decoding is not considered. However, the encoding and decoding may incur a high computational delay for large matrices.

Coding has previously been applied to several related problems in distributed computing. For example, the scheme in has been extended to distributed matrix-matrix multiplication where both matrices are too large to be stored at one server . Whereas the schemes in are based on MDS codes, the scheme in is based on a novel coding scheme that exploits the algebraic properties of matrix-matrix multiplication over a finite field to reduce the computational delay. In , it was shown that introducing sparsity in a structured manner during encoding can speed up computing dot products between long vectors. Distributed computing over heterogeneous clusters has been considered in .

In this paper, we propose two coding schemes for the problem of multiplying a matrix by a set of vectors. The first is a block-diagonal coding (BDC) scheme equivalent to partitioning the matrix and applying smaller MDS codes to each submatrix separately (we originally introduced the BDC scheme in ). The storage design for the BDC scheme can be cast as an integer optimization problem, whose computation scales exponentially with the problem size. We propose a heuristic solver for efficiently solving the optimization problem, and a branch-and-bound approach for improving on the resulting solution iteratively. Furthermore, we prove that up to a certain level of partitioning the BDC scheme has identical computational delay (as defined in ) and communication load to those of the scheme in . Interestingly, when the delay incurred by encoding and decoding is taken into account, the proposed scheme achieves an overall computational delay significantly lower than that of the scheme in . We further propose a second coding scheme based on Luby Transform (LT) codes under inactivation decoding , which in some scenarios achieves a lower computational delay than that of the BDC scheme at the expense of a higher communication load. We show that for the LT code-based scheme it is possible to trade an increase in communication load for a lower computational delay. We finally consider distributed computing under a deadline, where we are interested in completing a computation within some computational delay, and show numerically that both the BDC and the LT code-based schemes significantly increase the probability of meeting a deadline over the scheme in . In particular, the LT code-based scheme achieves the highest probability of meeting a deadline for the scenarios considered.

II System Model and Preliminaries

where we assume that $r$ divides $Km$ and hence $q$ is an integer. The $r$ coded rows of $\bm{C}$, $\bm{c}_{1},\ldots,\bm{c}_{r}$, are divided into $\binom{K}{\eta q}$ disjoint batches, each containing $r/\binom{K}{\eta q}$ coded rows. Each batch is assigned to $\eta q$ servers. Correspondingly, a batch $B$ is labeled by a unique set $\mathcal{T}\subset\{S_{1},\ldots,S_{K}\}$, of size $|\mathcal{T}|=\eta q$, denoting the subset of servers that store that batch. We write $B_{\mathcal{T}}$ to denote the batch stored at the unique set of servers $\mathcal{T}$. Server $S_{k}$, $k=1,\ldots,K$, stores the coded rows of $B_{\mathcal{T}}$ if and only if $S_{k}\in\mathcal{T}$.

We assume that running a computation on a single server takes a random amount of time, which is denoted by the random variable $H$, according to the shifted-exponential cumulative probability distribution function (CDF)

When an algorithm is split into $K$ parallel subtasks that are run across $K$ servers, we denote the runtime of the subtask running on server $S_{k}$ by $H_{k}$. As in , we assume that $H_{1},\ldots,H_{K}$ are independent and identically distributed random variables with CDF $F_{H}(Kh;\sigma)$. For $i=1,\dots,K$, we denote the $i$-th order statistic by $H_{(i)}$, i.e., the $i$-th smallest random variable of $H_{1},\ldots,H_{K}$. The runtime of the $i$-th fastest server to complete its subtask is thus given by $H_{(i)}$, which is a Gamma distributed random variable with expectation and variance given by

We parameterize the Gamma distribution by its inverse scale factor $a$ and its shape parameter $b$. We give these in terms of the distribution mean and variance as

Denote by $F_{H_{(i)}}(h_{(i)};\sigma,K)$ the CDF of $H_{(i)}$. It is given by

where $\Gamma$ denotes the Gamma function and $\gamma$ the lower incomplete Gamma function,

We remark that $F_{H_{(i)}}(h_{(i)};\sigma,K)$ is the probability of a computation finishing prior to some deadline $t=h_{(i)}$.

II-B Distributed Computing Model

We consider the coded computing framework introduced in , which extends the MapReduce framework . The overall computation proceeds in three phases, the map, shuffle, and reduce phases, which are augmented to make use of the coded multicasting strategy proposed in to address the bandwidth scarcity problem and the coded scheme proposed in to alleviate the straggler problem. Furthermore, we consider the delay incurred by the encoding of $\bm{A}$ that takes place before the start of the map phase. We refer to this as the encoding phase. Also, we assume that the matrices $\bm{A}$ and $\bm{\Psi}$ as well as the input vectors $\bm{x}_{1},\ldots,\bm{x}_{N}$ are known to all servers at the start of the computation. The overall computation proceeds in the following manner.

In the encoding phase, the coded matrix $\bm{C}$ is computed from $\bm{A}$ and $\bm{\Psi}$ in a distributed fashion. Specifically, denote by $\mathcal{R}^{(S)}$ the set of indices of rows of $\bm{C}$ that are assigned to server $S$ and denote by $\bm{\Psi}^{(S)}$ the matrix consisting of the rows of $\bm{\Psi}$ with indices from $\mathcal{R}^{(S)}$. Then, server $S$ computes the coded rows it needs by multiplying $\bm{\Psi}^{(S)}$ by $\bm{A}$. Note that since we assign each coded row to $\eta q$ servers, each row of $\bm{C}$ is computed separately by $\eta q$ servers. We define the computational delay of the encoding phase as its average runtime per source row and vector $\bm{y}$, i.e.,

where $\sigma_{\mathsf{encode}}$ is the complexity of the encoding. During the encoding process, the rows of $\bm{\Psi}$ are multiplied by the columns of $\bm{A}$. Therefore, the complexity scales with the product of the number of nonzero elements of $\bm{\Psi}$ and the number of columns of $\bm{A}$. Specifically,

Alternatively, we compute $\bm{C}$ by performing a decoding operation on $\bm{A}$. In this case $\sigma_{\mathsf{encode}}$ is the decoding complexity (see Section IV-B). Furthermore, since the decoding algorithms are designed to decode the entire codeword, each server has to compute all rows of $\bm{C}$. Using this strategy the encoding delay is

For each case we choose the strategy that minimizes the delay.

II-B2 Map Phase

In the map phase, we compute in a distributed fashion coded intermediate values, which will be later used to obtain vectors $\bm{y}_{1},\ldots,\bm{y}_{N}$. Server $S$ multiplies the input vectors $\bm{x}_{j}$, $j=1,\ldots,N$, by all the coded rows of matrix $\bm{C}$ it stores, i.e., it computes

The map phase terminates when a set of servers $\mathcal{G}\subseteq\{S_{1},\ldots,S_{K}\}$ that collectively store enough values to decode the output vectors have finished their map computations. We denote the cardinality of $\mathcal{G}$ by $g$. The $(r,m)$ linear code proposed in is an MDS code for which $\bm{y}_{1},\ldots,\bm{y}_{N}$ can be obtained from any subset of $q$ servers, i.e., $g=q$. We illustrate the completion of subtasks in Fig. 1.

We define the computational delay of the map phase as its average runtime per source row and vector $\bm{y}$, i.e.,

where $\sigma_{\mathsf{map}}=K\eta mN\left((n-1)\sigma_{\mathsf{A}}+n\sigma_{\mathsf{M}}\right)$, as all $K$ servers compute $\eta m$ inner products, each requiring $n-1$ additions and $n$ multiplications, for each of the $N$ input vectors. In , $D_{\mathsf{map}}$ is referred to simply as the computational delay.

After the map phase, the computation of $\bm{y}_{1},\ldots,\bm{y}_{N}$ proceeds using only the servers in $\mathcal{G}$. We denote by $\mathcal{Q}\subseteq\mathcal{G}$ the set of the first $q$ servers to complete the map phase. Each of the $q$ servers in $\mathcal{Q}$ is responsible to compute $N/q$ of the vectors $\bm{y}_{1},\ldots,\bm{y}_{N}$. Let $\mathcal{W}_{S}$ be the set containing the indices of the vectors $\bm{y}_{1},\ldots,\bm{y}_{N}$ that server $S\in\mathcal{Q}$ is responsible for. The remaining servers in $\mathcal{G}$ assist the servers in $\mathcal{Q}$ in the shuffle phase.

II-B3 Shuffle Phase

In the shuffle phase, intermediate values calculated in the map phase are exchanged between servers in $\mathcal{G}$ until all servers in $\mathcal{Q}$ hold enough values to compute the vectors they are responsible for. As in , we allow creating and multicasting coded messages that are simultaneously useful for multiple servers. Furthermore, as in , we denote by $\phi(j)$ the ratio between the communication load of unicasting the same message to each of $j$ recipients and multicasting that message to $j$ recipients. For example, if the communication load of multicasting a message to $j$ recipients and unicasting a message to a single recipient is the same, we have $\phi(j)=j$. On the other hand, if the communication load of multicasting a message to $j$ recipients is equal to that of unicasting that same message to each recipient, $\phi(j)=1$. The total communication load of a multicast message is then given by $\frac{j}{\phi(j)}$. The shuffle phase proceeds in three steps as follows.

Coded messages composed of several intermediate values are multicasted among the servers in $\mathcal{Q}$.

Intermediate values are unicasted among the servers in $\mathcal{Q}$.

Any intermediate values still missing from servers in $\mathcal{Q}$ are unicasted from the remaining servers in $\mathcal{G}$, i.e., from the servers in $\mathcal{G}\setminus\mathcal{Q}$.

For a subset of servers $\mathcal{S}\subset\mathcal{Q}$ and $S\in\mathcal{Q}\setminus\mathcal{S}$, we denote the set of intermediate values needed by server $S$ and known exclusively by the servers in $\mathcal{S}$ by $\mathcal{V}_{\mathcal{S}}^{(S)}$. More formally,

We transmit coded multicasts only between the servers in $\mathcal{Q}$, and each coded message is simultaneously sent to multiple servers. We denote by

the smallest number of recipients of a coded message . We remark that $m\alpha_{j}$ is the total number of coded values delivered to each server via the coded multicast messages with exactly $j$ recipients. More specifically, for each $j\in\{\eta q,\eta q-1,\ldots,s_{q}\}$, and every subset $\mathcal{S}\subseteq\mathcal{Q}$ of size $j+1$, the shuffle phase proceeds as follows.

The communication load, denoted by $L$, is the number of unicasts and multicasts (weighted by their cost relative to a unicast) per source row and vector $\bm{y}$ exchanged during the shuffle phase. Specifically, each unicasted message increases $L$ by $\frac{1}{mN}$, and each message multicasted to $j$ recipients increases $L$ by $\frac{j}{mN\phi(j)}$.

The communication load after completing the shuffle phase is given in . If the shuffle phase finishes by unicasting the remaining needed values (strategy $1$), the communication load after completing the multicast phase is

If instead steps $1)$ and $2)$ are repeated for $j=s_{q}-1$ (strategy $2$), the communication load is

For the scheme in , the total communication load is

where $1-\eta-\sum_{j=s_{q}}^{\eta q}\alpha_{j}$ is the communication load due to unicasting the remaining needed values.

II-B4 Reduce Phase

Finally, in the reduce phase, the vectors $\bm{y}_{1},\ldots,\bm{y}_{N}$ are computed. More specifically, server $S\in\mathcal{Q}$ uses the locally computed sets $\mathcal{Z}_{1}^{(S)},\ldots,\mathcal{Z}_{N}^{(S)}$ and the received messages to compute the vectors $\bm{y}_{j}$, $\forall j\in\mathcal{W}_{S}$. The computational delay of the reduce phase is its average runtime per source row and output vector $\bm{y}$, i.e.,

where $\sigma_{\mathsf{reduce}}$ is the computational complexity (see Section II-A) of the reduce phase.

The overall computational delay, $D$, is the sum of the encoding, map, and reduce phase delays, i.e., $D=D_{\mathsf{encode}}+D_{\mathsf{map}}+D_{\mathsf{reduce}}$.

II-C Previously Proposed Coded Computing Schemes

The uncoded scheme uses no erasure coding and no coded multicasting and has parameters $\eta_{\mathsf{UC}}=\frac{1}{K}$ and $q_{\mathsf{UC}}=K$, implying $\eta_{\mathsf{UC}}q_{\mathsf{UC}}=1$. Furthermore, the encoding matrix $\bm{\Psi}_{\mathsf{UC}}$ is the $m\times m$ identity matrix and the coded matrix is $\bm{C}_{\mathsf{UC}}=\bm{A}$.

The CMR scheme uses only coded multicasting, i.e., $\bm{C}_{\mathsf{CMR}}=\bm{A}$ and $q_{\mathsf{CMR}}=K$. Furthermore, the fraction of rows stored at each server is $\eta_{\mathsf{CMR}}=\frac{\eta q}{K}$. We remark that there is no reduce delay for this scheme, i.e., $D_{\mathsf{reduce}}=0$.

The SC scheme uses an erasure code but no coded multicasting. For the corresponding SC scheme, the code rate is unchanged, i.e., $q_{\mathsf{SC}}=q$, and the fraction of rows stored at each server is $\eta_{\mathsf{SC}}=\frac{1}{q_{\mathsf{SC}}}$. The encoding matrix $\bm{\Psi}_{\mathsf{SC}}$ of the SC scheme is obtained by splitting the rows of $\bm{A}$ into $q_{\rm{SC}}$ equally tall submatrices $\bm{A}_{1},\ldots,\bm{A}_{q_{\mathsf{SC}}}$ and applying a $(K,q_{\mathsf{SC}})$ MDS code to the elements of each submatrix, thereby creating $K$ coded submatrices $\bm{C}_{1},\ldots,\bm{C}_{K}$. The coded matrix $\bm{C}_{\mathsf{SC}}$ is the concatenation of $\bm{C}_{1},\ldots,\bm{C}_{K}$, i.e.,

The unified scheme uses both an erasure code and coded multicasting and has parameters $\eta_{\mathsf{unified}}=\eta$ and $q_{\mathsf{unified}}=q$. Furthermore, the encoding matrix of the unified scheme, $\bm{\Psi}_{\mathsf{unified}}$, is an $(r,m)$ MDS code encoding matrix.

III Block-Diagonal Coding

In this section, we introduce a BDC scheme for the problem of multiplying a matrix by a set of vectors. For large matrices, the encoding and decoding complexity of the proposed scheme is significantly lower than that of the scheme in , leading to a lower overall computational delay, as will be shown in Section VII. Specifically, the scheme is based on a block-diagonal encoding matrix of the form

where $\bm{\psi}_{1},\ldots,\bm{\psi}_{T}$ are $\frac{r}{T}\times\frac{m}{T}$ encoding matrices of an $(\frac{r}{T},\frac{m}{T})$ MDS code, for some integer $T$ that divides $m$ and $r$. Note that the encoding given by $\bm{\Psi}_{\mathsf{BDC}}$ amounts to partitioning the rows of $\bm{A}$ into $T$ disjoint submatrices $\bm{A}_{1},\ldots,\bm{A}_{T}$ and encoding each submatrix separately. We refer to an encoding $\bm{\Psi}_{\mathsf{BDC}}$ with $T$ disjoint submatrices as a $T$-partitioned scheme, and to the submatrix of $\bm{C}=\bm{\Psi}_{\mathsf{BDC}}\bm{A}$ corresponding to $\bm{\psi}_{i}$ as the $i$-th partition. We remark that all submatrices can be encoded using the same encoding matrix, i.e., $\bm{\psi}_{i}=\bm{\psi}$, $i=1,\ldots,T$, reducing the storage requirements, and encoding/decoding can be performed in parallel if many servers are available. Notably, by keeping the ratio $\frac{m}{T}$ constant, the decoding complexity scales linearly with $m$. We further remark that the case $\bm{\Psi}_{\mathsf{BDC}}=\bm{\psi}$ (i.e., the number of partitions is $T=1$) corresponds to the scheme in , which we will sometimes refer to as the unpartitioned scheme. We illustrate the BDC scheme with $T=3$ partitions in Fig. 2.

For a block-diagonal encoding matrix $\bm{\Psi}_{\mathsf{BDC}}$, we denote by $\bm{c}_{i}^{(t)}$, $t=1,\ldots,T$ and $i=1,\ldots,r/T$, the $i$-th coded row of $\bm{C}$ within partition $t$. For example, $\bm{c}_{1}^{(2)}$ denotes the first coded row of the second partition. As described in Section II, the coded rows are divided into $\binom{K}{\eta q}$ disjoint batches. To formally describe the assignment of coded rows to batches we use a $\binom{K}{\eta q}\times T$ integer matrix $\bm{P}=[p_{i,j}]$, where $p_{i,j}$ is the number of rows from partition $j$ that are stored in batch $i$. In the sequel, $\bm{P}$ will be referred to as the assignment matrix. Note that, due to the MDS property, any set of $m/T$ rows of a partition is sufficient to decode the partition. Thus, without loss of generality, we consider a sequential assignment of rows of a partition into batches. More precisely, when first assigning a row of partition $t$ to a batch, we pick $\bm{c}_{1}^{(t)}$. Next time a row of partition $t$ is assigned to a batch we pick $\bm{c}_{2}^{(t)}$, and so on. In this manner, each coded row is assigned to a unique batch exactly once. The rows of $\bm{P}$ are labeled by the subset of servers the corresponding batch is stored at, and the columns are labeled by their partition indices. For convenience, we refer to the pair $(\bm{\Psi}_{\mathsf{BDC}},\bm{P})$ as the storage design. The assignment matrix $\bm{P}$ must satisfy the following conditions.

The entries of each row of $\bm{P}$ must sum up to the batch size, i.e.,

The entries of each column of $\bm{P}$ must sum up to the number of rows per partition, i.e.,

We clarify the assignment of coded rows to batches and the coded computing scheme in the following example.

For these parameters, there are $r/T=6$ coded rows per partition, of which $m/T=4$ are sufficient for decoding, and $\binom{K}{\eta q}=15$ batches, each containing $r/\binom{K}{\eta q}=2$ coded rows. We construct the storage design shown in Fig. 3 with $\binom{K}{\eta q}\times T=15\times 5$ assignment matrix

where rows are labeled by the subset of servers the batch is stored at, and columns are labeled by the partition index. In this case rows $\bm{c}_{1}^{(1)}$ and $\bm{c}_{2}^{(1)}$ are assigned to batch $1$, $\bm{c}_{3}^{(1)}$ and $\bm{c}_{4}^{(1)}$ are assigned to batch $2$, and so on. For this storage design, any $g=4$ servers collectively store at least $4$ coded rows from each partition. However, some servers store more rows than needed to decode some partitions, suggesting that this storage design is suboptimal.

Assume that $\mathcal{G}=\{S_{1},S_{2},S_{3},S_{4}\}$ is the set of $g=4$ servers that finish their map computations first. Also, assign vector $\bm{y}_{i}$ to server $S_{i}$, $i=1,2,3,4$. We illustrate the coded shuffling scheme for $\mathcal{S}=\{S_{1},S_{2},S_{3}\}$ in Fig. 4. Server $S_{1}$ multicasts $\bm{c}_{1}^{(1)}\bm{x}_{3}\mathop{\oplus}\bm{c}_{3}^{(1)}\bm{x}_{2}$ to $S_{2}$ and $S_{3}$. Since $S_{2}$ and $S_{3}$ can cancel $\bm{c}_{1}^{(1)}\bm{x}_{3}$ and $\bm{c}_{3}^{(1)}\bm{x}_{2}$, respectively, both servers receive one needed intermediate value. Similarly, $S_{2}$ multicasts $\bm{c}_{2}^{(1)}\bm{x}_{3}\mathop{\oplus}\bm{c}_{5}^{(2)}\bm{x}_{1}$, while $S_{3}$ multicasts $\bm{c}_{4}^{(1)}\bm{x}_{2}\mathop{\oplus}\bm{c}_{6}^{(2)}\bm{x}_{1}$. This process is repeated for $\mathcal{S}=\{S_{2},S_{3},S_{4}\}$, $\mathcal{S}=\{S_{1},S_{3},S_{4}\}$, and $\mathcal{S}=\{S_{1},S_{2},S_{4}\}$. After the shuffle phase, we have sent $12$ multicast messages and $30$ unicast messages, resulting in a communication load of $(12+30)/20/4=0.525$, a $50\%$ increase from the load of the unpartitioned scheme ($0.35$, given by (2)). In this case, $S_{1}$ received additional intermediate values from partition $2$, despite already storing enough, further indicating that the assignment in (3) is suboptimal.

IV Performance of the Block-Diagonal Coding

In this section, we analyze the impact of partitioning on the performance. We also prove that we can partition up to the batch size, i.e., $T=r/\binom{K}{\eta q}$, without increasing the communication load and the computational delay of the map phase with respect to the original scheme in .

For the unpartitioned scheme of , $\mathcal{G}=\mathcal{Q}$, and the number of remaining values that need to be unicasted after the multicast phase is constant regardless which subset $\mathcal{Q}$ of servers finish first their map computations. However, for the BDC (partitioned) scheme, both $g$ and the number of remaining unicasts may vary.

For a given assignment matrix $\bm{P}$ and a specific $\mathcal{Q}$, we denote by $U_{\mathcal{Q}}^{(S)}(\bm{P})$ the number of remaining values needed after the multicast phase by server $S\in\mathcal{Q}$, and by

We first explain how $U_{\mathcal{Q}}^{(S)}$ is evaluated. Let $\bm{u}_{\mathcal{Q}}^{(S)}$ be a vector of length $T$, where the $t$-th element is the number of intermediate values from partition $t$ stored by server $S$ at the end of the multicast phase. Furthermore, each row of $\bm{P}$ corresponds to a batch, and coded multicasting is made possible by storing each batch at multiple servers. The intermediate values transmitted during the multicast phase thus correspond to rows of $\bm{P}$. The vector $\bm{u}_{\mathcal{Q}}^{(S)}$ is then computed by adding some set of rows of $\bm{P}$. The indices of the rows to add depend on $\mathcal{Q}$ and $S$ (see Section II-B3).

We denote by $\left(\bm{u}_{\mathcal{Q}}^{(S)}\right)_{t}$ the $t$-th element of the vector $\bm{u}_{\mathcal{Q}}^{(S)}$. The number of values $U_{\mathcal{Q}}^{(S)}$ is given by adding the number of intermediate values still needed for each partition, i.e.,

We consider the same system as in Example 1. We again assume that $\mathcal{G}=\mathcal{Q}=\{S_{1},S_{2},S_{3},S_{4}\}$ is the set of $g=q=4$ servers that finish their map computations first. During the multicast phase server $S_{1}$ receives the intermediate values in $\mathcal{V}_{\mathcal{S}\setminus S_{1}}^{(S_{1})}$ for all sets $\mathcal{S}$ of cardinality $j+1=3$ (see Section II-B3). In this case, we perform coded multicasting within the sets

$\mathcal{S}=\{S_{1},S_{2},S_{3}\}$, $\mathcal{V}_{\mathcal{S}\setminus S_{1}}^{(S_{1})}=\{\bm{c}_{5}^{(2)}\bm{x}_{1},\bm{c}_{6}^{(2)}\bm{x}_{1}\}$,

$\mathcal{S}=\{S_{1},S_{2},S_{4}\}$, $\mathcal{V}_{\mathcal{S}\setminus S_{1}}^{(S_{1})}=\{\bm{c}_{1}^{(3)}\bm{x}_{1},\bm{c}_{2}^{(3)}\bm{x}_{1}\}$,

$\mathcal{S}=\{S_{1},S_{3},S_{4}\}$, $\mathcal{V}_{\mathcal{S}\setminus S_{1}}^{(S_{1})}=\{\bm{c}_{1}^{(4)}\bm{x}_{1},\bm{c}_{2}^{(4)}\bm{x}_{1}\}$.

Note that $\mathcal{V}_{\{S_{2},S_{3}\}}^{(S_{1})}$ contains the intermediate values computed from the coded rows stored in the batch that labels the $6$-th row of the assignment matrix $\bm{P}$. In the same manner, $\mathcal{V}_{\{S_{2},S_{4}\}}^{(S_{1})}$ and $\mathcal{V}_{\{S_{3},S_{4}\}}^{(S_{1})}$ correspond to rows $7$ and $10$ of $\bm{P}$, respectively. Furthermore, prior to the shuffle phase server $S_{1}$ stores the batches corresponding to rows $1$ to $5$ of $\bm{P}$. Thus, $\bm{u}_{\{S_{1},S_{2},S_{3},S_{4}\}}^{(S_{1})}$ is equal to the sum of rows $1,2,3,4,5,6,7$, and $10$ of $\bm{P}$. In this case, $\bm{u}_{\{S_{1},S_{2},S_{3},S_{4}\}}^{(S_{1})}=(6,6,2,2,0)$, and $S_{1}$ needs $8$ more intermediate values, i.e., $U_{\{S_{1},S_{2},S_{3},S_{4}\}}^{(S_{1})}=8$. Computing $\bm{u}_{\mathcal{Q}}^{(S)}$ for arbitrary $\mathcal{Q}$ and $S$ then corresponds to summing the rows of $\bm{P}$ corresponding to batches either stored by server $S$ prior to the shuffle phase or received by $S$ in the multicast phase. The row indices are computed as explained in Section II-B3.

For a given $\bm{\Psi}_{\mathsf{BDC}}$, the assignment of rows into batches can be formulated as an optimization problem, where one would like to minimize $L_{\text{BDC}}(\bm{\Psi}_{\mathsf{BDC}},\bm{P})$ over all assignments $\bm{P}$. More precisely, the optimization problem is

IV-B Computational Delay

We consider the delay incurred by the encoding, map, and reduce phases (see Definition 2). As in , we do not consider the delay incurred by the shuffle phase as the computations it requires are simple in comparison. Note that in only $D_{\mathsf{map}}$ is considered, i.e., $D=D_{\mathsf{map}}$. However, one should not neglect the computational delay incurred by the encoding and reduce phases. Thus, we consider the overall computational delay

The encoding delay $D_{\mathsf{encode}}$ is a function of the number of nonzero elements of $\bm{\Psi}_{\mathsf{BDC}}$. As there are at most $\frac{m}{T}$ nonzero elements in each row of a block-diagonal encoding matrix, for an encoding scheme with $T$ partitions we have

The reduce phase consists of decoding the $N$ output vectors and hence the delay it incurs depends on the underlying code and decoding algorithm. We assume that each partition is encoded using a Reed-Solomon (RS) code and is decoded using either the Berlekamp-Massey (BM) algorithm or the FFT-based algorithm proposed in , whichever yields the lowest complexity. To the best of our knowledge the algorithm proposed in is the lowest complexity algorithm for decoding long RS codes. We measure the decoding complexity by its associated shifted-exponential parameter $\sigma$ (see Section II-A).

The number of field additions and multiplications required to decode an $(r/T,m/T$) RS code using the BM algorithm is $(r/T)\left(\xi(r/T)-1\right)$ and $(r/T)^{2}\xi$, respectively, where $\xi$ is the fraction of erased symbols . With $\xi$ upper bounded by $1-\frac{q}{K}$ (the map phase terminates when a fraction of at least $\frac{q}{K}$ symbols from each partition is available), the complexity of decoding the $T$ partitions for all $N$ output vectors is upper bounded as

On the other hand, the FFT-based algorithm has complexity $\mathcal{O}(r\log r)$ . We estimate the number of additions and multiplications required for a given code length $r$ by fitting a curve of the form $a+br\log_{2}(cr)$, where $(a,b,c)$ are coefficients, to empiric results derived from the authors’ implementation of the algorithm. For additions the resulting parameters are $(2,8.5,0.867)$ and for multiplications they are $(2,1,4)$. The resulting curves diverge negligibly at the measured points. The total decoding complexity for the FFT-based algorithm is

The encoding and decoding complexity of the unified scheme in is given by evaluating (8) and either (9) or (10) (whichever gives the lowest complexity), respectively, for $T=1$. For the BDC scheme, by choosing $T$ close to $r$ we can thus significantly lower the delay of the encoding and reduce phases. On the other hand, the scheme in uses codes of length proportional to the number of servers $K$. The encoding and decoding complexity of the SC scheme in is thus given by evaluating (8) and either (9) or (10) for $T=\frac{m}{q}$.

IV-C Lossless Partitioning

For $T\leq r/\binom{K}{\eta q}$, there exists an assignment matrix $\bm{P}$ such that the communication load and the computational delay of the map phase are equal to those of the unpartitioned scheme.

The computational delay of the map phase is equal to that of the unpartitioned scheme if any $q$ servers hold enough coded rows to decode all partitions. For $T=r/\binom{K}{\eta q}$ we let $\bm{P}$ be a $\binom{K}{\eta q}\times T$ all-ones matrix and show that it has this property by repeating the argument from [9, Sec. IV.B] for each partition. In this case, any set of $q$ servers collectively store $\frac{\eta qm}{T}$ rows from each partition, and since each coded row is stored by at most $\eta q$ servers, any $q$ servers collectively store at least $\frac{\eta qm}{\eta qT}=\frac{m}{T}$ unique coded rows from each partition. The computational delay of the map phase is thus unchanged from the unpartitioned scheme. The communication load is unchanged if $U_{\mathcal{Q}}^{(S)}$ is equal to that of the unpartitioned scheme for all $\mathcal{Q}$ and $S$. The number of values needed $U_{\mathcal{Q}}^{(S)}$ is computed from $\bm{u}_{\mathcal{Q}}^{(S)}$ (see (7)), which is the sum of $l$ rows of $\bm{P}$, for some integer $l$. For the all-ones assignment matrix, because all rows of $\bm{P}$ are identical, we have

which is the number of remaining values for the unpartitioned scheme.

Next, we consider the case where $T<r/\binom{K}{\eta q}$. First, consider the case $T=r/\binom{K}{\eta q}-j$, for some integer $j$, $0\leq j<\frac{r}{2\binom{K}{\eta q}}$. We first set all entries of $\bm{P}$ equal to $1$. At this point, the total number of unique rows of $\bm{C}$ per partition stored by any set of $q$ servers is at least

The number of coded rows per partition that are not yet assigned is given by $r/T$ multiplied by the fraction of partitions removed $\frac{j}{r/\binom{K}{\eta q}}$, i.e.,

We assign these rows to batches such that an equal number of coded rows is assigned to each of the $K$ servers, which is always possible due to the limitations imposed by the system model. Any set of $q$ servers will thus store a fraction $q/K$ of these rows. The total number of unique coded rows per partition stored among any set of $q$ servers is then lower bounded by the sum of (12) weighted by $q/K$ and (11), i.e.,

showing that it is possible to decode all partitions using the coded rows stored over any set of $q$ servers.

The communication load is unchanged with respect to the case where the number of partitions is $r/\binom{K}{\eta q}$ if and only if no server receives rows it does not need in the multicast phase. Due to decreasing the number of partitions from $r/\binom{K}{\eta q}$ to $T=r/\binom{K}{\eta q}-j$, we increase the number of coded rows needed to decode each partition by

Furthermore, reducing the number of partitions increases the number of coded rows per partition stored among any set of $q$ servers (see (12) and the following text) by

Note that the number of additional rows needed to decode each partition (see (13)) is greater than or equal to the number of additional rows stored among the $q$ servers (see (14)). It is thus impossible that too many coded rows are delivered for any partition.

Second, we consider the case $T=\frac{r/\binom{K}{\eta q}-j}{i}$, where $j$ is chosen as for the first case above and where $i$ is a positive integer. Now, we first set all elements of $\bm{P}$ to $i$. At this point the number of unique rows of $\bm{C}$ per partition stored by any set of $q$ servers is given by (11) multiplied by a factor $i$ (since we set each element of $\bm{P}$ to $i$ instead of one). Furthermore, the number of coded rows per partition that are not yet assigned is given by (12). Therefore, by using the same strategy as for $i=1$ and assigning the remaining rows to batches such that an equal number of rows is assigned to each of the $K$ servers, we are guaranteed that the communication load and the computational delay are unchanged also in this case. ∎

V Assignment Solvers

For all solvers, we first label the batches lexiographically and then optimize $L_{\text{BDC}}$ in (6). For example, for $\eta q=2$, we label the first batch by $S_{1},S_{2}$, the second by $S_{1},S_{3}$, and so on. The solvers are available under the Apache 2.0 license . We remark that choosing $\bm{P}$ is similar to the problem of designing the coded matrices stored by each server in .

The heuristic solver is inspired by the assignment matrices created by the branch-and-bound solver for small instances. It creates an assignment matrix $\bm{P}$ in two steps. We first set each entry of $\bm{P}$ to

thus assigning the first $\binom{K}{\eta q}Y$ rows of each partition to batches such that each batch is assigned $YT$ rows. Let $d=r/\binom{K}{\eta q}-YT$ be the number of rows that still need to be assigned to each batch. The $r/T-\binom{K}{\eta q}Y$ rows per partition not assigned yet are assigned in the second step as shown in Algorithm 1.

Interestingly, for $T\leq r/\binom{K}{\eta q}$ the heuristic solver creates an assignment matrix satisfying the requirements outlined in the proof of Theorem 1. In the special case of $T=r/\binom{K}{\eta q}$, the all-ones matrix is produced.

V-B Branch-and-Bound Solver

The branch-and-bound solver finds an optimal solution by recursively branching at each batch for which there is more than one possible assignment and considering all options. The solver is initially given an empty assignment matrix, i.e., an all-zeros $\binom{K}{\eta q}\times T$ matrix. For each branch, we lower bound the value of the objective function of any assignment in that branch and only investigate branches with possibly better assignments. The branch-and-bound operations given below are repeated until there are no more potentially better solutions to consider.

For the first row of $\bm{P}$ with remaining assignments, branch on every available assignment for that row. More precisely, find the smallest index $i$ of a row of the assignment matrix $\bm{P}$ whose entries do not sum up to the batch size, i.e.,

For row $i$, branch on incrementing the element $p_{i,j}$ by $1$ for all columns (with index $j$) such that their entries do not sum up to the number of coded rows per partition, i.e.,

V-B2 Bound

We use a dynamic programming approach to lower bound $L_{\text{BDC}}$ for a subtree. Specifically, for each row $i$ and column $j$ of $\bm{P}$, we store the number of vectors $\bm{u}_{\mathcal{Q}}^{(S)}$ that are indexed by row $i$ and where the $j$-th element satisfies

V-C Hybrid Solver

The branch-and-bound solver can only be used by itself for small instances. However, it can be used to complete a partial assignment matrix, i.e., a matrix $\bm{P}$ for which not all rows have entries that sum up to the batch size. The branch-and-bound solver then completes the assignment optimally. We first find a candidate solution using the heuristic solver and then iteratively improve it using the branch-and-bound solver. In particular, we decrement by $1$ a random set of entries of $\bm{P}$ and then use the branch-and-bound solver to reassign the corresponding rows optimally. We repeat this process until the average improvement between iterations drops below some threshold.

VI Luby Transform Codes

In this section, we consider LT codes for use in distributed computing. Specifically, we consider a distributed computing system where $\bm{\Psi}$ is an LT code encoding matrix, denoted by $\bm{\Psi}_{\mathsf{LT}}$, of fixed rate $\frac{m}{r}$. As explained in Section II, we divide the $r$ coded rows of $\bm{C}=\bm{\Psi}_{\mathsf{LT}}\bm{A}$ into $\binom{K}{\eta q}$ disjoint batches, each of which is stored at a unique subset of size $\eta q$ of the $K$ servers. For this scheme, due to the random nature of LT codes, we can assign coded rows to batches randomly. The distributed computation is carried out as explained in Section II-B, i.e., we wait for the fastest $g\geq q$ servers to complete their respective computations in the map phase, perform coded multicasting during the shuffle phase, and carry out the decoding of the $N$ output vectors in the reduce phase.

We assume that decoding is performed using inactivation decoding . Inactivation decoding is an efficient maximum likelihood decoding algorithm that combines iterative decoding with optimal decoding in a two-step fashion and is widely used in practice. As suggested in , we assume that the optimal decoding phase is performed by Gaussian elimination. In particular, iterative decoding is used until the ripple is empty, i.e., until there are no coded symbols of degree $1$, at which point an input symbol is inactivated. The iterative decoder is then restarted to produce a solution in terms of the inactivated symbol. This procedure is repeated until all input symbols are either decoded or inactivated. Note that the value of some input symbols may be expressed in terms of the values of the inactivated symbols at this point. Finally, optimal decoding of the inactivated symbols is performed via Gaussian elimination, and the decoded values are back-substituted into the decoded input symbols that depend on them. The decoding schedule has a large performance impact. Our implementation follows the recommendations in . It is important to tune the parameters $M$ and $\delta$ to minimize the number of inactivations.

Due to the nature of LT codes, we need to collect $m(1+\epsilon)$ intermediate values for each vector $\bm{y}$ before decoding. We refer to $\epsilon$ as the overhead. Under inactivation decoding, and for a given overhead $\epsilon$, the probability of decoding failure with an overhead of at most $\epsilon$, denoted by $P_{\mathsf{f}}(\epsilon)$, is lower bounded by

Note that $P_{\mathsf{f}}(\epsilon)$ is the CDF for the random variable “decoding is not possible at a given overhead $\epsilon$.” Furthermore, the lower bound (15) well approximates the failure probability for an overhead slightly larger than $\epsilon=0$. Denote by $F_{\mathsf{DS}}(\epsilon)$ the probability of decoding being possible at an overhead of at most $\epsilon$. It follows that

We find the decoding success probability density function (PDF) by numerically differentiating $F_{\mathsf{DS}}(\epsilon)$.

VI-B Code Design

We design LT codes for a minimum overhead $\epsilon_{\mathsf{min}}$, i.e., we collect at least $m(1+\epsilon_{\mathsf{min}})$ coded symbols from the servers before attempting to decode, and a target failure probability $P_{\mathsf{f,target}}=P_{\mathsf{f}}(\epsilon_{\mathsf{min}})$. We remark that increasing $\epsilon_{\mathsf{min}}$ and $P_{\mathsf{f,target}}$ leads to a lower average degree $\bar{\Omega}$, and thus to less complex encoding and decoding and subsequently to a lower computational delay for encoding and decoding. The tradeoff is that the communication load increases as more intermediate values need to be transferred over the network on average. Furthermore, increasing $\epsilon_{\mathsf{min}}$ and $P_{\mathsf{f,target}}$ may increase the average number of servers $g$ required to decode. We thus need to balance the computational delay of the encoding and reduce phases against that of the map phase to achieve a low overall computational delay. Furthermore, waiting for more than $g=q$ servers typically increases the overall computational delay by more than what is saved by the less complex encoding and decoding given by the larger $\epsilon_{\mathsf{min}}$ and $P_{\mathsf{f,target}}$. We thus choose $\epsilon_{\mathsf{min}}$ and $P_{\mathsf{f,target}}$ such that decoding is possible with high probability using the number of coded rows stored at any set of $q$ servers. Note that the overhead $\epsilon$ required for decoding may be larger than $\epsilon_{\mathsf{min}}$. We take this into account by numerically integrating the decoding success PDF multiplied by the performance of the scheme as a function of the overhead $\epsilon$.

For a given $\epsilon_{\mathsf{min}}$ and $P_{\mathsf{f,target}}$, we find a pair $(M,\delta)$ that minimizes the decoding complexity (see Section VI-C) under the constraint that $P_{\mathsf{f}}(\epsilon_{\mathsf{min}})\approx P_{\mathsf{f,target}}$. Essentially, we minimize the computational delay of the reduce phase for a fixed delay of the map phase. We remark that LT codes with low decoding complexity have a low average degree $\bar{\Omega}$, and thus also low encoding complexity. Note that for a given $M$, decreasing $\delta$ lowers the failure probability, but also increases the decoding complexity. We find good pairs $(M,\delta)$ by selecting through binary search the largest $M$ such that there exists a $\delta$ for which the lower bound on $P_{\mathsf{f}}(\epsilon_{\mathsf{min}})$ in (15) is approximately equal to $P_{\mathsf{f,target}}$. This heuristic produces codes with complexity very close to those found using basin-hopping combined with the Powell optimization method .

VI-C Computational Delay

There are on average $\bar{\Omega}$ nonzero entries in each row of the LT code encoding matrix. The LT code encoding complexity is thus given by

We simulate the complexity of the decoding $\sigma_{\mathsf{reduce,LT}}$. Furthermore, we assume that the decoding complexity depends only on $\epsilon_{\mathsf{min}}$, i.e., we evaluate the decoding complexity only at $\epsilon=\epsilon_{\mathsf{min}}$, and simulate the number of servers $g$ required for a given overhead $\epsilon$.

VI-D Communication Load

The coded multicasting scheme (see Section II-B3) is designed for the case where we need $m$ intermediate values per vector $\bm{y}$. Here, we tune it for the case where we instead need at least $m(1+\epsilon_{\mathsf{min}})$ intermediate values by increasing the number of coded multicast messages sent. Note that the coded multicasting scheme is greedy in the sense that it starts by multicasting coded messages to the largest possible number of recipients and then gradually lowers the number of recipients. Specifically, we perform the shuffle phase with (see (1))

The communication load of the LT code-based scheme for a given $\epsilon\geq\epsilon_{\mathsf{min}}$ is then given by

VI-E Partitioning of the LT Code-Based Scheme

We can apply partitioning to the LT code-based scheme in the same manner as for the BDC scheme. Specifically, we consider a block-diagonal encoding matrix $\bm{\Psi}_{\mathsf{BDC-LT}}$, where the blocks $\bm{\psi}_{1},\ldots,\bm{\psi}_{T}$ are LT code encoding matrices. In particular, we consider the case where the number of partitions $T$ is equal to the partitioning limit of Theorem 1, i.e., $T=r/\binom{K}{\eta q}$. In this case the all-ones assignment matrix $\bm{P}$ introduced in the proof of Theorem 1 is a valid matrix. By using this assignment matrix and identical encoding matrices for each of the partitions, i.e., $\bm{\psi}_{i}=\bm{\psi}$, $i=1,\ldots,T$, the encoding and decoding complexity of each partition is identical regardless of which set of servers $\mathcal{G}$ first completes the map phase. Furthermore, by the same argument as in the proof of Theorem 1, we are guaranteed that if any partition can be decoded using the coded rows stored at the set of servers $\mathcal{G}$, all other partitions can also be decoded.

VII Numerical Results

We present numerical results for the proposed BDC and LT code-based schemes and compare them with the schemes in . Furthermore, we compare the performance of the BDC scheme with assignment $\bm{P}$ produced by the heuristic and hybrid solvers. We also evaluate the performance of the LT code-based scheme for different $P_{\mathsf{f,target}}$ and $\epsilon_{\mathsf{min}}$. For each plot, the field size is equal to one more than the largest number of coded rows considered for that plot, $r+1$, rounded up to the closest power of $2$. The results, except those in Fig. 12, are normalized by the performance of the uncoded scheme. Unless stated otherwise, the assignment $\bm{P}$ is given by the heuristic solver. As in , we assume that $\phi(j)=j$.

In Fig. 5, we depict the communication load $L$ (see Definition 1) and the computational delay $D$ (see Definition 2) as a function of the number of partitions, $T$. The system parameters are $m=6000$, $n=6000$, $K=9$, $q=6$, $N=6000$, and $\eta=1/3$. The parameters of the CMR and SC schemes are $q_{\mathsf{CMR}}=9$, $\eta_{\mathsf{CMR}}=\frac{2}{9}$, and $\eta_{\mathsf{SC}}=\frac{1}{6}$. The minimum overhead for the LT code-based scheme is $\epsilon_{\mathsf{min}}=0.3$ and its target failure probability is $P_{\mathsf{f,target}}=0.1$. For up to $r/\binom{K}{\eta q}=250$ partitions (marked by the vertical dotted line), the BDC scheme does not incur any loss in $D_{\mathsf{map}}$ and communication load with respect to the unified scheme (see Theorem 1). Furthermore, the BDC scheme yields about a $2$% lower delay compared to the unified scheme for $T=1000$. The delay of the LT code-based scheme is slightly worse than that of the BDC scheme, and the load is about $65\%$ higher (for $T=250$). Partitioning the LT code-based scheme increases the communication load and reduces the computational delay by about $0.5$%. We remark that the number of partitions for the LT code-based scheme is fixed at $r/\binom{K}{\eta q}$. For heavy partitioning of the BDC scheme, a tradeoff between partitioning level, communication load, and map phase delay is observed. For example, with $3000$ partitions (the maximum possible), there is about a $10\%$ increase in communication load over the unified scheme. Note that the gain in computational delay saturates, thus there is no reason to partition beyond a given level. The load of the SC scheme is about twice that of our proposed schemes and the delay is about half. Finally, the delay of the BDC and the LT code-based scheme is about $25\%$ lower compared to the CMR scheme for $T>100$.

In Fig. 6, we plot the performance for a constant $\eta q=2$, $n=m/100$, $\eta m=2000$, code rate $m/r=2/3$, and $N=500q$ vectors as a function of the number of servers, $K$. The ratio $m/n$ is motivated by machine learning applications, where the number of rows and columns often represent the number of samples and features, respectively. Note that the number of arithmetic operations performed by each server in the map phase increases with $K$. We choose the number of partitions $T$ that minimizes the delay under the constraint that the communication load is at most $1$% higher compared to the unified scheme. The parameters of the LT code-based scheme are $\epsilon_{\mathsf{min}}=0.335$ and $P_{\mathsf{f,target}}=0.1$. The results shown are averages over $1000$ randomly generated realizations of $\mathcal{G}$. Our proposed BDC scheme outperforms the unified scheme in terms of computational delay by between about $25$% (for $K=6$) and $10$% (for $K=201$). Furthermore, the delay of both the BDC and LT code-based schemes are about $50$% lower than that of the CMR scheme for $K=201$. For $K=6$ the computational delay of the unpartitioned and partitioned LT code-based schemes is about $5$% higher and $8$% lower compared to the BDC scheme, respectively. For $K=201$ the delay of the LT code-based scheme is about $1$% lower than that of the BDC scheme. However, the communication load is about $45\%$ higher. Finally, the communication load of the BDC scheme is between about $42\%$ (for $K=6$) and $66\%$ (for $K=201$) of that of the SC scheme.

In Fig. 7, we show the performance for code rate $m/r=2/3$, $\eta q=2$, and a fixed workload per server as a function of $K$. Specifically, we fix the number of additions and multiplications computed by each server in the map phase to $10^{8}$ ($\pm 5$% to find valid parameters) and scale $m,n,N$ with $K$. The number of rows $m$ of $\bm{A}$ takes values between $12600$ and $59800$, and we let $n=m/100$ and $N=n$. The number of partitions $T$ is selected in the same way as for Fig. 6. The results shown are averages over $1000$ randomly generated realizations of $\mathcal{G}$. The computational delay of the unified scheme is about a factor $20$ higher than that of the BDC scheme for $K=300$. The computational delay of the partitioned LT code-based scheme is similar to that of the BDC scheme, while the delay of the unpartitioned LT code-based scheme is about $60$% higher. Furthermore, the communication load of the LT code-based scheme is about $45$% higher compared to those of the unified and BDC schemes.

In Fig. 8, we plot the performance of the BDC and LT code-based schemes as a function of the number of columns $n$. The system parameters are $m=2400$, $K=9$, $q=6$, $N=60$, $T=240$, and $\eta=1/3$. The communication load of the LT code-based scheme depends primarily on the minimum overhead $\epsilon_{\mathsf{min}}$ and the computational delay primarily on the target failure probability $P_{\mathsf{f,target}}$. We remark that a higher $P_{\mathsf{f,target}}$ allows for using codes with lower average degree and thus less complex encoding and decoding. For $n=20000$, the computational delay of the LT code-based scheme with $P_{\mathsf{f,target}}=0.1$ is about $1.5$% lower than that of the BDC scheme. For $P_{\mathsf{f,target}}=0.001$, the computational delay is about $3$% and $1.5$% higher than that of the BDC scheme when $\epsilon_{\mathsf{min}}=0.3$ and $\epsilon_{\mathsf{min}}=0.37$, respectively. On the other hand, the communication load of the LT code-based scheme with $\epsilon_{\mathsf{min}}=0.3$ and $\epsilon_{\mathsf{min}}=0.37$ is about $41\%$ and $44\%$ higher than that of the BDC scheme, respectively.

VII-B Assignment Solver Comparison

In Figs. 9 and 10, we plot the performance of the BDC scheme with assignment $\bm{P}$ given by the heuristic and the hybrid solver. We also give the average performance over $100$ random assignments. The vertical dotted line marks the partitioning limit of Theorem 1. The parameters in Figs. 9 and 10 are identical to those in Figs. 5 and 6, respectively.

In Fig. 9, we plot the performance as a function of the number of partitions, $T$. For $T$ less than about $200$, the performance for all solvers is identical. On the other hand, for $T>200$ both the computational delay and the communication load are reduced with $\bm{P}$ from the heuristic solver over the random assignments (about $5$% for load and $47$% for delay at $T=3000$). A further improvement in communication load can be achieved using the hybrid solver, but at the expense of a possibly larger computational delay.

In Fig. 10, we plot the performance as a function of the number of servers, $K$. The results shown are averages over $1000$ randomly generated realizations of $\mathcal{G}$. For $K=6$, the communication load of the heuristic solver is about $5\%$ lower than that of the random assignments, but for $K=201$ the difference is negligible. In terms of computational delay, the heuristic solver outperforms the random assignments by about $18$% and $3$% for $K=9$ and $K=201$, respectively. The hybrid solver is too computationally complex for use with the largest systems considered.

VII-C Tradeoff Between Communication Load and Computational Delay

In Fig. 11, we show the tradeoff between communication load and computational delay. The parameters are $K=14$, $m=50000$ ($\pm 3$% to find valid parameters), $n=500$, $N=840$, and $\eta=1/2$. Note that the code rate is decreasing toward the bottom of the plot. We select the number of partitions $T$ that minimizes the delay while the load is at most $1$% or $10$% higher compared to the unified scheme. Allowing a $10$% increased load gives up to about $7$% lower delay compared to allowing a $1$% increase. For the topmost data point of the BDC and unified schemes the encoding complexity dominates, and there is no reason to operate at this point since both the delay and load can be reduced. The parameters of the partitioned LT code-based scheme are $\epsilon_{\mathsf{min}}=0.3$ and $P_{\mathsf{f,target}}=10^{-1}$. For the data point with minimum computational delay, the LT code-based scheme yields about $15$% lower delay at the expense of about a $30$% higher load compared to the BDC scheme. Finally, the computational delay of the BDC scheme is between about $47$% and $4$% lower compared to the unified scheme for the topmost and bottommost data points, respectively.

VII-D Computational Delay Deadlines

In Fig. 12, we plot the probability of a computation not finishing before a deadline $t$, i.e., the probability of the computational delay being larger than $t$. As in , we plot the complement of the CDF of the delay in logarithmic scale. On the horizontal axis, we show the deadline $t$. The system parameters are $K=201$, $q=134$, $m=134000$, $n=1340$, $N=67000$ vectors, $T=6700$ partitions, and code rate $m/r=2/3$. The parameters for the LT code-based scheme are $\epsilon_{\mathsf{min}}=0.335$ and $P_{\mathsf{f,target}}=10^{-9}$. The results are due to simulations. In particular, we simulate the decoding failure probability of LT codes for various $t$ and extrapolate from these points under the assumption that the decoding failure probability is Gamma distributed. The fitted values deviate negligibly from the simulated values.

When the deadline is $t=3500$, the probability of exceeding the deadline is about $0.4$ for the unified and uncoded schemes. For the BDC scheme the probability is only about $7\cdot 10^{-3}$. The probability is slightly lower for the LT code-based scheme, about $4\cdot 10^{-3}$. If we instead consider a deadline $t=4000$, the probability of exceeding the deadline is about $10^{-3}$ and $0.15$ for the unified and uncoded schemes, respectively. For the BDC scheme the probability of exceeding the deadline is about $9\cdot 10^{-8}$, i.e., $4$ orders of magnitude lower compared to the unified scheme. The LT code-based scheme further improves the performance with a probability of exceeding the deadline of about $3\cdot 10^{-8}$. We remark that for the data point with minimum delay in Fig. 11, the LT code-based scheme has a significant advantage over the BDC scheme in terms of meeting a short deadline.

VII-E Alternative Runtime Distribution

Here, we consider a runtime distribution with CDF

where $\sigma$ is the shift and $\beta$ is a parameter that scales the tail of the distribution, i.e., it differs from the one considered previously by that the scale of the tail may be different from the shift. It is equal to the previously considered distribution if $\beta=\sigma$. This model has been used to model distributed computing in, e.g., . Under this model we assume that the reduce delay of the uncoded scheme follows the distribution above with parameters $\beta$ and $\sigma_{\mathsf{UC,reduce}}=0$ since each server has to assemble the final output from the intermediate results regardless coding is used or not. We assume that the encoding delay of the uncoded scheme is zero. Denote by $\sigma_{\mathsf{c}}$ the computational complexity of matrix-vector multiplication for the BDC and unified schemes. We let $\beta=\omega\sigma_{\mathsf{c}}$ for $\omega=0,1,10,100$. In Fig. 13, we plot the computational delay normalized by that of the uncoded scheme. The system parameters (and thus also the communication load) are identical to those in Fig. 7.

We observe the greatest gain of the BDC scheme over the unified scheme for small $\omega$ since the benefits of straggler coding are small compared to the added delay due to encoding and decoding, which is significant for the unified scheme. For larger $\omega$ the benefits of straggler coding are larger while the delay due to encoding and decoding remains constant. Hence, the performance of both schemes converge. However, even for $\omega=100$ the delay of the unified scheme is about $33$% higher than that of the BDC scheme for the largest system considered ($K=300$). We remark that for the example considered in the parameters $\beta=\sigma=1$, i.e., $\omega=1$, are used.

VIII Conclusion

We introduced two coding schemes for distributed matrix multiplication. One is based on partitioning the matrix into submatrices and encoding each submatrix separately using MDS codes. The other is based on LT codes. Compared to the earlier scheme in and to the CMR scheme in , both proposed schemes yield a significantly lower overall computational delay. For instance, for a matrix of size $59800\times 598$, the BDC scheme reduces the computational delay by about a factor $20$ over the scheme in with about a $1$% increase in communication load. The LT code-based scheme may reduce the computational delay further at the expense of a higher communication load. For example, for a matrix with about $50000$ rows, the computational delay of the LT code-based scheme is about $15$% lower than that of the BDC scheme with a communication load that is about $30\%$ higher. Finally, we have shown that the proposed coding schemes significantly increase the probability of a computation finishing within a deadline. The LT code-based scheme may be the best choice in situations where high reliability is needed due to its ability to decrease the computational delay at the expense of the communication load.

Acknowledgment

The authors would like to thank Dr. Francisco Lázaro and Dr. Gianluigi Liva for fruitful discussions and insightful comments on LT codes.

References