Service Cache-Based Offloading and Resource Optimization Algorithm for UAV-Assisted Computing

Abstract

Edge computing minimizes data transmission delay and fulfills the requirements of real-time applications for the wireless network coverage problem in edge computing. This paper proposes a resource optimization algorithm based on service caching, and designs a hybrid computing model of UAV-assisted computation offloading and service programs, in which the UAV (Unmanned Aerial Vehicle) not only carries a server for computation offloading but also serves as a relay to assist in the downloading of service programs. The objective is to minimize the system’s total energy consumption while adhering to constraints such as delay, cache capacity, and other relevant factors. Because of the non-convex nature of the objective problem, it is divided into three sub-problems for more effective handling. Through analysis, the relationship between the resource allocation ratio and total system energy consumption is established, and the simulated annealing algorithm, greedy algorithm, and genetic algorithm are used to solve these sub-problems, respectively. Finally, the global optimal solutions for location deployment, service caching, resource allocation, and offloading decisions are obtained through iteration. The simulation results show that the proposed algorithm successfully reduces the total energy consumption of the system while maintaining task completion delay constraints.

1. Introduction

Over the past few years, the swift advancement of mobile computing has been propelled by the growing use of different mobile devices, including smartphones and wearable devices, which enable computing and communication to be carried out anytime and anywhere. However, due to resource limitations, mobile devices often struggle to meet users’ quality of service expectations. Although cloud computing has significant advantages in resource management and computational performance compared to local computing, it usually relies on remote data centers with long data transmission latency [1,2], which can severely impact applications that demand high real-time performance such as multimedia or medical monitoring. In recent years, fog computing has emerged as a promising paradigm to address the limitations of traditional cloud-based architectures in smart city environments, such as high latency and limited context awareness. A recent systematic literature review by Rahman et al. [3] provides a comprehensive classification of fog computing research into service-based, resource-based, and application-based approaches, highlighting its crucial role in latency-sensitive urban applications. Additionally, by offloading computing tasks to servers closer to users or task sources, mobile edge computing (MEC) provides an efficient solution to these challenges, alleviating the computational burden on user devices, and effectively reducing the data transmission delay compared with cloud computing.

For the multi-user scenario, researchers have given solution ideas to reduce the energy consumption of the system. In [4], the authors introduced an energy-efficient beamforming scheme for downlink multi-user MISO systems, where a base station equipped with dynamic metasurface antennas (DMAs) simultaneously serves multiple users, and they used an efficient alternating optimization (AO) algorithm to solve it. Additionally, researchers have investigated computational offloading strategies and suggested various methods to optimize both energy and delay consumption. In [5], the authors combined energy and delay consumption into a single framework, reformulating the problem as the search for an optimal solution within a finite policy space, and applied a heuristic approach to make offloading decisions for mobile devices. In [6], the authors utilized an orthogonal frequency division multiplexing (OFDM) transmission mechanism to reduce inter-user interference while optimizing offloading decisions and bandwidth resources to lower the overall energy consumption of the MEC system. In [7], the authors considered the uncertainty of resource demand and the delay constraints of heterogeneous computing tasks for dynamic time-varying systems, and co-optimized the offloading decision, computational resources, and bandwidth resources in the MEC system to minimize the total system energy consumption. Yousefpour et al. [8] proposed a comprehensive IoT–fog–cloud architecture aimed at minimizing IoT service delay through fog offloading. Their framework allows IoT tasks to be adaptively offloaded among fog nodes based on real-time queue states and estimated processing times, effectively balancing load and improving response times. By developing both a Markovian queueing model and an event-driven simulator, they demonstrate that their fog-collaboration policy significantly lowers average service delay across different traffic patterns (e.g., light vs. heavy tasks). This work highlights the potential of collaborative fog offloading to meet stringent quality of service (QoS) requirements in large-scale IoT deployments, and it provides valuable insights for subsequent research on robust, low-latency fog-based architectures. The authors of [9] introduced a computational offloading algorithm that jointly considers task prioritization and partial offloading. This algorithm makes offloading decisions based on the task’s tolerable delay, the minimum computation delay, and the lowest energy consumption. The offloading task priorities and MEC server rankings are determined independently. Tasks with higher priority are offloaded firstly to MEC servers with greater computational power, alleviating the processing load on local devices. In [10], the authors proposed a mobile edge computing model consisting of multiple users and MEC servers, where each user has multiple independent tasks. Through optimizing task offloading, computation, and communication resource allocation, the goal is to achieve the overall best decision that minimizes the weighted total energy cost and latency for all users. However, the cache capacity of the MEC servers is not considered in the above studies, and all assumed that all service programs are cached in the servers.

In practice, the cache capacity of the MEC server’s storage is constrained, preventing it from caching all service programs. To address this problem, the authors of [11] proposed a cache-assisted computation offloading scheme and optimized the caching policy, offloading policy, and resource allocation to decrease task processing time and conserve energy on user devices. In [12], an integrated optimization approach for multi-user computation offloading and service caching was explored by the authors, modeling it as a mixed-integer nonlinear programming problem to reduce the system’s task cost. In [13], the authors designed a collaborative caching algorithm to assist computation offloading, which determined different cache contents for different tasks and designed corresponding update policies to optimize the usage of cache and computational resources in the system. The authors of [14] used game theory to develop a suboptimal offloading strategy that incorporates service caching and D2D communication in multi-access networks, aiming to reduce computational offloading overhead by optimizing the offloading decision. In [15], a cache-enhanced computational offloading system model was proposed, extending the local caching of a single region in a MEC network to collaborative caching across multiple regions. This approach improves the overall cache hit rate, with offloading decisions ultimately determined using deep reinforcement learning. The above studies assumed that users are within the mobile network coverage and did not consider the communication situation of users in complex environments such as when terrestrial infrastructure is scarce or unavailable.

Mobile networks cannot cover all areas due to complex terrain, infrastructure limitations, or natural disasters. The use of UAVs has become increasingly prevalent in wireless communication systems due to their flexibility to enable dynamic deployment [16]. Equipping MEC servers on UAVs to provide service to users who cannot be covered by wireless networks is an approach that can significantly improve the user experience compared to traditional terrestrial MEC networks. In [17], researchers have investigated the dominant barriers and key techniques of THz-ISAC-UAV from the transceiver design perspective. To enhance both energy and hardware efficiency while addressing challenges related to distance and mobility, the authors focused on three critical technologies: UM-MIMO-ISAC hybrid beamforming, THz-ISAC waveform design, and communication and sensing channel state information acquisition. Finally, they provided a comprehensive discussion of their underlying principles and the key challenges associated with each.

In [18], focusing on multi-UAV MEC systems, researchers examined service caching-based cooperative computation and resource allocation, proposing an optimization problem that minimizes the worst-case task completion delay under device and UAV energy constraints. In [19], the authors utilized UAV-assisted service caching to obtain an optimal offloading and resource allocation policy that minimizes energy consumption under delay constraints by determining the 3D location of the UAV and the deployment of its services in the edge servers. The authors of [20] proposed a model to minimize the total UAV endurance under delay constraints, which jointly optimizes the offloading and caching decisions, the UAV hovering trajectory, and its computational resource allocation to improve the communication and computational resource utilization.

Research on UAV-assisted service cache-based computational offloading has just begun, and the related literature and research results are relatively limited. Refs. [18,19] studied UAV-assisted service cache-based computation offloading, but all of them assumed that users cached the required services, but the service requirements of users are usually highly dynamic and diverse, it is difficult to match and cache suitable services for all users in advance, and some computational tasks not only rely on static code or data, but also require real-time back-end processing. In that circumstance, all users holding caches is inconsistent with reality and not feasible. In addition, the authors of [18] proposed a scheme to offload user tasks to the base station for computation when the UAV computational capability or cache resources do not meet the user’s needs, but it does not take into account the fact that the user is distant from the base station, which makes it difficult for the UAV to cover both users and the base station at the same time, and when the UAV does not cache the relevant service program, it only considers the download of service programs from the base station, which results in a waste of the user’s device service resources. In [19], the authors assumed that only the services cached by the UAV are possible to uninstall, and this scenario ignores the situation where the UAV can download programs from either the user or the base station, which underutilizes the computational resources of the UAV. In [20], the authors assumed that the user’s computing power and cache capacity are much smaller than those of the UAV. In addition, they did not study local computing and caching, and concentrated on offloading computing workloads and the processing of UAV-cached tasks at the current and previous moments, without considering service caching. To tackle the aforementioned problems, this paper presents a UAV-assisted resource optimization algorithm based on service caching and downloading, which introduces a relay UAV and a computing UAV in order to assist users in completing computation tasks. To reduce total system energy consumption, this paper jointly optimizes UAV positions, caching decisions, computational resource allocation for the computing UAV, and user offloading strategies. The key contributions are summarized as follows:

(1)

A UAV-assisted cooperative computing model based on service caching and downloading is constructed, which consists of users, a relay UAV, a computing UAV, and a base station, and users are outside the coverage range of the base station. Among them, the computing UAV is able to cache part of the service programs and can provide computing and downloading services to users. The relay UAV has a wider communication coverage and can act as a relay to download programs from the base station and forward them to a user or the computing UAV when neither the user nor the computing UAV has cached the relevant service programs.

(2)

Under the constraints of time delay and the computing UAV cache capacity, an optimization problem is designed to optimize and lower system-wide energy consumption. The problem is a mixed-integer nonlinear programming (MINLP) problem which is divided into three separate sub-problems. The UAV location deployment and service caching sub-problem involves the optimization of discrete and continuous variables, and is solved using a simulated annealing algorithm; the computational resource allocation sub-problem is examined to establish the association between the resource allocation ratio and the system overall energy consumption, and it is addressed by using a greedy algorithm; the optimization variables of the offloading strategy sub-problem are binary, and the offloading strategy is solved using a genetic algorithm as a genetic code for each individual.

(3)

The objective problem’s optimal solution is determined through global iteration. Simulation results demonstrate that the proposed algorithm achieves substantial energy savings compared to benchmark algorithms. In comparison with the algorithm introduced in [18], the overall energy consumption is reduced by approximately 40%.

This paper proceeds as follows: The system model is described in Section 2, and the objective problem based on this system model is presented in Section 3. In Section 4, the optimization method for each sub-problem is given and the analysis of the simulation results is conducted. Finally, the full paper is summarized in Section 5.

2. System Model

As shown in Figure 1, the system model is presented, which consists of a relay UAV, a computing UAV, $\mathcal{M}$ ground users, and a base station. Considering the UAV’s constrained capacity, the computation function and the longer distance communication function are completed by two UAVs, respectively, the computing UAV carries a MEC server to provide computation and service program caching services for users, and the relay UAV is used to assist the communication between users, the computing UAV, and the base station. The set of user devices is denoted by $\mathcal{M}=\{1,2,\dots ,m\}$; each device is assigned a computational task to complete, and execution of the task can take place on the local device or on the computing UAV.

Let $U_m=(S_m,L_m,T_m^{max})$ signify the task assigned to device m, where $S_m$ represents the size of the task data, $L_m$ represents the amount of CPU cycles needed to process a single bit of task data, and $T_m^{max}$ denotes the upper limit of permissible latency for processing the task. Let ${\alpha }_m=\{0,1\}$ be the user device offloading strategy, where ${\alpha }_m=0$ implies that the task is executed directly on the user device, and 1 means that the task is executed on the computing UAV, which can serve multiple user devices at the same time [21]. Each task requires a corresponding program to execute, the set of all executed programs is denoted as $P=\{1,2,...p\}$, and the size of each program is $W_p$. Here, $\varphi \left(m\right)=p_m$ is used to denote that the computational task of the device m requires a program p, and the tasks of multiple devices may require the same program to execute. The base station can cache the service programs required by all user devices because it is equipped with a high-performance server, and user devices and UAVs can only cache some of the programs due to their limited cache capacity.

A three-dimensional Cartesian coordinate system is used to specify the coordinates of the UAV and the user equipment, assuming that the positions of the UAV and the user equipment remain unchanged during the execution of the computational task, that the UAV hovers at a fixed altitude of $H_{\xi },\xi \in \{u_r,u_c\}$, whose horizontal coordinates are represented by $Q_{\xi }=(x_{\xi },y_{\xi }),\xi \in \{u_r,u_c\}$, that the user equipment and the base station coordinates are represented by $Q_m=(x_m,y_m)$ and $Q_b=(x_b,y_b)$, respectively, and that the horizontal altitude of both can be neglected with respect to the UAV.

2.1. Communication Model

This model involves wireless communication between the user device, UAV, and base station. Assuming that the communication spectrum between the three is independent and there is no interference with each other, the bandwidth of the link between the computing UAV and the relay UAV is $B_{u_r,u_c}$, the bandwidth of the link between the base station and the relay UAV is $B_{b,u_r}$, the link bandwidths between user devices and the two UAVs are both $B_{m,u}$.

2.1.1. Communication Between Ground Equipment (User Equipment, Base Stations) and UAVs

Considering the presence of multiple scatterers or obstructions in the real-world environment, which results in signals not being able to propagate according to the free-space model and generate additional path loss, it is difficult to reflect the actual situation by using the free path loss model (FSPL) [22]. In this paper, a probability-based path loss model [23] is used, which integrates the occurrence probability of line-of-sight (LoS) and non-line-of-sight (NLoS) communications and their corresponding path loss characteristics. The LoS and NLoS communication probabilities between the base station and the relay UAV are, respectively,

$$P_{b,u_r}^{\mathrm{LoS}}={\displaystyle \frac{1}{1+aexp[-b(\left(\frac{180}{\pi }\left)arcsin\left(\frac{H_{u_r}}{d_{b,u_r}}\right)-\alpha \right)\right]}}.$$

(1)

$$P_{b,u_r}^{\mathrm{NLoS}}=1-P_{b,u_r}^{\mathrm{LoS}}.$$

(2)

where $d_{b,u_r}$ signifies the Euclidean distance between the base station and the relay UAV, and a and b are environment-dependent constants. The path loss between the base station and the relay UAV is

$$L_{b,u_r}^v=20lg\left({\displaystyle \frac{4\pi f_c{d}_{b,u_r}}{c}}\right)+{\lambda }_v,v\in \{\mathrm{LoS},\mathrm{NLoS}\}.$$

(3)

where $f_c$ is the signal’s carrier frequency, c is the speed of light, and ${\lambda }_v$ is the additional path loss of line-of-sight and non-line-of-sight links. Therefore, the average path loss between the base station and the relay UAV is

$${\overline{L}}_{b,u_r}=P_{b,u_r}^{\mathrm{LoS}}{L}_{b,u_r}^{\mathrm{LoS}}+P_{b,u_r}^{\mathrm{NLoS}}{L}_{b,u_r}^{\mathrm{NLoS}}$$

(4)

The channel gain between the two is

$$g_{b,u_r}={\displaystyle \frac{1}{{\overline{L}}_{b,u_r}}}$$

(5)

Similarly, the channel gains for the computing UAV–user and relay UAV–user connections can be obtained, respectively,

$$g_{u_r,m}={\displaystyle \frac{1}{{\overline{L}}_{u_r,m}}}$$

(6)

$$g_{m,u_c}={\displaystyle \frac{1}{{\overline{L}}_{m,u_c}}}$$

(7)

where ${\overline{L}}_{u_r,m}$ is the average path loss between the computing UAV and user devices, while ${\overline{L}}_{m,u_c}$ denotes the average path loss between the relay UAV and user devices.

Accordingly, the communication rate between the base station and the relay UAV is

$$r_{b2u_r}=B_{b,u_r}{log}_2\left(1+{\displaystyle \frac{p_b{g}_{b,u_r}}{N}}\right)$$

(8)

where $p_b$ is the transmission power of the base station, and N is the noise power.

The data transmission rate between the relay UAV and the user device is

$$r_{u_{r}2m}=B_{m,u}{log}_2\left(1+{\displaystyle \frac{p_u{g}_{u_r,m}}{N}}\right)$$

(9)

where $p_{u_r}$ is the transmit power of the relay UAV.

If a user device offloads the computational task to the computing UAV, the data transfer rate is

$$r_{m2u_c}=B_{m,u}{log}_2\left(1+{\displaystyle \frac{p_m{g}_{m,u_c}}{N}}\right)$$

(10)

where $p_m$ is the device’s transmission power.

If a user device downloads the relevant service program from the computing UAV, the data transfer rate is

$$r_{u_{c}2m}=B_{m,u}{log}_2\left(1+{\displaystyle \frac{p_{u_c}{g}_{m,u_c}}{N}}\right)$$

(11)

where $p_{u_c}$ is the transmit power of the computing UAV.

2.1.2. Communication Between the Relay UAV and the Computing UAV

Considering that the UAV has sufficient hovering height, the communication environment can be assumed to be free space, so the path loss is

$$L_{u_r,u_c}=20lg\left({\displaystyle \frac{4\pi f_c{d}_{u_r,u_c}}{c}}\right)$$

(12)

where $d_{u_r,u_c}$ is the distance between the relay UAV and the computing UAV. The channel gain between the two is

$$g_{u_r,u_c}={10}^{-{\displaystyle \frac{L_{u_r,u_c}}{10}}}$$

(13)

Therefore, the data transfer rate between the relay UAV and the computing UAV is

$$r_{u_{r}2u_c}=B_{u_r,u_c}{log}_2\left(1+{\displaystyle \frac{p_{u_r}{g}_{u_r,u_c}}{N}}\right)$$

(14)

2.2. Cache Model

The computing UAV can cache some programs for use by the user devices. The caching decision of the computing UAV for a program p is denoted as $C_p\in \{0,1\}$; $C_p=1$ denotes that it has cached the service program p, and 0 indicates that it has not cached the program. Since the computing UAV has a constrained cache capacity, the cumulative size of the cached programs cannot surpass its maximum storage limit; then,

$$\sum _{p\in P}{C}_p{W}_p\le K$$

(15)

where K is the cache capacity of the computing UAV.

Each user device also has a cache tolerance, so there is

$$\sum _{p\in P}{J}_{p_m}{W}_p\le K_m$$

(16)

where $K_m$ indicates the cache capacity of the device m, $J_{p_m}$ is a binary constant, and $J_{p_m}=1$ indicates that the device m has cached the program p.

2.3. Computational Model

The flowchart of the computation offloading model designed in this paper is shown in Figure 2, where the computation tasks for each device can be computed locally or executed remotely on the computing UAV. When a user chooses local computation, there will be the following three scenarios:

1.

If the user device m caches the relevant service program, the delay and power consumption during task execution are as follows:

$$t_1^{\mathrm{local}}={\displaystyle \frac{S_m{L}_m}{f_m}}$$

(17)

$$E_1^{\mathrm{local}}=\eta f_m^2{S}_m{L}_m$$

(18)

where $\eta$ is an active capacitor switch, and $f_m$ denotes the local computing resources of the device.

2.

In the case where the user device does not cache the service program, but the computing UAV stores the relevant service program, then the device will download the service program from the computing UAV, and the task completion delay and energy consumption are, respectively,

$$t_2^{\mathrm{local}}=t_1^{\mathrm{local}}+{\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{u_{c}2m}}}$$

(19)

$$E_2^{\mathrm{local}}=E_1^{\mathrm{local}}+p_{u_c}{\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{u_{c}2m}}}$$

(20)

3.

If neither the user device m nor the computing UAV has cached the relevant service program, the device will download the service program from the base station through the relay UAV, and the task completion delay and energy consumption are, respectively,

$$t_3^{\mathrm{local}}=t_1^{\mathrm{local}}+{\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{b2u_r}}}+{\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{u_{r}2m}}}$$

(21)

$$E_3^{\mathrm{local}}=E_1^{\mathrm{local}}+p_b{\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{b2u_r}}}+p_{u_r}{\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{u_{r}2m}}}$$

(22)

When a task is offloaded by a user to the computing UAV for computation, the following three scenarios occur:

1.

If the corresponding service program for UAV caching is calculated, the task completion delay and energy consumption are, respectively,

$$t_1^{\mathrm{edge}}={\displaystyle \frac{S_m}{r_{m2u_c}}}+{\displaystyle \frac{S_m{L}_m}{{\beta }_m{f}_{u_c}}}$$

(23)

$$E_1^{\mathrm{edge}}=p_m{\displaystyle \frac{S_m}{r_{m2u_c}}}+\eta {\left({\beta }_m{f}_{u_c}\right)}^2{S}_m{L}_m$$

(24)

where $\beta \left(m\right)\in \{0,1\}$ is the computing resource allocation ratio for the user device by the computing UAV.

2.

If the computing UAV does not cache but the user device m caches the service program, then the computing UAV will download the service program from the device, and then the task completion delay and energy consumption are

$$t_2^{\mathrm{edge}}={\displaystyle \frac{S_m+W_{\varphi \left(m\right)}}{r_{m2u_c}}}+{\displaystyle \frac{S_m{L}_m}{{\beta }_m{f}_{u_c}}}$$

(25)

$$E_2^{\mathrm{edge}}=p_m{\displaystyle \frac{S_m+W_{\varphi \left(m\right)}}{r_{m2u_c}}}+\eta {\left({\beta }_m{f}_{u_c}\right)}^2{S}_m{L}_m$$

(26)

3.

If neither the computing UAV nor the user device m has cached the service program, then the computing UAV will download the service program from the base station through the relay UAV, and the task completion delay and energy consumption are, respectively,

$$t_3^{\mathrm{edge}}={\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{b2u_c}}}+max\left({\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{u_{r}2u_c}}},{\displaystyle \frac{S_m}{r_{m2u_c}}}\right)+{\displaystyle \frac{S_m{L}_m}{{\beta }_m{f}_{u_c}}}$$

(27)

$$E_3^{\mathrm{edge}}=p_b{\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{b2u_r}}}+p_{u_r}{\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{u_{r}2u_c}}}+p_m{\displaystyle \frac{S_m}{r_{m2u_c}}}+\eta {\left({\beta }_m{f}_{u_c}\right)}^2{S}_m{L}_m$$

(28)

Therefore, for the user device, the delay and system energy consumption required to accomplish its task are, respectively,

$$\begin{array}{cc}\hfill T_m& =(1-J_{\varphi \left(m\right)})(1-C_{\varphi \left(m\right)})\left\{{\alpha }_m{t}_3^{\mathrm{edge}}+\left(1-{\alpha }_m\right)t_3^{\mathrm{local}}\right\}\hfill \\ \hfill & +(1-J_{\varphi \left(m\right)})C_{\varphi \left(m\right)}\left\{{\alpha }_m{t}_1^{\mathrm{edge}}+\left(1-{\alpha }_m\right)t_2^{\mathrm{local}}\right\}\hfill \\ \hfill & +J_{\varphi \left(m\right)}\left(1-C_{\varphi \left(m\right)}\right)\left\{{\alpha }_m{t}_2^{\mathrm{edge}}+\left(1-{\alpha }_m\right)t_1^{\mathrm{local}}\right\}\hfill \\ \hfill & +J_{\varphi \left(m\right)}{C}_{\varphi \left(m\right)}\left\{{\alpha }_m{t}_1^{\mathrm{edge}}+\left(1-{\alpha }_m\right)t_1^{\mathrm{local}}\right\}\hfill \end{array}$$

(29)

$$\begin{array}{cc}\hfill E_m& =(1-J_{\varphi \left(m\right)})(1-C_{\varphi \left(m\right)})\left\{{\alpha }_m{E}_3^{\mathrm{edge}}+\left(1-{\alpha }_m\right)E_3^{\mathrm{local}}\right\}\hfill \\ \hfill & +(1-J_{\varphi \left(m\right)})C_{\varphi \left(m\right)}\left\{{\alpha }_m{E}_1^{\mathrm{edge}}+\left(1-{\alpha }_m\right)E_2^{\mathrm{local}}\right\}\hfill \\ \hfill & +J_{\varphi \left(m\right)}\left(1-C_{\varphi \left(m\right)}\right)\left\{{\alpha }_m^{\mathrm{edge}}{E}_2^{\mathrm{edge}}+\left(1-{\alpha }_m\right)E_1^{\mathrm{local}}\right\}\hfill \\ \hfill & +J_{\varphi \left(m\right)}{C}_{\varphi \left(m\right)}\left\{{\alpha }_m{E}_1^{\mathrm{edge}}+\left(1-{\alpha }_m\right)E_1^{\mathrm{local}}\right\}.\hfill \end{array}$$

(30)

2.4. Description of the Problem

This research aims to optimize system-wide energy consumption, and jointly optimize the location deployment of the computing UAV $Q_{u_c}$, the relay UAV $Q_{u_r}$, the service caching of the computing UAV C, the resource allocation for computation $\beta$, and the offloading decision of user devices $\alpha$ in order to minimize the total system energy consumption. Since the mechanical energy consumption is basically constant in this model, this paper takes the mechanical energy consumption as a pre-condition and focuses on the optimization problem of communication energy consumption and computational energy consumption. The problem can be expressed as

$$\begin{array}{cc}\hfill P1:& \underset{\begin{array}{c}{Q}_{u_c},Q_{u_r},C,\beta ,\alpha \end{array}}{min}\sum _{m\in \mathcal{M}}{E}_m\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& \mathrm{C}1:{\alpha }_m\in \{0,1\}\hfill \\ \hfill & \mathrm{C}2:C_{\varphi \left(m\right)}\in \{0,1\}\hfill \\ \hfill & \mathrm{C}3:{\beta }_m\in [0,1]\hfill \\ \hfill & \mathrm{C}4:\sum _{\begin{array}{c}m\in \mathcal{M}\end{array}}{\alpha }_m{\beta }_m\le 1\hfill \\ \hfill & \mathrm{C}5:\sum _{m\in \mathcal{M}}{C}_{\varphi \left(m\right)}{W}_{\varphi \left(m\right)}\le K\hfill \\ \hfill & \mathrm{C}6:T_m\le T_m^{max}\hfill \\ \hfill & \mathrm{C}7:D_{u_r,u_c}\le H_{u_r}{\displaystyle \frac{1}{cos\left(\frac{\theta }{2}\right)}}\hfill \\ \hfill & \mathrm{C}8:D_{b,u_r}\le R_b\hfill \\ \hfill & \mathrm{C}9:{\alpha }_m{L}_{m,u_c}+\left(1-{\alpha }_m\right)C_{\varphi \left(m\right)}\left(1-J_{\varphi \left(m\right)}\right)L_{m,u_c}\le H_{u_c}tan\left(\frac{\theta }{2}\right)\hfill \\ \hfill & \mathrm{C}10:\left(1-{\alpha }_m\right)\left(1-C_{\varphi \left(m\right)}\right)\left(1-J_{\varphi \left(m\right)}\right)L_{m,u_r}\le H_{u_r}tan\left(\frac{\theta }{2}\right).\hfill \end{array}$$

Constraint $C1$ enforces that the user device’s offloading decision must be a binary variable. Constraint $C2$ indicates that a binary variable is used to represent the computing UAV’s caching decision, and Constraint $C3$ indicates that the UAV’s computational resource allocation ratio is a continuous variable. Constraint $C4$ indicates that the computing UAV will only allocate resources to users who perform offloading, and the sum of the resource allocation ratios will not exceed 1. Constraint $C5$ indicates that the sum of the program sizes cached in the computing UAV must not exceed the maximum storage capacity of the UAV. Constraint $C6$ means that the maximum tolerable delay sets an upper limit on each task’s completion time. Constraint $C7$ limits the location of the two UAVs to ensure that they can communicate, where $D_{u_r,u_c}=\sqrt{{(x_{u_r}-x_{u_c})}^2+{(y_{u_r}-y_{u_c})}^2+{(H_{u_r}-H_{u_c})}^2}$, $\theta$ indicates the UAV antenna’s half-power beamwidth [24]. Constraint $C8$ guarantees that the relay UAV maintains communication with the base station, where $D_{b,u_r}=\sqrt{{(x_b-x_{u_r})}^2+{(y_b-y_{u_r})}^2+H_{u_r}^2}$, $R_b$ denotes the base station’s communication range in 3D space. For user devices that perform computational offloading or need to download a service program from the computing UAV, the constraint $C9$ restricts the said devices to be within the coverage area of the computing UAV, where $L_{m,uc}=\sqrt{{(x_m-x_{u_c})}^2+{(y_m-y_{u_c})}^2}$. If user devices need to download service programs from the base station via the relay UAV, the constraint $C10$ restricts these devices to be within the coverage area of the relay UAV, where $L_{m,u_r}=\sqrt{{(x_m-x_{u_r})}^2+{(y_m-y_{u_r})}^2}$.

3. Joint Optimization Algorithm

Due to its non-convexity, the original problem is broken into three sub-problems that are interrelated but can be solved separately, and then the three decompositions are updated iteratively, so as to obtain an approximate or global optimal solution on the whole. The sub-problem of UAV location deployment and service caching decision contains both discrete variables (caching decision) and continuous variables (UAV location), and the whole problem is non-convex, which is difficult to solve by conventional analytic or gradient class methods. The simulated annealing algorithm, as a typical global heuristic algorithm, is able to search in a larger solution space and avoid falling into local optimums to a certain extent, which is suitable for these kinds of complex optimization problems with mixed discrete and continuous variables. In the sub-problem of computational resource allocation, when other variables are fixed, there is a monotonic relationship between the task delay and the computational resources allocated to the user, so the optimal allocation policy can be obtained by directly adopting the greedy idea of “allocating as few resources as possible” under the premise of satisfying the delay constraint. This sub-problem is relatively simple, and the greedy algorithm can efficiently obtain a closed-form or approximate closed-form solution. Finally, the offloading decision sub-problem is a purely discrete binary variable optimization problem; the dimension increases with the number of users and also has non-convex characteristics. Genetic algorithms can efficiently find an approximate global optimal solution in a large discrete search space through the mechanism of “selection-crossover-mutation”, which is very suitable for this kind of discrete combinatorial optimization. These three algorithms are chosen to solve the corresponding sub-problems separately, which can take advantage of their respective advantages on the problem characteristics, but also spread out the complexity of different sub-problems, and ultimately obtain the optimal solution of the overall problem through iterative solving.

3.1. UAV Position and Cache Decision Solving

When the variables $\beta$, $\alpha$ are determined, the problem $P1$ can be rewritten as

$$\begin{array}{cc}\hfill P2:& \underset{\begin{array}{c}{Q}_{u_c},Q_{u_r},C\end{array}}{min}\sum _{m\in \mathcal{M}}{E}_m\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& \mathrm{C}2,\mathrm{C}5–\mathrm{C}10.\hfill \end{array}$$

(31)

The problem remains non-convex, and this paper employs the simulated annealing algorithm to solve it. The simulated annealing algorithm is a heuristic-based optimization approach that draws on the principle of solid matter annealing, in which the solid is able to make its internal particles gradually reach a more stable arrangement by slowly decreasing the temperature during the annealing process. The simulated annealing algorithm makes use of the above idea by gradually reducing the temperature parameter T when searching the solution space and accepting the worse solution with a certain degree of randomness, so that it can overcome the local optimum and eventually discover a superior solution in the solution space [25]. When the simulated annealing algorithm is used to solve the problem $P2$, the solution space, the fitness function, and the Metropolis criterion are defined as follows:

1.

Solution space: In this paper, the solution space can be expressed as ${\pi }_{\mathrm{best}n}^N=\left(Q_{u_c,n}^N,Q_{u_r,n}^N,C_n^N\right).$ The solution space ${\pi }_{best0}^1$ can be generated by random values in the initial stage, and the optimal solution ${\pi }_{bestn}^1$ is obtained after n iterations of the simulated annealing algorithm. In the global iteration stage, the initial solution space ${\pi }_{best0}^N$ of the Nth simulated annealing algorithm is the best solution ${\pi }_{bestn}^{N-1}$ of the $N-1$th algorithm.

2.

Fitness function: In order to improve the search efficiency of the algorithm and the quality of the solution, the fitness function consists of the objective function augmented by a weighted penalty value, i.e.,

$$\mathrm{fitness}=\sum _{m\in \mathcal{M}}{E}_m+\lambda {log}_2\left({\mu }_1{p}_1+{\mu }_2{p}_2+\cdots +{\mu }_n{p}_n\right)$$

(32)

$$p_n=max\left(0,X_n-Y\right)$$

(33)

where $p_n$ represents the penalty value accumulated during the iteration process when the solution does not satisfy the constraints in $P2$, $X_n$ is the value obtained in the nth iteration using the current solution, Y is the constraint value, and ${\mu }_n$ corresponds to the different weights of the penalty value. The logarithmic form of the penalty value is used to control the growth of the penalty value, to avoid the explosion of the value.

3.

Metropolis criterion: This criterion is used to determine whether or not to accept a new solution at each iteration of the algorithm. By introducing a certain amount of randomness, it can help the algorithm prevent convergence to a local optimum, and thus explore the global optimum solution more efficiently. The chance of adopting a new solution is

$$P_{\mathrm{accept}}=\left\{\begin{array}{cc}1,\hfill & \mathrm{\Delta }E\le 0,\hfill \\ e^{-{\displaystyle \frac{\mathrm{\Delta }E}{T}}},\hfill & \mathrm{\Delta }E>0\hfill \end{array}\right.$$

(34)

where $\mathrm{\Delta }E$ represents the difference between the new adaptation value and the current adaptation value, T denotes the current temperature, and the update equation is

$$T=T_0{\epsilon }^n,n\in {\mathbb{N}}^{+}$$

(35)

where $T_0$ is the initial temperature, $\epsilon$ is the cooling rate, and n is the number of iterations in the algorithm.

Firstly, the relevant parameters are initialized, the total energy consumption and the penalty term under the current scheme are calculated, and the penalty term is added to the total energy consumption to obtain the fitness value. Then, the variables are optimized by the simulated annealing algorithm; specifically, a neighborhood search method is used to generate the new solution to obtain the new fitness value, and a decision is made on whether to accept the new solution according to the acceptance criterion. Finally, the temperature is lowered by continuous iteration until the temperature reaches a certain threshold value. The specific solution process is shown in Algorithm 1.

The algorithm’s computational complexity is structured into two primary layers. For the outer annealing loop, it takes ${log}_{{\displaystyle \frac{1}{\epsilon }}}\left({\displaystyle \frac{T}{T_{min}}}\right)$ iterations for the temperature to decrease from the initial T to $T_{min}$; the loop also exits when $counter$ reaches the specified $times$, so the outer loop time complexity is $O(min\{{log}_{{\displaystyle \frac{1}{\epsilon }}}(\frac{T}{T_{min}}),\mathrm{times}\})$. For the inner loop at each temperature, the main operations of generating the neighborhood solution and calculating the total energy consumption and adaptation value are performed. The generation of the neighborhood solution is achieved by randomly deciding the number of this neighborhood perturbation, which in the worst case is of the same order of magnitude as the number of service program types, so the time complexity is $O\left(N_p\right)$ and $N_p$ is the number of service program types. Since the overall energy consumption and the adaptation value are calculated for each user, the time complexity of both operations is $O\left(\mathcal{M}\right)$, i.e., the time complexity of the inner loop at each temperature is $O(\mathcal{M}+N_p)$. In summary, the time complexity of Algorithm 1 is $O(L·min\{{log}_{\frac{1}{\epsilon }}(\frac{T}{T_{min}}),\mathrm{times}\}·(M+N_p))$.

Algorithm 1 Cache and UAV position optimization algorithm based on simulated annealing algorithm

Require: initialization constants, offloading decisions $\alpha$, calculating resource allocation ratios $\beta$, caching decisions C, UAV positions $Q_{u_r}$ and $Q_{u_c}$ Ensure: C, $Q_{u_r}$ and $Q_{u_c}$   1: $counter=0$, $bes{t}_{solution}=(C,Q_{u_r},Q_{u_c})$, initial temperature $T_0$, cooling rate $\epsilon$, minimum temperature threshold $T_{m}in$, number of iterations per temperature L, max maximum number of consecutive non-improvements allowed $times$, penalty factor $\lambda$   2: Calculate of the overall energy consumption of the system based on the current solution $curren{t}_{energy}$ with the adaptation value $curren{t}_{fitness}$   3: Let $bes{t}_{fitness}\leftarrow curren{t}_{fitness}$   4: while $T>T_{min}$ and $counter<times$ do   5:    $imp\leftarrow 0$   6:    for $iter=1$ to L do   7:      Calculate the overall energy consumption of the system $ne{w}_{energy}$ based on the neighborhood solution and the adaptation value $ne{w}_{fitness}$, respectively.   8:      if $ne{w}_{fitness}$ or $\mathrm{rand}<e^{{\displaystyle \frac{curren{t}_{fitness}-ne{w}_{fitness}}{T}}}$ then   9:         $curren{t}_{solution}\leftarrow ne{w}_{solution}$ 10:         $curren{t}_{fitness}\leftarrow ne{w}_{fitness}$ 11:      end if 12:      if $curren{t}_{fitness}<bes{t}_{fitness}$ then 13:         $bes{t}_{solution}\leftarrow curren{t}_{solution}$ 14:         $bes{t}_{fitness}\leftarrow curren{t}_{fitness}$ 15:         $imp\leftarrow imp+1$ 16:      end if 17:    end for 18:    if $imp=0$ then 19:      $counter\leftarrow counter+1$ 20:    else 21:      $counter\leftarrow 0$ 22:    end if 23:    $T=T^0{\epsilon }^n$ 24: end while 25: return  $res$

3.2. Optimization of Computing Resource Allocation

The problem $P1$ can be rewritten when the variables Q, C, $\alpha$ are determined:

$$\begin{array}{cc}\hfill P3:& \underset{\beta }{min}\sum _{m\in \mathcal{M}}{E}_m\hfill \\ \hfill & \mathrm{s}.\mathrm{t}.C3,C6\hfill \end{array}$$

(36)

By observing Equation (29), it suggests that the total system energy usage required to accomplish the computational task is proportional to the computational resources allocated by the computing UAV when other variables are known, so the computational resources can be allocated as little as possible while satisfying the delay constraints. For the user device m, it can be obtained from Equation (28) and Constraint $C6$ that

$${\beta }_m\ge {\displaystyle \frac{G_m}{\left(T_m^{max}-H_m\right)f_{u_c}}}$$

(37)

Among them,

$$G_m=S_m{L}_m$$

(38)

$$\begin{array}{cc}\hfill H_m=& (1-J_{\varphi \left(m\right)})(1-C_{\varphi \left(m\right)})\left\{(1-{\alpha }_m)t_3^{\mathrm{local}}+{\alpha }_m\left({\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{b2u_r}}}+max\left\{{\displaystyle \frac{W_{\varphi \left(m\right)}}{r_{u_{r}2u_c}}},{\displaystyle \frac{S_m}{r_{m2u_c}}}\right\}\right)\right\}\hfill \\ \hfill & +(1-J_{\varphi \left(m\right)})C_{\varphi \left(m\right)}\left\{{\alpha }_m{\displaystyle \frac{S_m}{r_{m2u_c}}}+(1-{\alpha }_m)t_2^{\mathrm{local}}\right\}\hfill \\ \hfill & +J_{\varphi \left(m\right)}{C}_{\varphi \left(m\right)}\left\{{\alpha }_m{\displaystyle \frac{S_m}{r_{m2u_c}}}+(1-{\alpha }_m)t_1^{\mathrm{local}}\right\}\hfill \\ \hfill & +J_{\varphi \left(m\right)}\left(1-C_{\varphi \left(m\right)}\right)\left\{{\alpha }_m{\displaystyle \frac{S_m+W_{\varphi \left(m\right)}}{r_{m2u_c}}}+(1-{\alpha }_m)t_1^{\mathrm{local}}\right\}\hfill \end{array}$$

(39)

The best resource allocation strategy is obtained to attain the lowest value of the objective function by converting Equation (34) into another equation. The specific implementation is shown in Algorithm 2.

Algorithm 2 Greedy-based UAV computational resource allocation algorithm

Require: initialization constants, offloading decisions $\alpha$, caching decision C, UAV positions $Q_{u_r}$ and $Q_{u_c}$ Ensure:  $\beta$ 1: resource allocations $\beta \leftarrow \left[\right]$ 2: for $m=1$ to $\mathcal{M}$ do 3:    ${\beta }_m={\displaystyle \frac{G_m}{\left(T_m^{max}-H_m\right)f_{u_c}}}$ 4:    $\beta \leftarrow \beta \cup {\beta }_m$ 5: end for 6: return  $\beta$

Since the number of iterations of the above algorithm is only related to the number of user devices, it has a linear time complexity and that complexity is $O\left(\mathcal{M}\right)$.

3.3. Offloading Decision Optimization

The optimization problem $P1$ can can be rewritten when the variables Q, C, and $\beta$ are determined:

$$\begin{array}{cc}\hfill \mathrm{P}4:& \underset{\alpha }{min}\sum _{m\in M}{E}_m\hfill \\ \hfill & \mathrm{s}.\mathrm{t}.\mathrm{C}1,\mathrm{C}4,\mathrm{C}6,\mathrm{C}10\hfill \end{array}$$

(40)

The problem involves the solution of discrete variables, which is suitable to be solved by the genetic algorithm. As a probabilistic approach, the genetic algorithm is used for search and optimization driven by concepts from natural selection and genetic evolution, which simulates the evolutionary process of natural selection in biological evolution, continuously optimizes the quality of the solution through the mechanisms of “selection”, “crossover” and “mutation”, and finally finds a near-optimal solution to the problem. Through “selection”, “crossover”, “mutation”, and other mechanisms, the quality of the solution is continuously optimized, ultimately yielding a near-optimal solution for the problem [26].

1.

Population formation and optimal individual selection: In this paper, it is assumed that $pop$ populations are needed, and each individual in the population is the offloading strategy, so the size of the initialized population matrix is $pop\times \mathcal{M}$. To prevent the inefficiency in optimization caused by a completely random population generation, the best solution of the previous optimization is used as a part of the initial solution of the current optimization. The fitness values of individuals are calculated according to Equations (32) and (33), and the tournament selection method is used to randomly select multiple individuals from the population each time and select the individual with the lowest fitness as the parent.

2.

Individual crossover and mutation: Two parents produce offspring by single-point crossover, and then mutation operation is performed on the offspring, i.e., randomly flipping the gene locus according to the probability $p_{mutation}$. Crossover and mutation processes are illustrated in Figure 3 and Figure 4.

3.

Population update: Replacing the current population with the offspring generated in Algorithm 2 ensures that the new population inherits superior genes and is also diverse.

Firstly, the relevant parameters are initialized, and the optimal individuals obtained previously are mutated to obtain the initial population. Secondly, the fitness value is obtained by calculating the energy consumption and task completion time of each individual in the current population, and the better individuals are retained by using the tournament selection method, which is shown in Algorithm 3. Then, the intersection is randomly selected for gene exchange, and the genes are flipped with a certain probability. Finally, the iteration is stopped when the number of times reaches the upper limit value to obtain the optimal offloading decision. Finally, upon reaching the maximum iteration count, the iteration is stopped to obtain the optimal offloading decision. Algorithm 4 illustrates the overall execution of the proposed algorithm.

Algorithm 3 Tournament selection method

Require: population matrix $population$, fitness value for each individual in the population $fitness$, number of individuals randomly selected from the population $t_{size}$ Ensure:  $bes{t}_{idx}$ 1: Counting the number of individuals in the current population 2: $po{p}_{size}=size(population,1)$ 3: Within $1\sim po{p}_{\mathrm{size}}$ randomly select $t_{size}$ individual indices $idxs$ that represent the individuals competing in the current round of the tournament. 4: Find the individual with the best fitness among the selected individuals $bes{t}_{idx}=min\left(fitness\left(idxs\right)\right)$ 5: return $bes{t}_{idx}$

Algorithm 4 Genetic algorithm-based optimization algorithm for offloading decision

Require: initialization constants, compute resource allocation ratio $\beta$, caching decision C, UAV positions $Q_{u_r}$ and $Q_{u_c}$, penalty factor $\lambda$, last offloading optimization strategy ${\alpha }_{prev}$ Ensure:  $\alpha$   1: Initialize population size $pop$, maximum number of iterations $ma{x}_{gen}$, crossover rate $p_{crossover}$, mutation rate $p_{mutation}$   2: Generate initial populations:   3: $population\leftarrow \left[{\alpha }_{\mathrm{prev}},\mathrm{rand}\left([0,1]\right),\mathrm{pop}-1,\mathcal{M}\right]$   4: $best\_fitness\leftarrow \infty$   5: $best\_solution\leftarrow \left[\right]$   6: for $gen=1$ to $ma{x}_{gen}$ do   7:    for $p=1$ to $pop$ do   8:      $fitness\left(m\right)\leftarrow$ calculate the fitness value for each individual   9:    end for 10:    $\left[{\mathrm{current}}_{\mathrm{fitness}},\mathrm{index}\right]=min\left(\mathrm{fitness}\right)$ 11:    if $curren{t}_{fitness}<bes{t}_{fitness}$ then 12:      $bes{t}_{fitness}\leftarrow curren{t}_{fitness}$ 13:      $bes{t}_{solution}\leftarrow population(index,1:\mathcal{M})$ 14:    end if 15:    for $p=1$ to $pop$ do 16:      Two parents $P_1$, $P_2$ were selected by Algorithm 3, and $child=P_1$ 17:      if $rand<p_{crossover}$ then 18:         Randomly select the intersection point and perform a crossover operation on $P_1$ and $P_2$ 19:      end if 20:      for $m=1$ to $\mathcal{M}$ do 21:         if $rand<p_{mutation}$ then 22:           $child\left(m\right)=1-child\left(m\right)$ 23:         end if 24:      end for 25:      $ne{w}_{population}(p,1:\mathcal{M})=child$ 26:    end for 27:    $population=ne{w}_{population}$ 28: end for 29: $\alpha =bes{t}_{solution}$ 30: return  $\alpha$

Since the fitness of each individual in the population must be evaluated in every generation, the time complexity of this operation is $O(\mathcal{M}·\mathrm{pop})$; for each individual, crossover and mutation are constant operations, so the time complexity of both population crossover and mutation is $O\left(pop\right)$. In summary, the time complexity of the algorithm is $O\left({max}_{\mathrm{gen}}·\mathcal{M}·\mathrm{pop}\right)$. The optimal solution for the aforementioned three algorithms is achieved via cyclic iteration. For any user device unable to obtain a feasible solution, the required energy consumption for task completion is assigned as $E_{penalty}$.

The global iteration is shown in Algorithm 5, and the overall time complexity of the algorithm is $O(n·max\{O_1,O_2,O_3\})$, where $O_1=O(L·min\{{log}_{\frac{1}{\epsilon }}(\frac{T}{T_{min}}),\mathrm{times}\}·(M+N_p))$, $O_2=O\left(\mathcal{M}\right)$, and $O_3=O\left({max}_{\mathrm{gen}}·\mathcal{M}·\mathrm{pop}\right)$.

Algorithm 5 Overall iterative algorithm

1: Randomly initialize {$Q_{u_r}^0$, $Q_{u_c}^0$, $C^0$, ${\beta }^0$, ${\alpha }^0$} 2: Initialize iteration number $n=0$ and convergence threshold $ϵ$ 3: repeat 4:    Given (${\beta }^n$, ${\alpha }^n$), obtain the optimal ($Q_{u_r}^{(n+1)}$, $Q_{u_c}^{(n+1)}$, $C^{(n+1)}$) by Algorithm 1 5:    Given ($Q_{u_r}^{(n+1)}$, $Q_{u_c}^{(n+1)}$, $C^{(n+1)}$, ${\alpha }^n$), obtain the optimal ${\beta }^{(n+1)}$ by Algorithm 2 6:    Given ($Q_{u_r}^{(n+1)}$, $Q_{u_c}^{(n+1)}$, $C^{(n+1)}$, ${\beta }^{(n+1)}$), obtain the optimal ${\alpha }^{(n+1)}$ by Algorithm 4 7:    $n=n+1$ 8: until The objective value decreases by less than $ϵ$ or the maximum number of iterations is reached.

4. Simulation Results and Analysis

In this work, the performance of the proposed algorithm is assessed through simulations in MATLAB 2023a, and the corresponding simulation scenario is depicted in Figure 1, where user devices are presumed to be dispersed within the area of $100\times 100$, the UAV computational resource is 7 GHz, and the environment-related parameters such as $a=9.61$, $b=0.16$, and the detailed simulation configurations are presented in

Table 1. Simulation parameters.

Parameter	Value
The Computing UAV’s Height $H_{u_c}$	60 m
The Relay UAV’s Height $H_{u_r}$	100 m
User Device Computing Resource	$0.5$ GHz
Types of Program	8
Noise Power	$-100$ dBm
Tolerable Delay	$0.9$ s
The Capacitor Switch $\eta$	${10}^{-27}$
Antenna’s Half-power Beamwidth $\theta$	${\displaystyle \frac{\pi }{2}}$
Penalty $E_{penalty}$	1 J
Transmitter Power $p_m$, $p_{u_r}$, $p_{u_c}$, $p_b$	1 W, 3 W, 3 W, 10 W
Bandwidth $B_{m,u}$, $B_{u_r,u_c}$, $B_{b,u_r}$	2 MHz, 3 MHz, 4 MHz

[20].

To assess and contrast the effectiveness of this algorithm, this paper uses three comparison algorithms:

1.

Algorithm 1 for computing the UAV cache decision without optimization, i.e., the random cache at initialization is used as the final decision, and other variables are optimized according to the algorithm presented in this paper.

2.

Algorithm 2 for computing UAV and relay UAV positions without optimization, i.e., fixing the UAV position, and other variables are optimized according to the algorithm presented in this paper.

3.

Algorithm 3 is the algorithm of [18], which adopts a single-UAV architecture, with limited UAV coverage; the UAV has both computing and relay functions, and it only considers downloading the service program from the base station when the UAV does not cache the related service program.

The convergence behavior of the proposed algorithm is demonstrated in Figure 5. As shown in the figure, the total energy consumption gradually decreases with an increasing number of iterations. Specifically, the proposed algorithm converges to the final solution within a maximum of 5 iterations across various conditions, demonstrating its fast convergence rate. Furthermore, when the UAV’s computing capacity is 7 GHz, the total energy consumption decreases by 36.1% and 33.6% for 25 and 30 users, respectively, which highlights the effectiveness of our proposed algorithm.

Figure 6 illustrates the influence of UAV cache capacity on overall energy consumption. It can be observed that with the cache capacity increasing, the energy consumption decreases. This is because the increase in the UAV cache capacity indicates that the UAV can cache more services and saves the transmission energy for downloading the services from the base station, so the curve is a decreasing trend. The figure also demonstrates that the algorithm proposed in this paper outperforms the other three algorithms. The caching policy of Algorithm 1 is not determined based on the user device task type and offloading decision, resulting in the type of services cached on the UAV possibly not being required by the device, and the device and the computing UAV will download the service program from the base station through the relay UAV, which increases the transmission energy consumption. Algorithm 2 fixes the position of the two UAVs, and some devices may be outside the UAV coverage range, which has an impact on devices that are outside the range and need to download service programs for local computation, i.e., leading to an infeasible solution. In this case, the user device whose energy consumption is high is assigned a larger value as a penalty. In addition, the overall energy consumption of the algorithm is larger because the UAV is not on the optimal location, the task upload or service download delay is larger, and thus the transmission energy consumption will be larger as well. The UAV in Algorithm 3 has the functions of both computing and relaying, and subject to the coverage, it needs to balance the communication distance with the base station and the user, there will be more devices outside the UAV’s coverage, and the number of devices that appear to have an infeasible solution is increased compared to the algorithm in this paper.

Figure 7 depicts the overall energy consumption trends of various algorithms as the maximum tolerable delay grows. For small tolerable delays, the task processing has less flexibility, and the device tends to complete the computation on the local device or UAV with larger computational resources to finish the acceptable delay limit. Thus, the computational energy consumption is larger at this time. In the process of gradually increasing the maximum tolerance delay, the task processing has more selectivity. When the overall delay of the task in the local computation or offloading to the UAV computation is within the tolerance range, the device opts for the option that consumes less energy to complete the task, resulting in a decrease in the device’s total energy consumption. The algorithm in this paper dynamically adjusts the offloading decision to prioritize local computing with lower energy consumption or low-power resource allocation (e.g., the lower bound of resource allocation in Equation (37)) when the delay margin increases. In contrast, Algorithms 1–3 are unable to flexibly utilize the delay margin due to rigid caching strategies or fixed UAV position.

Figure 8 illustrates the variation in system overall energy consumption as the number of user devices changes. It is evident that with the number of user devices growing, a corresponding increase in total energy consumption is observed for all four algorithms. Since the algorithm in this paper optimizes the computing UAV cache decision, the cache hit rate is higher than that of Algorithm 1, which saves some of the transmission energy of the service programs. An increase in the number of computing tasks means an increase in the likelihood of needing a greater number of service types. But the computing UAV cache capacity is limited, so when the service programs corresponding to the computing tasks are not cached, they also need to be downloaded from the base station via the relay UAV, which increases the transmission energy. Therefore, the overall energy consumption increases. In Algorithms 2 and 3, the fixed UAV location or single-function UAV architecture is prone to the problem that some users are forced to use energy-intensive local computation due to being out of coverage when the number of users increases, which leads to the result that the total energy consumption is greater than the energy consumption of the algorithm in this paper.

Figure 9 presents the relationship between average task size and system overall energy consumption, demonstrating that larger task sizes result in higher energy consumption. Given a fixed CPU workload per bit, an increase in task size directly results in a higher total CPU cycle demand for task execution, consequently leading to an increase in computational latency. Under the condition of constant maximum tolerable latency, the device tends to complete the computation on a local device or UAV with larger computational resources, which leads to an increase in computational energy consumption. In addition, an increase in task size also leads to an increased likelihood that the task completion delay will exceed the tolerated delay, ultimately affecting the overall energy consumption. Additionally, a low cache hit rate for Algorithm 1 requires frequent downloads of service programs from the base station, which adds additional transmission energy. For Algorithms 2 and 3, some users may be at the edge or in low-coverage areas, thus adding additional delay and transmission energy consumption.

Figure 10 shows that the overall energy consumption of the system decreases as the UAV computational resources increase. For the algorithms in this paper and Algorithm 1, when the computational resources are small, the number of users who can receive the UAV service is small, and more devices take local computation, which leads to larger total energy consumption. As the computational resources increase, the UAV can provide sufficient computational services to the users in the coverage area, resulting in smaller computational energy consumption. For Algorithms 2 and 3, when the computational resources exceed 7 GHz, the computational resources are more sufficient, and when the resources continue to increase, no more user devices can be served. It is difficult to effectively extend the service coverage, and when the resources are increased, the users beyond the coverage cannot utilize the additional resources, resulting in a limited reduction in the overall energy consumption.

Figure 11 gives the mean value as well as the standard deviation of the energy consumption obtained from multiple tests (with different user locations each time) for a given computational resource. From the figure, it can be seen that the average energy consumption shows an overall decreasing trend as the UAV computational resources increase, while the length of the error bars showing the magnitude of fluctuations in the effect of different user locations on energy consumption under each computational resource.

5. Conclusions

This paper investigates a UAV-assisted computing offloading model based on service caching with the objective of lowering system-wide energy consumption. The simulated annealing algorithm is applied to optimize UAV location deployment and computing UAV caching decisions, while a greedy-based approach is used for UAV computational resource allocation. Additionally, a genetic algorithm is adopted for selecting the optimal offloading strategy for user devices. Finally, the obtained simulation results reinforce the proposed algorithm’s effectiveness and outstanding performance. When the number of users is small, the gap between each algorithm is relatively small; when the number of users increases to 30, the gap becomes significant. When the number of users reaches 30, the energy consumption of the algorithm in this paper is about 12 J, while the energy consumption of the worst algorithm is as high as 24 J, indicating that the algorithm has better scalability and energy-saving effects for large-scale user scenarios. When the delay is short (0.7 s), the energy consumption of each algorithm is relatively high, but with an increase in delay, the energy consumption of the algorithm in this paper decreases the most, only about 5 J at 1.1 s, while the energy consumption of the comparison algorithm remains above 7.5 J or even higher, indicating that the algorithm can better use the delay redundancy for energy consumption optimization. When the task size is small, the difference between each algorithm is relatively limited; when the task increases to $2.15\times {10}^5$ bits, the gap increases. The energy consumption of the algorithm in this paper is kept at about 10 J, while the energy consumption of the worst algorithm is as high as 20 J, showing that the algorithm has better energy-saving advantages under large-task-load scenarios. Regarding the increase in cache capacity, the algorithm in this paper has the most obvious decrease, from about 8.5 J to 6.0 J, which saves about 29% of energy consumption, while the algorithm with the highest energy consumption remains above 13 J under the same caching condition, which indicates that the present algorithm more fully utilizes the cache resources to reduce the transmission overhead. In this paper, the energy consumption of the algorithm is about 9.0 J when the UAV’s computational resources are $1\times {10}^9$ Hz, and decreases to 6.0 J when the UAV’s computational resources are $9\times {10}^9$ Hz, which is a reduction of 33%. The energy consumption of the comparative algorithms is still higher than this paper’s algorithm by 20% to 50%, which indicates that this paper’s algorithm can better utilize the additional computational resources and further reduce the energy consumption. Future work will concentrate on improving latency performance, UAV trajectory optimization, and other related content in UAV-assisted computing offloading scenarios.