GAPSO: Cloud-Edge-End Collaborative Task Offloading Based on Genetic Particle Swarm Optimization

Abstract

In the 6G era, the proliferation of smart devices has led to explosive growth in data volume. The traditional cloud computing can no longer meet the demand for efficient processing of large amounts of data. Edge computing can solve the energy loss problems caused by transmission delay and multi-level forwarding in cloud computing by processing data close to the data source. In this paper, we propose a cloud–edge–end collaborative task offloading strategy with task response time and execution energy consumption as the optimization targets under a limited resource environment. The tasks generated by smart devices can be processed using three kinds of computing nodes, including user devices, edge servers, and cloud servers. The computing nodes are constrained by bandwidth and computing resources. For the target optimization problem, a genetic particle swarm optimization algorithm considering three layers of computing nodes is designed. The task offloading optimization is performed by introducing (1) opposition-based learning algorithm, (2) adaptive inertia weights, and (3) adjustive acceleration coefficients. All metaheuristic algorithms adopt a symmetric training method to ensure fairness and consistency in evaluation. Through experimental simulation, compared with the classic evolutionary algorithm, our algorithm reduces the objective function value by about 6–12% and has higher algorithm convergence speed, accuracy, and stability.

1. Introduction

With the rapid advancement of intelligent technology, mobile devices have become extremely popular in daily life. For example, in the Internet of Vehicles field, mobile devices equipped on vehicles are widely used for image processing, video streaming, and augmented reality/virtual reality [1]. In the smart healthcare domain, smart devices and sensors are widely used to remotely collect and monitor patient status in order to collect patient health data [2,3]. In the industrial field, Industry $5.0$ is the next stage of industrial development. It has become a trend to integrate modern technologies such as artificial intelligence, robotics, and the Internet of Things into manufacturing and production processes [4]. Numerous sensors and mobile devices continuously collect and generate massive amounts of data. However, mobile devices themselves have significant limitations in processing large-scale data. Their computing power and storage capacity are difficult to cope with such a huge data torrent. At the same time, the centralized processing method of traditional cloud computing is not friendly to delay-sensitive tasks [5]. Long delays will occur during data transmission, which cannot meet the immediacy requirements of scenarios such as autonomous driving and real-time industrial control. Edge computing (EC) sinks computing resources to the edge of the network. Mobile devices can offload tasks to edge servers to achieve task processing with lower transmission delays, while expanding computing resources and improving user service quality.

The continuous generation of large-scale data has led to an increasing demand for computing resources and user experience. In this context, cloud computing and mobile edge computing each play an indispensable and important role. Cloud computing provides powerful centralized computing and storage resources, which are suitable for processing tasks that require large amounts of computing and data storage [6,7]. Edge computing, due to its proximity to the data source, can provide low-latency computing services, which is particularly suitable for tasks with high real-time requirements. On the other hand, user devices themselves also have certain computing resources. For simple tasks and scenarios with high privacy protection requirements, local computing can be used for data processing. However, a single form of edge computing or cloud computing cannot meet the needs of complex scenarios and cannot balance energy consumption and time delay [8]. The cloud–edge–end collaborative computing model that integrates cloud computing, edge computing, and local computing can give full play to their respective advantages and build an efficient and flexible data processing architecture.

Task offloading is a key link in the cloud–edge–end collaborative environment, which involves the decision-making process of transferring tasks from mobile devices to edge servers or cloud servers [9]. This process requires a comprehensive consideration of the characteristics of the task itself, the performance parameters of the user device, the resource status of the edge server, and the relevant properties of the cloud server. By formulating a reasonable task offloading strategy, cloud–edge–end collaborative computing can achieve full utilization of resources and efficient processing of tasks, thereby meeting the diverse needs of users for service quality in different scenarios.

In this paper, we use the Genetic Particle Swarm Optimization (GAPSO) algorithm to solve the task offloading problem in the cloud–edge–end collaborative network environment. This algorithm helps to reduce task response time and energy consumption under the constraints of limited computing resources and edge server bandwidth. The main contributions of this paper are as follows:

(1)

This paper proposes a task processing framework for a cloud–edge–end collaborative environment. User devices can choose between three computing modes: local computing, edge computing, and cloud computing. Compared with the traditional mode, the cloud–edge–end collaborative environment can better utilize limited computing resources and improve data processing efficiency.

(2)

This paper implements a task transmission method that fully considers the bandwidth resources of edge servers. The transmission process of tasks from user devices (UDs) to edge servers (ESs) and ES to cloud servers (CSs) is more in line with the actual situation.

(3)

This paper designs a GAPSO algorithm, which improves the diversity of initial particles through the Opposition-Based Learning (OBL) algorithm, introduces adaptive inertia weights and adjustive acceleration coefficients, and uses a genetic algorithm (GA) to optimize the local optimal solution of particles.

(4)

This paper uses a symmetrical training method to conduct multiple experiments. The experimental results show that the GAPSO algorithm can achieve higher convergence accuracy, stability, and convergence speed.

In this paper, the entire experiment is constructed using a symmetric design method. All metaheuristic algorithms are applied under the same training conditions, including the same cloud–edge–end collaborative architecture and environmental parameter configuration. At the same time, the optimization target metric, number of training iterations, and experimental evaluation indicators are also kept consistent. This structured framework not only enhances the reliability of comparative analysis but also highlights the importance of symmetric experiments in the study of cloud–edge–end collaborative applications.

The rest of this paper is organized as follows. Related work is reviewed in Section 2. Section 3 presents the system model and problem formulation of this paper. The proposed GAPSO algorithm is introduced in Section 4. Section 5 provides our experimental results. Finally, in Section 6, we summarize our work.

2. Related Work

2.1. Task Offloading for Edge Computing

Edge computing task offloading refers to offloading tasks to edge servers close to data sources or user devices. Edge computing is usually deployed close to end devices, such as base stations or routers. Compared with cloud computing, edge computing can significantly reduce network latency and bandwidth usage [10,11] and is suitable for applications with high real-time requirements and large data volumes, such as intelligent transportation [12], smart healthcare [13], autonomous driving [14], unmanned aerial vehicles (UAVs) [15], and the Metaverse [16]. Zhou [17] considered the joint task offloading and resource allocation problem of multiple MEC server collaboration and proposed a two-level algorithm. The upper-level algorithm combines the advantages of algorithms such as PSO and GA to globally search for advanced offloading solutions. The lower-level algorithm is used to effectively utilize server resources and generate resource allocation plans with fairness guarantees. Sun [18] considers splitting multiple computationally intensive tasks into multiple subtasks simultaneously. A joint task segmentation and parallel scheduling scheme based on the dominant actor–critic (A2C) algorithm is proposed to minimize the total task execution delay. Chen [19] proposed a two-stage evolutionary search scheme (TESA), where the first stage optimizes computing resource selection, and the second stage jointly optimizes task offloading decisions and resource allocation based on a subset of the first stage, thereby significantly reducing latency. Zhu [20] considered the impact of user offloading decisions, uplink power allocation, and MEC computing resource allocation on system performance. An edge computing task offloading strategy based on improved genetic algorithm (IGA) is proposed.

2.2. Task Offloading for Cloud–Edge Collaboration

Cloud–edge collaborative task offloading refers to the collaborative processing between cloud computing and edge computing. Tasks can be allocated between the cloud and edge based on their characteristics and requirements. The advantage of cloud–edge collaboration is that it can take into account the powerful computing power of cloud computing and the low latency characteristics of edge computing, thereby optimizing resource utilization and service quality [21,22]. Zhang [23] proposed a task offloading strategy based on a time delay penalty mechanism and a bipartite graph matching method to optimize the task allocation between edge devices and the cloud. The aim is to minimize system energy consumption. Gao [24] established a dynamic queue model and used the drift and penalty function framework to transform the problem into a constrained optimization problem. Finally, a task offloading algorithm based on Lyapunov optimization was proposed. Lei [25] considered that the performance of geographically distributed edge servers varies over time and developed a dynamic offloading strategy based on a probabilistic evolutionary game theory model.

2.3. Task Offloading for Cloud–Edge–End Collaboration

Cloud–edge–end collaborative task offloading further extends the concept of cloud–edge collaboration by incorporating the computing capabilities of end devices (such as smartphones, sensors, and IoT devices). In this model, tasks can be flexibly allocated between end devices, edge servers, and cloud servers. This collaborative approach maximizes the use of computing resources at all levels and provides a more flexible and efficient computing solution. Liu [26] decomposed the task offloading and resource allocation problem into two sub-problems. First, the optimal solution of the task partitioning ratio was obtained using a mathematical analytical method, and then the Lagrangian dual (LD) method was used to optimize the task offloading and resource allocation strategies to minimize the task processing delay. Zhu [27] proposed a speed-aware and customized task offloading and resource allocation scheme aimed at optimizing service latency in mobile edge computing systems. By utilizing the Advantage Actor Critic (A2C) algorithm, computing nodes are dynamically selected to improve user service quality. Qu [28] takes the total task execution delay and key task execution delay as the optimization goals and proposes an emergency offloading strategy for smart factories based on cloud–edge collaboration through the Fast Chemical Reaction Optimization (Fast-CRO) algorithm. The algorithm can quickly make emergency unloading decisions for the system. Wu [29] proposed an online task scheduling algorithm based on deep reinforcement learning for mobile edge computing networks with variable task arrival intensity to achieve online task offloading and optimize overall task latency. Ji [30] performed intelligent tasks through a cloud–edge collaborative computing network. A hybrid framework that combines a model-free deep reinforcement learning algorithm and a model-based optimization algorithm was proposed to jointly optimize communication resources and computing resources, achieving near-optimal energy performance. Zhou [31] proposed an edge server placement algorithm ISC-QL to determine the optimal placement location of edge servers in the Internet of Vehicles system, which achieved optimization of load balancing, average latency, and average energy consumption.

In summary, researchers have conducted a lot of research on the task offloading problem of cloud computing and edge computing. The relevant work is shown in

Table 1. Summary of related works versus our survey.

Reference	Task Offloading Environment			Optimization Objective		Algorithm
	Cloud	Edge	End	Completion Time	Energy Consumption
[17]	✗	✓	✗	✓	✗	APGTO + FGRA two-level algorithm.
[18]	✗	✓	✗	✓	✗	Advantage Actor Critic (A2C) algorithm.
[19]	✗	✓	✓	✓	✗	Two-stage evolutionary search scheme (TESA).
[20]	✗	✓	✓	✓	✓	Improved genetic algorithm (IGA).
[23]	✓	✓	✗	✗	✓	Dichotomy search algorithm.
[24]	✓	✓	✗	✗	✓	Lyapunov optimization method.
[25]	✓	✓	✗	✓	✗	Evolutionary Game Algorithm.
[26]	✓	✓	✓	✓	✗	Mathematical analytical method and Lagrangian dual (LD) method.
[27]	✓	✓	✓	✓	✗	Speed aware and customized TORA scheme based on A2C algorithm.
[28]	✓	✓	✓	✓	✗	Fast Chemical Reaction Optimization (Fast-CRO) algorithm.
[29]	✓	✓	✓	✓	✗	Online task scheduling (Online-TS) algorithm.
[30]	✓	✓	✓	✗	✓	Deep reinforcement learning based hybrid (DRLH) framework.
[31]	✓	✓	✓	✓	✓	Edge Server Placement Algorithm ISC-QL.
Ours	✓	✓	✓	✓	✓	Genetic particle swarm optimization (GAPSO) algorithm.

, but there are relatively few studies that consider the collaborative integration of cloud, edge, and end for the task offloading environment. The above research content does not clarify the impact of edge bandwidth resources on the system data transmission environment. At the same time, there is a lack of stable and efficient algorithms to solve the task offloading problem of cloud–edge–end collaboration, which is crucial for optimizing the execution of large-scale tasks in a multi-user environment.

3. System Model and Problem Formulation

As shown in Figure 1, we consider a three-layer network framework for cloud–edge–end collaboration, which mainly includes the cloud computing layer, edge computing layer, and user device layer. It consists of 1 CS, S ESs, and N UDs, with a total of $1+S+N$ nodes. The coordinates of each node are composed of $(X,Y,Z)$ three-dimensional coordinates. Each node has its own CPU clock frequency f, $f_C$ represents the CPU clock frequency of the CS, $f_{E_j}$ represents the CPU clock frequency of the $j_{th}$ ES $(j\in S)$, and $f_{U_i}$ represents the CPU clock frequency of the $i_{th}$ UD $(i\in N)$. We assume that each $i_{th}$ UD has $M_i$ tasks to execute, and each task has a unique characteristic attribute $d_k$$(k\in M_i)$ to represent the computing data size of the task. Each task can be executed on its own user device, all edge servers, and cloud servers, and the offloading node is unique. Therefore, each task has $(S+2)$ execution modes. For tasks with a small computing data size, they can be executed on the user device, while for tasks with a large computing data size, they can be transferred to the edge server or cloud server for execution, that is, the processing power of the user device itself is taken into account, while the high computing resources of the cloud server are also taken into account.

Since users are generally concerned about task completion efficiency, while service providers focus on the energy consumption of service provision, we focus on optimizing the average response time and average energy consumption of all tasks. In the three-layer network architecture, response time must account for the influence of transmission delay factors in both edge computing and cloud computing modes. For the cloud computing mode, the edge server is selected as a transit node. Given that cloud servers feature abundant bandwidth resources, edge servers act as transit nodes for both edge computing and cloud computing modes; thus, we focus on the bandwidth resource constraints of edge servers. $W_j$ represents the bandwidth resource of the $j_{th}$ ES.

In order to make full use of bandwidth resources and computing resources in the three-layer computing environment, resource exclusivity will be adopted. When there is a task transmission, the remaining tasks will wait for the release of bandwidth resources. Similarly, when there is a task execution, the remaining tasks will wait for the release of computing resources.

Table 2. Commonly used terms in cloud–edge–end model.

Notation	Description
N	The number of UD
S	The number of ES
$M_i$	The amount of tasks generated by $i_{th}$ UD
M	Total number of tasks
$d_k$	The data size of $k_{th}$ task
c	The number of CPU clock cycles required per bit
$\kappa$	The effective switching capacitance of the chip
$W_j$	The communication bandwidth of $j_{th}$ ES
$N_0$	Power of noise
$\sigma$	Path loss index
$f_{U_i}$	The CPU clock frequency of $i_{th}$ UD
$f_{E_j}$	The CPU clock frequency of $j_{th}$ ES
$f_C$	The CPU clock frequency of the CS
$p_U$	The transmit power of UD
$p_E$	The transmit power of ES
$q_E$	Energy consumption per bit in ES
$q_C$	Energy consumption per bit in CS
$D_{U_i,E_j}$	The distance between $i_{th}$ UE and $j_{th}$ ES
$g_{U_i,E_j}$	Channel gain between $i_{th}$ UE and $j_{th}$ ES
$D_{E_j,C}$	The distance between $j_{th}$ ES and CS
$g_{E_j,C}$	Channel gain between $j_{th}$ ES and CS
$r_{U_i,E_j}$	The communication rate between $i_{th}$ UD and $j_{th}$ ES
$r_{E_j,C}$	The communication rate between $j_{th}$ ES and CS
$T_{re{s}_k}$	The response time of $k_{th}$ task
$E{G}_k$	The energy consumption of $k_{th}$ task

summarizes the key symbols used in this paper. Next, we introduce the response time model and energy consumption model, respectively [32,33,34,35], and analyze the three-layer computing mode corresponding to each model.

3.1. Response Time Model

Task response time refers to the complete time interval from task submission to the return of task processing results, and its components include task waiting time, task transmission time, and task processing time. In this subsection, we will calculate and analyze the response time of tasks in different computing modes.

(1)

Local computing mode: The local computing mode means that the tasks generated by the user device are directly executed on the user device. The local computing mode is not affected by the transmission delay factor. The task response time is the sum of the execution waiting time and the execution time. When $i_{th}$ UD is idle, the response time $T_{re{s}_k}$ of $k_{th}$ task $(k\in Mi)$ in $i_{th}$ UD is the local execution time of the task, and the task execution waiting time is 0. Otherwise, the response time $T_{re{s}_k}$ of $k_{th}$ task needs to take into account the waiting time of the task. The task response time of the local computing mode is defined as follows:

$$T_{{res}_k}=T_{{ew}_k}+{\displaystyle \frac{d_{k}c}{f_{U_i}}}$$

(1)

where $T_{e{w}_k}$ represents the execution waiting time of $k_{th}$ task.

(2)

Edge computing mode: The edge computing mode refers to the transmission of tasks generated by user devices to edge servers for execution. The edge computing mode needs to consider the transmission delay of tasks between user devices and edge servers. Since the result data after the task is executed is small, the transmission delay of the result data transmitted back to the user device is ignored here. The transmission time of $k_{th}$ task is the transmission delay of $k_{th}$ task from $i_{th}$ UD to $j_{th}$ ES. The task response time is the sum of the transmission waiting time, transmission time, execution waiting time, and execution time. When the edge server bandwidth resources are not occupied, the transmission waiting time of $k_{th}$ task is 0. When $j_{th}$ ES is idle, $T_{e{w}_k}$ of $k_{th}$ task is 0. The transmission rate $r_{U_i,E_j}$ [36] between $i_{th}$ UD and $j_{th}$ ES is defined as follows:

$$\begin{array}{c}\hfill D_{U_i,E_j}=\sqrt{{(X_{E_j}-X_{U_i})}^2+{(Y_{E_j}-Y_{U_i})}^2+{(Z_{E_j}-Z_{U_i})}^2}\end{array}$$

(2)

$$g_{U_i,E_j}={\left(D_{U_i,E_j}\right)}^{-\sigma }$$

(3)

$$r_{U_i,E_j}=W_j{log}_2(1+{\displaystyle \frac{p_U{g}_{U_i,E_j}}{N_0{W}_j}})$$

(4)

The task response time of the edge computing model is defined as follows:

$$T_{{to}_k}=T_{{tw}_k}+{\displaystyle \frac{d_k}{r_{U_i,E_j}}}$$

(5)

$$T_{{res}_k}=T_{{to}_k}+T_{{ew}_k}+{\displaystyle \frac{d_{k}c}{f_{E_j}}}$$

(6)

where $T_{t{w}_k}$ represents the transmission waiting time of $k_{th}$ task, and $T_{t{o}_k}$ represents the transmission end time of $k_{th}$ task.

(3)

Cloud computing mode: The cloud computing model refers to the task generated by the user device being transmitted to the cloud server for execution. The task is transmitted to the cloud server, with the edge server as the transit transmission node. The selection method of the transit edge node is determined by comprehensively considering the amount of tasks to be transmitted, bandwidth resources of the edge node, and the distance between the user UD and the CS to which the task is transited using the edge node. And the occupation of the edge bandwidth resources by the task transmission is not released until it is transmitted to the cloud server. Since the result data after the task is executed is small, the transmission delay of the result data from the cloud server back to the edge server and from the edge server back to the user device is also ignored here. The transmission time of $k_{th}$ task is the sum of the transmission delays of $k_{th}$ task from $i_{th}$ UD to $j_{th}$ ES and $j_{th}$ ES to CS. The task response time is the sum of the transmission waiting time, transmission time, execution waiting time, and execution time. Similarly, when the edge server bandwidth resources are not occupied, $T_{t{w}_k}$ of $k_{th}$ task is 0. When CS is idle, $T_{e{w}_k}$ of $k_{th}$ task is 0. The transmission rate $r_{E_j,C}$ between $j_{th}$ ES and CS is defined as follows:

$$\begin{array}{c}\hfill D_{E_j,C}=\sqrt{{(X_C-X_{E_j})}^2+{(Y_C-Y_{E_j})}^2+{(Z_C-Z_{E_j})}^2}\end{array}$$

(7)

$$g_{E_j,C}={\left(D_{E_j,C}\right)}^{-\sigma }$$

(8)

$$r_{E_j,C}=W_j{log}_2(1+{\displaystyle \frac{p_E{g}_{E_j,C}}{N_0{W}_j}})$$

(9)

The task response time of the cloud computing model is defined as follows:

$$T_{{to}_k}=T_{{tw}_k}+{\displaystyle \frac{d_k}{r_{U_i,E_j}}}+{\displaystyle \frac{d_k}{r_{E_j,C}}}$$

(10)

$$T_{{res}_k}=T_{{to}_k}+T_{{ew}_k}+{\displaystyle \frac{d_{k}c}{f_C}}$$

(11)

3.2. Energy Consumption Model

Energy consumption refers to the total energy consumed by the system in the process of processing tasks, and its components mainly include task execution energy consumption and task transmission energy consumption. In this subsection, we will specifically calculate and analyze the energy consumption of tasks in different computing modes.

(1)

Local computing mode: Since the local computing mode does not perform task transmission, there is no energy consumption generated by task transmission. Therefore, the energy consumption $E{G}_k$ of $k_{th}$ task is the execution energy consumption of $k_{th}$ task. The energy consumption of the local computing mode is defined as follows:

$${EG}_k=\kappa {\left(f_{U_i}\right)}^{v-1}{d}_{k}c$$

(12)

where v is a positive constant.

(2)

Edge computing mode: Since the edge computing mode requires the transmission of tasks between user devices and edge servers, the transmission energy consumption of tasks needs to be considered. Since the result data after the task is executed is small, the transmission energy consumption of the result data transmitted from the edge server back to the user device is ignored here. The transmission energy consumption only considers the transmission energy consumption of $k_{th}$ task from $i_{th}$ UD to $j_{th}$ ES. The energy consumption of $k_{th}$ task is the sum of the transmission energy consumption and the execution energy consumption. The energy consumption of the edge computing mode is defined as follows:

$${EG}_k=p_U\frac{d_k}{r_{U_i,E_j}}+d_k{q}_{E_j}$$

(13)

(3)

Cloud computing mode: Since the cloud computing model requires edge servers as transit nodes, it is necessary to consider the transmission energy consumption of tasks from user devices to edge servers and from edge servers to cloud servers. Since the result data after the task is executed is small, the transmission energy consumption of the result data from the cloud server back to the edge server and from the edge server back to the user device is also ignored here. The energy consumption of the cloud computing model is defined as follows:

$${EG}_k=p_U\frac{d_k}{r_{U_i,E_j}}+p_E\frac{d_k}{r_{E_j,C}}+d_k{q}_C$$

(14)

3.3. Problem Formulation

The purpose of this paper is to optimize the task offloading problem in the cloud–edge collaborative network environment while taking into account the full utilization of the edge server bandwidth resources and the CPU resources of the three-layer computing nodes. Formulas (1), (6), and (11) describe the task response time of the three computing modes, respectively. Since each user is mainly concerned about the efficiency of completing his or her own tasks, we use the average response time of the task as a measure of user service quality. The average response time of M tasks is defined as follows:

$${\displaystyle T_{{res}_{avg}}=\sum _{k=1}^M\left(\frac{T_{{res}_k}}{M}\right)}$$

(15)

Formulas (12)–(14) describe the energy consumption corresponding to the three computing modes, respectively. Since service providers are mainly concerned with the energy consumption caused by providing services, we use the average energy consumption of tasks as a measure to evaluate service energy consumption. The average energy consumption of M tasks is defined as follows:

$${\displaystyle {EG}_{avg}=\sum _{k=1}^M\left(\frac{{EG}_k}{M}\right)}$$

(16)

The target optimization problem is defined as follows:

$$\underset{{\omega }_1,{\omega }_2}{min}\left({\omega }_1{T}_{{res}_{avg}}+{\omega }_2{EG}_{avg}\right)$$

(17)

where $w_1$ and $w_2$ represent the weights of average response time and average energy consumption in the target optimization problem, respectively.

4. Task Offloading Based on GAPSO

4.1. Standard Particle Swarm Optimization (SPSO) Algorithm and Coding

(1)

SPSO: The particle swarm optimization algorithm is a swarm intelligence optimization technology that simulates the foraging behavior of bird flocks. It finds the optimal solution by simulating information sharing between individuals in a bird flock [37]. In the algorithm, each solution is regarded as a particle flying in the solution space. The particle adjusts its flight direction and velocity according to the individual’s historical best position (individual extremum) and the group’s historical best position (global extremum). Each particle has only two attributes: speed and position. The speed indicates the particle’s moving speed, and the position indicates the particle’s moving direction [38]. Specifically, since there are M tasks in total, the spatial dimension is M, and there are L particles in the population, then the solution space can be expressed as $X=(X^1,X^2,X^3,\dots ,X^L)$, where the lth particle consists of two M-dimensional vectors, $X^l$ and $V^l$. $X^l={(x_1^l,x_2^l,x_3^l,\dots ,x_M^l)}^{\mathsf{T}}$ represents the position of the particle, and $X^{l\left(h\right)}$ represents the position after h rounds of iteration. At the same time, the speed of each particle is expressed as $V^l={(v_1^l,v_2^l,v_3^l,\dots ,v_M^l)}^{\mathsf{T}}$. As the iteration proceeds, the position and speed of the particle will change according to the individual historical optimal solution $p_{best}$ and the global optimal solution $g_{best}$, as shown in Formulas (18) and (19). The solution can be obtained by iterative execution until the end.

$$\begin{array}{c}\hfill V^{l(h+1)}=\omega V^{l\left(h\right)}+c_1{r}_1(p_{best}-X^{l\left(h\right)})+c_2{r}_2(g_{best}-X^{l\left(h\right)})\end{array}$$

(18)

$$X^{l(h+1)}=X^{l\left(h\right)}+V^{l(h+1)}$$

(19)

where $r_1$ and $r_2$ are random numbers in the range $[0,1]$.

(2)

Coding: The position and speed of particles in the PSO algorithm are two important properties, since each task has $O=S+2$ execution modes. The position and speed of particles are expressed by Formulas (20) and (21). Among them, $x_{mo}=0$ means that task m is not executed at node o, and $x_{mo}=1$ means that task m is executed at node o. The particle position is constrained by Formula (22). And $v_{mo}$ is a random number between $(-5,5)$. After the calculation of Formula (18), $V^{l(h+1)}$ will be calculated by Formula (23), and each $v_{mo}$ value will be converted into a probability between $(0,1)$. Formula (19) indicates that roulette is used to select execution nodes to avoid falling into local optimality. In the particle position matrix of this paper, the higher the number of rows, the lower the corresponding task transmission and execution priority. Formula (24) is used as the particle fitness.

$$X=\left[\begin{array}{cccc}{x}_{11}\hfill & x_{12}\hfill & \dots \hfill & x_{1O}\hfill \\ x_{21}\hfill & x_{22}\hfill & \dots \hfill & x_{2O}\hfill \\ x_{31}\hfill & x_{32}\hfill & \dots \hfill & x_{3O}\hfill \\ \dots \hfill & \dots \hfill & \dots \hfill & \dots \hfill \\ x_{M1}\hfill & x_{M2}\hfill & \dots \hfill & x_{MO}\hfill \end{array}\right]$$

(20)

$$V=\left[\begin{array}{cccc}{v}_{11}\hfill & v_{12}\hfill & \dots \hfill & v_{1O}\hfill \\ v_{21}\hfill & v_{22}\hfill & \dots \hfill & v_{2O}\hfill \\ v_{31}\hfill & v_{32}\hfill & \dots \hfill & v_{3O}\hfill \\ \dots \hfill & \dots \hfill & \dots \hfill & \dots \hfill \\ v_{M1}\hfill & v_{M2}\hfill & \dots \hfill & v_{MO}\hfill \end{array}\right]$$

(21)

$${\Sigma }_{o=1}^O{x}_{mo}=1$$

(22)

$$\varphi \left(v\right)={\displaystyle \frac{1}{1+e^v}}$$

(23)

$$-\left({\omega }_1{T}_{{res}_{avg}}+{\omega }_2{EG}_{avg}\right)$$

(24)

where $m=1,2,...,M$. $o=1,2,...,O$.

4.2. Adaptive Inertia Weight w

The inertia weight w plays a balancing role between the global search capability and local search capability of the SPSO algorithm. It determines the extent to which the current velocity of the particle is affected by the previous velocity and has a significant impact on the accuracy and convergence speed of the algorithm. In the early stage of algorithm iteration, setting a larger w can increase the movement speed of particles, thus enhancing the global search capability. As the iterative process proceeds, gradually reducing w can reduce the moving speed of particles, prompting the particle swarm to focus on local search. We adopt a linear strategy to adjust w to adaptively adjust the local and global search ability of particles. The specific adjustment method is shown in Formula (25).

$$\omega ={\omega }_{max}-({\omega }_{max}-{\omega }_{min})\ast {\displaystyle \frac{h}{h_{max}}}$$

(25)

where h and $h_{max}$ represent the current iteration number and the maximum iteration number, respectively, and $w_{max}$ and $w_{min}$ are the maximum and minimum values of the predefined inertia weight, respectively.

4.3. Adaptive Acceleration Coefficients $c_1$, $c_2$

The acceleration coefficient $c_1$ determines the particle’s dependence on the local optimum, which helps to explore the local environment and maintain population diversity. The acceleration coefficient $c_2$ determines the particle’s dependence on the global optimum, which helps the algorithm converge quickly. We use a nonlinear strategy to dynamically adjust $c_1$ and $c_2$. Specifically, let $c_1$ gradually decrease from 2.5, while $c_2$ gradually increases from 0.5. In the early stages of iteration, particles rely more on personal experience, increase search diversity, quickly approach the global optimal solution, and avoid falling into the local optimum. As the iteration deepens, particles gradually turn to rely on group experience, enhance local search capabilities, fine-tune the optimal solution, and accelerate convergence. The specific adjustment method is shown in Formulas (26) and (27).

$$c_1=(c_{min}-c_{max})\ast \sqrt{{\displaystyle \frac{h}{h_{max}}}}+c_{max}$$

(26)

$$c_2=(c_{max}-c_{min})\ast \sqrt{{\displaystyle \frac{h}{h_{max}}}}+c_{min}$$

(27)

where $c_{max}$ and $c_{min}$ are the maximum and minimum values of the predefined acceleration coefficients, respectively.

4.4. OBL Algorithm Initialization Population

The OBL algorithm is a search strategy for optimization problems that enhances population diversity by introducing the concept of opposition. This approach effectively improves the algorithm’s search capability and the quality of the initial population. It increases the diversity of the search by generating a corresponding opposition solution for each initial solution, which helps to explore the solution space more comprehensively. Compared with simply introducing random solutions, it is more likely to approach the global optimum, thereby accelerating the convergence of the algorithm. At the same time, it also helps to avoid falling into the local optimum and improve the global search performance of the algorithm. The detailed process of initializing the particle swarm is shown in Algorithm 1.

4.5. Crossover and Mutation

Crossover in genetic algorithms is a process that simulates biological reproduction. It allows two parent individuals to exchange some of their genetic information to produce offspring. The purpose of crossover is to combine the excellent characteristics of parent individuals to create new individuals that may have higher fitness. Mutation is a process that simulates gene mutation. It introduces new genetic diversity by randomly changing one or more gene bits in the genetic code of an individual with a certain probability. Mutation operations can sometimes guide particles out of the local optimum and find the global optimal solution.

This paper uses crossover and mutation operations in GA to update the local optimal solution of particles, that is, to update the position matrix of particles. This paper uses two-point crossover to generate new individuals. And all gene bits of new individuals are mutated probabilistically. Since each column in the position matrix represents an execution mode, the S column is edge server computing, and the two columns are local computing and cloud server computing. Therefore, when a gene bit mutates, first, the three computing methods are selected with equal probability, and then the specific execution mode is selected with equal probability, that is, the probability of mutation to local computing and cloud server computing is ${\displaystyle \frac{1}{3}}$, and the probability of mutation to any edge server computing is ${\displaystyle \frac{1}{3S}}$. The crossover and mutation operations are shown in Figure 2 and Figure 3. Algorithm 2 details the process of GA updating the local optimal solution.

Algorithm 1 Initialize the population-based OBL

Input: L (population size), M (number of tasks), O (number of execution modes)   1: for $l=1$ to L do   2:     for $m=1$ to M do   3:         $mode=randint(1,O+1)$;   4:         $mod{e}^T=O+1-mode$;   5:         for $o=1$ to O do   6:            if then $o=mode$   7:                $x_{mo}^l=1$;   8:            else   9:                $x_{mo}^l=0$; 10:            end if 11:            if $o=mod{e}^T$ then 12:                $x_{mo}^{l^{\prime }}=1$; 13:            else 14:                $x_{mo}^{l^{\prime }}=0$; 15:            end if 16:            $v_{mo}^l=randfloat(-5,5)$; 17:            $v_{mo}^{l^{\prime }}=randfloat(-5,5)$; 18:         end for 19:     end for 20:     $P=P\cup (X^l,V^l)$; 21:     $P^{\prime }=P^{\prime }\cup (X^{l^{\prime }},V^{l^{\prime }})$; 22: end for 23: In the population $P\cup P^{\prime }$, the task response time and energy consumption of each particle are calculated using Equations (1), (6), (11)–(14) according to the position of each particle. And obtain the fitness of all particles according to (15), (16), (24) and sort them; 24: Select the top L particles as the initial population P; 25: return  P

Algorithm 2 Update local optimal solution based GA

Input: p (current particle), $X_{pbest}$ (position matrix of the local optimal solution of the current particle), $X_{gbest}$ (position matrix of the global optimal solution of the population), $p_m$ (mutation probability) 1: $X_1,X_2=Crossover(X_p,X_{pbest})$; 2: $X_3,X_4=Crossover(X_p,X_{gbest})$; 3: for $i=1$ to 4 do 4:     $X_i^{\prime }=Mutation\left(X_i\right)$; 5: end for 6: Calculate the fitness corresponding to the position matrices $X_1^{\prime }$, $X_2^{\prime }$, $X_3^{\prime }$, and $X_4^{\prime }$ respectively; 7: Compare the fitness corresponding to the position matrices $X_{pbest}$, $X_p$, $X_1^{\prime }$, $X_2^{\prime }$, $X_3^{\prime }$, $X_4^{\prime }$, select the position matrix with the best fitness as the position matrix of the local optimal solution for the current particle, and update the particle’s local optimal position $X_{pbest}$;

4.6. GAPSO Algorithm

This paper adopts the GAPSO algorithm to solve the problem of task offloading in cloud–edge–end collaboration. Task offloading is optimized by introducing the OBL algorithm, adaptive inertia weight, and adaptive acceleration coefficient. In this algorithm, the OBL algorithm is first used to initialize the particle swarm. The OBL algorithm introduces the concept of opposition in the particle initialization process, constructs opposing particles, and avoids the initial solution being confined to a limited range, so as to improve the quality and diversity of the initial population. Then the population is updated iteratively. The inertia weight and acceleration coefficient are updated at the beginning of each iteration, responding to the evolution state of the particle swarm in real time, dynamically optimizing the balance between exploration and development, and avoiding premature convergence or slow convergence. During the iteration process, the GA algorithm is used to implement particle crossover and mutation operations, update the local optimal solutions of all particles, and guide the particles to jump out of the local optimal solution with a certain possibility. Until the end condition is met, the optimal task offloading solution is output. The detailed process is shown in Algorithm 3.

Algorithm 3 The algorithm steps of GAPSO

Initialization parameters: $w_{max}$, $w_{min}$, $c_{max}$, $c_{min}$ Output:  The offloading solution for all tasks corresponding to the global optimal solution   1: Use Algorithm 1 to initialize the population P;   2: Initialize the local optimal solution of each particle and the global optimal solution of the population;   3: $h=0$;   4: while $(h<h_{max})$ or (the fitness function value does not change within a certain number of iterations) do   5:     Use Equations (25)–(27) to update the inertia weight $\omega$ and acceleration coefficients $c_1$, $c_2$;   6:     for $l=1$ to L do   7:         Particle $P^l=(X^l,V^l)$, use Equation (18) to update the speed $V^l$, and use Equations (19) and (23) to update the position $X^l$;   8:         Through the position $X^l$, calculate the response time and energy consumption of all tasks, and update the fitness of the current particle $P^l$;   9:         Use Algorithm 2 to update the local optimal solution of the current particle; 10:     end for 11:     Update the global optimal solution of the population; 12:     $h=h+1$; 13: end while

5. Experiments and Analysis

5.1. Experimental Settings

In this section, we will consider a network topology environment covered by one CS, multiple ESs, and multiple UDs. The positions of CS, ESs, and UDs are determined by three-dimensional spatial coordinates $(X,Y,Z)$. The position of CS is fixed. The positions of ESs and UDs are randomly distributed in the spatial area, and the distance between them is ensured to exceed a certain limit distance to avoid overcrowding. Each UD will generate a random number of tasks, each with a unique attribute, task data size, in the range of $[3000,5000]$ KB.

We use the Windows 11 operating system to build the experimental simulation environment on the Python 3.11.5 platform. The relevant parameters used in the simulation experiment are summarized in

Table 3. Experimental parameter setting.

Parameters	Value
$M_i$	Unif (8, 10)
$d_k$ (KB)	Unif (3000, 5000)
c (cycles/bit)	500
$\kappa$	${10}^{-28}$
v	3
$\sigma$	4
$W_j$ (MHZ)	randint (10, 15)
$N_0$ (dBm/HZ)	−174
$f_{U_i}$ (GHZ)	Unif (0.5, 1.0)
$f_{E_j}$ (GHZ)	Unif (5.0, 10.0)
$f_C$ (GHZ)	40
$p_U$ (mW)	100
$p_E$ (mW)	200
$q_E$ (J/bit)	Unif (${10}^{-8}$, $2\times {10}^{-8}$)
$q_C$ (J/bit)	Unif ($3\times {10}^{-8}$, $4\times {10}^{-8}$)

[39,40]. The following algorithms are used to compare the performance with the algorithm proposed in this paper: GA, SPSO, adaptive inertia weight and chaotic learning factor particle swarm optimization (AICLPSO) [41], and chaotic adaptive particle swarm optimization algorithm (CAPSO) [42]. This experiment is based on a symmetric architecture. All algorithms are run under the same conditions, including the same cloud–edge–end topology environment, environment parameter configuration, number of iterations, and evaluation criteria. This symmetric design ensures fairness in the comparison between algorithms and helps improve the reliability of the results. At the same time, this balanced experimental structure not only helps to enhance the effectiveness of the research but also fits in with the consistency emphasized by symmetry.

In view of the research problem in this paper, the parameter settings of each algorithm are shown in

Table 4. Information on algorithm parameters settings.

Algorithm	Parameter Settings
GA	$p_m=0.1$, $p_c=0.8$
SPSO	$\omega =0.9$, $c_1=c_2=2$
AICLPSO	${\omega }_1=0.75$, ${\omega }_2=0.35$, $c_{i1}=c_{i2}=n=h=2$, $g=m=1$, $s=f=0.4$, $a=0$, $r=0.5$, $\rho =2.593$, $x_0=0.6$
CAPSO	${\omega }_{max}=0.9$, ${\omega }_{min}=0.4$, $c_{max}=2.5$, $c_{min}=0.5$, $\xi =0.2$, $a=4$
GAPSO	${\omega }_{max}=0.9$, ${\omega }_{min}=0.4$, $c_{max}=2.5$, $c_{min}=0.5$, $p_m=0.2$

. Considering the influence of randomness, each algorithm is repeated 10 times.

5.2. Performance Evaluation

Based on actual needs, users are usually more concerned about the efficiency of task execution, while service providers regard energy consumption in the service process as a core concern. Based on this realistic scenario, in order to achieve a balanced optimization of the interests of both users and service providers, this section uses the average response time and average energy consumption with equal weights as comprehensive evaluation indicators. In this section, in order to intuitively show the significant advantages of the cloud–edge–end environment, we rely on the offloading algorithm proposed in this article. For the four environments of cloud–edge–end (CEE) collaboration, cloud–edge (CE1) collaboration, cloud–end (CE2) collaboration, and edge–end (EE) collaboration, we focus on comparing and analyzing their optimal average response time and total energy consumption performance under the task number gradient of 200, 225, 250, 275, and 300. At the same time, under the same cloud–edge–end collaboration experimental environment configuration, we will further compare the optimization performance differences between the proposed algorithm and other algorithms.

(1)

Parameter sensitivity analysis: Figure 4a,b are experiments conducted while keeping $c_{max}$ and $c_{min}$ unchanged. In Figure 4a, ${\omega }_{max}$ is kept unchanged. It can be seen from the figure that the curve converges earlier when ${\omega }_{min}$ is 0.2. This is because the low inertia weight in the middle and late stages of the iteration causes the particles to ignore the historical speed and completely rely on the current optimal position, resulting in too fast convergence. When ${\omega }_{min}$ is 0.6, the curve converges more slowly and the final effect is poor. This is because the particle speed is insufficiently attenuated, and a strong exploration inertia is always maintained, resulting in the inability to converge well in the over-exploration search space. In Figure 4b, ${\omega }_{min}$ is kept unchanged. It can be seen from the figure that the curve converges the worst when ${\omega }_{max}$ is 0.7. This is because when ${\omega }_{max}$ is small, the inertial component of the particle speed is weak, so the particles rely on the attraction of $c_1$ and $c_2$ earlier, which accelerates the development to the current optimal position, resulting in insufficient exploration, and the particles are easy to quickly gather in the local optimal area. When ${\omega }_{max}$ is 1.1, the effect of faster exploration of the optimal solution is shown in the early stage of the iteration. This is because the inertial component of the particle velocity is higher and more dependent on the historical velocity, which reduces the attraction of $c_1$ and $c_2$, thereby promoting a wider exploration of the search space, so there is a greater probability of finding a better solution in the early stage, but it will not be able to converge to the optimal solution quickly in the later stage. Figure 4c,d are experiments carried out while keeping ${\omega }_{max}$ and ${\omega }_{min}$ unchanged. In Figure 4c, $c_{max}$ is kept unchanged. It can be seen from the figure that the convergence effect is the worst when $c_{min}$ is 0.2. This may be because the particles in the later stage mainly rely on inertial motion, lack traction to the optimal solution, and cannot jump out of the suboptimal solution. When $c_{min}$ is 0.8, the convergence effect is poor. This is because the $c_1$ and $c_2$ coefficients are too high in the middle and late stages, forcing the particles to develop to the current optimal position too early and fall into the local optimal solution. In Figure 4d, $c_{min}$ is kept unchanged. It can be seen from the figure that when $c_{max}$ is 2.2, the convergence is slow and the convergence effect is the worst. This is because the maximum step size is limited in the early stage, the exploration ability is insufficient, and it is impossible to jump out of the local optimum. When $c_{max}$ is set to 2.6, the initial optimization is faster, but the convergence effect is poor. This is because the higher the $c_{max}$ value, the greater the exploration advantage in the early stage. However, this will also make the particle movement step too large, which makes it easy to miss the optimal solution. Therefore, in order to achieve a balance between exploration and development and ensure robust convergence, ${\omega }_{max}$ is set to 0.9, ${\omega }_{min}$ is set to 0.4, $c_{max}$ is set to 2.5, and $c_{min}$ is set to 0.5.

(2)

Comparison of average response time, total energy consumption, and number of tasks: Figure 5 and Figure 6 show the changing trends of the average response time for completing each task and the total energy consumption for completing all tasks in different environments. In the four operating environments, as the number of tasks increases, the amount of tasks waiting to be processed in different execution modes increases due to the total amount of computing resources, resulting in an upward trend in the average response time and total energy consumption of tasks. In Figure 5, under the same number of tasks, CEE has a maximum acceleration effect of 49.64% in response time compared with CE2, a maximum acceleration effect of 27.26% compared with EE, and a maximum acceleration effect of 4.31% compared with CE1, showing a significant advantage overall. In Figure 6, under the same number of tasks, CEE has a maximum energy saving of 24.83% compared with CE2 and a maximum energy saving of 22.89% compared with CE1, showing a significant advantage. Compared with EE, CEE takes the cloud computing model into consideration. Since the distance from CS to ES is significantly increased compared to the distance from ES to UD, a large amount of transmission energy is required to offload tasks to CS for processing, resulting in more total energy consumption for CEE than EE. These two figures show that the emergence of edge computing will greatly reduce the response time and energy consumption of completing tasks. At the same time, it can also show that cloud–edge–end collaboration has significant advantages and broad development prospects.

(3)

Algorithm performance: Under the cloud–edge–end collaborative processing framework proposed in this paper, the time complexity of the GAPSO, GA, SPSO, AICLPSO, and CAPSO algorithms is consistent with $O(n^{3}logn)$. The average change in the objective function value obtained by repeating 10 experiments for each algorithm to process the same task data in the same cloud–edge–end collaborative environment is shown in Figure 7. From the change in the curve, the GAPSO algorithm proposed in this paper shows obvious optimization effect. In the early stage of iteration, the GAPSO algorithm can obtain better initial solutions than the GA, SPSO, and AICLPSO algorithms, which highlights that the introduction of the OBL algorithm in the GAPSO algorithm can increase the diversity of the initial population and overcome the obstacle of falling into the local optimum to a certain extent. In the later stage of iteration, the GAPSO algorithm achieves better convergence accuracy than the other four algorithms and can reduce the objective function value by about 6–12%, indicating that the algorithm can find a better task allocation solution. The objective function value does not change after 1200 consecutive iterations, which is used as the basis for judging the convergence of the algorithm. From the convergence points marked in the figure, it can be seen that the GAPSO algorithm converges faster than the GA and SPSO algorithms. As can be seen from

Table 5. Test results of each algorithm.

Algorithm	Count	Mean	Variance	Standard Deviation
GA	10	23.2442	0.0667	0.2582
SPSO	10	21.9417	0.0193	0.1391
AICLPSO	10	22.3194	0.0464	0.2153
CAPSO	10	21.8245	0.0602	0.2453
GAPSO	10	20.3197	0.0134	0.1156

, GAPSO has obvious advantages over other algorithms in terms of mean, variance, and standard deviation, indicating that the algorithm has high stability. In general, the GAPSO algorithm we proposed has higher convergence accuracy and stronger stability. It can effectively avoid falling into local optimal solutions and is easier to search for global optimal solutions.

6. Conclusions

This paper focuses on the problem of task offloading in the cloud–edge–end collaborative environment and constructs a cloud–edge–end collaborative task processing framework. The framework supports flexible allocation of tasks between user devices, edge servers, and cloud servers, can give full play to the advantages of nodes at each layer, and effectively reduce the computing pressure of user devices. At the same time, in order to reduce the average response time and execution energy consumption of task completion, this paper introduces an opposition-based learning algorithm, adaptive inertia weight, and adaptive acceleration coefficient to propose a GAPSO algorithm. The proposed algorithm is compared with other traditional algorithms and heuristic algorithms using method symmetric design. Experimental results verify that the proposed algorithm can obtain a better initialization solution set and task offloading scheme, reducing the objective function value by about 6–12%, while showing excellent convergence speed, accuracy, and stability. At the algorithm level, there are many research algorithms for the cloud–edge–device collaborative environment. However, algorithms with high adaptability to actual application scenarios are still scarce. At the practical application level, cloud–edge–end collaboration has gradually penetrated into key areas such as industrial Internet of Things, intelligent transportation, smart cities, and telemedicine. However, the heterogeneity and dynamic nature of resources in different hardware devices, as well as the privacy and security issues of user devices during collaborative task processing, have not been effectively resolved. Therefore, for cloud–edge–end collaborative applications, the development of highly adaptable algorithms, the research on resource computing power, and the privacy and security of data transmission are still issues worth studying in the future.