Efficient Resource Allocation for Security-Aware Task Offloading in MEC System Using DVS

Abstract

With the Internet of Things (IoT) and communication technologies are snowballing, various applications (e.g., e-health and face recognition) are generated by IoT devices (IoTDs). Nevertheless, these IoTDs generally have constrained computation resources. By offloading the IoT applications to be processed by the MEC servers, mobile edge computing (MEC) is envisioned as a promising and effective solution to address this problem. Meanwhile, security is a critical issue for task offloading in MEC. While plenty of studies have focused on IoT tasks offloading, many of them ignored the security issue. Moreover, many previous works ignored the resource allocation of MEC servers. In addition, as dynamic voltage scaling (DVS) technology is flexible in the design of MEC systems, we integrate this technology with task offloading. In this paper, the problem of IoT applications offloading in an MEC system is studied, whose goal is to minimize computation overheads measured by the task processing delay and energy consumption of IoTDs. The AES cryptographic technique is adopted to make sure that the security of the data of the offloaded tasks is guaranteed. An optimization problem of security-aware task offloading is formulated and solved by proposing an efficient resource-allocation scheme. Experimental results are performed to evaluate and confirm the performance of the proposed security model.

1. Introduction

In the past few years, the number of Internet of Things (IoT) devices (IoTDs), such as wearable devices, has risen explosively [1]. According to the IOT ANALYTCS, the number of active IoTDs will grow to 22 billion by 2025 [2], as Figure 1 illustrates. The growing number of IoTDs has resulted in various IoT applications, which are typically delay sensitive and require a lot of computation resources. However, most of these IoT devices usually have limited resources and constrained battery power [3,4], which imposes a bottleneck for processing IoT applications. Although the remote public cloud (e.g., Amazon EC2) can provide abundant computing resources for processing IoT applications, their data centers are far away from the IoTDs, which will cause a long transmission latency. Therefore, the distant public cloud may not be suitable for latency-sensitive IoT applications [5].

To this end, the mobile edge computing (MEC) platform has been put forward [6]. In contrast to the remote public cloud, the servers of the edge cloud are implemented at a base station (BS), which are much closer to the IoTDs. Hence, the transmission latency can be significantly reduced. Meanwhile, by way of offloading computation-intensive IoT tasks to the edge cloud, the energy consumption of IoTDs can also be reduced. Therefore, offloading IoT tasks to the edge cloud can lower the processing latency as well as energy consumption.

In an MEC system, designing efficient resource-allocation schemes for task offloading is a hot research topic studied by a significant amount of works, such as [7,8,9]. However, many of them ignored the issue of data security, as the IoT users are concerned about privacy leakage when offloading applications to the edge cloud [10]. Although some of the related works, such as [11,12], did not jointly consider the DVS technology and the computing resources that are hosted in the edge server. In [13], the authors investigated the joint allocation of power and computing resources in an MEC system with multiple cells and edge servers. They did not take the data-security issue and DVS technology into account.

In this article, we study IoTDs’ task offloading in an MEC system by allocating the resources of the edge MEC server and adopting the DVS technology. The objective of our study is minimizing the execution time of tasks and the consumed energy by IoTDs, which is an optimization problem. As its objective function is non-convex, an algorithm is proposed to derive the optimal solution.

In a nutshell, we make the following contributions.

• We study the problem of IoTDs’ task offloading in a security-aware MEC system by allocating resources of the MEC server and adopting DVS technology. In particular, we take security issues into account, and the IoTDs adopt the DVS technology to reduce the task’s execution time and the consumed energy. Our objective is to obtain the minimization of the task-processing delay and the consumed energy for all IoTDs. We formulate this problem using an optimization problem.
• Since the objective function for the formulated problem is mixed-integer nonlinear programming (MINP), it is well-known as non-convex and NP-hard. This kind of problem is difficult to be solved. We propose an efficient algorithm by dividing the formulated problem into several sub-problems. The optimal solution for each sub-problem can be efficiently solved.
• The theoretical analysis and experimental results verify the performance of our proposed solution scheme.

2. Related Work

Recently, IoTDs’ task offloading and resource allocation have gained an enormous amount of research interest in recent years. We present a review of some works according to their objectives.

The minimization of delay or energy consumption. In [14], Gao et al. proposed a two-stage computing method using the aggregative game to minimize the processing latency of tasks while considering the proper management of a server load. In [15], Han et al. studied power-consumption minimization with the constraints of average latency by considering the MEC system dynamics. Lyu et al. studied resource-allocation and task-admission problems to minimize the total energy consumption considering delay constraints in MEC [16]. Their formulated problem is an integer programming problem, and the problem was solved by the proposed quantized DP algorithm. In [17], Wu et al. studied delay minimization for partial task offloading in the non-orthogonal multiple access (NOMA)-based MEC system. In [18], Wu et al. investigated multi-task multi-access MEC via NOMA to minimize the total energy consumption of entire tasks. They applied a two-step approach to studying the formulated problem. In [19], Tuong et al. investigated task offloading for the reduction of the average task delay by proposing a novel scheme, which can effectively improve the edge cloud service quality for all IoTDs by jointly optimizing the computation resource allocation (CRA) and sub-channel assignment (SA).

The minimization of both energy consumption and delay. In [6], a game-theoretic approach for mobile users is proposed to make task-offloading decisions by considering the overheads by the measurement of energy consumption and processing time in the multi-user MEC. In [20], Qian et al. investigated the joint resource allocation of communication and computation to minimize the delay and consumed energy by computing the resource allocation of edge servers in the NOMA-enabled multiaccess MEC with different edge servers. In [21], Zhang et al. studied data compression and the control speed of wireless transmission, aiming to minimize the energy consumption for wearable devices. An approximation algorithm was proposed such that the compression and transmission energy of wearable devices are minimized. Tang et al. studied partial task offloading in the MEC considering the overheads of time and energy [22]. The block coordinate descent method was proposed to solve the time and energy minimization problem. In [23], Feng et al. studied the trade-off of energy consumption and delay between the MEC system and the blockchain system by allocating the radio and communication resources in the blocked-enabled MEC systems. In [24], the authors focused on the study of sub-task offloading for minimizing both task-processing latency and energy consumption of the IoT devices with guarantees of dependency. They proposed an offloading scheme and compared it with different algorithms. However, this work did not consider resource allocation. In [25], Zhan et al. studied minimizing energy consumption and time for UAV applications in the MEC system enabled by UAV.

The works above did not consider security, an important issue when offloading tasks in MEC. To overcome this shortcoming, we present an efficient resource-allocation scheme for IoT task offloading in the MEC system by taking data security into account. Although some works considered the security issue of task offloading in the MEC system, many of them either overlooked the allocation of computing resources of the MEC server or the adoption of DVS without considering the joint study. In [11], Wu et al. studied power allocation in NOMA-enabled MEC networks aiming to minimize the energy consumption of two users while ensuring the task-offloading security. In [26], Elgendy et al. studied efficient and secure computation offloading for MEC-based mobile IoT networks minimizing the total energy consumed by the MDs. Although this security issue is considered in the two works, the work [11] did not take the allocation of computation resources into account, and the work [26] did not apply the DVS technology. Ref. [7] studied partial task offloading and the allocation of transmit power of MDs adopting the DVS technology. Two system-design goals, namely, minimizing energy consumption and task execution latency, were considered. However, allocating the computation resources of the MEC server and the security issue were not considered.

In order to present the existing challenges that this paper tries to address, we provide and summarize the limitations in the state-of-art literature in

Table 1. Comparison.

Reference	DVS	Processing Time	Consumed Energy	Computation Resources	Security
[14]	No	Yes	No	No	No
[15]	No	No	Yes	No	No
[16]	No	No	Yes	Yes	No
[17]	No	Yes	No	No	No
[18]	No	No	Yes	No	No
[19]	No	Yes	No	No	No
[6]	No	Yes	Yes	No	No
[20]	No	Yes	Yes	No	No
[21]	No	No	Yes	No	No
[22]	No	Yes	Yes	No	No
[24]	No	Yes	Yes	No	No
[25]	No	Yes	Yes	No	No
[11]	No	No	Yes	No	Yes
[26]	No	Yes	Yes	Yes	Yes
[7]	Yes	Yes	Yes	No	No
This Study	Yes	Yes	Yes	Yes	Yes

.

3. System Model

In this section, the system model is introduced, and the optimization problem is then formulated. Suppose that an MEC system consisting of multiple IoTD users and an edge cloud integrated with one server providing computing resources for the number of N IoTDs, which is illustrated in Figure 2. The IoTDs can be the fire alarms, which are delay-sensitive. By analyzing the sensed data, these fire alarms will alarm if there are fire accidents. There is a base station (BS) where the edge cloud is deployed, through which each IoTD’s task can be offloaded and processed in the MEC server. The task of IoTD i is denoted by $Q_i=(D_i,C_i)$ [27,28,29], where $D_i$ denotes the task’s data size, i.e., the input data, and $C_i$ denotes the CPU cycles that should be needed to compute one bit of task data size. Let $a_i$ denote the IoTD i’s task offloading policy. If the user of IoTD i processes its task in the edge cloud, $a_i=1$, otherwise, $a_i=0$.

3.1. Local Model

In the local model, each IoTD user will execute the task by adopting the DVS technology to use the computing resources of its device. For the IoTD i, its executing time and the consumed energy for the local execution are, respectively, expressed as [6,26]:

$$T_{i,l}=\frac{C_i{D}_i}{f_i}$$

(1)

$$E_{i,l}=P_i{C}_i{D}_i,$$

(2)

where $f_i$ represents the computing capability denoted by the number of CPU cycles that can be provided in one second, and $P_i$ means the one CPU cycle power consumption.

The power consumed by one CPU cycle of the IoTD i is [6]

$$P_i=k_i{f}_i^2,$$

(3)

where $k_i$ is a constant value parameter which is dependent on the chip architecture, and its value is ${10}^{-26}$ [30].

Therefore, we can obtain the computation overhead of the local model,

$$\begin{array}{cc}\hfill G_i& =w_{i,t}{T}_{i,l}+w_{i,e}{E}_{i,l}\hfill \\ \hfill & =w_{i,t}\frac{C_i{D}_i}{f_i}+w_{i,e}{P}_i{C}_i,D_i\hfill \end{array}$$

(4)

where $w_{i,t}$ and $w_{i,e}$$\in [0,1]$ represent the weighting parameters of task executing time and the energy consumed by the IoTD i, respectively. If $w_{i,t}>w_{i,e}$, the IoTD i cares more about execution time. Otherwise, if $w_{i,t}<w_{i,e}$, then the IoTD i focuses more on its energy consumption.

3.2. Edge Cloud Model

In the edge cloud model, each IoTD will offload its task to the MEC server in the edge cloud through a wireless channel. When offloading tasks to the edge cloud, extra transmission time and energy consumption will be caused. For the IoTD i, its data rate in the uplink is

$$r_i=B_i{log}_2(1+\frac{p_i{h}_i}{B_i{\varpi }_0}),$$

(5)

where $B_i$ is the bandwidth allocated to IoTD i, $p_i$ is the transmission power, $h_i$ means the channel gain expressed by $d_i^{-2}$, $d_i$ denotes the distance from the IoTD i to the BS, and ${\varpi }_0$ denotes the background noise power.

Then, the transmission time and the energy consumed for transmission are, respectively, computed as [7,26],

$$T_{i,t}=\frac{D_i}{r_i}$$

(6)

$$E_{i,t}=p_i{T}_{i,t}=p_i\frac{D_i}{r_i}$$

(7)

When executed by the edge server, the computational time is calculated as

$$T_{i,e}=\frac{C_i{D}_i}{F_{i,e}},$$

(8)

where $F_{i,e}$ is the allocated computing resources to the IoTD i.

3.3. Security Model

For the IoTD, i, the data of its task may be attacked by varieties of threats when it adopts the edge cloud model. Consequently, the AES cryptographic technique is adopted to protect the task against different types of threats [12,31,32]. In the security model, the tasks of IoTDs and their data will be encrypted before offloading. After receiving the data of these tasks, these data will be decrypted and executed by the edge servers. After accomplishing the execution of these tasks, the results will be sent back to the IoTDs.

Therefore, the additional time, including the encrypt time and decrypt time and energy consumption for securing data, are denoted, respectively, as [12,31,32],

$$T_{i,en}=\frac{C_i^e}{f_i}$$

(9)

$$T_{i,de}=\frac{C_i^d}{F_{i,e}}$$

(10)

$$T_{i,s}=T_{i,de}+T_{i,en}=\frac{C_i^e}{f_i}+\frac{C_i^d}{F_{i,e}}$$

(11)

$$E_{i,s}=k_i{f}_i^2{C}_i^e$$

(12)

where $C_i^e$ and $C_i^d$ indicate the number of CPU cycles that are needed to encrypt and decrypt the task of IoTD i’s data, respectively.

Therefore, the total computation overhead of the edge model is calculated as

$$\begin{array}{cc}\hfill H_i& =w_{i,t}(T_{i,t}+T_{i,e}+T_{i,s})+w_{i,e}(E_{i,e}+E_{i,s})\hfill \\ \hfill & =w_{i,t}(\frac{D_i}{r_i}+\frac{C_i{D}_i}{F_{i,e}}+\frac{C_i^e}{f_i}+\frac{C_i^d}{F_{i,e}})\hfill \\ \hfill & +w_{i,e}(\frac{p_i{D}_i}{r_i}+k_i{f}_i^2{C}_i^e).\hfill \end{array}$$

(13)

For the analysis of convenience, the notations that are used in this paper are summarized in Abbreviations.

3.4. Problem Formulation

The task offloading and resource-allocation problem while considering data security is described in the following problem. The objective of it is to minimize the task-processing time and energy consumption of all IoTDs.

For the IoTD i, we let $Z_i$ denote the execution time and energy consumption,

$$\begin{array}{cc}\hfill Z_i& =(1-a_i)G_i+a_i{H}_i\hfill \\ \hfill & =(1-a_i)[w_{i,t}\frac{C_i{D}_i}{f_i}+w_{i,e}{k}_i{f}_i^2{C}_i{D}_i]+\hfill \\ \hfill & a_i[w_{i,t}(\frac{D_i}{r_i}+\frac{C_i{D}_i}{F_{i,e}}+\frac{C_i^e}{f_i}+\frac{C_i^d}{F_{i,e}})\hfill \\ \hfill & +w_{i,e}(\frac{p_i{D}_i}{r_i}+k_i{f}_i^2{C}_i^e)].\hfill \end{array}$$

(14)

Hence, the formulated problem is expressed as,

Problem 1.

$$\begin{array}{cc}\hfill & \underset{f_i,F_{i,e},a_i}{min}\sum _{i=1}^N{Z}_i\hfill \\ \hfill & s.t.0<f_i\le f_i^m\hfill \\ \hfill & \sum _{i=1}^N{F}_{i,e}\le F\hfill \\ \hfill & a_i\in \{0,1\},\hfill \end{array}$$

(15)

where the first constraint is the maximum computational capability of IoTD i, the second constraint means that the allocated resources to the IoTDs should not be more than the computation capability of the MEC server, and $a_i$ is the task offloading policy.

Remark 1.

As the task-offloading policy is binary, and the resource allocation is continuous in Problem P, the above problem is a non-convex MINP problem, and it is notoriously challenging to find the optimal solution. Traditionally, the MINP problem can be solved by leveraging the Branch-and-Bound, the Dinkelbach, and the Alternating Direction Method of Multipliers (ADMM). However, the time complexity of applying these algorithms is prohibitive [16]. The authors in [33] obtain the solution of the MINP problem using these traditional algorithms and present the performances of these algorithms. To solve the task-offloading problem, Chen et al. presented a distributed learning-based framework [34]. In the following section, we will offer an efficient algorithm to obtain the optimal solution to Problem P.

4. Algorithm Design

It is obvious that Problem 1 is MINLP, which is difficult to solve [7,35,36]. In this part, we put forward an efficient algorithm to obtain the solution to Problem 1. Before that, a lemma is firstly presented whose proof is in [35], according to which the solution is obtained.

Lemma 1.

We can always obtain

$$\underset{x,y}{sup}f(x,y)=\underset{x}{sup}\tilde{f}\left(x\right),$$

where $\tilde{f}\left(x\right)$ = $su{p}_{y}f(x,y)$.

By referring to Lemma 1, we have the conclusion that we could always solve a function from minimizing over some of the variables firstly, and minimize over the left ones later.

From Lemma 1, Problem 1 can be solved by minimizing $p_i$, $F_i$, and $a_i$ sequentially. That is, we can first optimize the transmission power of IoTDs and computing resources of the edge server provided that the offloading decisions of IoTDs are given. Consequently, Problem 1 can be solved by dividing it into the following sub-problems:

(1)

Local model computation problem;

(2)

Edge model computing problem;

(3)

Task offloading decision problem.

4.1. Local Model Computation Problem

Based on Problem 1, when $a_i=0$, the IoTD users execute tasks on their own devices. Hence, the local model computing problem is written as follows,

Problem 2.

$$\begin{array}{cc}\hfill & \underset{f_i}{min}{G}_i\left(f_i\right)\hfill \\ \hfill & s.t.0<f_i\le f_{i,m},\hfill \end{array}$$

(16)

where $G_i\left(f_i\right)$ is denoted as

$$\begin{array}{cc}\hfill G_i& =w_{i,t}{T}_{i,l}+w_{i,e}{E}_{i,l}\hfill \\ \hfill & =w_{i,t}\frac{C_i{D}_i}{f_i}+w_{i,e}{k}_i{f}_i^2{C}_i{D}_i\hfill \end{array}$$

(17)

From the second-order derivative of Equation (17),

$$\frac{{\partial }^2{G}_i}{\partial {f_i}^2}=\frac{2w_{i,t}{C}_i{D}_i}{f_i^3}+2C_i{D}_i{w}_{i,e},$$

(18)

we know that $G_i^{″}$ is positive in the domain of $f_i$; therefore, $f_i$ is convex. Therefore, from the first derivative, we have

$$\frac{\partial G_i}{\partial f_i}=-\frac{w_{i,t}{C}_i{D}_i}{{\left(f_i\right)}^2}+2w_{i,e}{k}_i{f}_i{C}_i{D}_i=0.$$

(19)

From Equation (19), the optimal solution is

$$f_i^{*}=\sqrt[3]{\frac{w_{i,t}}{2k_i{w}_{i,e}}}.$$

(20)

It can be clearly observed that $G_i\left(f_i\right)$ monotonously increases if $f_i>f_i^{*}$ and monotonously increases when $f_i<f_i^{*}$.

Hence, the optimal solution to the local computation problem P2 is

$$G_i\left(f_i\right)=\left\{\begin{array}{c}\hfill G_i\left(f_{i,m}\right),f_i^{*}\ge f_{i,m}\\ \hfill G_i\left(f_i\right),f_i^{*}<f_{i,m}\end{array}\right.$$

(21)

4.2. Edge Model Computing Problem

According to Problem 1, when $a_i=1$, the users of the IoTDs will execute their tasks in the edge cloud. Therefore, the allocation of the MEC server computing problem can be written as follows.

Problem 3.

$$\begin{array}{cc}\hfill & \underset{f_i,F_{i,e}}{min}\sum _{i=1}^N{H}_i(f_i,F_{i,e})\hfill \\ \hfill & s.t.0<f_i\le f_{i,m}\hfill \\ \hfill & \sum _{i=1}^N{F}_{i,e}\le F\hfill \\ \hfill & F_{i,e}>0,\hfill \end{array}$$

(22)

where $H_i(f_i,F_{i,e})$ is denoted as

$$\begin{array}{cc}\hfill H_i(f_i,F_{i,e})& =w_{i,t}(\frac{D_i}{r_i}+\frac{C_i{D}_i}{F_{i,e}}+\frac{C_i^e}{f_i}+\frac{C_i^d}{F_{i,e}})\hfill \\ \hfill & +w_{i,e}(\frac{p_i{D}_i}{r_i}+k_i{f}_i^2{C}_i^e).\hfill \end{array}$$

(23)

By checking the objective function of Problem 3, we can further divide the above problem into the following two sub-problems: (1) Local computing resource-allocation problem; and (2) Edge cloud computing resource-allocation problem.

The problem of resource allocation in local model computing is formulated as follows.

Problem 4.

$$\begin{array}{cc}\hfill & \underset{f_i,F_{i,e}}{min}\sum _{i=1}^N{H}_i\left(f_i\right)\hfill \\ \hfill & s.t.0<f_i\le f_{i,m},\hfill \end{array}$$

(24)

where $H_i\left(f_i\right)$ is denoted as

$$H_i\left(f_i\right)=w_{i,t}\frac{C_i^e}{f_i}+w_{i,e}{k}_i{f}_i^2{C}_i^e.$$

(25)

As function $H_i\left(f_i\right)$ has a similar structure to $G_i\left(f_i\right)$, the solution of function $H_i\left(f_i\right)$ can easily be obtained, which is expressed as

$$H_i\left(f_i\right)=\left\{\begin{array}{cc}\hfill H_i\left(f_{i,m}\right),& f_i^{*}\ge f_{i,m}\hfill \\ \hfill H_i\left(f_i\right),& f_i^{*}<f_{i,m},\hfill \end{array}\right.$$

(26)

where $f_i^{*}$ is given as follows

$$f_i^{*}=\sqrt[3]{\frac{w_{i,t}}{2k_i{w}_{i,e}}}.$$

(27)

The edge cloud resource-allocation problem is as follows.

Problem 5.

$$\begin{array}{cc}\hfill & \underset{F_{i,e}}{min}\sum _{i=1}^N{H}_i\left(F_{i,e}\right)\hfill \\ \hfill & s.t.\sum _{i=1}^N{F}_{i,e}\le F_e\hfill \\ \hfill & F_{i,e}>0,\hfill \end{array}$$

(28)

where $H_i\left(F_{i,e}\right)$ is denoted as

$$H_i\left(F_{i,e}\right)=w_{i,t}(\frac{C_i{D}_i+C_i^d}{F_{i,e}}).$$

(29)

From

$$\frac{{\partial }^2{H}_i}{\partial {F_{i,e}}^2}=\frac{2w_{i,t}(C_i{D}_i+C_i^d)}{F_{i,e}^3}>0,$$

(30)

we know that $H_i$ is convex [35]. Consequently, the Lagrangian function is

$$\begin{array}{cc}\hfill L(F_{i,e},u)& =\sum _{i=1}^N[\frac{w_{i,t}(C_i+C_i^d)}{F_{i,e}}\hfill \\ \hfill & +u(\sum _{i=1}^N{F}_{i,e}-F_e)],\hfill \end{array}$$

(31)

where $u\ge 0$ is the Lagrange multiplier. Referring to the KKT conditions [35], we have

$$\frac{\partial L}{\partial F_{i,e}}=\frac{-w_{i,t}(C_i{D}_i+C_i^d)}{F_{i,e}^2}+u=0$$

(32)

$$u(\sum _{i=1}^N{F}_{i,e}-F_e)=0$$

(33)

$$u\ge 0.$$

(34)

According to Equation (33), it is obvious that $u>0$. Hence, from Equation (32), we have

$$F_{i,e}^{*}=\sqrt{\frac{w_{i,t}(C_i{D}_i+C_i^d)}{u}}.$$

(35)

Substituting Equation (37) back into the Equation (33), we can obtain the optimal value of Lagrangian multiplier, which is

$$u={(\frac{{\displaystyle \sum _{i=1}^N}\sqrt{w_{i,t}(C_i{D}_i+C_i^d)}}{F_e})}^2.$$

(36)

Therefore, by substituting Equation (36) into Equation (37), the optimal value of the allocated computing resource is

$$F_{i,e}^{*}=\frac{\sqrt{w_{i,t}(C_i{D}_i+C_i^d)}}{{\displaystyle \sum _{i=1}^N}\sqrt{w_{i,t}(C_i{D}_i+C_i^d)}}{F}_e.$$

(37)

By substituting Equation (37) into Equation (25), the optimal value of $H_i\left(F_{i,e}\right)$ is

$$H_i^{*}\left(F_{i,e}\right)=\frac{{[{\displaystyle \sum _{i=1}^N}\sqrt{w_{i,t}(C_i{D}_i+C_i^d)}]}^2}{F_e}.$$

(38)

4.3. Offloading Decision Problem

In this subsection, an efficient resource-allocation and task-offloading algorithm in the security-aware MEC system is presented. The users of IoTDs decide to execute their tasks in the MEC server if the computation overheads are smaller than the computation overheads of the local model [6]. For each user of IoTD, whether offloading its task or not is set by making a comparison of the computation overhead of the local model and edge model.

$$o_i=\left\{\begin{array}{cc}\hfill 1,& G_i\ge H_i\hfill \\ \hfill 0,& G_i<H_i\hfill \end{array}\right.$$

(39)

After obtaining the minimum computation cost of each IoTD, we can obtain the optimal system computation cost, which is

$$Z^{*}={\displaystyle \sum _{i=1}^N}((1-a_i)G_i^{*}+a_i{H}_i^{*}).$$

(40)

An algorithm is presented to obtain an optimal solution for the offloading decision policies, which is shown in Algorithm 1. This algorithm provides a detailed process to obtain the optimal decision for each IoTD user. In Algorithm 1, all users of IoTDs firstly initialize their task-offloading policies as 0 to obtain their optimal solution to the CPU frequency. Then, all users of IoTDs set the task-offloading policies as 1 to reach their optimal solution to the allocated computing resources and the local CPU frequency. At last, all IoTD users make the optimal offloading policies by comparing the computation overheads of the two models.

4.4. Complexity Analysis

In the local model, assume that there are n IoTDs, the computation overhead needs n times computing. Therefore, the time complexity of steps 3–6 in Algorithm 1 is $O\left(n\right)$. In the edge model considering the security issue, the computation overhead needs $N-n$ times computing. Therefore, the time complexity of steps 7–8 in Algorithm 1 is $O(N-n)$. Consequently, the time complexity of Algorithm 1 is $O\left(N\right)$. In [33], Yu et al. studied power resource allocation and interference management in Fog computing by applying the combination of the traditional methods, namely, ADMM, benders decomposition, and the Dinkelbach algorithm. The time complexity of this work is $O\left(max\{N/\left({\epsilon }^2\right),2^N\}\right)$, where $\epsilon$ denotes the tolerance.

Algorithm 1 The Proposed Algorithm in the Security-Aware MEC System

Input:

1: N tasks of IoTDs;

Output:

2: The resources allocation, task offloading, and the system computation overhead;

3: Initialize $i\leftarrow 1$

4: repeat

5: $f_i*\leftarrow$ Obtain its computational resource allocation by solving subproblem P2;

6: $G_i\leftarrow$ Obtain its computation overhead in the local computing model based on

Equation (21);

7: $F_{i,e}*\leftarrow$ Obtain its optimal allocation of computational resources by solving problem

P3;

8: $H_i\leftarrow$ Obtain its the optimal computation overhead in the MEC server model from

Equation (13);

9: if $G_i\ge H_i$ then

10:      $a_i\leftarrow 1$;

11: else

12:      $a_i\leftarrow 0$;

13: end if

14: $i\leftarrow i+1$

15: until $i\leftarrow N$

5. Experimental Results

In this section, the experimental results are provided to demonstrate the performance of the proposed model. The proposed efficient resource allocation for the security-aware task-offloading model labeled as Secured Model is evaluated through simulation results by comparing with the following models.

Local Model: In this model, all the IoTDs’ tasks do not offload and are executed using the resources of IoTDs.

Edge Model: In this model, all IoTDs will take the offloading strategies. Their tasks are all processed by the MEC server.

Unsecured Model: In this model, the IoTDs’ tasks may be computed in the local model or offloaded to the MEC server according to the proposed offloading algorithms. This kind of model is widely studied in existing works, such as [6,37].

5.1. Simulation Parameter Settings

Assuming that some IoTDs and one server exist in a MEC system, the default number of the IoTDs is $N=10$ unless otherwise specified. The distance from the IoTD i to the BS is 1000 m. The computational capability of the MEC server is $F=10$ GHz, and the computational capability of each IoTD is in [0, 1] GHz. Each IoTD has a task processed by itself or in the MEC server. The IoTDs’ tasks can be the face-recognition application, whose data size is uniformly distributed in [0, 10] Mb. The needed CPU cycles to complete one bit are set to 1000 cycles. As far as the IoTD i is concerned, its transmission power is set to 0.1 W, the bandwidth is 0.3 MHz, its channel gain $h_i$ is $2.6\times {10}^{-7}$, and the background noise power is ${10}^{-7}$ W. The weighting parameter values $w_{i,t}$ and $w_{i,e}$ are set from $\{0.2,0.5,0.8\}$ and $w_{i,t}+w_{i,e}=1$. Moreover, the number of CPU cycles to encrypt and decrypt the IoTD i’s data are both set to 100 megacycles. A summary of the values of the main parameters is given in

Table 2. Parameter values Settings.

Parameters	Values
The IoTDs’ number N	10
The allocated bandwidth of IoTD i $B_i$	0.3 MHz
The IoTD is’ data size $D_i$	[0, 10] Mb
The transmission power $p_i$	0.1 W
The needed CPU cycles to process one bit of data size $C_i$	1000 cycles
The number of CPU cycles to encrypt the IoTD i’s data $C_i^e$	100 magacycles
The number of CPU cycles to decrypt the IoTD i’s data $C_i^d$	100 magacycles
$k_i$	${10}^{-26}$
The channel gain $h_i$	${10}^{-6}$
The maximum computational capability $f_{i,m}$	1 GHz
The background noise power ${\varpi }_0$	${10}^{-7}$ W
The computational capability for the MEC server F	30 GHz

. We set these parameter values according to [6,12,16,38].

5.2. Simulation Results

Figure 3 shows the offloading percentage of IoTD users under different numbers of IoTD users considering the security model and the one without security. It is evident that the offloading percentage is lower when the security methodology is adopted. The offloading percentage of the two models decreases, respectively, versus the increasing number of IoTD users. For the secured model, the offloading percentage decreases more rapidly than the unsecured model. Moreover, we observe that the offloading percentage of IoTD users with the unsecured model remains at 100 percent when the number is less than 10.

Figure 4 shows the energy consumption of all tasks versus different numbers of IoTDs. Specifically, Figure 4a makes a comparison of the energy consumption under the models of Local Model, Edge Model, and the Unsecured Model, and Figure 4b also shows the consumed energy in the Secured model. It is evident from the two figures that processing tasks of IoTDs under the Local Model consumes the most energy of the four models. In contrast, less energy is consumed in the Edge Model than the other three models. It can also be observed that energy consumption significantly increases when the number of IoTDs rises. Furthermore, we can notice that, when the number of IoTD users is less than 15, the energy consumption under the Secured model and the proposed Unsecured model are both near to the Edge model. However, when the number of IoTD users exceeds 15, the gap will become larger.

Figure 5 depicts the task-execution time of all the IoTDs versus different numbers of IoTDs under different models. In Figure 5a, a comparison among the models of Local Model, Edge Model, and the Unsecured Model is shown, while Figure 5b shows the task-execution time of the Secured model. By observing Figure 5, it is found that the task-execution time in the Local Model is the least among the four models, while processing in the Edge Model costs more time than the other three models. From the two sub-figures, we see that the total task execution time under the four models, respectively, increases if the number of IoTD users increases. By comparing Figure 4 and Figure 5, we find that the proposed Secured Model consumes more energy than the baseline model Unsecured Model, while costing less time. In addition, it can be noticed that, when the number of IoTD users is less than 20, the task-execution time under the Secured model and the proposed Unsecured model are both near to the Edge model. However, when the number of IoTD users exceeds 20, the gap between the two models will become larger.

Figure 6a,b show the total computation overheads under the Unsecured model and Secured model, respectively. It can be noticed from Figure 6a that the computation overheads under the Unsecured model are higher than under the Local Model and the Edge Model. It can be noticed from Figure 6b that the computation overheads under the proposed secured model are higher than under the Local Model and the Edge Model. By comparing Figure 6a and Figure 6b, we observe that the proposed secured model obtains higher computation overheads than the Unsecured model. However, the gap is not obvious. This may be the reason that encrypting and decrypting data of the tasks of IoTD users may cause extra computation overheads. In addition, it is noted that the computation overheads in the Local Model are higher than or near equal to those of the Edge Model when the number of IoTD users is less than 20. However, the computation overheads under the Edge Model will be higher than the Local Model when the number of IoTD users is over 20.

In the last section, we analyze the impact of the computational capacity of the MEC server on the offloading percentage of IoTD users under the unsecured model and the secured model. We set the number of IoTD users N as 15 and vary the computational capability of the MEC server from 10 GHz to 30 GHz. We present the corresponding results in Figure 7. It can obviously be found from Figure 7 that the offloading percentage of IoTD users will increase with the computational capabilities of MEC servers increasing. Moreover, the offloading percentage under the secured model is lower than that under the unsecured model. This is because taking the secure technique will cost additional processing time and energy.

5.3. Discussions

In this paper, only the binary task offloading, that is, the task of IoTD that is either processed in the model or in the edge model by offloading, is considered. In our proposed Secured Model, as far as each IoTD is considered, since the proposed algorithm selects the smaller computation overhead, the system computation overhead is the lowest compared with the Local Model and the Edge Model. However, compared with the Unsecured Model, as the adoption of the secure technique costs additional processing time and energy, the Secured Model will cost additional computation overheads. This can be extended to the partial task-offloading case, namely, one part of the task for each IoTD is locally processed, and the other part of this task is offloaded.

According to the experimental results and the results’ analysis, the proposed secured model can be applied to some IoT applications, such as face-recognition applications. However, for applications that need higher requirements for the delay, such as traffic safety applications, the edge cloud owner has to provide more resources to meet the applications of the requirements.

As far as the formulated MINP problem is concerned, as well as the proposed algorithm, other methods such as the dandelion algorithm (DA) [39] or the Bat algorithm [40], may be applied to obtain the optimal solution. Queuing models can be used to model the system model [41]. Besides, task Offloading in the air-ground integrated MEC Systems also needs to be further studied [42].

6. Conclusions

In this paper, the IoT task-offloading problem with security taking into account an MEC system is studied, whose objective is minimizing the task-executing time and energy consumption of IoTDs by allocating the computing resources while adopting the DVS technology. Meanwhile, to ensure the security the offloaded tasks, we adopt the AES cryptographic technique to secure the data of these tasks. An optimization problem considering the computation overheads of the IoTDs is formulated. For the optimization problem, since its objective function is not convex, the computation-overhead minimization problem is a MINP problem, and it is well-known as NP-hard. To obtain the solution to this problem, we first split it into three layered sub-problems and obtain the answer to each. The experimental simulation results are validated to show the effectiveness of the proposed task-offloading model. The experimental simulation results reveal the fact that the number of the IoTDs has an evident effect on the energy consumption, task-execution time, and offloading percentage of IoTD users. In a comparison to baseline models, the proposed secured model reveals its better performances.