Service Capacity Enhanced Task Offloading and Resource Allocation in Multi-Server Edge Computing Environment

TL;DR

This paper proposes an online resource allocation algorithm for multi-server edge computing that optimizes service latency, power consumption, and capacity, demonstrating significant performance improvements over baseline methods.

Contribution

It introduces a novel stochastic optimization framework with an online Lyapunov-based algorithm for resource allocation in multi-server edge computing environments.

Findings

Significant reduction in service latency and power consumption.

Increased number of offloaded computation tasks.

Outperforms baseline approaches in experiments.

Abstract

An edge computing environment features multiple edge servers and multiple service clients. In this environment, mobile service providers can offload client-side computation tasks from service clients' devices onto edge servers to reduce service latency and power consumption experienced by the clients. A critical issue that has yet to be properly addressed is how to allocate edge computing resources to achieve two optimization objectives: 1) minimize the service cost measured by the service latency and the power consumption experienced by service clients; and 2) maximize the service capacity measured by the number of service clients that can offload their computation tasks in the long term. This paper formulates this long-term problem as a stochastic optimization problem and solves it with an online algorithm based on Lyapunov optimization. This NP-hard problem is decomposed into three sub-problems, which are then solved with a suite of techniques. The experimental results show that our approach significantly outperforms two baseline approaches.

Figures

Tables

Table 1. TABLE I: System Parameters

Parameter	Value	Parameter	Value
$\omega$	10 Hz	$N_0$	-174 dBm/Hz
$g_0$	-40 dB	$d_0$	1 m
$\theta$	4	$k_{mod,i}$	$1\times {10}^{-27}$
$f_{max,i}$	1 GHz	$p_{max,i}$	500 mW
$L_i$	737.5 cycles/bit	$f_{max,j}$	2.5 GHz
${\phi }_j$	4	$\tau$	2 ms

Equations

$$\text{centering}{Q}_i(t+1)=max\{Q_i(t)-D_{\sum ,i}(t),0\}+A_i(t),i\in U.\text{@add@centering}$$

$$\text{centering}{H}_i(t+1)=max\{H_i(t)-D_{s,i}(t),0\}+D_{r,i}(t),i\in U.\text{@add@centering}$$

$$\text{centering}{D}_{l,i}(t)=\tau f_{l,i}(t)L_i^{-1},i\in U.\text{@add@centering}$$

$$\text{centering}{p}_{l,i}(t)=k_{mod,i}{f}_{l,i}^3(t),i\in U,\text{@add@centering}$$

$$\text{centering}0\le f_{l,i}(t)\le f_{max,i},i\in U.\text{@add@centering}$$

$$\text{centering}{\Gamma }_{i,j}(t)={\gamma }_{i,j}(t)g_0(\frac{d_0}{d_{i,j}}{)}^{\theta },i\in U,j\in S,\text{@add@centering}$$

$$\text{centering}\sum _{j\in S}{x}_{i,j}(t)\le 1,i\in U.\text{@add@centering}$$

$$\text{centering}{r}_{i,j}(t)=\{\begin{array}{ccc}& B_j{\log }_2(1+\frac{{\Gamma }_{i,j}(t)p_{r,i}(t)}{B_j{N}_0}),x_{i,j}=1& \\ & 0,x_{i,j}=0& \end{array}\text{@add@centering}$$

$$\text{centering}0\le p_{r,i}(t)\le p_{max,i},i\in U.\text{@add@centering}$$

$$\text{centering}{D}_{r,i}(t)=\sum _{j\in S}{r}_{i,j}(t)\tau ,i\in U.\text{@add@centering}$$

$$\text{centering}{D}_{s,i}(t)=\sum _{j\in S}{D}_{s,i,j}(t),i\in U.\text{@add@centering}$$

$$\text{centering}\sum _{j\in S}{D}_{s,i,j}(t)L_i\le \tau {\phi }_j{f}_{max,j}.\text{@add@centering}$$

$$\text{centering}{\xi }_i(t)=\beta {\xi }_i^{latency}(t)+(1-\beta ){\xi }_i^{power}(t),i\in U,\text{@add@centering}$$

$$\text{centering}{\xi }_i^{latency}(t)=\alpha (Q_i(t)-D_{\sum ,i})+(1-\alpha )(H_i(t)-D_{s,i}(t)).\text{@add@centering}$$

$$\text{centering}{\xi }_i^{power}(t)=p_{l,i}(t)+p_{r,i}(t),i\in U.\text{@add@centering}$$

$$\text{centering}\bar{O}=\underset{T\to +\infty }{\lim }\frac{1}{T\cdot m}\sum _{t=0}^{T-1}\sum _{i\in U,j\in S}{x}_{i,j}(t).\text{@add@centering}$$

$$\text{centering}\underset{T\to +\infty }{\lim }\frac{\text{E}[|Q_i(T)|]}{T}=0,\underset{T\to +\infty }{\lim }\frac{\text{E}[|H_i(T)|]}{T}=0.\text{@add@centering}$$

$$\begin{array}{rl}{\text{P}}_1:& \underset{\{\text{R}(t)\}}{\min }\underset{T\to +\infty }{\lim }\frac{1}{T}\sum _{T-1}^0\text{E}\left[\sum _{i\in U}{\xi }_i(t)\right]\\ & \underset{\{\text{R}(t)\}}{\max }\bar{O}\\ & s.t.(\text{ref}equ5)(\text{ref}equ7)(\text{ref}equ9)(\text{ref}equ12)(\text{ref}equ17),t\in T\end{array}$$

$$\text{centering}L(\mathbf{\Theta }(t))=\frac{1}{2}\sum _{i\in U}[Q_i^2(t)+H_i^2(t)].\text{@add@centering}$$

$$\text{centering}\Delta (\mathbf{\Theta }(t))=\text{E}[(L(\mathbf{\Theta }(t+1))-L(\mathbf{\Theta }(t)))|\mathbf{\Theta }(t)].\text{@add@centering}$$

$$\text{centering}{\Delta }_{\nu }(\mathbf{\Theta }(t))=\Delta (\mathbf{\Theta }(t))+V\cdot \text{E}[\mathbf{\xi }(t)|\mathbf{\Theta }(t)],\text{@add@centering}$$

$$\text{centering}\begin{array}{rl}{\Delta }_{\nu }(t)\le & C-\text{E}[\sum _{i\in U}{Q}_i(t)(D_{\sum ,i}(t)-A_i(t))|\mathbf{\Theta }(t)]\\ & -\text{E}[\sum _{i\in U}{H}_i(t)(D_{s,i}(t)-D_{r,i}(t))|\mathbf{\Theta }(t)]\\ & +V\cdot \text{E}[\mathbf{\xi }(t)|\mathbf{\Theta }(t)],\end{array}\text{@add@centering}$$

$$\begin{array}{rl}{\text{P}}_{PTS}:& \underset{\text{R}(t)}{\min }-\sum _{i\in U}{Q}_i(t)D_{\sum ,i}(t)\\ & -\sum _{i\in U}{H}_i(t)(D_{s,i}(t)-D_{r,i}(t))+V\cdot \mathbf{\xi }(t)\\ & s.t.(\text{ref}equ5)(\text{ref}equ7)(\text{ref}equ9)(\text{ref}equ12)\end{array}$$

$$\begin{array}{rl}{\text{SP}}_1:& \underset{\{\text{f}(t)\}}{\min }\sum _{i\in U}[-(Q_i(t)+V\cdot \alpha \beta )\tau L_i^{-1}{f}_{l,i}(t)\\ & +V\cdot (1-\beta )k_{mod,i}{f}_{l,i}^3(t)]\\ & s.t.(\text{ref}equ5).\end{array}$$

$$\text{centering}{f}_{l,i}^{\ast }(t)=\{\begin{array}{ccc}& min\{\sqrt{\frac{(Q_i(t)+V\cdot \alpha \beta )\tau }{3k_{mod,i}V(1-\beta )L_i)}},f_{max,i}\},others& \\ & f_{max,i},\beta =1& \end{array}\text{@add@centering}$$

$$\begin{array}{rl}{\text{SP}}_2:& \underset{\{\text{p}(t),\text{X}(t)\}}{\min }\sum _{i\in U}[-{\Psi }_i(t)D_{r,i}(t)+V(1-\beta )p_{r,i}(t)]\\ & s.t.(\text{ref}equ7)(\text{ref}equ9).\end{array}$$

$$\begin{array}{rl}{\text{SP}}_2^{{}^{\prime }}:& \underset{\{\text{p}(t),\text{X}(t)\}}{\min }\sum _{i\in U_{off}(t)}[-{\Psi }_i(t)D_{r,i}(t)+V(1-\beta )p_{r,i}(t)]\\ & s.t.(\text{ref}equ7)(\text{ref}equ9).\end{array}$$

$$\begin{array}{rl}{\text{SP}}_{PWR}:& \underset{\{\text{p}(t)\}}{\min }\sum _{i\in U_{off}(t)}[-{\Psi }_i(t)D_{r,i}(t)+V(1-\beta )p_{r,i}(t)]\\ & s.t.(\text{ref}equ9)\end{array}$$

$$\text{centering}{r}_{i,j^{\ast }}(t)=B_{j^{\ast }}{\log }_2(1+\frac{{\Gamma }_{i,j^{\ast }}(t)p_{r,i}(t)}{B_{j^{\ast }}{N}_0}),\text{@add@centering}$$

$$\text{centering}{p}_{l,i}^{\ast }(t)=\{\begin{array}{ccc}& min\{{\Lambda }_i(t),p_{max,i}\},others& \\ & p_{max,i},\beta =1& \end{array}\text{@add@centering}$$

Full text

I Introduction

Edge computing has emerged as a new paradigm for powering applications by offering computing, storage and networking resources at the edge of the cloud [1, 2]. As illustrated on the 5G standardization roadmap, edge servers will be distributed at ultra-dense small-cell base stations (CBS) [3, 4]. In such an environment, the coverages of adjacent edge servers partially overlap to avoid blank areas not covered by any edge servers [5]. Service providers can offload client-side computation tasks from service clients’ devices onto edge servers to reduce the service cost measured by the service latency and power consumption experienced by service clients [6, 7]. This is referred to as task offloading.

The edge infrastructure provider looks at task offloading from two general perspectives. A large number of edge servers sharing service clients’ offloaded computation tasks can provide service clients with low service cost from service clients’ perspective. That is the benefit of computation loading. However, the deployment of excessive edge servers result in overly high operational cost from edge infrastructure provider’s perspective. After all, the edge infrastructure provider is interested in the overall revenue, i.e., the benefit minus the cost. The economy of scale maximizes the edge infrastructure provider’s revenue by maximizing the service capacity,i.e., the ability to serve the maximum number of service clients. To achieve a cost-effective solution, the service cost needs to be traded off to allow more service clients to be served by edge servers. Thus, how to trade off the service cost and service capacity is a critical problem in edge computing.

A lot of researchers have focused on solving the task offloading problem in a single-server edge computing environment. However, in a particular area, there are usually multiple edge servers available for offloading service clients’ computation tasks. The edge computing environment is in fact a multi-server environment. In such an environment, it is critical and challenging to optimize the utilization of edge computing resources, including computation and transmission resources, with the aim to maximize the service capacity while minimizing the service cost. Firstly, the characteristics of latency-tolerant applications, i.e., the coupling among randomly-arrived tasks, must be captured [8]. Stochastic computation partitioning strategies must be formulated to split the resources to be shared among service clients. Secondly, each service client needs to decide not only how to partition its computation tasks between its device and the edge server but also which edge server to offload its computation tasks to.

In this paper, we propose a holistic solution to computation offloading and resource allocation in multi-server edge computing environment with the aim to serve as many service clients as possible with minimum service cost. The main contributions of this paper are as follows:

• •

Task offloading in such an environment is modelled as a stochastic optimization problem with multiple optimization objectives. It aims to maximize the number of service clients served with minimum service cost in the long term.

• •

Based on Lyapunov optimization, the above long-term stochastic optimization problem is converted to a deterministic optimization problem within each time slot, which is then further decomposed into three sub-problems.

• •

To solve the optimization problem, an online joint task offloading and resource allocation algorithm (OJTORA) powered by a suite of techniques is proposed to solve each sub-problem with low complexity.

• •

Extensive experiments are conducted to evaluate OJTORA. The results show that OJTORA outperforms the baseline approaches significantly.

The remainder of this paper is organized as follows. Section II reviews related work. Section III presents the edge computing model. Section IV formulates the research problem. Section V introduces the proposed approach. Section VI experimentally evaluates the proposed approach. Section VII concludes this paper.

II Related Works

In recent years, joint task offloading and resource allocation in edge computing has attracted many researchers’ attention. Most existing work studied the problem in a single-server edge computing environment [8, 9, 10, 11]. Some researchers have considered multi-server scenarios [12, 13, 14, 15, 16, 17, 18]. The authors of [12] optimize task offloading, uplink transmission power of service clients, and computing resource allocation on edge servers to minimize task completion time and power consumption. In [13], the tradeoff between latency and power consumption was studied. The problem was formulated as computation and transmits power minimization subject to latency and reliability constraints. The authors of [14] studied how to minimize mobile power consumption through data offloading. Centralized and distributed algorithms for power allocation and transmission channel assignment were proposed. In [15], device-edge-cloud edge was investigated. A network-aware multi-user and multi-edge computation partitioning problem was formulated. Computation and radio transmission resources were allocated such that service clients’ average throughput was maximized. In [16], the shareable storage was considered, and a constant-factor approximation algorithm was proposed to decide the server placement and resource allocation. In [17], the edge task offloading control was investigated in cloud radio access network (C-RAN) environments, and a multi-stage heuristic was proposed to minimize the refusal rate for user’s task offloading requests. In [18], an online algorithm was proposed to allocate edge server’s resource over time.

In the studies of task offloading, service latency and power consumption have been commonly acknowledged as two very important optimization objectives. However, few researchers have considered service capacity, i.e., the total number of service clients served, which is a key issue from the edge infrastructure provider’s perspective in a multi-server edge computing environment[5]. In [19]. A quality-of-experience (QoE) driven LTE downlink scheduling scheme for VoIP applications was proposed to improve the service capacity with acceptable QoE for all service clients. However, they only consider single-server environments. In addition, the proposed LTE downlink scheduling scheme is specifically designed for VoIP applications and thus is not applicable to most other applications in the edge computing environment.

Our work differentiates from existing work in the following ways. First, we consider a multi-server edge computing environment. Second, our approach is applicable to most latency-tolerant applications in the edge computing environment. Third, we consider both resource allocation and task offloading. Finally, we attempt to achieve the optimization objectives in the long term.

III System Model

An example multi-server edge computing scenario is shown in Fig. 1. A service client can offload some or all of its computation tasks to one of its nearby edge servers. Let us denote the set of service clients with U, the set of edge servers with S, the connection between the ith service client and the jth edge server with $c_{i,j}=\{0,1\}$, where $c_{i,j}=1$ indicates that the ith service client can access the jth edge server or $c_{i,j}=0$ otherwise. Let us define $G_{i}=\{j|c_{i,j}=1,j\in S\},i\in U$, and $Z_{j}=\{i|c_{i,j}=1,i\in U\},j\in S$. Task offloading in the edge computing environment is an ongoing process. Let us denote different time slots with $T=\{1,2,3,...\}$ and the time slot length is $\tau$. The available bandwidth of each edge server is $\omega$ Hz and the noise power spectral density is $N_{0}$.

III-A Computation Task and Task Queue Model

The computation tasks running on service clients’ devices are bit-wise independent [1]. Let us denote the amount of tasks of the ith service client in the tth time slot as $A_{i}(t)$, which are independent and identically distributed in different time slot within $[0,A_{i,max}],A_{i,max}\in\mathbb{R}^{+}$, with the expectation $\mathbb{E}[A_{i}(t)]=\lambda_{i},\lambda_{i}\in[0,A_{i,max}],i\in U$. As shown in Fig. 2, at the beginning of the tth time slot, the local queue length of the ith service client is $Q_{i}(t)$. At $t$th time slot, the amount of tasks which has arrived but not been executed locally or offloaded will be put in $Q_{i}(t)$. Within the tth time slot, the ith service client will locally execute $D_{l,i}(t)$ tasks and will offload $D_{r,i}(t)$ tasks to an edge server, i.e., $D_{\sum,i}(t)=D_{l,i}(t)+D_{r,i}(t)$.

[TABLE]

As shown in Fig. 2, a service client chooses only one edge server to offload its tasks in each time slot. Thus, we maintain a virtual task queue $H_{i}(t)$ for each service client, which represents the amount of tasks offloaded but not been executed in all edge servers. In the tth time slot, let us denote the amount of tasks of the ith service client that has been offloaded but not executed by the jth edge server as $H_{i,j}(t)$, where $H_{i}(t)=\sum_{j\in G_{i}}H_{i,j}(t)$, the amount of tasks of the ith service client which has been executed by the edge server as $D_{s,i}(t)$.

[TABLE]

III-B Local Execution and Task Offloading Model

The ith service client’s device executes 1bit task using $L_{i}$ (cycles/bit) CPU cycles [20, 21]. The dynamic frequency and voltage scaling (DVFS) technique is used to adjust the CPU-cycle frequency of service clients’ devices [1, 8, 12]. In the tth time slot, $f_{l,i}(t)$ is the CPU-cycle frequency of the ith service client’s device.

[TABLE]

According to circuit theories [22, 23], the CPU power consumption of the ith service client’s device in the tth time slot is calculated as

[TABLE]

where $k_{mod,i}$ is the effective switched capacitance of the CPU of the ith service client’s device. $f_{max,i}$ is the maximum CPU-cycle frequency of the ith service client’s device, i.e.,

[TABLE]

In this paper, the operational frequency band of the jth edge server is divided equally into $|Z_{j}|$ which $B_{j}=\omega/|Z_{j}|$. In the tth time slot, let us denote the fading of wireless channels between the ith service client’s device and the jth edge server as $\gamma_{i,j}(t)$, the channel power gain from the ith service client’s device to the jth edge server as

[TABLE]

where $g_{0}$ is a constant, $\theta$ is an exponent, $d_{0}$ is the reference distance [8], and $d_{i,j}$ is the distance between the ith service client’s device and the jth edge server. The task offloading variables in the tth time slot are defined as $\textbf{X}(t)=\{x_{i,j}(t)|i\in U,j\in S\}$, where $x_{i,j}(t)\in\{0,1\}$, where $x_{i,j}(t)=1$ indicates that the ith service client’s device offloads its computation tasks to the jth edge server in the tth time slot.

[TABLE]

The transmit power of the ith service client’s device in the tth time slot is denoted by $p_{r,i}(t)$. According to the Shannon-Hartley formula [24], the transmit rate between the ith service client’s device and the jth edge server in the tth time slot is

[TABLE]

Without loss of generality, $p_{r,i}(t)$ must not exceed the maximum transmit power of the ith service client’s device.

[TABLE]

Based on the above definitions, the number of offloading tasks of the ith service client’s device is calculated as

[TABLE]

III-C Edge Server Scheduling

As shown in Fig. 2, the edge server can transfer input data to a neighboring edge server via an X2 link [25]. The amount of tasks of the ith service client’s device that have been executed by the jth edge server in the tth time slot is denoted as $D_{s,i,j}(t)$. Then, $D_{s,i}(t)$ can be expressed as

[TABLE]

For the jth edge server, $f_{max,j}$ is the maximum CPU-cycle frequency and $\varphi_{j}$ is the number of CPUs.

[TABLE]

IV Problem Formulation

This section first defines the service cost function and then formulates the average service capacity, i.e., the long-term average number of service clients that can offload their tasks. Finally, the optimization problem studied in this paper is formulated.

The service cost function is defined as follows:

[TABLE]

where $\beta\in[0,1]$. $\xi_{i}^{latency}(t)$ and $\xi_{i}^{power}(t)$ are the latency cost and power cost of the ith service client’s device in the tth time slot. According to Little’s Law, the average execution delay of a service client’s device is proportional to the average amount of its tasks in the edge environment.

[TABLE]

where $\alpha\in[0,1]$. Therefore, $\xi_{i}^{power}(t)$ is calculated as

[TABLE]

Let us denote the long-term average number of service clients that can offload their tasks as $\bar{O}$.

[TABLE]

Constraint (17) requires that the service clients’ task queues are stable [26].

[TABLE]

Let us denote the system operation at the tth time slot with $\textbf{R}(t)\triangleq\{\textbf{f}(t),\textbf{p}(t),\textbf{X}(t),\textbf{D}(t)\}$, in which $\textbf{f}(t)\triangleq\{f_{l,i}(t)|i\in U\}$, $\textbf{p}(t)\triangleq\{p_{r,i}(t)|i\in U\}$, $\textbf{D}(t)\triangleq\{D_{s,j}(t)|j\in S\}$. Accordingly, the objective functions that minimize the average service cost and maximize the average service capacity respectively are defined below as $\emph{{P}}_{1}$ together:

[TABLE]

V Algorithm Design

This section introduces an online algorithm for solving the joint task offloading and resource allocation problem $\emph{{P}}_{1}$. Based on Lyapunov optimization, the stochastic optimization problem is converted into a deterministic optimization problem.

V-A Lyapunov Optimization-based Online Algorithm

We employ the Lyapunov optimization to ensure the stability of the task queues through minimizing the average service cost. To model the problem as a Lyapunov optimization problem, we define the Lyapunov function as:

[TABLE]

where $\bm{\Theta}(t)=[\textbf{Q}(t),\textbf{H}(t)]$. Then, the conditional Lyapunov drift is defined as

[TABLE]

The Lyapunov drift-plus-penalty function is defined as:

[TABLE]

where $\bm{\xi}(t)=\sum_{i\in U}\xi_{i}(t)$ and $V\in(0,+\infty)$ is a control parameter to keep the balance between task queues and service cost.

The upper bound of $\Delta(\bm{\Theta}(t))$ with constraints (5), (7),

(9) and (12) is defined as:

[TABLE]

where C is a constant [8].

According to Lyapunov optimization, in order to minimize $\bm{\xi}(t)$ and maintain the stability of service clients’ task queues, we need to minimize the upper bound of $\Delta_{\nu}(t)$ in each time slot as expressed in formula (21). This minimization is denoted as $\emph{{P}}_{\textbf{PTS}}$. All the constraints of $\emph{{P}}_{1}$ except constraint (17) are included in $\emph{{P}}_{\textbf{PTS}}$. Algorithm 1 presents the pseudo code of the Online Joint Task Offloading and Resource Allocation Algorithm (OJTORA). The pseudo-code for solving $\emph{{SP}}_{1}$, $\emph{{SP}}_{2}$ and $\emph{{SP}}_{3}$ are presented below in Section V-B.

V-B *Optimal Solution to $\textbf{P}_{PTS}$ *

V-B1 Optimal CPU-Cycle Frequencies of Mobile Devices

The $\textbf{SP}_{1}$ is defined as

[TABLE]

The objective function of $\textbf{\emph{SP}}_{1}$ is convex and constraint (5) is linear. Therefore, $\textbf{\emph{SP}}_{1}$ is a convex problem. For each service client, we can find that $f_{l,i}(t)$ is independent. Let us denote the optimal CPU-cycle frequency of the ith service client’s device as $f_{l,i}^{*}(t)$. We can obtain $f_{l,i}^{*}(t)$ by finding the minimum point of $-(Q_{i}(t)+V\cdot\alpha\beta)\tau L_{i}^{-1}f_{l,i}(t)+V\cdot(1-\beta)k_{mod,i}f_{l,i}^{3}(t)$. At the same time, $f_{l,i}^{*}(t)$ must fulfil constraint (5).

[TABLE]

V-B2 Optimal Transmit Power Consumption and Task Offloading Policy

$p_{r,i}^{*}(t)$ and $\textbf{X}^{*}(t)$ refer to the optimal $p_{r,i}(t)$ and the optimal $\textbf{X}(t)$ respectively. They are obtained by solving $\textbf{SP}_{2}$:

[TABLE]

When there is $\Psi_{i}(t)=Q_{i}(t)-H_{i}(t)+V\cdot\alpha\beta\leq 0$, the object function of $\textbf{SP}_{2}$ is non-decreasing with $p_{r,i}(t)$. Then, because of constraint (9), $p_{r,i}^{*}(t)=0$ means that the ith service client’s device will not offload its tasks to edge servers. Let us denote $U_{off}(t)=\{i|\Psi_{i}(t)\geq 0,i\in U\}$. The optimal transmit power consumption and the optimal task offloading policy can be achieved by solving $\textbf{SP}_{2}^{{}^{\prime}}$:

[TABLE]

This objective function is determined by two variables, i.e., $\textbf{p}(t)$ and $\textbf{X}(t)$. It is hard to obtain $p_{r,i}^{*}(t)$ and $\textbf{X}^{*}(t)$ simultaneously. Therefore, we divide $\textbf{SP}_{2}^{{}^{\prime}}$ into two sub-problems.

First, we assume a $\textbf{X}^{*}(t)$. For a fixed computation offloading policy, we denote the first sub-problem of $\textbf{SP}_{2}^{{}^{\prime}}$ as $\textbf{SP}_{PWR}$, which can be expressed as

[TABLE]

where $D_{r,i}(t)$ is non-decreasing with $p_{r,i}(t)$. The objective function of $\textbf{SP}_{PWR}$ is convex and constraint (9) is linear. Therefore, $\textbf{SP}_{PWR}$ is a convex problem. Similar to $\textbf{SP}_{1}$, $\textbf{SP}_{PWR}$ can be decomposed for individual mobile devices. Let us denote the edge server to which the ith service client offloads its computation tasks in the tth time slot as $j^{*}$, there is $x_{i,j^{*}}=1$. In addition, $r_{i,j^{*}}(t)$ can be obtained by

[TABLE]

where $r_{i,j}(t)=0$ if $j\neq j^{*}$. Then, $D_{r,i}(t)=r_{i,j^{*}}(t)\tau$. Therefore, we can obtain $p_{l,i}^{*}(t)$ by finding the minimum of $-\Psi_{i}(t)D_{r,i}(t)+V\cdot(1-\beta)p_{r,i}(t)$. Let us denote $\Lambda_{i}(t)=\frac{\Psi_{i}(t)\tau B_{j^{*}}}{V\cdot(1-\beta)\ln 2}-\frac{N_{0}B_{j^{*}}}{\Gamma_{i,j^{*}}(t)}$. Then, the $p_{l,i}^{*}(t)$ can be written as

[TABLE]

Secondly, we assume a fixed $p^{*}(t)$ and denote the second sub-problem of $\textbf{SP}_{2}^{{}^{\prime}}$ as $\textbf{SP}_{CO}$, expressed as follows:

[TABLE]

For a service client where $i\in U_{off}(t)$, it independently selects an edge server to offload its computation tasks. Therefore, $\textbf{SP}_{CO}$ can be decomposed for individual service clients. In order to solve $\textbf{SP}_{CO}$, we propose an algorithm to obtain $\textbf{X}^{*}(t)$, as described in Algorithm 2.

V-B3 Computing Resource Allocation of Edge Servers

All the parts remaining in $\textbf{P}_{PTS}$ are only related to the allocation of edge servers’ computing resources, defined as $\textbf{SP}_{3}$:

[TABLE]

The value achieved by the objective function of $\textbf{SP}_{3}$ decreases with $D_{s,i}(t)$. Let us denote $value_{i}=V(1-\alpha)\beta+H_{i}(t)$. It can be found that the greater the $value_{i}$, the more benefit will be generated when an edge server executes an equivalent amount of tasks. Then, OJTORA employs Algorithm 3 to solve $\textbf{SP}_{3}$.

VI Experimental Evaluation

This section evaluates the performance of OJTORA against two baseline approaches. All the experiments were conducted on a machine equipped with Intel Core i5-7400T processor (4 CPUs, 2.4GHz) and 8GB RAM, running Windows 10 x64.

VI-A Baseline Approaches

To our best knowledge, OJTORA is the first attempt to consider both the resource allocation and task offloading in a multi-server edge computing environment for latency-tolerant applications. Due to the issue of edge server coverage overlapping, existing approaches designed for the single-server edge computing environment cannot be directly applied to the multi-server environment. Thus, in the experiments, OJTORA is evaluated against two intuitive baseline approaches, namely Random and Greedy:

• •

Random: The Random approach select edge servers randomly to offload service clients’ tasks.

• •

Greedy: In (6), a shorter distance between an edge server and a service client’s device results in a smaller communication interference. Based on this fact, the Greedy approach selects the closest edge servers to offload service clients’ tasks.

VI-B Experiment Settings

The experiments are set up in a way similar to [8]. In each experiment, a total of n service clients are distributed in an area covered by m base stations. The radius of each base station is 150 m, and there is $\gamma_{i,j}(t)\sim Exp(1),i\in U,j\in S$. The simulation results are the average values over 10,000 time slots. In general, there is n=30, m=3. The $A_{i,max}=1000$ bits.Table I presents the parameter settings used in the experiments.

In the experiments, we vary three parameters that may have an impact on OJTORA:

• •

Control Parameter $V$: We change the value of $V$, where $V=1\times 10^{9},2\times 10^{9},...,9\times 10^{9}$, under four circumstances: 1) $\alpha=0.3,\beta=1\times 10^{-5}$; 2) $\alpha=0.3,\beta=1\times 10^{-6}$; 3) $\alpha=0.7,\beta=1\times 10^{-5}$; and 4) $\alpha=0.7,\beta=1\times 10^{-6}$.

• •

Number of Users $n$: We change the number of service clients, where $n=10,20,30,100,200$, with $\alpha=0.3,\beta=1\times 10^{-5}$, $V=1\times 10^{9}$.

• •

Number of Edge Servers $m$: We change the number of edge servers, where $m=3,6,9$, with $\alpha=0.3,\beta=1\times 10^{-5}$, $V=1\times 10^{9}$.

Two performance metrics are employed to evaluate OJTORA, corresponding to the two optimization objectives.

• •

Service Capacity. Service capacity is measured by the long-term average number of service clients served, as formally defined in (16).

• •

Service Cost. Service cost is defined as $\bar{\xi}_{\sum}=\frac{1}{T\cdot n}\sum_{t=0}^{T-1}\sum_{i\in U}\xi_{i}(t)$. In order to compare the power consumption and service latency more clearly, two more specific metrics are defined and employed in the evaluation: 1) the average power consumption of service clients’ devices, defined as $\bar{p}_{\sum}=\frac{1}{T\cdot n}\sum_{t=0}^{T-1}\sum_{i\in U}(p_{l,i}(t)+p_{r,i}(t))$; and 2) the average queue length of service clients’ devices: $\bar{q}_{\sum}=\frac{1}{T\cdot n}\sum_{t=0}^{T-1}\sum_{i\in U}(Q_{i}(t)+H_{i}(t))$.

VI-C Experimental Results

VI-C1 Optimality

As shown in Fig. 3, OJTORA outperforms the two baselines approaches significantly in achieving both optimization objectives. Specifically, it outperforms the Random approach by 27.8%-41.1% in power consumption, 23.2%-37.1% in queue length, 0.2%-10.9% in average service capacity and 23.1%-37.2% in average service cost. OJTORA also outperforms the Greedy approach, by 25.6%-39.1% in power consumption, 20.1%-35.7% in queue length, 0.2%-6.7% in average service capacity and 22.1%-35.8% in average service cost. Fig. 3 also shows that the Greedy approach outperforms the Random approach. The reason is that the Greedy approach selects the closest edge servers to offload service clients’ tasks. This reduces the power consumed by the data transmission between service clients’ devices and edge servers.

VI-C2 Impact of Parameter $V$

As shown in Fig. 4, as $V$ increases, the average service capacities achieved by all three approaches decrease. However, the average service costs increase. According to (22) and (24), as $V$ increases, the transmit power consumption of service clients’ devices decreases. This results in the decrease in the average service capacity. With the increase in V, the power consumption increases more rapidly than the latency. As a result, the average service cost increases.

VI-C3 Impact of the Number of Service Clients $n$

As shown in Fig.5, As $n$ increases, the average service cost increases. This is because the competition among service clients for the computing resources on the edge servers becomes fiercer with the increase in $n$.

VI-C4 The Impact of the Number of Edge Servers $m$

As shown in Fig.6, with the increase in $m$, the average power consumption, the average queue length and the average service cost increase. However, when $m$ continues to increase, the average service cost converges and remains steady. This is because the resources are more than sufficient to allow all service clients to be served.

VII Conclusion

In this paper, we investigated a joint task offloading and resource allocation problem in multi-server edge computing environments with the objectives to maximize service capacity, i.e., the number of mobile devices served, and to minimize the service cost, i.e., the service latency and power consumption experienced by service clients. To solve this problem, we proposed OJTORA, an online algorithm based on Lyapunov optimization, which converts the stochastic optimization problem to a per-time-slot deterministic optimization problem. The experimental results show that our approach significantly outperforms two baseline approaches. However, OJTORA does not consider the fairness in the resource sharing among service clients because it assumes static bandwidth allocation for now. In the future, dynamical allocation of bandwidth will be studied. We will also extend OJTORA to accommodate users service clients’ mobility.