SPMOO: A Multi-Objective Offloading Algorithm for Dependent Tasks in IoT Cloud-Edge-End Collaboration

Abstract

With the rapid development of the internet of things, there are more and more end devices, such as wearable devices, USVs and intelligent automobiles, connected to the internet. These devices tend to require large amounts of computing resources with stringent latency requirements, which inevitably increases the burden on edge server nodes. Therefore, in order to alleviate the problem that the computing capacity of edge server nodes is limited and cannot meet the computing service requirements of a large number of end devices in the internet of things scenario, we combined the characteristics of rich computing resources of cloud servers and low transmission delay of edge servers to build a hybrid computing task-offloading architecture of cloud-edge-end collaboration. Then, we study offloading based on this architecture for complex dependent tasks generated on end devices. We introduce a two-dimensional offloading decision factor to model latency and energy consumption, and formalize the model as a multi-objective optimization problem with the optimization objective of minimizing the average latency and average energy consumption of the task’s computation offloading. Based on this, we propose a multi-objective offloading (SPMOO) algorithm based on an improved strength Pareto evolutionary algorithm (SPEA2) for solving the problem. A large number of experimental results show that the algorithm proposed in this paper has good performance.

1. Introduction

With the rapid development of various internet-of-things (IoT) fields, such as intelligent traffic, intelligent home and intelligent manufacturing [1,2,3,4], the number of various IoT devices (e.g., wearable devices, unmanned surface vehicles (USVs) and intelligent automobiles [5,6,7] etc.) has increased significantly. According to Cisco, there are now more than 30 billion mobile IoT devices worldwide, generating about 2.5 EB of data per day, which often requires further processing and analysis. However, IoT devices have limited computing power and storage resources because they are mostly small, battery-powered and equipped with sensors. So, many latency-sensitive computing tasks generated in real time, such as face recognition, virtual reality (VR) and augmented reality (AR) [8,9,10], are present difficulties in guaranteeing users’ real-time experience when executed on local devices. These tasks are usually passed to the cloud, which costs time and computation power in maintaining the long-distance connection [11]. However, since the ultra-long-distance communication between IoT devices and remote clouds in real-world scenarios requires a large amount of bandwidth resources, sending all locally generated tasks to remote clouds for processing would bring serious problems, such as high latency and network congestion.

To alleviate these problems, one of the more effective approaches today is to offload all complex computing tasks from the local device to a nearby edge server. The edge servers are geographically closer to the local devices, they feature low communication costs and short response times. SDN can be set up at the edge layer to manage network traffic and resources with more flexibility and scalability support [12]. This not only ensures the real-time requirements of latency-sensitive tasks, but also reduces the energy consumption of the local devices. However, due to cost and scale constraints, the computing resources on edge servers are not unlimited. When a large number of tasks are offloaded to edge servers at the same time or when resource-poor local devices require more computing and storage resources, the edge servers can be overloaded and cannot effectively meet the complex application requirements.

Since these single-computing paradigms cannot solve all offload problems, there is a need to jointly consider the heterogeneity of cloud and edge computing to build a cloud-edge-end-collaborative computing architecture. A white paper from ETSI illustrates that cloud and edge computing are highly complementary, and that cloud-edge-end-collaborative computing can provide better computing performance and transport performance than cloud or edge computing alone [13]. However, it remains a challenge to effectively offload in a cloud-edge-end-computing environment due to resource heterogeneity, the diversity of user requirements, network complexity and task dependencies. At present, a part of the related work does not consider the complexity of tasks in realistic scenarios and only considers each computing task as an indivisible whole when performing offloading [14,15,16,17,18,19,20,21], which is obviously unreasonable. Another part of the related work considers the complexity of the tasks and partitions the tasks, but the complexity of calculating the communication cost between subtasks makes it extremely difficult to perform offloading research in cloud-edge-end architectures [22,23,24,25,26], so their work is often performed in two-tier offloading architectures (cloud–edge architecture or edge–end architecture, etc.). Therefore, in this paper, we propose a multi-objective optimal offloading algorithm for the offloading problem of complex tasks in IoT cloud-edge-end-computing architectures, aiming to optimize both the average latency and average energy consumption through the offloading of subtasks and the scheduling of resources in a heterogeneous environment. The main contributions of this paper are as follows:

• We integrate the characteristics of edge computing and cloud computing, and then fully integrate and, based on heterogeneous computing resources, establish an IoT cloud-edge-end-collaborative computing offload architecture.
• Defining tasks as a directed, acyclic graph (DAG) composed of a set of nodes with interdependent subtasks, we then establish latency and energy consumption models by introducing two-dimensional offloading factors.
• Based on the delay and energy consumption models, the offloading problem is formalized as a multi-objective optimization problem with the objective of minimizing the average delay and average energy consumption of task offloading, and a multi-objective offloading (SPMOO) algorithm based on an improved strength Pareto evolutionary algorithm (SPEA2) is proposed for solving the problem.

The rest of the paper is organized as follows. Section 2 discusses the related work; Section 3 presents the system model and the analysis of the problem; Section 4 describes the proposed multi-objective task offloading algorithm in detail; in Section 5 we perform extensive simulations and analyze different aspects; finally, Section 6 concludes the paper and discusses future work.

2. Related Work

To address the important challenges of working together with IoT systems and emerging computing paradigms, some researchers have proposed many effective task offloading algorithms to maximize application service performance from different perspectives. Based on whether the computing tasks are divisible or not, the tasks involved in the current related offloading research work are divided into two main categories: indivisible independent tasks and complex tasks consisting of multiple subtasks with data or logical dependencies.

2.1. Offloading Strategies for Independent Tasks

Since the dependency between subtasks is not involved, the offloading problem of independent tasks is much easier than that of dependent tasks. Therefore, there are many studies on the offloading strategy of independent tasks at present.

The study [15] proposed an online task scheduling algorithm for improving the total weighted response time (WRT) of all jobs. The study [16] considered the optimization problem of minimizing the long-term average delay of an IoT fog–cloud system and applied the Lyapunov drift-plus-penalty method to solve it. However, the optimization of long-term average delay may lead to performance imbalance among different tasks or time slots. The study [17] proposed an online method that attempts to maximize the number of tasks that meet the deadline while minimizing the average completion time (ACT) of the tasks through joint scheduling of network and computing resources. The study [18] proposed an energy-efficient dynamic task offloading (EEDTO) algorithm with the goal of minimizing energy consumption and task response time. This algorithm could adaptively select the optimal computation location for each task without requiring future system information as a priori knowledge. The study [19] transformed the dynamic performance optimization problem of service deployment for each user during system operation into a multi-arm bandit problem (MAB), which was then solved using a contextual Thompson sampling learning approach. The study [20] proposed a distributed, deep-learning method. They used a parallel deep neural network (DNN) to input the output of task load and offload decisions and updated the DNN parameters with the newly generated data.

2.2. Offloading Strategies for Dependent Tasks

The tasks generated by IoT devices in real scenarios are usually composed of a number of subtasks with logical or data dependencies. Any subtask must start execution only after all its predecessors have been executed; and, when executing these subtasks at different locations, data transfer between subtasks with dependencies is required, which can incur communication costs. Therefore, achieving optimal offloading decisions should not only focus on user requirements, complex access networks and resource utilization, but also take into account the dependencies between subtasks.

The study [27] proposed a greedy task graph partitioned offloading algorithm in order to minimize task communication overhead and energy consumption, which offloaded tasks at the device layer, cloudlet layer and cloud layer based on the computing power of the device and the type of task. However, the algorithm easily fell into local optimal solutions. The study [22] proposed an adaptive content-aware task scheduling (CATSA) framework. The approach was based on a multi-criteria technique to determine the way each task pair matches each computing paradigm and then selected an optimal solution from the solution set using a random search method. However, this work did not consider the resource heterogeneity between different computing layers. The study [28] used a long-short-term memory (LSTM) approach to predict the data size for each task. Based on the predicted values, the latency of each user task was optimized. However, this work simply partitioned the tasks without considering the dependencies between subtasks. The study [23] considered response time, reliability, and task execution cost in an edge cloud environment, and then formulated the offloading problem as an NP-hard, multi-objective optimization problem based on then on-dominated sorting genetic algorithm (NSGA-II) [29] and simulated binary crossover and polynomial variation to provide an offloading policy in the Pareto frontier. However, this work did not consider the power consumption model. The study [24] designed an online recurring score matrix-based heuristic algorithm (RSM-H) using a network state prediction method for the offloading problem of stateful, dataflow applications. However, this work only offloaded to the edge cloud and did not consider the power consumption model. The study [30] quantified the execution overhead as a weighted sum of task completion time and data transfer energy consumption and used this as an optimization objective to determine the execution location of a task. However, this work ignored the queueing order of tasks and the waiting execution time.

3. System Model and Problem Formulation

3.1. Overview

Since cloud servers have powerful computing and storage resources and rich applications, while edge servers have advantages of low communication cost, short response time, and strong network adaptability, we establish an IoT cloud-edge-end-collaborative computing offload architecture by combining the characteristics of both, fully integrating and invoking heterogeneous computing resources, and offloading tasks to the appropriate location based on the requirements of different applications in terms of computing power, energy cost and latency. As shown in Figure 1, the architecture consists of three layers, the end-device layer, edge layer and cloud layer. The end-device layer consists of a wide variety of IoT devices with sensors. These devices are usually small in size, have limited battery capacity, and have only limited computing and storage capabilities. So, to further process the data, these devices transmit the task data to the edge or cloud layers through wireless access points (APs) or base stations (BSs) [31]. The edge layer mainly consists of some lightweight edge servers that can provide low-latency computing services at the edge of the network. Meanwhile, to avoid overload, the edge servers can transfer tasks to the cloud servers for processing via wired links. The cloud layer has many cloud servers with rich computing and storage resources, and these servers provide services for users in different areas at the same time. However, the sharing among multiple users and the long transmission distance of connections to other layers lead to high communication cost for data transmission.

In this three-tier computing offload architecture, it is assumed that a total of $U=\{1,2,3,\dots ,u\}$ computing tasks are generated at the end device layer and sent to the edge layer, with $K=\{1,2,3,\dots ,k\}$ edge server nodes and $S=\{1,2,3,\dots ,s\}$ cloud server nodes available to provide services. Then we partition the computing tasks from end devices into multiple subtasks with dependencies, which are offloaded to edge servers or cloud services for execution.

In this paper, these interdependent subtasks are defined architecturally as a directed acyclic graph (DAG) $G=(V,E)$ as shown in Figure 2. Where the vertex $V=\{i_u\mid i_u=1_u,$$2_u,3_u,\dots ,n_u\}$ represents the services or microservices used by all subtasks of the task u. The modularity of the services or microservices makes it possible to deploy each service or microservice on various types of hardware, virtualized devices and specific libraries, thus solving the compatibility problem. The edge $E=\left\{\left(i_u,j_u\right)\mid i_u,j_u\in V\right\}$ represents the dependency between subtask $i_u$ and subtask $j_u$, and $w_{i,j}^u$ indicates the size of data to be transferred between $i_u$ and $j_u$, which will incur additional communication cost when these two subtasks are executed at different locations when data transfer is required.

Meanwhile, we introduce the offloading decision factor $x_{u,i}\in \{0,1\}$ to indicate whether the subtask $i_u$ is offloaded or not, and the offloading location factor $x_{u,i}\in \{-1,0,1\}$ to indicate the specific location where the subtask $i_u$ is offloaded. When $x_{u,i}=0$ indicates that subtask $i_u$ is executed locally, at this time $y_{u,i}=-1$ indicates that $i_u$ is not offloaded. When $x_{u,i}=1$, $y_{u,i}=0$ indicates that subtask $i_u$ is offloaded to the edge node, and when $x_{u,i}=1$, $y_{u,i}=1$ indicates that subtask $i_u$ is offloaded to the cloud node. For convenience, some important symbols adopted in this paper and their description are listed in

Table 1. Important symbols used in the paper and their description.

Symbols	Description
U	the total number of tasks
K	the total number of edge servers
S	the total number of cloud servers
N	the total number of subtasks
u	index of tasks
k	index of edge devices
s	index of cloud devices
i	index of subtasks
$pr{e}_i$	index of the predecessor of the subtask
$x_{u,i}$	the offloading decision factor to indicate whether the subtask $i_u$ is offloaded or not
$y_{u,i}$	the offloading location factor to indicate the specific location where the subtask $i_u$ is offloaded
$w_{i,j}^u$	the size of data to be transferred between $i_u$ and $j_u$
$D_i^u$	the CPU resources required to execute subtask $i_u$
$t_{u,i}^{st}$	the time when the subtask $i_u$ started to be executed
$t_{u,i}^{ed}$	the time when the subtask $i_u$ finished to be executed
$f_{local}$	the CPU frequency of local device
$f_k$	the CPU frequency of edge server
$f_s$	the CPU frequency of cloud server
$r_{u,k}$	the transmission rate between the end device and the edge server
$r_{u,s}$	the transmission rate between the end device and the cloud server
$r_{k,s}$	the transmission rate between the edge server and the cloud server
B	wireless transmission channel bandwidth
$H_u$	channel gain
$c_u$	transmission power of the end device for wireless transmission
$d_{u,k}^{\eta }$	path loss between the end device and the edge server
$d_{u,s}^{\eta }$	path loss between the end device and the cloud server
$P_i^u$	the set of all predecessor nodes of subtask $i_u$
$T_u^{total}$	the total delay required for the execution of task u
${\mu }_u$	the CPU energy factors of the end device
${\mu }_k$	the CPU energy factors of the edge server
$E_u^{cal}$	the computing energy consumption of the task u
$E_u^{trans}$	the transmission energy consumption of the task u
$E_u^{total}$	the total energy consumption

.

Here is an example which takes USVs as end devices for intelligent water quality monitoring application. The application breaks through the limits of conventional manual sampling monitoring, realizing the collection of changes of water quality, water temperature and other data in a certain area, and can regularly report the regional water quality analysis results. As shown in Figure 3, the application includes the following four parts: information collection and inspection, water quality level analysis and evaluation, historical water quality data query and water-quality distribution visualization. Among them, information collection and inspection can only be run locally, while the other three parts can be run locally, on the edge or cloud. The specific task offload execution position is determined by the scheduler according to the system state and task configuration information.

3.1.1. Delay Model

Since each subtask has a time to start execution and a time to finish execution, in this paper we use $t_{u,i}^{st}$ to denote the subtask $i_u$ start execution time and $t_{u,i}^{ed}$ to denote the subtask finish execution time. Then we denote the delay required for subtask $i_u$ to be executed at the local device as $\frac{D_i^u}{f_{local}}$, the delay required at the edge server node as $\frac{D_i^u}{f_k}$, and the delay required at the cloud server node as $\frac{D_i^u}{f_s}$, where $D_i^u$ denotes the CPU resources required to execute subtask $i_u$, $f_{local}$ denotes the CPU frequency of local device, $f_k$ denotes the CPU frequency of edge server, and $f_s$ denotes the CPU frequency of cloud server. From this we can obtain:

$$t_{u,i}^{ed}=t_{u,i}^{st}+\left(1-x_{u,i}\right)·\frac{D_i^u}{f_{\mathrm{local}}}+x_{u,i}·\left(\left(1-y_{u,i}\right)·\frac{D_i^u}{f_k}+y_{u,i}·\frac{D_i^u}{f_s}\right)$$

(1)

Since the end device layer generally communicates with the edge server and the cloud server through wireless access points (APs) or small base stations (BSs), the transmission rate $r_{u,k}$ between the end device and the edge server can be obtained according to Shannon’s formula as:

$$r_{u,k}=B{log}_2\left(1+\frac{H_u{c}_u{d}_{u,k}^{\eta }}{{\sigma }^2}\right)$$

(2)

where B denotes the channel bandwidth of wireless transmission, $H_u$ denotes the channel gain of the end device communicating through the wireless channel or base station, $c_u$ denotes the transmitting power of the end device for wireless transmission, and $d_{u,k}^{\eta }$ denotes the path loss between the end device and the edge server. Similarly, the transmission rate $r_{u,k}$ between the end device and the cloud server can be expressed as:

$$r_{u,s}=B{log}_2\left(1+\frac{H_u{c}_u{d}_{u,s}^{\eta }}{{\sigma }^2}\right)$$

(3)

since edge servers usually communicate with cloud servers through wired links, we denote the transmission rate between them as $r_{k,s}$.

For each subtask, its earliest start execution time is mainly limited by the completion execution time of all its predecessor nodes, and if the subtask is not executed at the same location as its predecessor nodes, the time consumed by data transmission is also considered, which can be expressed as:

$$t_{u,i}^{st}={max}_{pre\in P_i^u}\left\{\begin{array}{c}{t}_{u,pr{e}_i}^{ed}+x_{u,i}·\left(1+x_{u,i}\oplus x_{u,pr{e}_i}\right){\left(y_{u,i}-y_{u,pr{e}_i}\right)}^2·\frac{w_{pre\to i}^u}{r_{k,s}}\hfill \\ +\left(x_{u,i}\oplus x_{u,pr{e}_i}\right)\left(\left(y_{u,i}+y_{u,pr{e}_i}+1\right)·\frac{w_{pre\to i}^u}{r_{u,s}}+{\left(y_{u,i}+y_{u,pr{e}_i}\right)}^2·\frac{w_{pre\to i}^u}{r_{u,k}}\right)\hfill \end{array}\right\}$$

(4)

where, $t_{u,pr{e}_i}^{ed}$ denotes the completion execution time of the predecessor nodes of subtask $i_u$, $P_i^u$ denotes the set of all predecessor nodes of subtask $i_u$, and $w_{pre\to i}^u$ denotes the amount of data to be transferred between subtask $i_u$ and its predecessor nodes.

To facilitate the representation of the total delay of the task computation, we abstracted the input and output of the task as two subtasks $i_0^u$ and $i_{n+1}^u$, which do not need to consider the amount of computation, placed at the beginning and end of the task, respectively, so that the total delay required for the execution of task u can be expressed as:

$$T_u^{total}=t_{u,n+1}^{st}-t_{u,0}^{st}$$

(5)

3.1.2. Energy Consumption Model

When the task is executed in the cloud server, the energy required is often negligible compared to the abundant computing resources of the cloud service nodes themselves, so this paper mainly considers the energy consumption of three parts, local computing energy, edge server node computing energy and communication transmission energy. Among them, the computing energy consumption of the task u can be expressed as:

$$E_u^{cal}=\sum _{i=0}^N\left({\mu }_u·\left(1-x_{u,i}\right)·D_i^u+{\mu }_k·x_{u,i}·\left(1-y_{u,i}\right)·D_i^u\right),$$

(6)

where, ${\mu }_u$ and ${\mu }_k$ denote the CPU energy conversion factors of the end device and the edge server node, respectively.

The energy consumption generated by data transmission during the execution of task u includes the communication energy consumption $E_u^{trans}(local,edge)$ between the local device and the edge server, the communication energy consumption $E_u^{trans}(local,cloud)$ between the local device and the cloud server and the communication energy consumption $E_u^{trans}(edge,cloud)$ between the edge server and the cloud server, which can be expressed as:

$$E_u^{trans}(local,edge)=\sum _{i=1}^{N+1}\sum _{pre}^{P_i^u}\left(x_{u,i}\oplus x_{u,pr{e}_i}\right){\left(y_{u,i}+y_{u,pr{e}_i}\right)}^2·\frac{w_{pre\to i}^u}{r_{u,s}}·c_{u,s}$$

(7)

$$E_u^{trans}(local,cloud)=\sum _{i=1}^{N+1}\sum _{pre}^{P_i^u}\left(x_{u,i}\oplus x_{u,pr{e}_i}\right)\left(y_{u,i}+y_{u,pr{e}_i}+1\right)·\frac{w_{pre\to i}^u}{r_{u,s}}·c_{u,k}$$

(8)

$$E_u^{trans}(edge,cloud)=\sum _{i=1}^{N+1}\sum _{pre}^{P_i^u}{x}_{u,i}·\left(1+x_{u,i}\oplus x_{u,pr{e}_i}\right){\left(y_{u,i}-y_{u,pr{e}_i}\right)}^2·\frac{w_{pre\to i}^u}{r_{k,s}}·c_{k,s}$$

(9)

Therefore, the total communication energy consumption generated by performing data transfer during the execution of task u is

$$E_u^{trans}=E_u^{trans}(local,edge)+E_u^{trans}(local,cloud)+E_u^{trans}(edge,cloud).$$

(10)

Finally, the total energy consumption required during the computation and offloading performed by task u can be expressed as:

$$E_u^{total}=E_u^{cal}+E_u^{trans}.$$

(11)

3.2. Problem Formulation

Considering the real scenario where there is a conflict between the objectives of minimizing the average delay and minimizing the average energy consumption of task computation offload, if we use the weighted sum aggregation method to assign weights to the objectives, we can only obtain a single optimal solution, for which it is often difficult to meet the diverse needs of different users or service providers in a resource-variant environment. Therefore, in order to better meet the needs of users and providers, and to improve user experience and resource utilization as much as possible, we formalize the problem as a multi-objective optimization problem, where the optimization objective is to minimize the average delay and average energy consumption of task computation offloading. According to Equations (5) and (11), the optimization objective can be expressed as:

$$min\frac{1}{U}\sum _{u=1}^U{T}_u^{total}$$

(12)

$$min\frac{1}{U}\sum _{u=1}^U{E}_u^{total}$$

(13)

$$\begin{array}{cc}\hfill s.t.& C1:x_{u,i}\in \{0,1\},y_{u,i}\in \{-1,0,1\},\forall u\in [1,U],\forall i\in [0,N+1]\hfill \\ \hfill & C2:x_{u,0}=0,x_{u,N+1}=0,\forall u\in [1,U]\hfill \\ \hfill & C3:t_{u,i}^{st}\ge max{t}_{u,pr{e}_i}^{ed},\forall pre\in P_i^u,\forall u\in [1,U],\forall i\in [1,N+1]\hfill \\ \hfill & C4:\sum _{u=1}^U\sum _{i=1}^N{x}_{u,i}·\left[\left(1-y_{u,i}\right)·\mathfrak{M}\left(\tau -t_{u,i}^{st}\right)·\mathfrak{M}\left(t_{u,i}^{st}+\frac{D_i^u}{f_k}-\tau \right)\right.\hfill \\ \hfill & \left.+y_{u,i}·\mathfrak{M}\left(\tau -t_{u,i}^{st}\right)·\mathfrak{M}\left(t_{u,i}^{st}+\frac{D_i^u}{f_s}-\tau \right)\right]\le K+S\hfill \end{array}$$

(14)

Constraint C1 in Equation (14) indicates that for any subtask can only be executed on the edge server node or on the cloud server node. Constraint C2 indicates that for any task u, its input and output are at the local device. Constraint C3 indicates that each subtask must complete all its predecessors before it can start execution. Constraint C4 indicates that any edge server node and cloud server node cannot process multiple subtasks simultaneously in parallel. In this paper, we divide the time duration into a sequence of $T=\{1,2,3,\dots ,\tau \}$ time slots, and for each time slot, the number of offloaded subtasks cannot exceed the sum of the number of edge servers and cloud servers.

4. The Proposed SPMOO Algorithm

For the multi-objective optimization problems formulated in Section 3.2, the more frequently used solution algorithms are NSGA-II, MOEA/D, SPEA2, and etc. [29,32,33,34]. In this paper, a multi-objective offloading algorithm (SPMOO) based on the improved strength Pareto evolutionary algorithm (SPEA2) is proposed considering the parallel processing mechanism and global optimization. Since the standard SPEA2 algorithm has high randomness and poor ability in local search, we add local search set to enhance the local search ability of the algorithm based on the original algorithm, and we also adopt intergenerational crossover and individual similarity judgment strategies to improve population diversity and convergence speed. Therefore, our algorithm is able to obtain a set of Pareto-optimal solutions for user or supplier selection in a short time.

As shown in Algorithm 1, we initialize the population $P_0$ with size M and create an empty external archive set $A_0$ and an empty local search set $L_0$, both with size $M^{\prime }$. Then we calculate the fitness of all individuals in the population and external archive set and local search set, and save all the non-dominated solution sets in them to the next generation of external archive set $A_{t+1}$ and local search set $L_{t+1}$. If the number of individuals in the external archive set exceeds $M^{\prime }$ at this time, truncate the operation; if the number of individuals does not reach, we select some of the dominant liberation from $P_t$ and $A_t$ into $A_{t+1}$ and $L_{t+1}$. After that, the local search update is performed for $L_{t+1}$, and the individuals from the external archive set $A_{t+1}$ at this time are selected into the mating pool for crossover and mutation and the results are kept into the next generation population $P_{t+1}$ to recalculate the fitness, thus iterating. Finally, the non-dominated solution set in $A_{t+1}$ is taken as the final output of the offloading policy.

Algorithm 1: SPMOO

4.1. Fitness Calculation

To avoid the situation that individuals have the same fitness, the SPEA2 algorithm calculates the number of dominated solutions for each individual in the population and external archive set and defines it as the strength value $S\left(i\right)$, and based on this, the original fitness $R\left(i\right)$ is defined to represent the number of dominated solutions for individual i. The larger the $R\left(i\right)$, the more individuals dominate individual i.

$$S\left(i\right)=\left|\left\{j\mid j\in P_t+A_t\wedge i\succ j\right\}\right|$$

(15)

$$R\left(i\right)=\sum _{j\in P_t+A_t,j\succ i}S\left(i\right)$$

(16)

When most of the individuals are non-dominated, it is difficult to distinguish them by $R\left(i\right)$ alone, so the density value $D\left(i\right)$ is introduced, and the density value is calculated using the K-nearest neighbor method, where the density value of any individual is a function of the distance of its k neighboring individuals.

$$D\left(i\right)=\frac{1}{{\sigma }_i^k+2}$$

(17)

$$k=\sqrt{M+M^{\prime }}$$

(18)

In the above equations, ${\sigma }_i^k$ represents the Euclidean distance between individual i and its adjacent individual k. Finally, the fitness of individual i is obtained:

$$F\left(i\right)=R\left(i\right)+D\left(i\right).$$

(19)

4.2. Local Search Update

In order to avoid falling into local optimum, we replicate the external archive set to create a local search set, and then rank the individuals in this set according to their fitness and perform domain search on some of them with higher fitness. First, the decision factor of the selected individuals is the center of the circle, and then the search is performed within the determined search range, where the search radius and search density can be set by ourselves, and the higher the radius and density, the stronger the local search capability, and at the same time the computing effort will increase. Generally speaking, individuals with high adaptability will be closer to the Pareto optimal solution boundary, and the local search operation for these individuals can effectively improve the search efficiency of the algorithm.

4.3. Intergenerational Crossover

The standard SPEA2 algorithm uses tournament selection to select individuals from an external archive to generate a mating pool. As the number of individuals in the non-dominated solution gradually increases, this approach reduces the genetic composition of the resulting next generation because it has a high probability of selecting similar individuals to generate a mating pool. Intergenerational crossover uses tournament selection with replacement to select an individual from the current generation external archive set while selecting an individual from the previous generation archive set. Compared to the original crossover, intergenerational crossover generates both good and bad individuals, so we keep only the best solutions from both intergenerational and original crossovers.

On the other hand, we evaluate the similarity of individuals before performing a crossover, and only perform a crossover operation on two individuals when the difference between them exceeds the maximum threshold of similarity. Many related works use the number of identical gene positions of chromosomes as individual similarity, which is simple to operate but has some drawbacks. For binary coding, there may be many identical gene positions in two chromosomes corresponding to the same position, but their corresponding actual values may be very different, which may easily cause the Hamming cliff phenomenon [35]. Therefore, this paper adopts the Euclidean distance of individuals to be crossed as the measure of individual similarity. Its corresponding formula is:

$$\mathrm{Crossover}=\left\{\begin{array}{cc}1,& D_{ij}\ge D_{max}\\ 0,& D_{ij}<D_{max}\end{array}\right.,$$

(20)

where, $D_{ij}$ denotes the Euclidean distance between individuals to be crossed and $D_{max}$ denotes the set maximum similarity threshold.

4.4. Algorithm Complexity Analysis

The computational complexity of the NSGA-II, MOEA/D and SPEA2 algorithms are $\mathrm{O}\left(r{N}^2\right)$, $\mathrm{O}\left(rNT\right)$ and $\mathrm{O}\left(rNlogN\right)$. The computational complexity of SPMOO proposed in this paper is $\mathrm{O}\left(rNlogN\right)$, where r is the number of objective functions and N is the population size. The evaluation population set P, external archive A and empty local search set $L_0$ are taken into consideration simultaneously in SPMOO, so $N=M+2M^{\prime }$. Compared with the SPEA2 algorithm, the SPMOO algorithm optimizes the evolutionary selection mechanism without increasing time complexity, which reduces mutation and crossover operations of optimal solutions and accelerates the iteration speed.

5. Simulation Results

In this section, we conducted a large number of experiments to verify and evaluate our algorithm. Firstly, we describe the experimental setup and several benchmark methods. Then, we do some comparison with the benchmark methods and finally we analyze and evaluate the experimental results.

5.1. Simulation Settings

In the simulation experiments, we set the number of endpoint devices to 40 by default. Since the number of edge layer nodes is usually much smaller than the number of endpoint layers, we set the number of servers to eight by default. The execution time of the tasks varies from device to device, since they have different processing capabilities. All parameters used in the experiments are shown in

Table 2. Parameters and values.

Parameter	Value	Parameter	Value
U	[20, 60]	$f_s$	20 GHz
K	[2, 10]	$D_i^u$	[1000, 1500] megacycles
S	[1, 2]	$w_{i,j}^u$	[200, 500] kB
N	[4, 12]	$c_u$	[1, 2] W
B	10 MHz	$H_u$	[2, 4]
$f_u$	[0.5, 1] GHz	$d_{u,k}^{\eta }$	[0.0001, 0.0005]
$f_k$	[2, 10] GHz	$\sigma$	30 dBm

.

We compare the proposed SPMOO algorithm with the following three benchmark algorithms, which are described as follows.

ALE (All Local Execution), which does not consider the resources of edge nodes and cloud nodes, with all tasks processed locally on the device.

RA (Random Allocation), which randomly places all subtasks, except those that can only be executed locally, to the edge or cloud nodes.

GA (Genetic Algorithm), which simulates the natural biological evolution mechanism and performs efficient, parallel random global search and optimization for all policies, and adaptively controls the search process to find the optimal solution.

5.2. Analysis and Evaluation

From Figure 4a, we can see that the average delay of the four algorithms does not change much when the number of end devices increases, and the average delay of the SPMOO algorithm proposed in this paper is the lowest among the four algorithms. This is mainly due to the full consideration of the environmental factors in the subtask offloading process, such as the computing power of the edge server and the communication laws between subtasks and nodes, which make our algorithm more accurate and efficient in performing task offloading. The traditional GA algorithm does not introduce methods such as local search strategy and intergenerational crossover strategy, which leads to a gap between it and the algorithm proposed in this paper in terms of constraint processing. The RA algorithm does not use an optimization algorithm for the node offloading location, so it performs poorly in terms of both average delay and average energy consumption. The analysis of the average energy consumption in Figure 4a is similar to the analysis in Figure 4b.

It can be seen in Figure 5a,b that when the number of end devices is kept constant and the number of subtasks increases, the average latency of all four algorithms increases accordingly, while the SPMOO algorithm proposed in this paper has the best results.

Figure 6a,b show the graphs of average delay and average energy consumption with the number of edge servers when the number of end devices is 10, 15, 20 and 25, respectively. We can see that the latency and energy consumption slowly decrease with the increase of the number of edge servers, and when the number of edge servers reaches eight, the average latency and average energy consumption can basically reach an optimal state. Therefore, in order to improve the utilization of resources and allocate them rationally, we can occupy as few edge servers’ resources as possible while ensuring the latency and energy consumption requirements. Figure 7a,b show the graphs of average delay and average energy consumption with the number of edge servers when the number of subtasks is 6, 8, 10 and 12, respectively. Similarly, the average delay and average energy consumption can be seen to decrease and stabilize as the number of edge servers increases.

6. Conclusions

In this paper, we study the multi-objective optimization task offloading problem with resource-constrained edge servers in an IoT environment. To address this problem, we construct a cloud-edge-end-collaborative computing offload architecture consisting of end device layer, edge layer and cloud layer. Based on this, we construct a latency and energy consumption model by introducing two-dimensional offloading decision factors, and formalize the model as a multi-objective optimization problem with the optimization objective of minimizing the average latency and average energy consumption of task offloading, and then propose a multi-objective offloading (SPMOO) algorithm based on an improved strength Pareto evolutionary algorithm (SPEA2) for solving the problem. Extensive experiments show that our proposed method can significantly reduce the overall average delay and average energy consumption of the system. However, our method is less adaptable to new scenarios and takes a lot of time to get new offload decisions when the type of offload tasks or device resources change. Therefore, in future work we will further explore how to get offload decisions faster in dynamically changing heterogeneous scenarios by combining the feature of deep reinforcement learning that builds on prior experience to significantly accelerate the learning of new tasks.