Multi-Joint Symmetric Optimization Approach for Unmanned Aerial Vehicle Assisted Edge Computing Resources in Internet of Things-Based Smart Cities

Abstract

Smart cities are equipped with a vast number of IoT devices, which help to collect and analyze data to improve the quality of life for urban people by offering a sustainable and connected environment. However, the rapid growth of IoT systems has issues related to the Quality of Service (QoS) and allocation of limited resources in IoT-based smart cities. The cloud in the IoT system also faces issues related to higher consumption of energy and extended latency. This research presents an effort to overcome these challenges by introducing opposition-based learning incorporated into Golden Jackal Optimization (OL-GJO) to assign distributed edge capabilities to diminish the energy consumption and delay in IoT-based smart cities. In the context of IoT-based smart cities, a three-layered architecture is developed, comprising the IoT system, the Unmanned Aerial Vehicle (UAV)-assisted edge layer, and the cloud layer. Moreover, the controller positioned at the edge of UAV helps determine the number of tasks. The proposed approach, based on opposition-based learning, is put forth to offer effective computing resources for delay-sensitive tasks. The multi-joint symmetric optimization uses OL-GJO, where opposition-based learning confirms a symmetric search process is employed, improving the task scheduling process in UAV-assisted edge computing. The experimental findings exhibit that OL-GJO performs in an effective manner while offloading resources. For 200 tasks, the delay experienced by OL-GJO is 2.95 ms, whereas Multi Particle Swarm Optimization (M-PSO) and the auction-based approach experience delays of 7.19 ms and 3.78 ms, respectively.

1. Introduction

The rapid development of mobile networks and the widespread usage of the Internet of Things (IoT) in different fields, such as smart healthcare, smart homes, and smart industries, creates a drastic demand for IoT devices [1,2,3]. The corresponding drastic growth of devices creates larger data, which need to be stored for future endeavors. However, many IoT devices, like sensors or mobile devices, have minimal computing and storage abilities. To handle this problem, edge computing offers computational services near the edge of a structured network [4,5]. The data generated by IoT devices no longer need to be offloaded to the cloud. Instead, they can be processed at the nearest edge of the mobile network, which helps to minimize latency [6,7,8]. The process of offloading computational tasks to the edge server ensures higher energy efficiency than traditional approaches. Moreover, the cost of task offloading is diminished, and it offers a high bandwidth. However, the computing ability of edge servers is low, making them inappropriate for use in IoT applications related to smart cities [9,10]. To provide better service for IoT users, the edge and central cloud should be exploited jointly, which helps in faster execution and more stable operations [11]. When all tasks are offloaded to the edge server, the link between the IoT device and the edge server becomes congested, which diminishes the overall performance of offloading in an edge computing environment [12].

Modern computation techniques offer an optimal solution, which permits storage and computational resources to be placed nearer to the IoT system. The emergence of edge computing in Unmanned Aerial Vehicles (UAVs) acts as a fundamental framework in IoT, which helps to diminish delay between the IoT system and the edge [13,14]. Although UAV-based edge computing is an effective approach, it results in minor delays and minimal resource offloading [15,16]. Offloading resources in IoT environments requires numerous entities, such as Virtual Machines (VMs), to accomplish important tasks and perform VM distribution [17]. To rectify these issues, a distributed approach is utilized to forward the workload, which helps in balancing the usage of resources, and assists in attaining a superior management of resources [18,19]. Since distributed computing places resources nearer to the location of the model, it can be utilized in smart city applications [20,21,22]. The edge servers are present in the middle layer of the IoT system, where they bridge a gap, and they also exist in the bottom layer [23,24]. The edge layer acts as a bridge to IoT devices but it has fewer resources than the cloud. Therefore, an effective approach is needed to provide a Quality of Service (QoS) in smart city applications [25]. This research puts forward a robust approach to examine the existing limitations while offloading tasks in the UAV-assisted edge layer. In UAV-assisted edge computing, optimized task scheduling is obtained by leveraging OL-GJO, a form of multi-joint symmetric optimization, to perform a symmetric searching process.

The major contribution of this research study are as follows:

• This research developed a three-layered architectural framework for smart city applications, which includes the IoT layer with the IoT system, UAV-assisted edge layer, and cloud layer.
• By integrating these three layers, the proposed architecture provides an efficient solution for smart city applications, enabling enhanced resource allocation, data management, task scheduling, and scalability.
• The OL-GJO is positioned at the edge of UAVs to determine the number of resources to be assigned for task allocation and VMs.
• Opposition-based learning is incorporated into GJO to allocate resources efficiently, minimizing energy consumption and delay in IoT-based smart cities.

The rest of this research paper is structured in the following way: The recent techniques related to offloading edge resources in IoT environments are discussed in Section 2. Section 3 presents the proposed methodology, and the results are deliberated over in Section 4. Finally, the conclusions are presented in Section 5.

2. Related Works

Herein, the recent research on different techniques for distributed edge computing resources in IoT environments is discussed, along with their advantages and drawbacks.

ZhangRong Liu [26] developed a multi-joint optimization framework for distributed edge computing resources in IoT. The suggested framework is based on four-layered architectures, which help in determining the number of resources allocated and controllers placed at the edge of UAV. The edge capabilities were assigned using auction-based Multi-Joint Particle Swarm Optimization (M-PSO) to diminish energy consumption and latency. However, the auction-based approach faces issues related to information asymmetry, where the actual value of the resource is in an uncertain condition.

Xiangxiang Zhang and Yichao Wang [27] introduced multi-agent computing resource allocation for UAV-assisted edge computing in a distributed IoT system, referred to as DeepMECagent. The suggested approach helps in optimizing computational offloading with minimal delay. The UAV is utilized as an aerial edge server to process the computational tasks offloaded by IoT devices. However, the suggested framework only suits a centralized environment.

Omar Abdulkareem Mahmood et al. [28] introduced a three-layered architecture for the allocation of resources in IoT environments. Initially, controllers were deployed at the edge of UAVs to allocate tasks. An auction-based approach was used to allocate the edge resources to diminish energy consumption and delay. The usage of the auction approach helps to reduce the task of executing VMs, which offers the ability to perform effective resource allocation. The suggested approach fails to retain the original resource value in indeterminate conditions.

Xiangyi Chen et al. [29] introduced Distributed Computation Offloading and Path Planning (DCOP) for offloading IoT nodes and performing trajectory optimization in UAV-enabled edge computing environments. An intelligent positioning algorithm helps obtain real-time information of IoT devices, and an online distributed algorithm was introduced for the computation of IoT nodes. The suggested framework maximizes utility coverage and consensus agreement to enhance energy efficiency. However, the complex terrain nature affects the ability of the algorithm, which may result in excessive consumption of energy.

Jianhua Liu et al. [30] developed a distributed location-aware task-scheduling scheme in a multi-UAV-enabled edge computing environment. The suggested approach rectifies issues related to task assignment by considering energy limits and the sensitivity of nodes. An efficient online algorithmic approach was utilized to convert the allocation problem to a convergence problem for a parametrized competitive ratio of resources. However, the migration rate of the suggested approach was not equal to the variation among tasks.

Mohamed H. Mousa and Mohamed K. Hussein [31] developed efficient UAV-based mobile edge computing using the differential evolution and ant colony optimization algorithms. The differential evolution algorithm was used to achieve an optimal solution for varying cluster numbers, and the UAV trajectory was minimized by selecting the nearest optimal solution using ant colony optimization. The suggested approach has the ability to reduce task delay and energy consumption, but the ability was limited with a smaller number of tasks.

Cheng Zhan et al. [32] introduced UAV-enabled edge computing related to time constrained IoT applications. Edge servers equipped with UAV, offering computation assistance to IoT devices. To maximize the number of IoT devices, the UAV trajectory with service indicators is optimized using mixed-integer nonlinear programming to rectify the issues in allocation. However, the successful probability of allocating resources decreased when the number of edge servers was reduced.

Xiaoge Huang et al. [33] introduced task offloading optimization for UAV-assisted fog-based IoT. The UAV-assisted fog-based IoT has an air network layer with multiple UAVs at the edge and a ground layer. The suggested approach considered delay and energy consumption as major factors while offloading the tasks. The UAV assisted Task offloading Optimization (USTO) was used to optimize issues related to UAV trajectory. Although the suggested approach suits multi-user scenarios, increasing the number of users in a constrained environment is impractical.

Nima Nouri et al. [34] developed three-dimensional multi-UAV placement and resource allocation to offer energy-efficient IoT communication. The ultimate objective of the framework is to enhance energy efficiency, thereby reducing the usage of drones. The Modified Global K-means (MGKM) algorithm was used to minimize cluster error, and successive linear programming was used to find the optimal solution and evaluate the altitude of a UAV. However, the evaluation of the framework was considered only for static users.

Bo Jiang et al. [35] developed the Trust-based Energy-Efficient Data Collection with Unmanned Aerial Vehicle (TEEDC-UAV) approach to enhance the lifespan of the network. Initially, ant colony optimization was utilized to create data anchors with the shortest trajectory. The evaluation approach was used to detect the sensor node’s degree to improve quality of the data. However, energy consumption increased when the number of data anchors increased.

Mingfang Ma and Zhengming Wang [36] presented the significant pointer name called Age of Information (AoI), which measures data freshness, and developed an intelligent hierarchical cloud–edge architecture called AoI Optimization Data Processing (AODP). This research designed a management mechanism over the formation of clusters by terminals and service associations among terminals and hovering positions (HPs) while analyzing the AODP. Moreover, an HP clustering method was introduced to design the UAV-HP association to enhance UAV collection efficiency. However, inappropriate trajectory planning causes increased latency among multiple UAVs.

From the overall analysis, we surmise that the existing techniques for UAV-based edge computing encounter substantial problems such as energy consumption and latency time, which affect the overall efficiency. On the other hand, delayed latency in task execution affects overall system performance, which leads to a poor user experience. To address these problems, the proposed method concentrated on introducing advanced solutions that reduce energy consumption and latency and enhance throughput. Moreover, this research explores an architecture designed to minimize latency by effectively allocating resources and optimizing UAV trajectories, which eventually produces a reliable, efficient, and scalable result for UAV-based edge computing.

3. Proposed Methodology

This research introduces an effective approach to overcoming the optimization problems in IoT-based smart cities, aiming to diminish the consumption of energy and time delay. In the initial stage, a three-layered structure is developed for IoT smart cities. Next, opposition learning-based Golden Jackal Optimization (OL-GJO) is utilized for assigning edge capabilities to minimize energy consumption and computational delay in smart cities related to IoT. The three-layered architecture for IoT-based smart cities with UAV-assisted edge computing is shown in Figure 1.

The proposed three-layered architecture is motivated by the need to consider the restrictions in current architectures, especially in IoT and UAV-based systems. The goal of this proposed architecture is to deliver a scalable and effective framework for supporting data-intensive applications. Current architectures often struggle with problems including high latency, inadequate scalability, and incompetent resource utilization, which have substantial effects in applications where appropriate decision-making is serious. By focusing on these drawbacks, the suggested architecture targets improved resource utilization, scalability, latency, and flexibility for task allocation. The proposed architecture differs from current architectures [37,38] in numerous ways, including comprising data storage and decoupling computation, which presents a UAV-assisted edge layer for real-time processing, allowing hierarchical decision-making and providing enhanced scalability and flexibility. These differences confirm that the proposed architecture can successfully support data-intensive applications.

3.1. Three-Layered Structures

The bottom layer in the three-layered architecture comprises an IoT layer, UAV-assisted edge layer, and cloud layer.

• The IoT layer manages the tasks of the IoT system, which is responsible for transferring the QoS request and characters based on the task, such as size and time. The minimal operating time of IoT helps to offload tasks to the UAV to diminish the consumption of energy and time.
• The UAV-assisted edge layer is located closer to the IoT layer and is comprised of VM and controllers, which are responsible for allocating resources, evaluating energy and latency, and making decisions.
• Similar to the edge layer, the cloud layer is comprised of a controller and VMs. The controller receives information from the edge of the UAV and cloud layer, like computation and energy utilization ability. While evaluating each task, the controller checks whether the available resources at the edge are sufficient to perform the task. When the necessity of the user is satisfied, the task is completed by considering latency and energy consumption. The overall process involved in the proposed architecture is presented in Figure 2.

The three-layered architecture in IoT smart cities provides numerous advantages, such as scalability, modularity, enhanced data management, interoperability, resource allocation, security, and simplified maintenance. Moreover, the separation of perception, network, and application layers provides enhanced resource allocation and smooth communication among the systems and connected devices, which eventually improves the overall reliability and system performance.

3.2. Opposition Learning-Based Golden Jackal Optimization

The integration of opposition learning-based Golden Jackal Optimization (OL-GJO) effectively optimizes complex issues. The proposed OL-GJO influences OL to produce opposing solutions, which enhances the convergence speed and eliminates local optima. Furthermore, the GJO method initializes the jackal’s population and fitness and updates their locations. OL-GJO is well-suited for task scheduling in UAV-assisted edge computing, where it must handle complex optimization issues such as multiple tasks, UAVs, and edge nodes. Moreover, OL-GJO of multi-joint symmetric optimization has the ability to enhance the convergence speed and exploration–exploitation balance, which makes it an ideal choice for task scheduling and resource allocation. This research introduces an effective approach to minimize latency and energy consumption. The proposed OL-GJO is used to address issues related to energy and delay concerns in IoT. The local IoT device uploads UAV tasks to an access point through a wireless medium. This research partitions time into small chunks so that the UAV has a task and the user does not need to move around each time. The rate of transmission between the cluster and the access point is represented in Equations (1) and (2).

$$P_t={\sum }_{k\in K}[{\epsilon }_k(t)/{\sum }_{j\in M}{C}_j(t)y_j^k(t)]$$

(1)

$$v_{k,i}^t=W{\mathrm{l}\mathrm{o}\mathrm{g}}_2\left(1+\left({\displaystyle \frac{P_{\tan h_{k,i}^t}}{{\sigma }^2+I_{k,i}^t}}\right)\right)$$

(2)

where the strength of the wireless channel in UAV $k$ and the access point $i$ at time slot $t$ is represented as $h_{k,i}^t$. The communication ability of the UAV is defined as $P_{\mathrm{t}\mathrm{a}\mathrm{n}}.$ This research develops an effective approach based on opposition learning incorporated with the GJO algorithm to assign edge capabilities to minimize energy and computation delay.

3.2.1. Overview of GJO

GJO is developed on the basis of exploration and exploitation phases. The exploration phase defines the searching capability, while the exploitation phase is based on hunting their prey. Moreover, the central vectors ($C_i$) involve discovering the midpoint between a solution and its opposite, which is vital for improving exploration and exploitation during the optimization process, as expressed in Equation (3).

$$C_i={\displaystyle \frac{\left(x_i+x_{i^{\prime }}\right)}{2}}$$

(3)

where $x_i$ and $x_{i^{\prime }}$ refer to the solution and the opposite of the $ith$ vector. GJO is a type of swarm-based approach, where the candidate solutions are initialized in a random manner based on Equation (4).

$$Z_0=L+rand\times (U-L)$$

(4)

where the lower and upper limits are represented as $L$ and $U$, and the random number, which lies in the range $\left[0,1\right],$ is represented as $rand.$ Random selection is used in Equation (4) to set the candidate solutions for the GJO algorithm. This algorithm enables exploration of the entire solution space, which supports diversity between the candidate solutions and prevents bias from developing in the optimization procedure. With the help of a random selection process, GJO efficiently converges to the global optimum, leading to enhanced optimization outcomes.

Exploration Stage

In the exploration stage, the male performs a leading role in hunting, whereas the female follows the male, which is presented in Equations (5) and (6).

$$Z_1\left(t\right)=Z_M\left(t\right)-E\left|Z_M\left(t\right)-rl\times prey\left(t\right)\right|$$

(5)

$$Z_1\left(t\right)=Z_{FM}\left(t\right)-E\left|Z_{FM}\left(t\right)-rl\times prey\left(t\right)\right|$$

(6)

where the number of iterations at the current state is represented as $t$ and the position vector is represented as $prey\left(t\right)$. The positions of the male and female jackal in the randomized search space are represented as $Z_M\left(t\right)$ and $Z_{FM}\left(t\right)$, respectively. The energy exhibited by the prey while escaping from the jackal is represented in Equation (7).

$$E=E_1\times E_0$$

(7)

where the diminishing energy and the energy at the initial stage are represented as $E_1$ and $E_0$, respectively, as presented in Equations (8) and (9).

$$E_0=2\times r-1$$

(8)

$$E_1=C_1\times \left(1-\left(t/T\right)\right)$$

(9)

where the random number in the range of [0, 1] is represented as $r$ and $C_1$ is a constant. The iteration in the current state and the maximum number of iterations are represented as $t$ and $T$, respectively. The randomized vector $\left(rv\right)$ based on the Levy flight $\left(LF\right)$ function is evaluated based on Equation (10).

$$rv=0.05\times LF\left(z\right)$$

(10)

The $LF$ function is evaluated based on Equation (11).

$$LF\left(z\right)=0.01\times {\displaystyle \raisebox{1ex}{$\left(\mu \times \sigma \right)$}\!\left/ \!\raisebox{-1ex}{$\left(\left|v^{\left(1/\beta \right)}\right|\right)$}\right.}$$

(11)

where $\mu$ and $\sigma$ are arbitrary numbers that lie in the range of 0 and 1 and $\beta$ is a constant value. The finalized updated position of the golden jackal is evaluated based on Equation (12).

$$Z\left(t+1\right)={\displaystyle \frac{Z_1\left(t\right)+Z_2\left(t\right)}{2}}$$

(12)

Exploitation Stage

The capability of the prey to escape from the jackal diminishes when they are subjected to attack. The hunting behavior of the male and female jackals is mathematically presented in Equations (13) and (14).

$$Z_1\left(t\right)=Z_M\left(t\right)-E.\left|{rl.Z}_M\left(t\right)-prey\left(t\right)\right|$$

(13)

$$Z_2\left(t\right)=Z_{FM}\left(t\right)-E.\left|{rl.Z}_{FM}\left(t\right)-prey\left(t\right)\right|$$

(14)

The usage of $rl$ is to achieve randomized behavior during exploitation and exploration.

3.2.2. OL-GJO for Analyzing Edge Capabilities

OL was developed to accelerate convergence when it is deployed in complex environments. In opposition-based learning, the convergence speed is enhanced by producing an opposing point for each probable solution. In opposition learning, the opposite number for any random value $Z\in [L,U]$ is stated in Equation (15).

$$\overline{Z}=L+U-Z$$

(15)

where the opposite and the real position vector are represented as $Z$ and $\overline{Z}$, and the values in the upper and lower bounds are represented as $L$ and $U$. The proposed strategy is performed under two cases, such as selecting the jackal closest to the optimal solution and the second aphasia based on the golden jackal’s new generation.

Initialization

During initialization, the actual population $Z_i=\left\{z_{i1},z_{i2},\dots z_{ij},\dots ,z_{iD}\right\}$ is generated randomly in the search space. The value of $i=\mathrm{1,2},\dots NP$ and $j=\mathrm{1,2},\dots ,D$, where $NP$ represents the population size and the dimension is denoted as $D$. Using Equation (4), the opposite jackal is produced. Alongside this, the original and opposite population are integrated as a single population.

Stage of Update

Following initialization, searching is performed to identify the male and female jackals considered the fittest ones among the population. The poor searching capability of GJO causes the algorithm to fall into local optima, but the development of opposition-based learning helps generate new jackals with random values in the range of 0 to 1, with probability $p_r.$ Whenever the random values are smaller than the probability values, the opposition learning approach helps acquire new jackals. After this, the fittest jackal from the population is chosen. The opposition learning approach acts as a mutation factor that helps keep the algorithm from falling into local optima. The choice of network and deployment of service values for each jackal are obtained. In general, the deployment point is selected based on the actual coordinates of the starting station.

The probability of distributing resources in edge IoT is based on two factors: the distance between the base station and optimized regulation. The mathematical expression for selecting the best network and service placement point is represented in Equation (16).

$$P_i={\displaystyle \frac{\left(\frac{1}{d_i\times {path}_i}\right)}{\sum _{i\in \pi }{d}_i\times path}}$$

(16)

where the distance $\left(d_i\right)$ between the base station $\left(i\right)$ and the total task count at the base station is represented as ${path}_i$. The OL-GJO utilized in evaluating tasks in the UAV-assisted edge environment is expressed in the following sections. Below is the pseudocode for OL-GJO, described in Algorithm 1.

Algorithm 1 Pseudocode for OL-GJO

Initialize position of the prey $Z_0$ in a randomized search space    Fitness value is evaluated for each prey    Choose the best prey $\left(Z_1\right)$ and second best one $\left(Z_2\right)$ Initialize population based on opposition learning according to Equation (15)    Fitness function is evaluated for range $\left\{Z_{0,}\widehat{Z_t}\right\}$    Choose an optimal fittest solution from $\left\{Z_{0,}\widehat{Z_t}\right\}$ to create a position for prey     while t < maximum iteration      for each prey       Update the energy based on Equations (7)–(9)       Update arbitrary vector $rl$ based on Equations (10) and (11)        if $(\left(E\right)<1)$         Update position of the prey based on Equations (5)–(7)        else $(\left(E\right)\ge 1)$         Update position of the prey based on Equations (12)–(14)        end       end      end     if $rand<p_r$      Create position of the prey based on Equation (15)      Fitness function is evaluated for range $\left\{Z_{0,}\widehat{Z_t}\right\}$      Choose the fittest solution in the range $\left\{Z_{0,}\widehat{Z_t}\right\}$      $t=t+1$     end

3.2.3. Evaluation of Energy and Latency Using OL-GJO

There are three cases based on the IoT layer, UAV-assisted edge layer, and cloud layer. In the IoT layer, the IoT device evaluates the task on the basis of the user’s time frame and task size, as shown in Equation (17).

$$T_i={\displaystyle \frac{U_{size}}{f_i}}$$

(17)

where the size of the IoT task is represented as $U_{size}$ and the computational ability of the IoT device is represented as $f_i.$ Next, the computation delay $d_i$ for the IoT device is evaluated based on Equation (18).

$$d_i={ST}_{i.l}+T_{i.l}$$

(18)

where the initial time period of the IoT device is denoted as ${ST}_{i.l}$ and the energy consumed by the device is evaluated using Equation (19).

$$E_i=U_{size}\times U_{E_i}$$

(19)

where the size of the IoT task is represented as $U_{size}$ and the energy consumed by the IoT device is represented as $U_{E_i}$.

In the UAV edge-assisted layer, the computation takes place at the single edge level. When the tasks are offloaded to the UAV at the edge level, the transmission time is evaluated based on Equation (20).

$$T_{trans}={\displaystyle \frac{U_{size}}{f_{i,t}}}$$

(20)

where the transmission ability of the communication channel is represented as $f_{i,t}$. The time taken to implement the task of the IoT device is evaluated based on Equation (21).

$$T_{i,imp}={\displaystyle \frac{U_{size}}{f_j}}$$

(21)

where the size of the task generated by the IoT device is represented as $U_{size}$ and the calculation ability of the VM is represented as $f_j$. The computational delay of the task generated by the IoT device is represented as $d_{i.c}$, which is evaluated based on Equation (22).

$$d_{i.c}=T_{t.i}+(S{T}_{t.j}+T_{i.j})$$

(22)

where the starting time of the IoT device in the VM is represented as $T_{t.i}$. The energy utilized in transmitting information for each CPU cycle due to the task assigned by the IoT device is represented in Equation (23).

$$E_{tr}=E_t+U_{size}$$

(23)

The computational energy $E_{ij}$ while creating tasks for the IoT device is represented in Equation (24).

$$E_{ij}=E_j+U_{size}$$

(24)

The overall energy utilized while offloading tasks to the edge level is represented as $E_{i.tot}$, which is evaluated using Equation (25).

$$E_{i.tot}=E_{tr}+E_{ij}$$

(25)

Consider that the binary predictor $b_i$ defines whether a task takes place in a local manner or is offloaded to the UAV, which is based on the following condition in Equation (26).

$$b_i=\left\{\begin{array}{c}0 \mathrm{local} \mathrm{case} \left(\mathrm{IoT}\right)\\ 1 \mathrm{edge} \mathrm{case} \left(\mathrm{UAV}\right)\end{array}\right.$$

(26)

The delay at the edge layer $d_{i.j}$ and the exhausted energy $E_{ij}$ during task execution are represented in Equations (27) and (28), respectively.

$$d_{i.j}=\left(1-h_i\right)\times d_{i.l}+h_i\times d_{i.j}edge$$

(27)

$$E_{i.j}=\left(1-h_i\right)\times E_{i.l}+h_i\times E_{i.tot}$$

(28)

where $d_{i.j}\le {dl}_i$ and $E_{i.j}\le E_{max}$. The deadline for the task created by the IoT device is represented as ${dl}_i.$ $E_{max}$ is the maximum amount of energy consumed. Based on OL-GJO, the multi optimization problem related to latency and energy consumption is considered as a single objective $\left(X_{ij}\right)$, which is shown in Equation (29):

$$X_{ij}=\beta \times {\displaystyle \frac{d_{i.j}}{d_{max}}}+(1-\beta )\times {\displaystyle \frac{E_{i.j}}{E_{max}}}$$

(29)

where the maximum delay is represented as $d_{max}$, and the weighted element corresponding to latency and energy consumption is represented as $\beta .$ For $n$ IoT devices, the loss function $y_t$ is assessed as per Equation (30).

$$y_t={\sum }_{VMj\in Q_E}{\sum }_{i=1}^n{X}_{i.j}\times b_{i.j}$$

(30)

where the binary variable which analyzes the task in VMs is represented as $b_{i.j}.$ The amount of energy utilized in carrying out the task involves both the energy consumed while delivering information to the edge server and the energy utilized in implementing the task in the edge environment. The OL-GJO algorithm terminates when the following condition is met: Iteration ≥ maximum iteration. By satisfying this stopping condition, OL-GJO ensures effective convergence to an optimal solution.

4. Results and Discussion

This section presents the results achieved while evaluating OL-GJO based on local computation and edge offloading. The efficiency of OL-GJO is compared with state-of-the-art techniques and existing research. Moreover, the simulation of the proposed approach was conducted in MATLAB R2020a, with the system configured with 16 GB of RAM, Windows 11/64-bit OS, and an Intel i7 processor. The efficiency of the proposed approach is evaluated by the delay time, energy consumption, and throughput, based on the number of tasks and VMs. The proposed OL-GJO for distributing edge resources was evaluated based on two cases:

(i)

Computation of the local layer: Computation is performed in the IoT system at the IoT layer for execution of a task.

(ii)

Edge offloading: The tasks which are conducted in the IoT system are offloaded to UAVs based on a greedy method.

The simulation parameters considered in this research are listed in

Table 1. Simulation parameters.

Parameter	Values
Number of CPU cycles	10–30
Energy consumption	${10}^{-7}$ joules/cycle
Computation ability	150–600 M cycle
Computation ability for transmission	${10}^2-2\times {10}^2$ M cycles/s
Energy consumed while transmitting	${10}^{-8}$ J/cycle
Energy consumed by VM	${10}^{-7}$ J/cycle
Computational ability of VM	${10}^4-3\times {10}^2$ M cycles/s

.

The simulation parameters, including CPU cycles, computation ability, and energy consumption, were selected based on the literature surveys referred to in [26], [28], and [29], respectively. The values of CPU cycles were selected as 10–30, because it considers the distinctive IoT device processing times, whereas computation ability and energy consumption values were chosen to assess the energy efficiency of the proposed method under fluctuating circumstances. This enhances the validity and reliability of the simulation results.

4.1. Performance Analysis

In this section, the competence of the proposed OL-GJO is evaluated against state-of-the-art optimization techniques, such as Grey-Wolf Optimization (GWO), Elephant Herd Optimization (EHO), Sand Cat Swarm Optimization (SCSO), and Golden Jackal Optimization (GJO). The results are evaluated based on delay, energy consumption, throughput, sensitivity, precision, and accuracy. The mathematical formulas for sensitivity, precision, and accuracy are defined in Equations (31), (32), and (33), respectively.

$$Accuracy={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}$$

(31)

$$Precision={\displaystyle \frac{TP}{TP+FP}}$$

(32)

$$Sensitivity={\displaystyle \frac{TP}{TP+FN}}$$

(33)

For analysis purposes, the sensitivity, precision, and accuracy of each algorithm have been analyzed and are presented in

Table 2. Evaluation of different algorithms.

Method	Performance Metrics
	Accuracy	Precision	Sensitivity
GWO	0.85	0.84	0.83
EHO	0.87	0.87	0.86
SCSO	0.92	0.91	0.89
GJO	0.95	0.93	0.92
OL-GJO	0.98	0.97	0.95

.

The proposed OL-GJO accomplishes higher results because of its enhanced resource allocation, task offloading, efficient exploration–exploitation balance, and robust optimization capabilities. Moreover, the symmetric searching process obtained using OL-GJO, a form of multi-joint symmetric optimization, has an improved performance. These factors enable OL-GJO to adaptively search for optimal results, which minimizes energy consumption and latency and efficiently allocates tasks to edge nodes that eventually lead to substantial performance enhancements over conventional approaches.

4.1.1. Evaluation of Delay for Different Task Counts and Numbers of VMs

This sub-section presents results based on delays for different numbers of tasks and VMs. The evaluation takes place based on different task counts, ranging from 25 to 200.

Table 3. Evaluation of delay for different task counts.

Method	Number of Tasks
	25	50	75	100	125	150	175	200
GWO	0.95	0.97	1.98	2.01	2.59	2.73	2.89	3.29
EHO	1.02	0.91	1.55	2.59	2.80	2.98	2.99	3.41
SCSO	1.21	1.05	1.63	2.09	2.71	2.90	3.12	3.35
GJO	0.98	1.01	1.79	2.02	2.66	2.59	2.83	3.13
OL-GJO	0.51	0.82	1.11	1.82	2.20	2.51	2.78	2.95

presents the outcomes achieved while assessing OL-GJO with state-of-the-art algorithms. The graphical depiction of the delays of OL-GJO for various task counts is presented in Figure 3.

Next, the evaluation of delay is performed based on different numbers of VMs, ranging from 30 to 120.

Table 4. Evaluation of delay for different numbers of VMs.

Method	Number of VMs
	30	60	90	120
GWO	0.06	0.029	0.026	0.018
EHO	0.09	0.030	0.028	0.019
SCSO	0.08	0.037	0.031	0.022
GJO	0.07	0.026	0.021	0.016
OL-GJO	0.04	0.020	0.015	0.010

presents the outcomes achieved while assessing OL-GJO with state-of-the-art algorithms, and the respective graphical depiction is presented in Figure 4.

The experimental outcomes attained from Table 3 and Table 4 present the results of evaluating delays for different tasks and VMs, respectively. Task counts from 25 to 200 and of VMs from 30 to 120 are considered for evaluation. For example, the delay of OL-GJO for 200 tasks is 2.95 ms, whereas existing methods like GWO, EHO, SCSO, and GJO obtained delay times of 3.29 ms, 3.41 ms, 3.35 ms, and 3.13 ms, respectively. The superior outcome of OL-GJO is due to the incorporation of opposition-based learning in GJO, which helps assign tasks for IoT-based edge resources with minimal computational time.

4.1.2. Evaluation of Energy Consumption for Different Task Counts and Numbers of VMs

This sub-section presents results based on energy consumption for different tasks and different VMs. At first, the evaluation takes place with different numbers of tasks, from 20 to 200.

Table 5. Evaluation of energy consumption for different task counts.

Method	Number of Tasks
	20	40	60	80	100	120	140	160	180	200
GWO	24.38	33.61	47.03	49.67	61.14	67.78	69.82	75.02	78.26	77.90
EHO	26.79	37.99	42.18	47.59	63.68	67.13	71.77	73.48	75.98	75.41
SCSO	29.11	34.21	43.56	44.89	65.44	68.59	73.19	75.22	79.82	76.84
GJO	21.43	32.12	39.90	45.09	59.99	66.92	68.90	72.87	74.99	76.09
OL-GJO	18.51	29.63	36.98	41.58	57.20	62.66	66.01	69.14	70.85	73.98

presents the outcomes achieved while assessing OL-GJO with state-of-the-art algorithms. The graphical depiction of the energy consumptions of OL-GJO for various task counts is presented in Figure 5. Here, the results achieved are based on energy consumption in UAV (edge) offloading.

Next, the evaluation of energy consumption is performed based on different numbers of VMs, ranging from 30 to 120.

Table 6. Evaluation of energy consumption for different numbers of VMs.

Method	Number of VMs
	30	60	90	120
GWO	49.43	98.68	128.12	163.82
EHO	48.90	93.19	133.31	159.22
SCSO	47.11	96.09	131.82	160.78
GJO	48.69	94.11	129.55	161.41
OL-GJO	46.12	91.27	123.75	155.20

presents the outcomes achieved while assessing OL-GJO with state-of-the-art algorithms based on energy consumption, and the corresponding graphical depiction is presented in Figure 6.

The experimental outcome attained from Table 5 and Table 6 present the results achieved while evaluating energy consumption for different counts of tasks and VMs, respectively. Task counts range from 20 to 200, and the number of VMs ranges from 30 to 120. For example, the energy consumption of OL-GJO for 200 tasks is 73.98 mJ, whereas existing methods like GWO, EHO, SCSO, and GJO consume energy of 77.90 J, 75.41 J, 76.84 J, and 76.09 J, respectively. The superior performance of OL-GJO is due to the incorporation of opposition-based learning in GJO, which helps assign tasks to IoT-based edge resources with minimal computational time. The assignment of tasks with minimal computational time helps to minimize energy consumption compared to other methods.

4.1.3. Evaluation of Throughput for Different Task Counts

This sub-section presents results based on throughput for different numbers of tasks. At first, the evaluation takes place with different numbers of tasks, from 20 to 100.

Table 7. Evaluation of task count based on computational throughput.

Method	Throughput (mbps)
	20	40	60	80	100
GWO	76	98	133	144	157
EHO	72	94	135	137	154
SCSO	75	97	137	141	155
GJO	73	96	131	138	159
OL-GJO	70	92	128	136	152

presents the outcomes achieved while assessing OL-GJO with state-of-the-art algorithms. The graphical depiction of OL-GJO’s throughput for various task counts is presented in Figure 7.

The experimental outcomes achieved can be determined from Table 7, and Figure 7 presents the results based on the evaluation of throughput for various UAV task edge offloading counts. Throughput is considered from 20 mbps to 100 mbps. In the results, it is shown that the proposed OL-GJO achieves better outcomes than the state-of-the-art algorithms. The suggested approach exhibits lower computational throughput than other methods, and this minimalized computational throughput helps to diminish the computational cost of each task in UAVs.

4.1.4. Evaluation of Energy Consumption for Different Numbers of Users

This sub-section presents the results achieved while evaluating OL-GJO based on different energy consumption and system utility levels. The evaluation is based on different numbers of users, ranging from 300 to 1000.

Table 8. Evaluation of energy consumption for different numbers of users.

Method	Energy Consumption (kb/J)
	Number of Users
	300	400	500	600	700	800	900	1000
GWO	2.75	2.95	3.56	3.98	4.28	4.59	4.69	4.84
EHO	2.21	3.01	3.50	4.02	4.59	4.63	4.79	4.88
SCSO	2.48	3.13	3.41	4.11	4.33	4.78	4.81	4.98
GJO	2.33	2.98	3.39	4.18	4.25	4.89	4.90	4.97
OL-GJO	2.10	2.89	3.26	3.79	4.17	4.41	4.56	4.73

presents the results achieved while evaluating energy consumption based on the number of users, and the corresponding graphical depiction is provided in Figure 8.

The experimental outcomes from Table 8 and Figure 8 exhibit that OL-GJO obtained better energy efficiency than existing state-of-the-art algorithms. For instance, when the number of users is 1000, the energy consumption of OL-GJO is 4.73 kb/J, which is comparatively lower than existing methods such as GWO, EHO, SCSO, and GJO, which have energy consumption values of 4.84 kb/J, 4.88 kb/J, 4.98 kb/J, and 4.97 kb/J, respectively. The improved result of OL-GJO is due to the opposition-based learning incorporated into GJO, which helps assign tasks to VMs in a minimal time period, resulting in reduced energy consumption.

4.2. Comparative Analysis

Here, the results achieved by the proposed OL-GJO are evaluated with the existing techniques listed in the literature. The existing techniques include Multi-Joint Particle Swarm Optimization (M-PSO) [26], the auction-based approach [28], and Distributed Computation Offloading and Path Planning (DCOP) [29]. The experimental outcomes are assessed by considering energy consumption, delay, and throughput. The proposed approach is compared with M-PSO and the auction-based approach based on the simulation parameters listed in Table 1. The comparison of OL-GJO is performed with DCOP for users from 300 to 1000, with a maximum CPU frequency between 3 and 17 GHz, and with a transmission power of 1 W.

4.2.1. Delay

Table 9. Comparison of delays for different numbers of tasks.

Methods	Number of Tasks
	25	50	75	100	125	150	175	200
M-PSO [26]	1.73	1.96	2.23	3.12	3.59	4.82	6.12	7.19
Auction-based approach [28]	0.72	0.98	1.52	1.96	2.47	2.93	3.46	3.78
OL-GJO	0.51	0.82	1.11	1.82	2.20	2.51	2.78	2.95

presents the experimental outcomes achieved while evaluating OL-GJO with M-PSO and the auction-based approach based on delays for various task counts. The evaluation of delay is considered during edge offloading in IoT devices.

The experimental results in Table 9 exhibit that OL-GJO results in minimal delay when compared with the existing M-PSO and auction-based approaches. For instance, when the number of tasks is assigned as 200, the delay experienced by OL-GJO is 2.95 ms, whereas M-PSO and the auction-based approach experienced delays of 7.19 ms and 3.78 ms, respectively. Similarly, the evaluation of delay is performed for different numbers of VMs: 30, 60, and 90. The evaluation of delay based on the number of VMs is presented in

Table 10. Comparison of delays for different VMs.

Method	Number of VMs
	30	60	90
Auction-based approach [28]	0.05	0.025	0.017
OL-GJO	0.04	0.020	0.015

.

The experimental outcomes obtained from Table 9 and Table 10 show that the proposed OL-GJO achieved better results in both cases (i.e., different task counts and different numbers of VMs). OL-GJO is an improved version of GJO, where opposition-based learning is incorporated, which helps to achieve better results by assigning tasks with a minimal time period.

4.2.2. Throughput

In this sub-section, the evaluation is performed based on different throughputs for the number of tasks. M-PSO is used to evaluate the efficacy of OL-GJO, and the attained experimental results are presented in

Table 11. Comparison of computational throughputs.

Method	Performance Metric	Throughput (mbps)
		20	40	60	80	100
M-PSO [26]	Number of tasks	76	97	135	158	167
OL-GJO		70	92	128	136	152

.

The results in Table 11 show that OL-GJO achieved a better outcome than M-PSO. OL-GJO minimized computational throughput, which helped to reduce the computational cost for each task in the UAV.

4.2.3. Energy Consumption

Table 12. Evaluation based on case 1.

Method	Number of Tasks
	20	40	60	80	100	120	140	160	180	200
M-PSO [26]	21.13	32.41	46.89	53.71	61.82	67.5	69.21	71.36	72.95	76.78
OL-GJO	18.51	29.63	36.98	41.58	57.20	62.66	66.01	69.14	70.85	73.98

presents the evaluation of the results based on energy consumption, which are compared with M-PSO and the auction-based approach. The evaluation is performed in two cases: in case 1, OL-GJO is validated with M-PSO, and in case 2, OL-GJO is evaluated with the auction-based approach. Case 1 shows the results based on energy consumption during UAV (edge) offloading, and case 2 evaluates energy consumption during local offloading (IoT layer). Table 12 presents the experimental outcomes based on case 1 (i.e., validation of OL-GJO with M-PSO).

Table 12 shows that the proposed OL-GJO consumed less energy than the existing M-PSO. The energy consumption of OL-GJO for 200 tasks is 73.98 mJ, which is lower than M-PSO (76.78 mJ). Next, the results are evaluated based on case 2, and the attained results are presented in

Table 13. Evaluation based on case 2.

Method	Number of Tasks
	20	40	60	80	100	120	140	160	180	200
Auction based approach [28]	1.23	1.49	1.68	1.91	2.18	2.52	2.71	3.11	3.26	3.59
OL-GJO	1.10	1.27	1.39	1.68	1.93	2.11	2.36	2.78	2.98	3.13

.

In case 3, the results achieved by OL-GJO are validated based on the number of users.

Table 14. Evaluation based on case 3.

Energy Consumption (kb/J)
Method	Number of Users
	300	400	500	600	700	800	900	1000
DCOP [29]	2.32	3.12	3.86	4.12	4.43	4.67	4.98	4.98
OL-GJO	2.10	2.89	3.26	3.79	4.17	4.41	4.56	4.73

presents the outcomes achieved based on the energy consumed by different numbers of users. The existing DCOP [29] is used to assess the efficacy of OL-GJO.

The results obtained from Table 14 show that OL-GJO results in lower energy usage than DCOP. For instance, when the number of users is 500, the energy consumption of DCOP is 3.86 kb/J, whereas the proposed approach requires only 3.26 kb/J. The overall experimental outcomes from Table 12, Table 13 and Table 14 show that OL-GJO achieved better results in both cases considered for evaluation.

Table 15. Comparison of energy consumption with different UAVs.

Method	Performance Metric	Energy Consumption (kJ)
		4	5	6	7	8
AODP [36]	Number of UAVs	16.4	14.3	12.7	11.2	10
OL-GJO		14.8	12.9	11.3	10.4	9.5

shows the comparative analysis of energy consumption with the existing AODP [36]. The minimal energy consumption of OL-GJO is due to the learning strategy in GJO, which helps assign tasks in a shorter time, preventing the overconsumption of energy. From the overall analysis, it is clear that the proposed OL-GJO achieves lower energy consumption in all the UAVs when compared with the existing AODP [36].

5. Conclusions

This research has introduced an effective approach, which pairs opposition learning with GJO for offloading tasks in IoT-based smart cities. The IoT network faces issues related to energy constraints, which can be overcome by the edge computing process. This research has developed a three-layered architecture for IoT-based smart cities. Moreover, OL-GJO, a form of multi-joint symmetric optimization, is introduced to rectify the issues related to the assignment of IoT-based edge resources. Energy consumption and latency are considered the major factors in this research study while allocating resources. The experimental outcomes obtained through the proposed approach exhibit better performance than other existing techniques. The efficiency of OL-GJO is assessed with M-PSO, the auction-based approach, and DCOP. Through experimental analysis, it is proven that OL-GJO attained better results in all metrics considered during the evaluation. For example, when the number of tasks is allotted as 200, OL-GJO experienced a delay of 2.95 ms, whereas M-PSO and the auction-based approach achieved delays of 7.19 ms and 3.78 ms, respectively. However, OL-GJO faces convergence problems, including becoming stuck in local optima or experiencing slow convergence rates when analyzing a large number of tasks. Therefore, in the future, this research will be enhanced by analyzing an increased number of tasks, such as 500, 1000, and 2000, with convolutional artificial neural networks and fuzzy logic to improve the optimization process and performance measures.