Communication-Aware Computing for Edge Processing

TL;DR

This paper introduces a universal coded edge computing scheme that optimizes computation load and wireless communication efficiency in mobile edge networks by creating interference-free transmission through coding.

Contribution

It proposes a novel universal coded scheme for linear functions in edge computing that reduces computation load and enhances wireless communication without channel state knowledge.

Findings

Minimized computation load at edge nodes

Maximized physical-layer communication efficiency

Achieved interference-free wireless transmission

Abstract

We consider a mobile edge computing problem, in which mobile users offload their computation tasks to computing nodes (e.g., base stations) at the network edge. The edge nodes compute the requested functions and communicate the computed results to the users via wireless links. For this problem, we propose a Universal Coded Edge Computing (UCEC) scheme for linear functions to simultaneously minimize the load of computation at the edge nodes, and maximize the physical-layer communication efficiency towards the mobile users. In the proposed UCEC scheme, edge nodes create coded inputs of the users, from which they compute coded output results. Then, the edge nodes utilize the computed coded results to create communication messages that zero-force all the interference signals over the air at each user. Specifically, the proposed scheme is universal since the coded computations performed at the edge nodes are oblivious of the channel states during the communication process from the edge nodes to the users.

Equations

$$\text{vspace}-0.5mm{\varphi }_b(\alpha {\mathbf{d}}_m[i]+\beta {\mathbf{d}}_n[j])=\alpha {\varphi }_b({\mathbf{d}}_m[i])+\beta {\varphi }_b({\mathbf{d}}_n[j]),$$

$${\mathcal{L}}_m^{(j)}=\sum _{i=1}^F\sum _{k=1}^K{\alpha }_{mk}^{(j)}[i]{\mathbf{d}}_k[i],$$

$$s_{mb}^{(j)}={\varphi }_b({\mathcal{L}}_m^{(j)}).$$

$$X_m(t)={\psi }_m(t)(\{s_{mb}^{(j)}:b\in {\mathcal{W}}_m^{(j)}{\}}_{j=1}^{{\ell }_m}).$$

$$\text{vspace}-0.5mm{Y}_k(t)=\sum _{m=1}^M{h}_{km}(t)X_m(t)+Z_k(t),\text{vspace}-0.5mm$$

$${\hat{\varphi }}_b({\mathbf{d}}_k[i])={\rho }_{kb}[i](\{Y_k(t){\}}_{t=1}^T).$$

$$D_{kb}[i]=\mathbb{E}\{({\hat{\varphi }}_b({\mathbf{d}}_k[i])-{\varphi }_b({\mathbf{d}}_k[i]){)}^2\}.$$

$$\underset{P\to \infty }{\lim }\frac{\log (1/D_{kb}[i])}{\log P}=1.$$

$$s_{1t}^{(t)}$$

$$s_{2t}^{(t)}$$

$$\left[\begin{array}{c}{X}_1(1)\\ X_1(2)\end{array}\right]$$

$$={\mathbf{v}}_{11}{y}_{11}(1)+{\mathbf{v}}_{12}(y_{12}(1)+y_{21}(1)),$$

$$\left[\begin{array}{c}{X}_2(1)\\ X_2(2)\end{array}\right]$$

$${\mathcal{L}}_m^{(p_{11},p_{12},\dots ,p_{KK})}=\sum _{k=1}^K{\mathbf{d}}_k^{(p_{11},p_{12},\dots ,p_{km}-1,\dots ,p_{KK})}.$$

$$s_{mb}^{(p_{11},p_{12},\dots ,p_{KK})}$$

$$\displaystyle=\sum_{k=1}^{K}\phi_{b}\big{(}{\bf d}_{k}^{(p_{11},p_{12},\ldots,p_{km}-1,\ldots,p_{KK})}\big{)},$$

$$\mathbf{H}(t)=\left[\begin{array}{ccc}{h}_{11}(t)& \cdots & h_{1K}(t)\\ ⋮& \ddots & ⋮\\ h_{K1}(t)& \cdots & h_{KK}(t)\end{array}\right],$$

$$\mathbf{B}(t)=\left[\begin{array}{ccc}{b}_{11}(t)& \cdots & b_{K1}(t)\\ ⋮& \ddots & ⋮\\ b_{1K}(t)& \cdots & b_{KK}(t)\end{array}\right]\triangleq \mathbf{H}(t{)}^{-1},$$

$$\displaystyle X_{m}(t)\!=\!\gamma\!\!\!\!\!\sum_{{\bf p}\in\Delta_{N+1}}\!\!Q(t)^{\bf p}s_{m1}^{\bf p}\!=\!\!\gamma\!\!\!\sum_{{\bf p}\in\Delta_{N}}\!\!Q(t)^{\bf p}\!\bigg{(}\sum_{k=1}^{K}\!b_{km}(t)\phi_{1}({\bf d}_{k}^{\bf p})\!\!\bigg{)},$$

$$\left[\begin{array}{c}{Y}_1(t)\\ ⋮\\ Y_K(t)\end{array}\right]$$

$$=\mathbf{B}(t{)}^{-1}\gamma \sum _{\mathbf{p}\in {\Delta }_N}Q(t{)}^{\mathbf{p}}\mathbf{B}(t)\left[\begin{array}{c}{\varphi }_1({\mathbf{d}}_1^{\mathbf{p}})\\ ⋮\\ {\varphi }_1({\mathbf{d}}_K^{\mathbf{p}})\end{array}\right]+\left[\begin{array}{c}{Z}_1(t)\\ ⋮\\ Z_K(t)\end{array}\right]$$

$$=\gamma \sum _{\mathbf{p}\in {\Delta }_N}Q(t{)}^{\mathbf{p}}\left[\begin{array}{c}{\varphi }_1({\mathbf{d}}_1^{\mathbf{p}})\\ ⋮\\ {\varphi }_1({\mathbf{d}}_K^{\mathbf{p}})\end{array}\right]+\left[\begin{array}{c}{Z}_1(t)\\ ⋮\\ Z_K(t)\end{array}\right].$$

Full text

I Introduction

We consider a mobile edge computing (or fog computing) scenario (see e.g., [1, 2, 3]), in which as shown in Fig. 1, a set of $K$ mobile users, denoted by User $i$ ($i=1,\ldots,K$), offload their computation tasks to a set of $M$ computing nodes scattered at the network edge, which are called the edge nodes and denoted by EN $j$ ($j=1,\ldots,M$). Each User $i$ ($i=1,\ldots,K$) has an input ${\bf d}_{i}$, and requests the computation of an output $\boldsymbol{\phi}({\bf d}_{i})$, which is performed at the edge nodes. The overall computation proceeds in two phases: the computation phase, and the communication phase. In the computation phase, the edge nodes compute all output results for all users. In the communication phase, the edge nodes communicate the the computed results back to the users through wireless links.

One example of the above computing scenario is object recognition and collaborative filtering, which is the key enabler of many augmented reality and machine learning applications. In this case, mobile users are smartphones that want to recognize the pictures captured by their cameras, using a large common database that is stored at the edge nodes (e.g., routers and base stations). During the computation process, the smartphones upload their pictures (or their feature vectors) to the edge nodes. The edge nodes then process the pictures over the database, and return the recognition results to the users. Hence, the pictures (or their feature vectors) correspond to the users’ inputs (${\bf d}_{i}$’s) and the recognition results correspond to the requested outputs ($\boldsymbol{\phi}({\bf d}_{i})$’s). Similar operations are also commonly seen in other mobile edge computing applications like navigation and recommendation systems.

We aim to understand how to design the computations across the edge nodes, in order to maximize the physical-layer efficiency (i.e., design the optimum communication-aware computing schemes). We note that as we perform more computations, the spectral efficiency increases. For example, consider the case where we have the same number of edge nodes as the users (i.e., $M=K$), and every single node computes all $K$ outputs (i.e., a computation load of $K^{2}$). In this case, since all output results are available at all nodes, effectively, we have a $K\times K$ multiple-input single-output (MISO) broadcast channel on the physical layer, which can be diagonalized into $K$ parallel interference-free channels, and the requested outputs of all users can be delivered simultaneously using one unit of communication load.

The above scheme represents one rather trivial point in the set of all possible computation-communication load pairs that accomplish the computation task and deliver the results, denoted by the computation-communication load region. In this paper, our objective is to formalize and characterize the entire load region for edge processing. In particular, we focus on universal schemes in which the edge nodes perform the computations without knowing the channel gains towards the users in the upcoming communication phase. Universal computation is in fact a common practice in mobile computing systems (see e.g., [4, 5]), where the computation phase and the communication phase are executed independently of each other. This is primarily due to the fact that the channel state information (CSI) at the communication phase cannot be predicted ahead of time at the computation phase.

Our main result is a full characterization of the computation-communication load region for linear output functions. In particular, we show that the load region is dominated by one corner point that simultaneously achieves the minimum computation load and the maximum spectral efficiency. To establish this result, we first argue that each edge node should execute coded computations, in which computation tasks are executed on some linear combinations of the inputs, rather than executing the task on each input individually. We then propose a Universal Coded Edge Computing (UCEC) scheme, in which coded computations are performed at the edge nodes to create messages that neutralize all interference signals in the upcoming communication phase. In particular, the edge nodes create coded inputs, each as the sum of certain carefully selected users’ inputs, and pass them into the output functions to compute coded results. The coded computation at each node is such that (i) it achieves the minimum computation load of 1 computation unit/user’s input, (ii) it is independent of CSI in communication phase, i.e., it is universal, (iii) no matter what the CSI in communication phase is, the coded computation results allow the edge nodes to create messages that cancel all interference signals over the air and achieve the maximum spectral efficiency of 1 symbol/user/channel use.

The coding technique in the proposed UCEC scheme is motivated by the “Aligned Network Diagonalization” technique in [6], and the “Aligned Interference Neutralization” technique in [7], for communications over a two-hop relay network. In particular, we develop the coded computations, following the patterns of aligned signals recovered at the relays in [6, 7]. These aligned signals can be used for signaling over the next hop of the relays such that all interference are cancelled at the destinations. We notice and exploit in this paper the fact that the aligned signals at the relays are independent of CSI of the next hop. While this property is completely irrelevant in communication over the two-hop relay network, it allows us to decouple computation phase from communication phase and form universal computing schemes for edge processing.

Finally, while in this paper we focus on the case where the entire dataset used to process the requests is stored on each edge node, we can also consider the setting where each edge node only stores a part of the dataset and need to work collaboratively to meet the computational needs. For this setting, recent works [8, 9, 10, 11, 12, 13] have proposed to use coding to minimize the load of communication between edge nodes. An interesting future direction is to design optimal coding schemes for a framework that accounts for communications both from edge nodes to the users and between edge nodes.

II Problem Formulation

We consider a mobile edge computing problem, in which $K$ mobile users (e.g., smartphones) offload their computation tasks to $M$ edge nodes (e.g., base stations), for some $K,M\in\mathbb{N}$. We denote the $K$ users as User 1$$,\ldots, User $K$, and the $M$ edge nodes as EN 1$$,\ldots, EN $M$. User $k$, $k=1,\ldots,K$, has a sequence of input vectors $({\bf d}_{k}[i])_{i=1}^{\infty}$ (e.g., pictures of objects in an object recognition application), where for each $i\in\mathbb{N}$, ${\bf d}_{k}[i]\in\mathbb{R}^{Q}$, for some $Q\in\mathbb{N}$. For each input vector ${\bf d}_{k}[i]$, User $k$ wants to compute $B$ output functions (e.g., recognition results) $\phi_{1},\ldots,\phi_{B}:\mathbb{R}^{Q}\rightarrow\mathbb{R}$, for some $B\in\mathbb{N}$.

Example: Matrix Multiplication. One example of the above computation is matrix-vector multiplication, in which each user wants to compute a sequence of output vectors from a dataset matrix ${\bf A}$ stored at the edge nodes. That is, for each input vector ${\bf d}_{k}[i]$, $i\in\mathbb{N}$, User $k$ requests the output vector $[\phi_{1}({\bf d}_{k}[i]),\ldots,\phi_{B}({\bf d}_{k}[i])]^{T}={\bf A}{\bf d}_{k}[i]$, for all $k=1,\ldots,K$. This type of computation commonly arises in many machine learning algorithms. For example, in the gradient decent algorithm for linear regression, when computing the gradient in the current iteration, we need to multiply the data matrix with the model vector from the previous iteration. $\hfill\square$

In this paper, we focus on linear functions such that

[TABLE]

for any coefficients $\alpha,\beta\in\mathbb{R}$, $m,n\in\{1,\ldots,K\}$, $i,j\in\mathbb{N}$, and all $b=1,\ldots,B$.

The computation proceeds over a block of $F$ input vectors at each user, for some $F\in\mathbb{N}$. The computation process consists of the computation phase and the communication phase. In the computation phase, the $M$ edge nodes compute some output functions from the input vectors ${\bf d}_{1}[i],\ldots,{\bf d}_{K}[i]$, for all $i=1,\ldots,F$. In the communication phase, the edge nodes communicate the computed results to the intended users.

II-A Computation Phase

In the beginning of the computation phase, EN $m$, $m=1,\ldots,M$, is given $\ell_{m}$ linear combinations of the users’ inputs, denoted by $\mathcal{L}^{(1)}_{m},\ldots,\mathcal{L}^{(\ell_{m})}_{m}$, for some $\ell_{m}\in\mathbb{N}$, i.e.,

[TABLE]

for some coefficients $\alpha_{mk}^{(j)}[i]\in\mathbb{R}$, and $j=1,\ldots,\ell_{m}$.

For each linear combination $\mathcal{L}_{m}^{(j)}$ and a subset $\mathcal{W}_{m}^{(j)}\subseteq\{1,\ldots,B\}$, $j=1,\ldots,\ell_{m}$, EN $m$ computes a function $s_{mb}^{(j)}:\mathbb{R}^{Q}\rightarrow\mathbb{R}$, such that for each $b\in\mathcal{W}_{m}^{(j)}$,

[TABLE]

Definition 1** (Computation Load).**

We define the computation load, denoted by $r$, as the total number of functions computed across all edge nodes, normalized by the total number of required functions. That is, $r\triangleq\frac{\sum_{m=1}^{M}\sum_{j=1}^{\ell_{m}}|\mathcal{W}_{m}^{(j)}|}{FKB}$. $\hfill\Diamond$

II-B Communication Phase

After the computation phase, the edge nodes communicate the computed results back to the users. We consider a communication scheme that ranges over $T$ time slots, for some $T\in\mathbb{N}$. The symbol communicated by EN $m$ at time $t$, $t=1,\ldots,T$, denoted by $X_{m}(t)\in\mathbb{R}$, is generated as a function, denoted by $\psi_{m}(t)$, of the functions computed locally at EN $m$ in the computation phase, for all $m=1,\ldots,M$, i.e.,

[TABLE]

Each edge node has an average power constraint of $P$.

The received symbol at User $k$ in time $t$, $t=1,\ldots,T$,

[TABLE]

where $h_{km}(t)\in\mathbb{R}$, $k=1,\ldots,K$, $m=1,\ldots,M$, is the channel gain from EN $m$ to User $k$ in time $t$. The channel gains $\{h_{km}(t):k=1,\ldots,K,\,m=1,\ldots,M\}_{t=1}^{T}$ are time-varying, and they are drawn i.i.d. from a continuous distribution with a bounded second moment. We assume that in the communication phase, the instantaneous channel state information is available at all edge nodes. $Z_{k}(t)\sim\mathcal{N}(0,1)$ is the additive white Gaussian noise at User $k$ in time $t$.

Definition 2** (Communication Load).**

We define the communication load, denoted by $L$, as the total number of communication time slots $T$ normalized by the total number of output functions required by each user, i.e., $L\triangleq\frac{T}{FB}$. $\hfill\Diamond$

After $T$ time slots of communication, User $k$, $k=1,\ldots,K$, for each $i=1,\ldots,F$, and each $b=1,\ldots,B$, reconstructs the intended output function $\phi_{b}({\bf d}_{k}[i])$ using a decoding function $\rho_{kb}[i]$. That is, the reconstructed output function

[TABLE]

We assume that all input vectors are arbitrary random vectors, and each of the computed output functions is a random variable with finite variance. We define the distortion of the output function $\phi_{b}$ of the input vector ${\bf d}_{k}[i]$ from User $k$ as

[TABLE]

We say that a computation-communicate load pair $(r,L)$ is achievable, if there exist a computation scheme with a computation load of $r$ and a communication load of $L$, such that by the end of the communication phase, User $k$, $k=1,\ldots,K$, can obtain a noisy version of $\phi_{b}({\bf d}_{k}[i])$, for all $b=1,\ldots,B$, and all $i=1,\ldots,F$, or more precisely,

[TABLE]

We define the computation-communication load region, denoted by ${\cal C}$, as the closure of the set of all achievable computation-communication load pairs.

III Motivation and Main Results

For the mobile edge computing scenario formulated in the previous section, since each output function needs to be computed at least once, the minimum computation load is at least 1. On the other hand, in the communication phase, even when we can create parallel communication channels for the $K$ users, we need to use the channel at least $FB$ times, one for delivering an output function required by a single user. Hence, the minimum communication load is also at least 1.

Given the above individual lower bounds on the computation load and the communication load, We ask the following question: Can we achieve the minimum computation load and the minimum communication load simultaneously? Or is there an edge computing scheme that achieves the load pair $(1,1)$? We first show through the following example, the achievability of the $(1,1)$ pair when the edge nodes know the channel gains towards the users when executing the computation phase.

Example 1** (“Zero-Forcing Ready” Coded Computing).**

We consider a scenario in which $K=2$ mobile users offload their computation tasks to $M=2$ edge nodes. User $k$, $k=1,2$, has an input vector ${\bf d}_{k}\in\mathbb{R}^{Q}$, and wants to compute a length-$B$ output vector ${\bf y}_{k}={\bf A}{\bf d}_{k}$, for some data matrix ${\bf A}\in\mathbb{R}^{B\times Q}$.

In this case, we consider a communication phase of $T=B$ time slots, i.e., a communication load of $L=1$, and we assume that the channel gains $\{h_{11}(t),h_{12}(t),h_{21}(t),h_{22}(t)\}_{t=1}^{B}$ are known at the two edge nodes in the computation phase.

In the computation phase, for each $t=1,\ldots,B$, EN 1 generates a linear combination of the two input vectors $\mathcal{L}^{(t)}_{1}=-h_{22}(t){\bf d}_{1}+h_{12}(t){\bf d}_{2}$, and EN 2 also generates a linear combination $\mathcal{L}_{2}^{(t)}=h_{21}(t){\bf d}_{1}-h_{11}(t){\bf d}_{2}$. Then, as shown in Fig. 2, for the $t$-th row of ${\bf A}$, denoted by ${\bf a}_{t}$, $t=1,\ldots,B$, EN 1 and EN 2 respectively computes

[TABLE]

where $y_{k}(t)$ is the $t$th element of the output vector ${\bf y}_{k}$. We perform $B$ coded computations at each of the two ENs, achieving a computation load of $r=1$.

In the communication phase, at time $t$, $t=1,\ldots,B$, EN $k$, $k=1,2$, simply sends $X_{k}(t)=\gamma s^{(t)}_{kt}$, where $\gamma$ is some factor enforcing the power constraint. As a result, as shown in Fig. 2, User $k$, $k=1,2$, receives a noisy version of $y_{k}(t)$, i.e., ${\cal L}(y_{k}(t))$. Therefore, we have successfully performed the computation task, and simultaneously achieved the minimum computation load and the minimum communication load. $\hfill\square$

Remark 1*.*

We note that in order to achieve the minimum computation load and the minimum communication load simultaneously, it is critical to perform coded computations at the edge nodes, which can create a linear combination of the output functions using one computation unit. Also, the coding needs to be communication-aware, such that the computed coded results can be directly utilized to create messages that zero-force the interference signals over the air at each user. $\hfill\square$

While the above example shows the achievability of the optimum load pair $(1,1)$ under the assumption that the channel states are known in prior in the computation phase, this result is not practically interesting. This is due to the fact that the channel states at the communication phase cannot be predicted ahead of time. Hence, we should focus on universal schemes in which the edge nodes perform the computations without knowing the channel gains towards the users in the future communication phase (i.e., the coefficients in (2) are independent of the channel states). Motivated by this phenomenon, we ask the following question:

Is there a universal computation scheme that simultaneously achieves the minimum computation load and the minimum communication load, i.e., the load pair $(1,1)$, without requiring channel state information in the computation phase at the edge nodes?

We answer the above question affirmatively, and present the main result of this paper in the following theorem.

Theorem 1**.**

For a mobile edge computing scenario with $K$ mobile users and $K$ edge nodes, there exists a universal computation scheme, named Universal Coded Edge Computing (UCEC), that achieves the minimum computation load and the minimum communication load simultaneously, i.e., the load pair $(1,1)$, for time-varying channels and no channel state information in the computation phase at the edge nodes.

We prove Theorem 1 in Section V, by describing the proposed UCEC scheme, and analyzing its performance.

Remark 2*.*

The key feature of the UCEC scheme is that in the computation phase, without using channel state information, the edge nodes compute coded outputs with a computation load $r=1$. In the communication phase, the edge nodes create messages that admit a communication load $L=1$ and can still neutralize all the interference signals over the air. $\hfill\square$

Remark 3*.*

Theorem 1 implies that when no channel state information is available in the computation phase, the computation-communication load region has a simple shape that is dominated by a single corner point $(1,1)$. Hence, performing computations without being aware of the channel gains does not cause any performance loss. $\hfill\square$

Remark 4*.*

In contrast to the “zero-forcing ready” scheme in Example 1, we can execute the computation phase separately from the communication phase, without losing any performance. For example, we can perform the computations at some remote edge clusters without knowing when and how the computed results will be delivered to the mobile users, and later have the access points close to the users (e.g., base stations) communicate the results. $\hfill\square$

Remark 5*.*

We can directly apply the proposed UCEC scheme in Theorem 1 to the general case of $K$ users and $M$ edge nodes. In particular, when $M>K$, we can use any $K$ out of the $M$ edge nodes to achieve the load pair $(1,1)$. When $M<K$, we can split the $K$ users into $\lceil\frac{K}{M}\rceil$ partitions of size $M$ (except that one partition has size $K-M\lfloor\frac{K}{M}\rfloor$). Then we repeatedly apply the UCEC scheme between the $M$ edge nodes and each of the user partitions, achieving a load pair $(1,\lceil\frac{K}{M}\rceil)$. Overall, the UCEC scheme achieves the load pair $(1,\lceil\frac{K}{M}\rceil)$, for the case of $K$ users and $M$ edge nodes. $\hfill\square$

In the next section, we illustrate the key ideas of the proposed UCEC scheme through a simple example.

IV Illustration of the Universal Coded Edge Computing scheme via a simple example

We consider a scenario where $K=2$ mobile users offload their tasks to $M=2$ edge nodes. User $k$, $k=1,2$, has $F=3$ input vectors, and wants to compute the output vectors ${\bf y}_{k}[i]={\bf A}{\bf d}_{k}[i]$, $i=1,2,3$, from some data matrix ${\bf A}$. In contrast to Example 1, now we do not assume the knowledge of channel gains at the edge nodes in the computation phase.

In the computation phase, EN $1$ generates ${\cal L}_{1}^{(1)}={\bf d}_{1}[1]$ and ${\cal L}_{1}^{(2)}={\bf d}_{1}[2]+{\bf d}_{2}[1]$, and EN $2$ generates ${\cal L}_{2}^{(1)}={\bf d}_{1}[1]+{\bf d}_{2}[1]$. These linear combinations do not depend on the channel gains.

Then for each $b=1,\ldots,B$, EN $1$ computes two functions $s_{1b}^{(1)}={\bf a}_{b}{\cal L}_{1}^{(1)}=y_{11}(b)$, $s_{1b}^{(2)}={\bf a}_{b}{\cal L}_{1}^{(2)}=y_{12}(b)+y_{21}(b)$, where $y_{ki}(b)$ is the $b$th element of the vector ${\bf y}_{k}[i]$. Also, EN 2 computes a function $s_{2b}^{(1)}={\bf a}_{b}{\cal L}_{2}^{(1)}=y_{11}(b)+y_{21}(b)$.

In the communication phase, for each $b=1,\ldots,B$, we employ a communication scheme ranging over $2$ time slots. For example, for $b=1$, and some transmit directions ${\bf v}_{11},{\bf v}_{12},{\bf v}_{2}\in\mathbb{R}^{2}$, we create the transmitted symbols

[TABLE]

In order to zero-force the interfering signals, we select the transmit directions such that ${\bf H}_{11}{\bf v}_{12}=-{\bf H}_{12}{\bf v}_{2}$, ${\bf H}_{21}{\bf v}_{11}=-{\bf H}_{22}{\bf v}_{2}$, where ${\bf H}_{km}=\begin{bmatrix}h_{km}(1)&0\\ 0&h_{km}(2)\end{bmatrix}$ is the channel matrix from EN $m$ to User $k$ in the two time slots.

After the communication phase, User 1 recovers noisy versions of $y_{11}(1)$ and $y_{12}(1)$ respectively, and User 2 recovers a noisy version of $y_{21}(1)$. Similarly, repeating the same communication process for $B$ times, User 1 can reconstruct ${\bf y}_{1}[1]$ and ${\bf y}_{1}[2]$, and User 2 can reconstruct ${\bf y}_{2}[1]$.

Next, we swap the role of User $1$ and User $2$, and perform the same computation and communication operations as before to deliver ${\bf y}_{2}[2]$ and ${\bf y}_{2}[3]$ to User 2, and ${\bf y}_{1}[3]$ User 1.

The above scheme achieves a computation load $r\!=\!\frac{(2+1)\times B\times 2}{3\times 2\times B}\!=\!1$, and a communication load of $L\!=\!\frac{2\times B\times 2}{3\times B}\!=\!\frac{4}{3}$. Without channel state information, the edge nodes can still exploit coding to reduce the communication load by 33.3% (the communication load would have been 2 if uncoded computations and orthogonal communications were employed), while maintaining the minimum computation load of $1$.

The techniques utilized above are motivated by the “Aligned Interference Neutralization” (AIN) technique in [7], and the “Aligned Network Diagonalization” (AND) technique in [6], for communications over a two-hop relay network. AIN and AND design the transmitted signals at the sources, such that each aligned signal at the relays is the sum of some message symbols, which does not depend on the channel gains on either hop of the network. On the second hop, relays create messages that cancel interference signals over the air at the destinations.

We finally note that if in general we consider a block of $F=2W-1$ input vectors, for some $W\in\mathbb{N}$, employing coding techniques motivated by the AIN scheme that is designed specifically for the $2\times 2\times 2$ relay network, we can achieve a computation-communication load pair $(1,\frac{2W}{2W-1})$, which goes to the optimal pair $(1,1)$ as $W$ increases.

V Universal Coded Edge Computing Scheme

We prove Theorem 1 by presenting a Universal Coded Edge Computing (UCEC) scheme, for a case of $K$ users and $K$ edge nodes, and time-varying channels. The proposed scheme does not use the channel gains when executing the computation phase, and still asymptotically achieves the optimum computation-communication load pair.

First, we define the set of transmit directions $\Delta_{N}\triangleq\{0,1,\ldots,N-1\}^{K^{2}}$, for some arbitrary $N\in\mathbb{N}$. Then, we consider a block of $F=N^{K^{2}}$ input vectors at each user. For User $k$, $k=1,\ldots,K$, we assign each of her $N^{K^{2}}$ input vectors to a unique transmit direction in $\Delta_{N}$. More specifically, for each element ${\bf p}\in\Delta_{N}$, we label the input of User $k$ on the direction ${\bf p}$ as ${\bf d}_{k}^{{\bf p}}$.

V-A Computation Phase

At EN $m$, $m=1,\ldots,K$, for each transmit direction $(p_{11},p_{12},\ldots,p_{KK})\in\Delta_{N+1}$, we create a coded input vector ${\cal L}_{m}^{(p_{11},p_{12},\ldots,p_{KK})}$ as the sum of certain input vectors

[TABLE]

Then EN $m$ computes the functions

[TABLE]

for all $b=1,\ldots,B$. Here we set $\phi_{b}({\bf d}_{k}^{\bf p})=0$ if any element in ${\bf p}$ is $N$ or $-1$. We note that in (14), no channel state information is used when creating the coded input vectors.

V-B Communication Phase

In communication phase, the channel state information is known at the edge nodes. At EN $m$, $m=1,\ldots,K$, for each $b=1,\ldots,B$, we note that the computed functions $\{s_{mb}^{\bf p}:{\bf p}\in\Delta_{N+1}\}$ resemble the aligned signals decoded at the $m$th relay, using the AND scheme in [6] for a $K\times K\times K$ relay network. We perform the communication phase exploiting the communication techniques in AND from the relays to the destinations. Specifically, for channel matrix at time $t$

[TABLE]

we define

[TABLE]

and $Q(t)^{\bf p}=Q(t)^{(p_{11},p_{12},\ldots,p_{KK})}\triangleq\prod_{1\leq k,m\leq K}b_{km}(t)^{p_{km}}$.

We demonstrate the communication process to deliver the first function $\phi_{1}$, and repeat the same process for all other $B-1$ functions. Specifically, we consider a transmission over $d=|\Delta_{N+1}|=(N+1)^{K^{2}}$ time slots, such that at time $t=1,\ldots,d$, EN $m$, $m=1,\ldots,K$, communicates a symbol

[TABLE]

where $\gamma$ is some factor to enforce the power constraint.

The received signals at the $K$ users in time $t$, $t=1,\ldots,d$,

[TABLE]

As a result, at User $k$, $k=1,\ldots,K$, all interference signals, i.e., $\{\phi_{1}({\bf d}_{k^{\prime}}^{\bf p}):k^{\prime}\neq k,{\bf p}\in\Delta_{N}\}$, are zero-forced over the air, and the received signals $Y_{k}(1),\ldots,Y_{k}(d)$ are $d=(N+1)^{K^{2}}$ noisy linear combinations of the intended functions $\{\phi_{1}({\bf d}_{k}^{\bf p}):{\bf p}\in\Delta_{N}\}$, from which User $k$ can decode them individually.

Using this scheme, we achieve a computation load $r=\frac{|\Delta_{N+1}|BK}{FKB}=\frac{(N+1)^{K^{2}}}{N^{K^{2}}}$, and a communication load $L=\frac{dB}{FB}=\frac{(N+1)^{K^{2}}}{N^{K^{2}}}$, which both go to 1 as $N$ increases.

VI Acknowledgement

This work is in part supported by NSF grants CCF-1408639, NETS-1419632, ONR award N000141612189, NSA grant, and a research gift from Intel. This material is based upon work supported by Defense Advanced Research Projects Agency (DARPA) under Contract No. HR001117C0053. 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.