Coded Computation over Heterogeneous Clusters

TL;DR

This paper introduces HCMM, a coding framework for distributed matrix multiplication in heterogeneous clusters, achieving significant speedups and cost efficiency over existing schemes through theoretical analysis and practical experiments.

Contribution

The paper proposes HCMM, a novel coding scheme tailored for heterogeneous clusters, with proven asymptotic optimality and practical validation on Amazon EC2.

Findings

HCMM is up to 61% faster than benchmark schemes.

HCMM is asymptotically optimal for broad class of processing times.

Heuristic load allocation improves cost efficiency in budget-constrained scenarios.

Abstract

In large-scale distributed computing clusters, such as Amazon EC2, there are several types of "system noise" that can result in major degradation of performance: bottlenecks due to limited communication bandwidth, latency due to straggler nodes, etc. On the other hand, these systems enjoy abundance of redundancy - a vast number of computing nodes and large storage capacity. There have been recent results that demonstrate the impact of coding for efficient utilization of computation and storage redundancy to alleviate the effect of stragglers and communication bottlenecks in homogeneous clusters. In this paper, we focus on general heterogeneous distributed computing clusters consisting of a variety of computing machines with different capabilities. We propose a coding framework for speeding up distributed computing in heterogeneous clusters by trading redundancy for reducing the latency of computation. In particular, we propose Heterogeneous Coded Matrix Multiplication (HCMM) algorithm for performing distributed matrix multiplication over heterogeneous clusters that is provably asymptotically optimal for a broad class of processing time distributions. Moreover, we show that HCMM is unboundedly faster than any uncoded scheme. To demonstrate practicality of HCMM, we carry out experiments over Amazon EC2 clusters where HCMM is found to be up to $61\%$, $46\%$ and $36\%$ respectively faster than three benchmark load allocation schemes - Uniform Uncoded, Load-balanced Uncoded, and Uniform Coded. Additionally, we provide a generalization to the problem of optimal load allocation in heterogeneous settings, where we take into account the monetary costs associated with the clusters. We argue that HCMM is asymptotically optimal for budget-constrained scenarios as well, and we develop a heuristic algorithm for (HCMM) load allocation for budget-limited computation tasks.

Tables

Table 1. TABLE I : Total computation load ( ∑ i = 1 n ℓ i superscript subscript 𝑖 1 𝑛 subscript ℓ 𝑖 \sum_{i=1}^{n}\ell_{i} ) of HCMM and Uniform Coded

Scenario	$n$	HCMM	Uniform Coded
$1$	$10$	$11397$	$22600$
$2$	$15$	$11402$	$21201$
$3$	$15$	$11403$	$21201$

Table 2. TABLE II : Amazon EC2 Pricing for Linux

machine	vCPU	ECU	Memory (GiB)	Instance Storage (GB)	price (/Hour)
m3.medium	1	3	3.75	1$\times$4 SSD	$0.077
m3.large	2	6.5	7.5	1$\times$32 SSD	$0.154
m3.xlarge	4	13	15	2$\times$40 SSD	$0.308
m3.2xlarge	8	26	30	2$\times$80 SSD	$0.616

Equations

$$\mathrm{Pr}[T_i\le t]=1-e^{-\frac{{\mu }_i}{{\ell }_i}(t-a_i{\ell }_i)},$$

$$\mathrm{Pr}[T_i\le t]=1-e^{-{\left(\frac{{\mu }_i}{{\ell }_i}(t-a_i{\ell }_i)\right)}^{{\alpha }_i}},$$

$${\mathcal{P}}_{\text{main}}:$$

$$\frac{\mathbb{E}[T_{\mathsf{UC}}]}{\mathbb{E}[T_{\mathsf{HCMM}}]}=\Theta\big{(}\log n\big{)}.$$

$$\frac{\mathbb{E}[T_{\mathsf{UC}}]}{\mathbb{E}[T_{\mathsf{HCMM}}]}\geq\Theta\big{(}(\log n)^{1/\tilde{\alpha}}\big{)},$$

$$X(t)=\sum _{i=1}^n{X}_i(t).$$

$$\displaystyle\mathcal{P}_{\textnormal{alt}}^{(1)}:\bm{\ell}^{*}(t)=\arg\max_{\bm{\ell}}\mathbb{E}\big{[}X(t)\big{]}.$$

$${\mathcal{P}}_{\text{alt}}^{(2)}:$$

$$\displaystyle\Pr\big{[}{X^{*}}(t)<r\big{]}=o\left(\frac{1}{n}\right),$$

$$X^{\ast }(t)=\sum _{i=1}^n{X}_i^{\ast }(t)=\sum _{i=1}^n{\ell }_i^{\ast }(t)\text{mathbbm}{1}_{\{T_i\le t\}}.$$

$$\mathbb{E}\big{[}X(t)\big{]}=\sum_{i=1}^{n}\mathbb{E}\big{[}X_{i}(t)\big{]}=\displaystyle\sum_{i=1}^{n}\ell_{i}\left(1-e^{-\frac{\mu_{i}}{\ell_{i}}(t-a_{i}\,\ell_{i})}\right).$$

$$\ell^{*}_{i}(t)=\arg\max_{\ell_{i}}{\mathbb{E}\big{[}X_{i}(t)\big{]}},$$

$$\frac{\partial }{\partial {\ell }_i}\mathbb{E}\left[X_i(t)\right]$$

$${\ell }_i^{\ast }(t)=\frac{t}{{\lambda }_i},$$

$$e^{{\mu }_i{\lambda }_i}=e^{a_i{\mu }_i}({\mu }_i{\lambda }_i+1).$$

$${\ell }_i^{\ast }(t^{\ast })=\frac{t^{\ast }}{{\lambda }_i},$$

$$\mathbb{E}\left[X^{\ast }(t)\right]$$

$$=\sum _{i=1}^n\frac{t}{{\lambda }_i}\left(1-e^{-\frac{{\mu }_i}{t/{\lambda }_i}\left(t-\frac{a_{i}t}{{\lambda }_i}\right)}\right)$$

$$=ts,$$

$$s=\sum _{i=1}^n\frac{1}{{\lambda }_i}\left(1-e^{-{\mu }_i{\lambda }_i(1-\frac{a_i}{{\lambda }_i})}\right)=\sum _{i=1}^n\frac{{\mu }_i}{1+{\mu }_i{\lambda }_i}=\Theta (n),$$

$$\mathbb{E}\big{[}X^{*}(t)\big{]}=\sum_{i=1}^{n}\ell_{i}^{*}(t)\left(1-e^{-\frac{\mu_{i}}{\ell_{i}^{*}(t)}(t-a_{i}\ell_{i}^{*}(t))}\right)=r.$$

$${\tau }^{\ast }$$

$${\ell }_i^{\ast }({\tau }^{\ast })$$

$${\tau }^{\ast }\le t^{\ast }\le {\tau }^{\ast }+o(1).$$

$$\mathbb{E}[T_{\mathsf{HCMM}}]\le t^{\ast }+o(1).$$

$${\mathcal{E}}_1=\{T_{\mathsf{max}}>\Theta (n)\}\text{ and }{\mathcal{E}}_2=\{T_{\mathsf{HCMM}}>t^{\ast }\}.$$

$$\mathbb{E}[T_{\mathsf{HCMM}}]$$

$$+\mathbb{E}[T_{\mathsf{HCMM}}|{{\mathcal{E}}_1}^c\cap {\mathcal{E}}_2]\mathrm{Pr}[{{\mathcal{E}}_1}^c\cap {\mathcal{E}}_2]$$

$$+\mathbb{E}[T_{\mathsf{HCMM}}|{{\mathcal{E}}_1}^c\cap {{\mathcal{E}}_2}^c]\mathrm{Pr}[{{\mathcal{E}}_1}^c\cap {{\mathcal{E}}_2}^c].$$

$$\mathbb{E}[$$

$$=\mathbb{E}[T_{\mathsf{HCMM}}|T_{\mathsf{max}}\le \Theta (n),T_{\mathsf{HCMM}}>t^{\ast }]$$

$$\times \mathrm{Pr}[T_{\mathsf{max}}\le \Theta (n),T_{\mathsf{HCMM}}>t^{\ast }]$$

$$\le \mathbb{E}[T_{\mathsf{max}}|T_{\mathsf{max}}\le \Theta (n),T_{\mathsf{HCMM}}>t^{\ast }]\mathrm{Pr}[T_{\mathsf{HCMM}}>t^{\ast }]$$

$$\stackrel{(a)}{\le }\Theta (n)\cdot o\left(\frac{1}{n}\right)$$

$$=o(1).$$

$$\mathrm{Pr}[T_{\mathsf{HCMM}}>t^{\ast }]\le \mathrm{Pr}[X^{\ast }(t^{\ast })<r]=o\left(\frac{1}{n}\right).$$

Full text

I Introduction

General distributed computing frameworks, such as MapReduce [2] and Spark [3], along with the availability of large-scale commodity servers, such as Amazon EC2, have made it possible to carry out large-scale data analytics at the production level. These “virtualized data centers” enjoy an abundance of storage space and computing power, and are cheaper to rent by the hour than maintaining dedicated data centers round the year. However, these systems suffer from various forms of “system noise” which reduce their efficiency: system failures, limited communication bandwidth, straggler nodes, etc.

The current state-of-the-art approaches to mitigate the impact of system noise in cloud computing environments involve creation of some form of “computation redundancy”. For example, replicating the straggling task on another available node is a common approach to deal with stragglers [4], while partial data replication is also used to reduce the communication load in distributed computing [5]. However, there have been recent results demonstrating that coding can play a transformational role for creating and exploiting computation redundancy to effectively alleviate the impact of system noise. In particular, there have been two coding concepts proposed to deal with the communication and straggler bottlenecks in distributed computing.

The first coding concept introduced in [6, 7, 8] enables an inverse-linear tradeoff between computation load and communication load in distributed computing. This result implies that increasing the computation load by a factor of $r$ (i.e. evaluating each computation at $r$ carefully chosen nodes) can create novel coding opportunities that reduce the required communication load for computing by the same factor $r$. Hence, these codes can be utilized to pool the underutilized computing resources at network edge to slash the communication load of Fog computing [9]. Other related works tackling the communication bottleneck in distributed computation include [10, 11, 12, 13, 14].

In the second coding concept introduced in [10], an inverse-linear tradeoff between computation load and computation latency (i.e. the overall job response time) is established for distributed matrix multiplication in homogeneous computing environments. More specifically, this approach utilizes coding to effectively inject redundant computations to alleviate the effects of stragglers and speed up the computations. Hence, by utilizing more computation resources, this can significantly speed up distributed computing applications. A number of related works have been proposed recently to mitigate stragglers in distributed computation. In [15], the authors propose the use of redundant short dot products to speed up distributed computation of linear transforms. The work in [16] proposes coding schemes for mitigating stragglers in distributed batch gradient computation. Coding schemes for high-dimensional matrix-matrix multiplication have been developed in [17, 18, 19, 20, 21]. Techniques for efficient straggler mitigation for matrix-vector computation in distributed wireless settings have been developed in [22]. In [23], the potential of the multicore nature of computing machines is studied. In [24], the authors propose an anytime approach to distributed computing, developing an approximate matrix multiplication scheme. The authors in [25] propose a novel encoding scheme for achieving large sparsity in the encoded matrix. Work in [26] develops a coding strategy for mitigating straggling decoders in cloud radio access network. Speeding up the computation of linear transformations with unreliable components is studied in [27]. Straggler mitigation through data encoding in distributed optimization is proposed in [28]. A coded scheme based on LT codes is proposed in [29] for multiplying a matrix by a set of vectors in a distributed computing environment. Addressing stragglers has attracted a lot of attention in the queuing-based frameworks for large-scale computation as well [30, 31]. These works utilize the technique of dynamically replicating the tasks in a careful manner to minimize run-time.

We extend the problem of distributed matrix multiplication in homogeneous clusters in [10] to heterogeneous environments. As discussed in [4], the computing environments in virtualized data centers are heterogeneous and algorithms based on homogeneous assumptions can result in significant performance reduction. In this paper, we focus on general heterogeneous distributed computing clusters consisting of a variety of computing machines with different capabilities. Specifically, we propose a coding framework for speeding up distributed matrix multiplication in heterogeneous clusters with straggling servers, named Heterogeneous Coded Matrix Multiplication (HCMM). Matrix multiplication is a crucial computation module in many engineering and scientific disciplines. In particular, it is a fundamental component of many popular machine learning algorithms such as logistic regression, reinforcement learning and gradient descent-based algorithms. Implementations that speed up matrix multiplication would naturally speed up the execution of a wide variety of popular algorithms. Therefore, we envision HCMM to play a fundamental role in speeding up big data analytics in virtualized data centers by leveraging the wide range of computing capabilities provided by these heterogeneous environments.

We now describe the main ideas behind HCMM, which results in asymptotically optimal performance. In a coded implementation of distributed matrix-vector multiplication, each worker node is assigned the task of computing inner products of the assigned coded rows with the input vector, where the assigned coded rows are random linear combinations of the rows of the original matrix. Computation time at each worker is a random variable, which is first assumed to have shifted exponential distribution, and we later generalize it to shifted Weibull distribution. The master node receives the results from the worker nodes and aggregates them until it receives a decodable set of inner products and recovers the matrix-vector multiplication. We are interested in finding the optimal load allocation that minimizes the expected waiting time to complete this computation. However, due to heterogeneity, finding the exact solution to the optimization problem seems intractable.

As the main contribution of the paper, we propose an alternative optimization that focuses on maximizing the expected number of returned computation results from the workers. Apart from being computationally tractable, the alternative optimization asymptotically approximates the problem of finding the optimal computation load allocation. Specifically, we develop the HCMM algorithm that is derived as a solution to the alternative formulation, and prove it is asymptotically optimal. Furthermore, we prove that given a heterogeneous cluster of $n$ workers, HCMM is $\Theta(\log n)$ times faster than uncoded schemes under the shifted exponential distribution for run-time. We further generalize the proposed HCMM algorithm to shifted Weibull model and provide similar unbounded gains over uncoded scenarios.

In addition to proving the asymptotic optimality of HCMM, we carry out numerical studies and experiments over Amazon EC2 clusters to demonstrate how HCMM can be used in practice. We compare HCMM with three benchmark schemes – Uniform Uncoded, Load-balanced Uncoded, and Uniform Coded. In our numerical analysis, HCMM results in significant speedups of up to $73\%$, $56\%$ and $42\%$ over the three aforementioned benchmark schemes, respectively. In experiments using Amazon EC2 clusters, we use the Luby transform (LT) codes for coding and demonstrate that HCMM combined with LT codes significantly reduces the overall execution time in comparison to uncoded and coded schemes. In particular, HCMM achieves gains of up to $61\%$, $46\%$ and $36\%$, respectively over Uniform Uncoded, Load-balanced Uncoded and Uniform Coded. Furthermore, the overall computation load of HCMM is less than the one of Uniform Coded. Our results demonstrate that HCMM combines the benefits of both Load-balanced Uncoded and Uniform Coded schemes by achieving efficient load balancing along with minimal number of redundant computations.

Furthermore, we consider the problem of load allocation under budget constraints, considering an intuitive and convincing pricing model. In particular, we show that HCMM is the (asymptotically) optimal load allocation in feasible budget-constrained scenarios as well, and determine whether a budget-constrained computation task is feasible given a cluster of machines. We then develop a heuristic algorithm to find the (sub)optimal load allocations using the proposed HCMM scheme. The heuristic is based on the observation that given a computation task and a set of machines, decreasing the number of fastest machines participating in HCMM results in smaller average cost.

Notation. We denote by $[n]$ the set $\{1,\cdots,n\}$ for any $n\in\mathbb{N}$. For non-negative sequences $g(n)$ and $h(n)$, we denote g(n)=\mathcal{O}\big{(}h(n)\big{)} if there exist constants $c>0$ and $n_{0}\in\mathbb{N}$ such that $g(n)\leq c\cdot h(n)$ for all $n>n_{0}$; and g(n)=\Theta\big{(}h(n)\big{)} if g(n)=\mathcal{O}\big{(}h(n)\big{)} and h(n)=\mathcal{O}\big{(}g(n)\big{)}. Moreover, we write g(n)=o\big{(}h(n)\big{)} if $\lim_{n\to\infty}g(n)/h(n)=0$.

II Problem Formulation and Main Results

In this section, we describe our computation model, the network model and the precise problem formulation. We then conclude with four theorems highlighting the main contributions of the paper.

II-A Computation Model

We consider the problem of matrix-vector multiplication, in which given a matrix $\mathbf{A}\in\mathbb{R}^{r\times m}$ for some positive integers $r$ and $m$, we want to compute the output $\mathbf{y}=\mathbf{A}\mathbf{x}$ for an input vector $\mathbf{x}\in\mathbb{R}^{m}$. Due to limited computing power, the computation cannot be carried out at a single server and a distributed implementation is required. As an example, consider a matrix $\mathbf{A}$ with an even number of rows and two computing nodes. The matrix can be divided into two equally tall matrices $\mathbf{A}_{1}$ and $\mathbf{A}_{2}$, and each will be stored in a different worker node. The master node receives the input $\mathbf{x}$ and broadcasts it to the two worker nodes. These nodes will then compute $\mathbf{y}_{1}=\mathbf{A}_{1}\mathbf{x}$ and $\mathbf{y}_{2}=\mathbf{A}_{2}\mathbf{x}$ locally and return their results to the master node, which combines them to obtain the intended outcome $\mathbf{y}=[\mathbf{y}_{1};\mathbf{y}_{2}]=\mathbf{A}\mathbf{x}$. This example also illustrates an uncoded implementation of distributed computing, in which results from all the worker nodes are required to recover the final result.

We now present the formal definition of Coded Distributed Computation.

Definition 1**.**

(Coded Distributed Computation) The coded distributed implementation of a computation task $f_{\mathbf{A}}(\cdot)$ is specified by:

• •

local data blocks $\left<\mathbf{A}_{i}\right>_{i=1}^{n}$ and local computation tasks $\left<f_{\mathbf{A}_{i}}^{i}(\cdot)\right>_{i=1}^{n}$;

• •

a decoding function that outputs $f_{\mathbf{A}}(\cdot)$ given the results from a decodable set of local computations.

For matrix-vector multiplication tasks in particular, local data blocks $\mathbf{A}_{i}\in\mathbb{R}^{\ell_{i}\times m}$ are matrices consisting of coded combinations of the rows in $\mathbf{A}$, for non-negative integers $\ell_{i}$. To assign the computation tasks to each worker, we use random linear combinations of the $r$ rows of the matrix $\mathbf{A}$, such that the master node can recover the result $\mathbf{A}\mathbf{x}$ from any $r$ inner products received from the worker nodes with probability 1. As an example, if worker $i$ is assigned a matrix-vector multiplication with matrix size $\ell_{i}\times m$, it will compute $\ell_{i}$ inner products of the assigned coded rows of $\mathbf{A}$ with $\mathbf{x}$. The master node shall wait for the first $r$ inner products and will use them to decode the required output. In order to ensure the recovery of the output from any $r$ inner products received from the workers, we pick the computation matrix assigned to worker $i$ as $\mathbf{A}_{i}=\mathbf{S}_{i}\mathbf{A}$, where $\mathbf{S}_{i}\in\mathbb{R}^{\ell_{i}\times r}$ is the coding matrix with i.i.d. $\mathcal{N}(0,1)$ entries. Worker $i$ computes $\mathbf{A}_{i}\mathbf{x}$ and returns the result to the master node. Upon receiving $r$ inner products, the aggregated results at the master will be in the form of $\mathbf{z}=\mathbf{S}_{(r)}\mathbf{A}\mathbf{x}$, where $\mathbf{S}_{(r)}\in\mathbb{R}^{r\times r}$ is the aggregated coding matrix, and it is full-rank with probability $1$ [32]. Therefore, the master node can recover $\mathbf{A}\mathbf{x}=\mathbf{S}_{(r)}^{-1}\mathbf{z}$ with probability $1$.111Although we consider random linear coding in our theoretical analysis, other codes such as Maximum-Distance Separable (MDS) codes and Luby transform (LT) codes are compatible with HCMM as well, given a decodable set of results at the master. For example, in the MDS case, the entries in the coding matrix $\{\mathbf{S}_{i}\}_{i=1}^{n}$ are drawn from a finite field. Specifically, one can encode the rows of $\mathbf{A}$ using an $(\sum_{i=1}^{n}\ell_{i},r)$ MDS code and assign $\ell_{i}$ coded rows to the worker node $i$. The output $\mathbf{Ax}$ can be recovered from the inner products of any $r$ coded rows with the input vector $\mathbf{x}$. Furthermore, to implement the ideas developed in this work, we use LT codes in our experiments over Amazon EC2 clusters.,222Instead of i.i.d. Gaussian, we could use any continuous distribution for the random entries, since Schwartz-Zippel lemma ensures that such random matrix is full-rank with high probability

II-B Network Model

The network model is based on a master-worker setup illustrated in Fig. 1. The master node receives an input $\mathbf{x}$ and broadcasts it to all the workers. Each worker computes its assigned set of computations and unicasts the result to the master node. The master node aggregates the results from the worker nodes until it receives a decodable set of computations and recovers the output $\mathbf{A}\mathbf{x}$.

We denote by $T_{i}$ the random variable representing the task run-time at node $i$ and assume that the run-times $T_{1},\cdots,T_{n}$ are mutually independent. We consider the distribution of run-time random variables to be exponential, and later generalize it to Weibull distribution. More specifically, we consider a 2-parameter shifted exponential distribution for the execution time of each worker, i.e., the CDF of execution time of worker node $i$, $T_{i}$, loaded with $\ell_{i}$ row vectors is as follows:

[TABLE]

for $t\geq a_{i}\ell_{i}$ and $i\in[n]$, where $a_{i}>0$ is the shift parameter and $\mu_{i}>0$ denotes the straggling parameter associated with worker node $i$. The shifted exponential model for computation time, which is the sum of a constant (deterministic) term and a variable (stochastic) term, is motivated by the distribution model proposed by authors in [33] for latency in querying data files from cloud storage systems. As demonstrated in [10] as well as by our own experiments, exponential model provides a good fit for the distribution of computation times over cloud computing environments such as Amazon EC2 clusters. Moreover, these experiments confirm the assumption that as a first order approximation, both shift and mean parameters of the shifted exponential distributions linearly scale with the load size.

We further generalize the analysis to shifted Weibull distribution in Section IV, where we consider a 3-parameter shifted Weibull distribution for the execution time of each worker. That is, the CDF of task run-time at worker node $i$, loaded with $\ell_{i}$ row vectors is as follows:

[TABLE]

for $t\geq a_{i}\ell_{i}$ and $i\in[n]$, where $a_{i}>0$ denotes the shift parameter, $\mu_{i}>0$ is the straggling parameter and $\alpha_{i}>0$ represents the shape parameter associated with worker $i$. A similar model has been considered in [34] as well.

II-C Problem Formulation

We consider the problem of using a cluster of $n$ worker nodes for distributedly computing the matrix-vector multiplication $\mathbf{A}{\mathbf{x}}$, where $\mathbf{A}$ is a size $r\times m$ matrix for positive integers $r$ and $m$. Let $\bm{\ell}=(\ell_{1},\cdots,\ell_{n})$ be the load allocation vector where $\ell_{i}$ denotes the number of rows assigned to worker node $i$. Let $T_{\mathsf{CMP}}$ be the random variable denoting the waiting time for receiving a decodable set of results, i.e. at least $r$ inner products. We aim at finding the optimal load allocation vector that minimizes the average waiting time by solving the following optimization problem:

[TABLE]

For a homogeneous cluster, to achieve a coded solution, one can divide $\mathbf{A}$ into $k$ equal size submatrices, and apply an $(n,k)$ MDS code to these submatrices. The master node can then obtain the final result from any $k$ responses. In [10], the authors find the optimal $k$ for minimizing the average running time for the shifted exponential run-time model.

For heterogeneous clusters, however, assigning equal loads to servers is clearly not optimal. Moreover, directly finding the optimal solution to $\mathcal{P}_{\textnormal{main}}$ is hard. In homogeneous clusters, the problem of finding a sufficient number of inner products can be mapped to the problem of finding the waiting time for a set of fastest responses, and thus closed form expressions for the expected computation time can be found using order statistics of i.i.d. run-times. However, this is not straight-forward in heterogeneous clusters, where the load allocation is non-uniform. In Section III, we present an alternative formulation to $\mathcal{P}_{\textnormal{main}}$ in (3), and show that the solution to the alternative formulation – which we shall name HCMM – is tractable and provably asymptotically optimal.

Assumptions. From now onward, we consider the practically relevant regime where the size of the problem scales linearly with the size of the network, while the computing power and the storage capacity of each worker node remain constant. Specifically, we assume $r=\Theta{(n)}$, $a_{i}=\Theta{(1)}$, $\mu_{i}=\Theta{(1)}$ and $\alpha_{i}=\Theta{(1)}$ for each worker $i$.

II-D Main Results

Having set the model and formulation of the problem, we now present the main contributions of this paper. The following theorem characterizes the asymptotic optimality of HCMM for the shifted exponential run-time model.

Theorem 1**.**

Let $T_{\mathsf{HCMM}}$ be the random variable denoting the finish time of the HCMM algorithm and $T_{\mathsf{OPT}}$ be the random variable representing the finish time of the optimum algorithm obtained by solving $\mathcal{P}_{\textnormal{main}}$. Then, for shifted exponential run-times in (1) with constant parameters $a_{i}=\Theta{(1)}$ and $\mu_{i}=\Theta{(1)}$ for each worker $i\in[n]$ and $r=\Theta{(n)}$, we have $\lim_{n\to\infty}\mathbb{E}[T_{\mathsf{HCMM}}]=\lim_{n\to\infty}\mathbb{E}[T_{\mathsf{OPT}}]$.

Remark 1*.*

Theorem 1 demonstrates that our proposed HCMM algorithm is asymptotically optimal as the number of workers $n$ approaches infinity. In other words, the optimal computation load allocation problem $\mathcal{P}_{\textnormal{main}}$ in (3) can be optimally solved using the proposed HCMM algorithm as $n$ gets large.

Remark 2*.*

We note that $\mathcal{P}_{\textnormal{main}}$ in (3) is a hard combinatorial optimization problem since it will require checking all load combinations to minimize the overall expected execution time. The key idea in Theorem 1 is to consider an alternative formulation to (3) focusing on maximizing the expected number of returned computation results from the workers, i.e. maximizing the aggregate return. As we describe in Section III, the alternative optimization problem not only can be solved efficiently in a tractable way giving rise to HCMM algorithm, it also asymptotically approximates $\mathcal{P}_{\textnormal{main}}$ and allows us to establish Theorem 1.

Remark 3*.*

While Theorem 1 theoretically characterizes the optimality of our proposed scheme HCMM, we also demonstrate gains that one can get in practice. In particular, we carry out numerical studies and experiments over Amazon EC2 clusters that demonstrate that HCMM can provide significant gains in a wide variety of computing scenarios. In particular, we compare HCMM’s performance with three benchmark load allocation policies – Uniform Uncoded, Load-balanced Uncoded, and Uniform Coded. In numerical studies, HCMM achieves speedups of up to $71\%$ over Uniform Uncoded, up to $53\%$ over Load-balanced Uncoded, and up to $39\%$ over Uniform Coded. In EC2 experiments, HCMM combined with the Luby transform (LT) codes provides speedups of up to $61\%$, $46\%$ and $36\%$ over Uniform Uncoded, Load-balanced Uncoded and Uniform Coded, respectively.

Theorem 2**.**

Let $T_{\mathsf{UC}}$ denote the completion time of the uncoded distributed matrix multiplication algorithm. Then, for the shifted exponential run-times with constant parameters and $r=\Theta{(n)}$,

[TABLE]

Remark 4*.*

As Theorem 2 shows, our proposed HCMM guarantees an improvement of \Theta\big{(}\log n\big{)} in expected execution time over any uncoded scheme, including the one that optimally allocates the workers’ loads. This result illustrates that by leveraging coded computing, one achieves the same order-wise gain over heterogeneous clusters as over homogeneous clusters [10].

Although Theorems 1 and 2 are based on the shifted exponential model (1) for run-time random variables for the workers, our analyses are general and can be extended to other models. The following two theorems generalize the results when the execution time of each worker follows the Weibull distribution as described in (2).

Theorem 3**.**

For the shifted Weibull distribution of run-times with constant parameters $a_{i}=\Theta{(1)}$, $\mu_{i}=\Theta{(1)}$ and $\alpha_{i}=\Theta{(1)}$ for each worker $i\in[n]$ and $r=\Theta{(n)}$, the proposed HCMM algorithm is asymptotically optimal, i.e., $\lim_{n\to\infty}\mathbb{E}[T_{\mathsf{HCMM}}]=\lim_{n\to\infty}\mathbb{E}[T_{\mathsf{OPT}}]$.

Theorem 4**.**

Under the Weibull distribution for run-times with constant parameters and $r=\Theta{(n)}$, the proposed HCMM scheme unboundedly outperforms the uncoded scheme, i.e.,

[TABLE]

where $\tilde{\alpha}=\max_{i\in[n]}\alpha_{i}$ is the largest shape parameter among the workers.

Remark 5*.*

As stated in Theorem 4, HCMM provides an unbounded gain over any uncoded scheme – including the optimal uncoded load allocation – under the Weibull distribution for workers’ run-times. Furthermore, our numerical simulations demonstrate speedups of up to $73\%$, $56\%$ and $42\%$ over Uniform Uncoded, Load-balanced Uncoded and Uniform Coded, respectively.

In the following section, we describe our alternative formulation based on aggregate return and describe our proposed HCMM algorithm that solves the alternative optimization.

III The Proposed HCMM Scheme and Proofs of Theorems 1 and 2

In this section, we prove Theorems 1 and 2 for the exponential model (1). In particular, we start by describing the HCMM algorithm and show that it asymptotically achieves the optimal performance, as stated in Theorem 1, and lastly conclude the section by characterizing the gain of HCMM over uncoded scheme.

To derive HCMM, we start by reformulating $\mathcal{P}_{\textnormal{main}}$ defined in (3) and show that the alternative formulation can be efficiently solved, as opposed to solving $\mathcal{P}_{\textnormal{main}}$ that needs an exhaustive search over all possible load allocations. The solution to the alternative problem gives rise to HCMM. We will further prove the optimality of HCMM and compare its average run-time to uncoded schemes.

III-A Alternative Formulation of $\mathcal{P}_{\textnormal{main}}$ via Maximal Aggregate Return

Consider an $n$-tuple load allocation $\bm{\ell}=(\ell_{1},\cdots,\ell_{n})$ and let $t$ be a feasible time for computation, i.e., $t\geq\displaystyle\max_{i}\{a_{i}\,\ell_{i}\}$. The number of equations received from worker $i\in[n]$ at the master node till time $t$ is a random variable, $X_{i}(t)=\ell_{i}\,\mathbbm{1}_{\{T_{i}\leq t\}}$, where $T_{i}$ is the random execution time for machine $i$ that is assigned the load $\ell_{i}$ and $\mathbbm{1}_{\{\cdot\}}$ denotes the indicator function. Then, the aggregate return at the master node at time $t$ is:

[TABLE]

We propose the following two-step alternative formulation for $\mathcal{P}_{\textnormal{main}}$ defined in (3). First, for a fixed feasible time $t$, we maximize the aggregate return over different load allocations, i.e., we solve

[TABLE]

Then, given the load allocation \bm{\ell}^{*}(t)=\big{(}\ell^{*}_{1}(t),\cdots,\ell^{*}_{n}(t)\big{)} obtained from $\mathcal{P}_{\textnormal{alt}}^{(1)}$, we find the smallest time $t$ such that with high probability, there is enough aggregate return by time $t$ at the master node, i.e., we solve

[TABLE]

where ${X^{*}}(t)$ is the aggregate return at time $t$ for load allocation obtained from $\mathcal{P}_{\textnormal{alt}}^{(1)}$, that is

[TABLE]

From now onward, we denote the solution to $\mathcal{P}_{\textnormal{alt}}^{(2)}$ by $t^{*}$ and hence $\bm{\ell}^{*}(t^{*})$ denotes the solution to the two-step alternative formulation in (4) and (5) which gives rise to our proposed HCMM scheme described next.

III-B Solving the Alternative Formulation

Considering the exponential distribution for workers’ run-times, we first proceed to solve $\mathcal{P}_{\textnormal{alt}}^{(1)}$ in (4). The expected number of equations aggregated at the master node at time $t$ is:

[TABLE]

Since there is no constraint on load allocations, $\mathcal{P}_{\textnormal{alt}}^{(1)}$ can be decomposed to $n$ decoupled optimization problems, i.e.,

[TABLE]

for all workers $i\in[n]$. The solution to (6) satisfies the following optimality condition:

[TABLE]

which yields

[TABLE]

where $\lambda_{i}=\Theta{(1)}$ is a constant independent of $t$ and is the positive solution to the following equation:

[TABLE]

One can easily check that the condition $t\geq a_{i}\ell_{i}^{*}(t)$ holds for all $i$ as well. Moreover, we denote by $t^{*}$ the solution to $\mathcal{P}_{\textnormal{alt}}^{(2)}$. Now, we define the HCMM load allocation as

[TABLE]

for all workers $i$. In the following, we formally define the HCMM algorithm which is basically the solution to $\mathcal{P}_{\textnormal{alt}}$.

Remark 6*.*

We note that in order to implement any load allocation scheme, each worker supposedly admits an integer number of rows as its associated computation load. However, the load allocation $\ell_{i}^{*}(t^{*})$ given by HCMM scheme in Algorithm 1 is a real number for any worker $i$ and therefore one needs to round the result before proceeding with experiments. In practical scenarios, $\ell_{i}^{*}(t^{*})$ is fairly large, e.g. in the order of $100$ row vectors. Therefore, the effect of rounding the load allocations shall be insignificant.

We now provide an approximation to $t^{*}$ and show it asymptotically converges to $t^{*}$. The expected aggregate return at time $t$ for optimal loads obtained in (7) is

[TABLE]

where

[TABLE]

since $\mu_{i}=\Theta{(1)}$ and $\lambda_{i}=\Theta{(1)}$. Let $\tau^{*}$ be the solution to the following equation when solved for $t$:

[TABLE]

In other words, $\tau^{*}$ is the time for which there are exactly $r$ inner products – on average – aggregated at the master node, when the workers are loaded according to the loading obtained in (7). Using (7), (III-B) and (10), we find that

[TABLE]

We now present the following lemma, which shows that $\tau^{*}$ converges to $t^{*}$ for large $n$ (see Appendix for proof).

Lemma 1**.**

Let $t^{*}$ be the solution to the alternative formulation $\mathcal{P}_{\textnormal{alt}}$ in (4-5) and $\tau^{*}$ be the solution to (10). Then,

[TABLE]

III-C Asymptotic Optimality of HCMM

In this subsection, we prove the asymptotic optimality of HCMM as claimed in Theorem 1.

Proof of Theorem 1.

Consider the HCMM load assignment in (8). Let the random variable $T_{\mathsf{HCMM}}$ denote the finish time associated to this load allocation, i.e. the waiting time to receive at least $r$ inner products from the workers. Let $T_{\mathsf{max}}$ be the random variable denoting the finish time of all the workers for the HCMM load assignment.

First, we show that

[TABLE]

Let us define two events $\mathcal{E}_{1}$ and $\mathcal{E}_{2}$ as follows:

[TABLE]

Conditioning on these events, we can write

[TABLE]

We can write the second term in RHS of (III-C) as follows:

[TABLE]

To prove $(a)$, we note that HCMM returns $r$ inner products by time $T_{\mathsf{HCMM}}$. Moreover, the aggregate return is increasing in time. Therefore,

[TABLE]

Furthermore, we have

[TABLE]

Moreover, the third term in RHS of (III-C) can be written as

[TABLE]

where proof of $(b)$ is similar to proof of $(a)$ in (III-C). Regarding the first term in RHS of (III-C), we have

[TABLE]

for some $k_{1}=\Theta(1)$ and large enough $n$. To derive inequality $(c)$, we find a stochastic upper bound on $T_{\mathsf{max}}$ by considering $n$ i.i.d. copies of the worker run-times with largest shift and smallest straggling parameters that are also $\Theta(1)$, and use the PDF of the maximum of $n$ i.i.d. exponential random variables. As we later use in the proof of Theorem 3, one can similarly write for the shifted Weibull distribution:

[TABLE]

for some constants $k_{1}$ and $k_{2}$. Therefore, using (III-C), (III-C) and (III-C) (or (III-C) for the shifted Weibull model) in (III-C) we have

[TABLE]

Let $\bm{\ell}_{\mathsf{OPT}}=(\ell_{\mathsf{OPT},1},\cdots,\ell_{\mathsf{OPT},n})$ denote the optimal load allocation corresponding to $\mathcal{P}_{\textnormal{main}}$ in (3) and $X_{\mathsf{OPT}}(\cdot)$ represent the aggregate return under load allocation $\bm{\ell}_{\mathsf{OPT}}$. Now we prove the following lower bound on the average completion time of the optimum algorithm:

[TABLE]

To this end, we show the following two inequalities,

[TABLE]

where $\delta_{1}=\Theta\left(\frac{\log n}{\sqrt{n}}\right)$, $\delta_{2}=\Theta\left(\frac{\log n}{\sqrt{n}}\right)$ and $\tau$ is the solution to $\mathbb{E}[X_{\mathsf{OPT}}(\tau)]=r.$ We have

[TABLE]

where we used the fact that $\ell_{\mathsf{OPT},i}=\Theta(1)$444We argue that the allocated loads in the optimum coded scheme are all $\Theta(1)$. Without loss of generality, suppose $\ell_{\mathsf{OPT},1}>\Theta(1)$ which implies $\lim_{n\to\infty}\Pr[T_{1}<t]=0$ for any $t=\Theta(1)$. We have already implemented HCMM, a (sub-)optimal algorithm achieving computation time $\tau^{*}=\Theta(1)$, therefore the optimal scheme should have a better finishing time $\tau\leq\Theta(1)$. Now assume the load of machine 1 is replaced by $\tilde{\ell}_{\mathsf{OPT},1}=\Theta(1)$. Clearly, for any time $t=\Theta(1)$, the aggregate return for the new set of loads is larger than the former one by any $\Theta(1)$ time, almost surely. This is in contradiction to optimality assumption.. By McDiarmid’s inequality (see Appendix for its description), we have

[TABLE]

which implies inequality $(d)$. We proceed to prove $(e)$ by showing the following two inequalities,

[TABLE]

[TABLE]

where $\tau^{*}$ is obtained in (11). Given the fact that HCMM maximizes the expected aggregate return, we have

[TABLE]

for every feasible $t$, which implies (18). Moreover, Lemma 1 proves (19). All in all, we have

[TABLE]

which yields $\lim_{n\to\infty}\mathbb{E}[T_{\mathsf{HCMM}}]=\lim_{n\to\infty}\mathbb{E}[T_{\mathsf{OPT}}]$ and the claim is concluded. ∎

III-D Comparison with Uncoded Schemes

This subsection provides the proof of Theorem 2 by comparing the performance of HCMM to uncoded scheme. In an uncoded scheme, the redundancy factor is $1$; thus, the master node has to wait for the results from all the worker nodes in order to complete the computation.

Proof of Theorem 2.

We start by characterizing the expected run-time of the best uncoded scheme. Particularly, we show that

[TABLE]

where $T_{\mathsf{UC}}$ denotes the completion time of the optimum uncoded distributed matrix multiplication algorithm. To do so, we start by showing that

[TABLE]

for a constant $c$ independent of $n$. For a set of machines with parameters $\{(a_{i},\mu_{i})\}_{i=1}^{n}$, let $\tilde{a}=\min_{i}a_{i}$ and $\tilde{\mu}=\max_{i}\mu_{i}$. Now, consider another set of $n$ machines in which every machine is replaced with a faster machine with parameters $(\tilde{a},\tilde{\mu})$. Since the computation times of the new set of machines are i.i.d., one can show that the optimal load allocation for these machines is uniform, i.e.,

[TABLE]

for every machine $i\in[n]$. Let $\{\widetilde{T}_{i}\}_{i=1}^{n}$ represent the i.i.d. shifted exponential random variables denoting the execution times for the new set of machines where each machine is loaded by $\widetilde{\ell}^{*}_{i}=\frac{r}{n}$. Therefore, the CDF of the completion time of each new machine can be written as

[TABLE]

for $t\geq\frac{\tilde{a}r}{n}$ and the expected computation time can be written as

[TABLE]

for all $i\in[n]$. Since the master needs to wait for all of the machines to return their results, the total run-time is $\widetilde{T}_{\mathsf{UC}}=\max_{i\in[n]}\widetilde{T}_{i}$. Therefore,

[TABLE]

where $H_{n}=1+\frac{1}{2}+\frac{1}{3}+\cdots+\frac{1}{n}$ is the sum of the harmonic series. We can further bound (20) using the fact that

[TABLE]

for a constant $c$ independent of $n$, since $r=\Theta(n)$, $\tilde{a}=\Theta(1)$, and $\tilde{\mu}=\Theta(1)$ for all $i\in[n]$. All in all, we have the following lower bound on the optimal uncoded scheme:

[TABLE]

Now consider another set of $n$ machines, where each machine is replaced with a slower one with parameters $(\hat{a},\hat{\mu})$ for $\hat{a}=\max_{i}a_{i}$ and $\hat{\mu}=\min_{i}\mu_{i}$. By an argument similar to the one employed the lower bound, we can write

[TABLE]

for another constant $C$. From (21) and (22), one can conclude that

[TABLE]

Further, by Theorem 1 and Lemma 1, we find that

[TABLE]

Comparing (23) to (24) demonstrates that HCMM outperforms the best uncoded scheme by a factor of $\Theta(\log n)$, i.e.,

[TABLE]

∎

IV Generalization to the Shifted Weibull Model and Proofs of Theorems 3 and 4

In this section, we consider the shifted Weibull distribution for the workers’ execution times, which captures a broader class of run-time models than the exponential distribution. We particularly generalize our proposed HCMM algorithm to the class of shifted Weibull distributed run-times and prove Theorems 3 and 4. More specifically, we argue that asymptotic optimality of HCMM is derived similar to the shifted exponential case and further show that HCMM provides unbounded gain over uncoded schemes, asymptotically.

A random variable $T$ has Weibull distribution with shape parameter $\alpha>0$ and scale parameter $\mu>0$, denoted by $T\sim\mathcal{W}(\alpha,\mu)$, if the CDF of $T$ is of the following form:

[TABLE]

The expected value of the Weibull distribution is known to be $\mathbb{E}[T]=\frac{1}{\mu}\Gamma(1+1/\alpha)$, where $\Gamma(\cdot)$ denotes the Gamma function.

As stated in Section II-B, we consider a 3-parameter shifted Weibull distribution for workers’ run-times defined in (2). The mean value of the worker $i$’s run-times is then $\mathbb{E}[T_{i}]=a_{i}\ell_{i}+\frac{\ell_{i}}{\mu_{i}}\Gamma(1+1/\alpha_{i})$. Clearly, shifted exponential distribution is a special case of the shifted Weibull model when $\alpha_{i}=1$. By slight reparameterizations, this model can be similarly applied to the HCMM algorithm proposed in Algorithm 1, meaning that the main and alternative optimization problems defined in (3), (4) and (5) can be similarly analyzed under the shifted Weibull model.

As in the exponential case, we begin by maximizing the expected aggregate return at the master node ($\mathcal{P}_{\textnormal{alt}}^{(1)}$) under the shifted Weibull distribution, which is given by

[TABLE]

The optimal load allocation that maximizes the individual expected aggregate returns at each worker (and thus the total aggregate return) can be found by solving the following equation:

[TABLE]

Solving (25) for $\ell_{i}$ yields $\ell_{i}^{*}(t)=\frac{t}{\lambda_{i}}$ where the constant $\lambda_{i}>a_{i}$ is the positive solution to

[TABLE]

Similar to Section III, we can define $s$ as follows,

[TABLE]

The last equality uses the fact that all the distribution parameters are constants. The expected aggregate return with optimal loads, $\mathbb{E}\left[X^{*}(t)\right]$, equals to $r$ at time $t=\tau^{*}$. Thus, $\tau^{*}=\frac{r}{s}=\Theta(1)$ and $\ell_{i}^{*}(\tau^{*})=\frac{\tau^{*}}{\lambda_{i}}=\frac{r}{s\lambda_{i}}=\Theta(1)$.

Proof of Theorem 3.

With the aforementioned reparametrizations of ${\lambda_{i}}$, $s$ and $\tau^{*}$, the HCMM algorithm defined in Algorithm 1 is identically applicable to the Weibull model. Proof of the asymptotic optimality of HCMM under the Weibull distribution follows the similar steps as in the proof for the exponential case in Section III-C (unless specifically justified, e.g. (III-C)). We avoid rewriting these steps for the purpose of readability of the paper, but we note that the concentration inequalities used to establish the proof of Theorem 1 can be applied to a wide class of distributions including the Weibull distribution. ∎

As an implication of Theorem 3, the induced expected execution time by HCMM algorithm is asymptotically constant, that is $\mathbb{E}[T_{\mathsf{HCMM}}]=\Theta(1)$; which was also the case for shifted exponential distribution. To compare with the uncoded scenario, we start by the following lemma which characterizes the extreme value of a sequence of Weibull random variables.

Lemma 2**.**

Let $\{T_{i}\}_{i=1}^{\infty}$ be a sequence of i.i.d. $\mathcal{W}(\alpha,\mu)$ random variables and $T^{*}_{n}=\max_{i\in[n]}T_{i}$ denote the maximum of the first $n$ variables. Then,

[TABLE]

Proof.

Consider the sequence of maximums $\{T^{*}_{i}\}_{i=1}^{\infty}$. From Markov’s inequality, we have $\frac{\mathbb{E}[T^{*}_{n}]}{t_{n}}\geq\Pr[T^{*}_{n}\geq t_{n}]$, for any $t_{n}>0$ and $n\in\mathbb{N}$. Pick t_{n}=\frac{1}{\mu}\big{(}\log n\big{)}^{1/\alpha}. Therefore,

[TABLE]

Therefore,

[TABLE]

which implies $\mathbb{E}[T^{*}_{n}]\geq\Theta\left((\log n)^{1/\alpha}\right)$. ∎

Now we complete the proof of Theorem 4.

Proof of Theorem 4.

Recall that $T_{\mathsf{UC}}$ denotes the completion time of the optimum uncoded distributed matrix multiplication algorithm across $n$ workers parametrized by tuples $\{(a_{i},\mu_{i},\alpha_{i},)\}_{i=1}^{n}$. To bound the mean of $T_{\mathsf{UC}}$, assume that every machine is replaced with a stochastically faster machine with parameters $(\tilde{a},\tilde{\mu},\tilde{\alpha})$ where $\tilde{a}=\min_{i}a_{i}$, $\tilde{\mu}=\max_{i}\mu_{i}$ and $\tilde{\alpha}=\max_{i}\alpha_{i}$, i.e., the expected run-time of the latter scenario is no greater than that of the former one. For the new set of $n$ identical machines, the optimal loading is uniform, i.e., $\widetilde{\ell}^{*}_{i}=\frac{r}{n}$. Let $\{\widetilde{T}_{i}\}_{i=1}^{n}$ denote the i.i.d. shifted Weibull run times for new set of machines which have CDFs of the form

[TABLE]

for $t\geq\frac{\tilde{a}r}{n}$. The mean of computation time for the new set of machines is

[TABLE]

where {\mathchoice{\widetilde{\hbox{\set@color\displaystyle\widetilde{T}}}}{\widetilde{\hbox{\set@color\textstyle\widetilde{T}}}}{\widetilde{\hbox{\set@color\scriptstyle\widetilde{T}}}}{\widetilde{\hbox{\set@color\scriptscriptstyle\widetilde{T}}}}}_{i}=\widetilde{T}_{i}-\frac{\tilde{a}r}{n} are i.i.d. $\mathcal{W}(\tilde{\alpha},\tilde{\mu}\frac{n}{r})$ for all workers $i\in[n]$. Using Lemma 2, we can write

[TABLE]

Comparing the best uncoded scheme with the proposed coded algorithm demonstrates that HCMM outperforms the best uncoded scheme by a factor of at least $\Theta\left((\log n)^{1/\tilde{\alpha}}\right)$, i.e.,

[TABLE]

∎

V Numerical Studies and Experiments using Amazon EC2 Machines

In this section, we present our results both from simulations as well as from experiments over Amazon EC2 clusters. These results demonstrate how HCMM can provide significant speedups in comparison to state-of-the-art load allocation schemes.

V-A Numerical Analysis

We now present numerical results evaluating the performance of HCMM. We consider both the shifted exponential model in (1) and the shifted Weibull model in (2) for run-time distributions in our simulations, assuming the unit seconds per row ($\text{s}/\text{row}$) for $a$ and $1/\mu$. The underlying computation task is to compute $r=10000$ inner products using a heterogeneous cluster of $n=100$ workers, where different scenarios for heterogeneity are considered. For each scenario under consideration, we implement the following load allocation schemes555For each scheme, the load number for each worker is approximated to the nearest larger integer using the $\mathtt{ceil()}$ function. For the practical large load regime considered in simulations, this rounding step has negligible impact on load allocation and on the overall results.:

Uniform Uncoded: Each worker is assigned an equal number of rows, i.e., $\ell_{i}=r/n$ for all workers $i$. 2. 2.

Load-balanced Uncoded: Each worker is assigned a load which is inversely proportional to its expected time for computing one inner product, i.e., for the shifted exponential model, $\ell_{i}\propto\mu_{i}/(a_{i}\mu_{i}+1)$, while for the shifted Weibull model, $\ell_{i}\propto\mu_{i}/(a_{i}\mu_{i}+\Gamma(1+1/\alpha_{i}))$ for all workers $i$. Furthermore, we set $\sum_{i=1}^{n}\ell_{i}=r$. 3. 3.

Uniform Coded: Equal number of coded rows are assigned to each worker. Redundancy is numerically optimized for minimizing the average computation time for receiving results of at least $r$ inner products at the master node. 4. 4.

HCMM: Each worker is assigned the asymptotically optimal load allocation derived in Section III-B, i.e., $\ell_{i}=\tau^{*}/\lambda_{i}$ for each worker $i$ according to (III-B) and (12).

For simulations under the shifted exponential model, we consider the following three scenarios:

• •

Scenario $\mathbf{1}$ ($\mathbf{2}$-mode heterogeneity): $(a_{i},\mu_{i})=(1,1)$ for $50$ workers, and $(a_{i},\mu_{i})=(4,0.5)$ for the other $50$ workers.

• •

Scenario $\mathbf{2}$ ($\mathbf{3}$-mode heterogeneity): $(a_{i},\mu_{i})=(1,0.5)$ for $25$ workers, $(a_{i},\mu_{i})=(4,2)$ for $25$ workers, and $(a_{i},\mu_{i})=(12,0.25)$ for the remaining $50$ workers.

• •

Scenario $\mathbf{3}$ (Random heterogeneity): For each worker $i$, parameters $a_{i}$ and $\mu_{i}$ are sampled from the sets $\{1,4,12\}$, $\{0.5,2,0.25\}$, respectively and all uniformly at random.

The following three scenarios are considered for simulations under the shifted Weibull distribution for run-times:

• •

Scenario $\mathbf{1}$ ($\mathbf{2}$-mode heterogeneity): $(a_{i},\mu_{i},\alpha_{i})=(1,1,1.2)$ for $50$ workers, and $(a_{i},\mu_{i},\alpha_{i})=(4,0.5,0.8)$ for the other $50$ workers.

• •

Scenario $\mathbf{2}$ ($\mathbf{3}$-mode heterogeneity): $(a_{i},\mu_{i},\alpha_{i})=(1,0.5,0.9)$ for $25$ workers, $(a_{i},\mu_{i},\alpha_{i})=(4,2,1.2)$ for $25$ workers, and $(a_{i},\mu_{i},\alpha_{i})=(12,0.25,1.5)$ for the remaining $50$ workers.

• •

Scenario $\mathbf{3}$ (Random heterogeneity): For each worker $i$, parameters $a_{i}$, $\mu_{i}$ and $\alpha_{i}$ are sampled from the sets $\{1,4,12\}$, $\{0.5,2,0.25\}$ and $\{0.9,1.2,1.5\}$, respectively and all uniformly at random.

Fig. 2 and 3 illustrate the performance comparison of the four schemes for the two run-time models. We make the following conclusions from the results.

• •

HCMM significantly outperforms the benchmark load allocation schemes. In particular, for the shifted exponential model, HCMM provides speedups of up to $71\%$ over Uniform Uncoded, up to $53\%$ over Load-balanced Uncoded, and up to $39\%$ over Uniform Coded, among the three scenarios. When the machine run-time is assumed to have a shifted Weibull distribution, among the three scenarios HCMM results in gains of up to $73\%$, $56\%$ and $42\%$ over Uniform Uncoded, Load-balanced Uncoded, and Uniform Coded respectively.

• •

The coding redundancy $\sum_{i=1}^{n}\ell_{i}/r$ for Uniform Coded is higher in comparison to the one for HCMM. In particular, for simulations under the shifted exponential model, the coding redundancy for the three scenarios is in the range of $2.3-2.8$ for Uniform Coded and in the range of $1.41-1.46$ for HCMM. For simulations under the shifted Weibull distribution, the coding redundancy is in the range of $2.0-2.5$ for Uniform Coded, while for HCMM, it is in the range $1.30-1.42$. This demonstrates that HCMM leads to a better utilization of computing resources.

• •

Both Load-balanced Uncoded and Uniform Coded improve upon the performance of Uniform Uncoded. In Load-balanced Uncoded scheme, assigning larger loads to faster machines leads to better performance, while for Uniform Coded, repeated computations lead to better performance as the master does not need to wait for all the results. HCMM provides the best expected execution time among the four schemes as it combines the gains of Load-balanced Uncoded and Uniform Coded by employing efficient load balancing along with minimal number of redundant computations.

Next, we present the results from our experiments over Amazon EC2 clusters. These results show agreement with our numerical studies.

V-B Experiments using Amazon EC2 machines

We use Python with mpi4py package [35] to implement our developed HCMM scheme over Amazon EC2 clusters. To emulate the straggler effects in large-scale systems [36], we inject artificial delays.666Artificial delays are injected since stragglers are rarely observed in small clusters in Amazon EC2. Though other emerging platforms such as federated learning, computation with deadline, mobile edge computing, fog computing, etc., still suffer from stragglers where our ideas can be employed [37]. This is achieved by selecting some workers to be stragglers at the beginning of experiments and slowing down each such worker by making it wait for $3$ times the amount of time it spends in computation before it sends its results to the master. This is done using the sleep() function in time package. For each scenario, the choice of stragglers is made by drawing a sample from the Bernoulli$(0.5)$ distribution for each worker, i.e., each worker is chosen to be a straggler with probability $0.5$.

In line with our simulation studies, we compare the performance of HCMM with the three benchmark load allocation schemes. For Load-balanced Uncoded, the number of uncoded rows $\ell_{i}$ assigned to a worker $i$ is proportional to the number of virtual CPUs, and the loads are normalized to have a sum equal to $r$. For the encoding and the decoding steps for Uniform Coded as well as HCMM, we utilize the Luby transform (LT) codes with peeling decoder which provides nearly linear decoding complexity [38]. Utilization of LT codes for distributed computing is proposed in [39] as well. However, they perform a homogeneous load allocation by assigning an equal number of rows of the encoded data matrix to each worker and hence do not capture the heterogeneity of the computing cluster in distributing the encoded data matrix. Towards this end, we relax our goal of recovering all the inner products from any $r$ of the coded inner products to recovering all the inner products from any $r^{\prime}=r(1+\epsilon)$ coded inner products with high probability. Ideally, we would like to have $\epsilon>0$ to be as small as possible. In our experiments, we keep $r=10000$, and based on the results in [39], we use the robust Soliton degree distribution with $(c,\delta)=(0.03,0.1)$ and select $\epsilon=0.13$, where $c$ is a tuning parameter and $\delta$ is a bound on the probability of failure of decoding from a certain number of received coded inner products (see [39] for details). Therefore, for both HCMM and Uniform Coded, we design the load allocation such that the master needs to wait only for $r^{\prime}=11300$ coded inner products. The total computation time is equal to the waiting time for $r^{\prime}=11300$ results plus the average time for decoding the $r=10000$ inner products from the received $r^{\prime}=11300$ coded inner products.777The average time for decoding $r=10000$ inner products from any $r(1+\epsilon)$ coded inner products is obtained using a

m4.xlarge

instance. For HCMM, we use the shifted exponential distribution for estimating the computation model for each worker.

For performance comparison of the four schemes, we consider the following three computing scenarios:

• •

Scenario $\mathbf{1}$: Each row has $500000$ elements. We use a heterogeneous cluster of $11$ machines – one master of instance type

m4.xlarge

, four workers of instance type

r4.2xlarge

, and six workers of instance type

r4.xlarge

.

• •

Scenario $\mathbf{2}$: Each row has $500000$ elements. We use a heterogeneous cluster of $16$ machines – one master of instance type

m4.xlarge

, six workers of instance type

r4.2xlarge

, and nine workers of instance type

r4.xlarge

.

• •

Scenario $\mathbf{3}$: Each row has $1000000$ elements. We use the same heterogeneous cluster as in the previous scenario.

Fig. 4 provides a performance comparison of HCMM with the benchmark load allocation schemes for the three scenarios, where the decoding time is taken into account as well. Fig. 5 presents the typical cumulative distribution functions for the instances used in the experiments. We make the following conclusions from the results:

• •

As demonstrated in Fig. 5, the shifted exponential model is a good first order fit for the run-times of the workers.

• •

HCMM achieves significant speedups over the benchmark load allocation policies. In particular, HCMM combined with LT codes provides gains in the overall execution time of up to $61\%$ over Uniform Uncoded, up to $46\%$ over Load-balanced Uncoded, and up to $36\%$ over Uniform Coded.

• •

As presented in Table I, HCMM has significantly lower total computation load compared to Uniform Coded. Hence, HCMM leads to efficient utilization of the computing resources, combining the benefits of both Load-balanced Uncoded and Uniform Coded schemes.

These results demonstrate that HCMM can provide significant speedups in large-scale computing environments.

VI Generalization to Computing Scenarios under Budget Constraints

In this section, we consider the optimization problem in (3) under the shifted exponential distribution with a monetary constraint for carrying out the overall computation. Running computation tasks on a commodity server costs depending on several factors including CPU, memory, ECU, storage, bandwidth, etc. Different cloud computing platforms employ different pricing policies, and these need to be taken into account for developing efficient task allocation and execution algorithms [40, 41, 42, 43, 44]. For example, Table II summarizes the cost per hour of using Amazon EC2 clusters with different parameters (at the time of writing this manuscript) [45]. In this section, we take into account the monetary constraint in the optimization problem in (3) and provide a heuristic algorithm towards finding the optimal load allocation under cost budget constraint.

We now present the precise problem formulation we are interested in. For a computation task and a given set of $N$ machines, the goal is to minimize the expected run-time while satisfying the budget constraint $C$, that is

[TABLE]

where $c_{i}$ represents the cost per time unit of using machine $i\in[N]$. According to the pricing polices provided by AWS, e.g. Table II, a linear model for cost (versus performance parameters) is intuitive and convincing. Considering the last two rows of Table II for instance, doubling the parameters results in doubled cost. To be general, we model the computation cost of a single machine as $c=\kappa\mu^{\gamma}$ per unit of time, which captures a convex dependency of the speed parameter $\mu$ for constants $\gamma\geq 1$ and $\kappa>0$.

We assume that there are $K$ types of machines parameterized with $\{(a_{k},\mu_{k})\}_{k=1}^{K}$, and $N_{k},k\in[K]$ of each type is available to run a distributed computation task, where $N=\sum_{k=1}^{K}N_{k}$ is the total number of available machines. We also assume that $\mu_{1}\leq\cdots\leq\mu_{K}$ and $a_{1}\mu_{1}=\cdots=a_{K}\mu_{K}=\xi$ for a constant $\xi$.888The latter assumption can be intuitively justified as follows. If a machine is $c$ times more powerful than another machine, as the first order estimation, one can assume that both the shift ($a_{k}$) and the straggling parameter ($\mu_{k}$) of the computation are $c$ times stronger. As we showed in Theorem 1, HCMM is asymptotically optimal (i.e. optimal within a vanishing deviation) regarding the average run-time. In this section, we also consider the asymptotic regime, i.e. for large enough number of machines and hence HCMM attains the optimality per $\mathcal{P}_{\textnormal{main}}$ in (3).

The following lemma states a useful observation regarding the solutions to the constrained problem $\mathcal{P}_{\textnormal{main-constrained}}$ and the minimum possible cost for carrying out a computation task.

Lemma 3**.**

HCMM is the (asymptotic) solution to the feasible $\mathcal{P}_{\textnormal{main-constrained}}$. Moreover, given a computation task and a set of machines, decreasing the number of fastest (slowest) machines in HCMM, results in smaller (greater) expected cost. And, the minimum (maximum) cost of HCMM is induced by running the task only on any number of the slowest (fastest) machines.

Proof.

We first argue that if the budget-constrained problem defined in $\mathcal{P}_{\textnormal{main-constrained}}$ is feasible, then HCMM determines the asymptotically optimal load allocation. Consider a set of $N$ machines and assume that $M$ of them are assigned non-zero loads in the optimal budget-constrained scheme. Now, one can run HCMM load allocation over the set of these $M$ machines and according to asymptotic optimality results, HCMM asymptotically attains the optimal run-time while satisfying the budget constraint.

Now assume that $n_{k}$ number of type $k\in[K]$ machine is used. Then, by assigning the loads obtained from HCMM and the result of Theorem 1, the induced expected cost (for large number of machines) can be written as

[TABLE]

where $x_{\xi}=1+\mu_{k}\lambda_{k}$ is the solution to the equation $e^{x_{\xi}-\xi-1}=x_{\xi}$ for all machine type $k\in[K]$. In another scenario, assume that we remove one machine of type $K$ (the fastest machine type) and run HCMM accordingly, i.e. $n_{k}$ of type $k\in[K-1]$ and $n_{K}-1$ of type $K$. The expected cost of this scenario can be written as follows:

[TABLE]

where inequality $(f)$ can be easily verified given that $\mu_{1}\leq\cdots\leq\mu_{K}$. We can iteratively apply the same argument and conclude that the minimum expected cost is achieved when only the slowest machines are used, that is

[TABLE]

for any $1\leq n_{1}\leq N_{1}$. Similar to (VI), one can show that reducing the number of participating slowest machines increases the induced expected cost of HCMM, that is

[TABLE]

Therefore, applying (VI) iteratively shows that the maximum expected cost occurs when only the fastest machines are employed, that is

[TABLE]

for any $1\leq n_{K}\leq N_{K}$. ∎

Lemma 3 implies that if the available budget $C$ is less than $C_{\text{min}}$ defined in (29), then $\mathcal{P}_{\textnormal{main-constrained}}$ is infeasible and it is impossible to run the task on the given set of machines while satisfying the budget constraint. Moreover, reducing one machine from the available set of fastest machines along with HCMM results in a lower expected cost; and reducing the number of participating slowest machines results in a larger expected cost.

Now that HCMM asymptotically solves the feasible budget-constrained problem in (26), i.e. for $C\geq C_{\text{min}}$, finding the optimal number of machines of each type to use in HCMM requires combinatorial search over all possible allocations. However, as Lemma 3 suggests, using faster machines induces a larger cost. Further, the computation time increases if we decrease the number of machines. This is the motivation behind our heuristic algorithm for an efficient search to find the number of machines of each type to include in HCMM, which we describe next.

First, Algorithm 2 runs HCMM algorithm using all machines, i.e., $n_{k}=N_{k}$ for each $k\in[K]$. Then, it calculates the corresponding cost according to (VI). If the cost is $>C$, it starts to decrease the number of available fastest machines, i.e. $n_{K}\leftarrow n_{K}-1$, and runs HCMM again. While the cost is $>C$, the algorithm keeps decreasing the number of used fast machines till $n_{K}=0$. Then, the algorithm sets $n_{K}=0$ and starts decreasing $n_{K-1}$ and so on, until a feasible cost is achieved. Thus, the algorithm returns $(N_{1},\cdots,N_{j},n_{j+1},0,\cdots,0)$ which is the first tuple that satisfies the cost constraint. Therefore, the search space complexity of the heuristic is $\mathcal{O}(N_{1}+\cdots+N_{K})=\mathcal{O}(N)$ which is more efficient than the exhaustive search where the complexity is $\mathcal{O}(N_{1}\cdots N_{K})$. The pseudo-code in Algorithm 2 summarizes the heuristic.

Example**.**

In this example, we consider two different scenarios to demonstrate the application of the proposed heuristic search algorithm. For the cost model, we assume $\gamma=2$ and $\kappa=1$, i.e. $c=\mu^{2}$. Further, we consider the task of computing $r=100$ equations.

• •

Scenario $\mathbf{1}$: Two types of machines are available parameterized by $(a_{1},\mu_{1})=(0.5,2)$ and $(a_{2},\mu_{2})=(0.25,4)$, assuming $10$ machines available of each type. Further, the available budget is $C=860$. Using Lemma 3, the minimum and maximum induced costs are $C_{\text{min}}=629.2$ and $C_{\text{max}}=1258.4$. As $C\geq C_{\text{min}}$, there exists an HCMM load allocation which is asymptotically optimal per (26). Applying the proposed heuristic search, it takes $9$ iterations (see Fig. 6 and 7) to arrive at the load allocation $(n_{1},n_{2})=(10,2)$ which corresponds to the expected cost $808.9$ and average execution time $\mathbb{E}[T_{\mathsf{HCMM}}]=11.23$.

• •

Scenario $\mathbf{2}$: Three types of machines are available which are parameterized by $(a_{1},\mu_{1})=(1,1),\,(a_{2},\mu_{2})=(0.5,2)$ and $(a_{3},\mu_{3})=(0.125,8)$, assuming $10$ machines of each type available. Further, the available budget is $C=475$. Using Lemma 3, the minimum and maximum induced costs for the task of computing $r=100$ equations are $C_{\text{min}}=314.6$ and $C_{\text{max}}=2516.8$ respectively. It takes $15$ iterations for the proposed heuristic search algorithm to arrive at the tuple $(n_{1},n_{2},n_{3})=(10,6,0)$. This corresponds to the expected cost $486.2$ and the average time $\mathbb{E}[T_{\mathsf{HCMM}}]=14.3$.

VII Conclusion

In this paper, we proposed a coding framework for distributed matrix-vector multiplication in heterogeneous cloud computing environments. In particular, we considered two distributions for machines’ run-times, i.e. shifted exponential and shifted Weibull and tackled the intractable problem of minimizing the average run-time of a computation task over all possible load allocations by proposing a tractable alternative formulation. The solution to the alternative problem established our proposed HCMM load allocation scheme which we proved to be asymptotically optimal. We also demonstrated the speedup of HCMM over three benchmark load allocation schemes and presented both the numerical and the experimental results. Experiments over Amazon EC2 clusters demonstrate that HCMM combined with LT codes and peeling decoders can provide significant gains in the average overall execution time. Moreover, we argued that HCMM is the asymptotically optimal allocation in budget-constrained scenarios as well, which led to providing a heuristic search in order to find a (sub)optimal load-machine assignment for a given set of machines while satisfying a pre-defined budget constraint.

VIII Acknowledgment

This material is based upon work supported by Defense Advanced Research Projects Agency (DARPA) under Contract No. HR001117C0053, ARO award W911NF1810400, NSF grants CCF-1703575, ONR Award No. N00014-16-1- 2189, CCF-1763673, CCF-1755808 and the UC Office of President under grant No. LFR-18-548175. The views, opinions, and/or findings expressed are those of the author(s) and should not be interpreted as representing the official views or policies of the Department of Defense or the U.S. Government.

Appendix A

McDiarmid’s Inequality: Let $X_{1},\cdots,X_{n}$ be independent random variables taking values in $\mathcal{X}$. Further, let the function $f:\mathcal{X}^{n}\to\mathbb{R}$ be $L_{i}$-Lipschitz for all $i\in[n]$, that is

[TABLE]

for any $x_{1},\cdots,x_{n},x^{\prime}_{i}\in\mathcal{X}$ and $i\in[n]$. Then, for any $\epsilon>0$,

[TABLE]

[TABLE]

For each $i$, the aggregate return at time $t$ satisfies $X_{i}(t)\in\{0,\ell_{i}\}$. Therefore, we can use McDiarmid’s inequality as follows:

[TABLE]

[TABLE]

for any $\epsilon>0$. Now, we proceed to the proof of Lemma 1.

Proof of Lemma 1.

Let $t=\tau^{*}+\delta$ for some $\delta=\Theta\left(\frac{\log n}{\sqrt{n}}\right)$ and $\epsilon=\delta^{2}$. The claim is that \Pr\big{[}X^{*}(t)\leq r-\epsilon\big{]}=o\left(\frac{1}{n}\right). From McDiarmid’s inequality, we have

[TABLE]

In above, equality $(g)$ follows from the fact that $r=\Theta(n)$, $s=\Theta(n)$, $\lambda_{i}=\Theta(1)$, $\delta=\Theta\left(\frac{\log n}{\sqrt{n}}\right)$, and therefore $\sum_{i}\lambda_{i}^{2}=\Theta(n)$ and $s^{2}=\Theta(n^{2})$. Moreover, if $t^{*}<\tau^{*}$, with a positive probability there are less than $r$ equations at the master node by time $t^{*}$ which is a contradiction. Therefore,

[TABLE]

∎