Applying the Cheetah Algorithm to optimize resource allocation in the fog computing environment

ABSTRACT

This study investigates the application of heuristic and meta-heuristic algorithms to address resource allocation challenges in Internet of Things (IoT) applications within fog computing environments. The primary advantage of these algorithms lies in their ability to optimize functions without the need for stringent restrictions, allowing adaptability to various linear, nonlinear, continuous, or discrete problems. Through the implementation and comparison of the Cheetah algorithm, Gray Wolf algorithm, Particle Swarm-Gravitational Search algorithm, and Gray Wolf-Cuckoo Search algorithm using MATLAB software in a simulation environment, the study aims to minimize criterion function and total time and energy consumption for IoT applications. Preliminary results indicate that the statistical average performance of the Cheetah algorithm surpasses that of the Gray Wolf algorithm, the combined Particle Swarm-Gravitational Search algorithm, and the Gray Wolf-Cuckoo Search algorithm. This suggests the efficacy of the Cheetah algorithm in IoT resource allocation optimization within fog computing environments. The study provides insights into the comparative performance of these algorithms, laying the foundation for further exploration into enhancing resource allocation strategies in the dynamic and resource-constrained IoT and fog computing landscapes.

Introduction

Nowadays, with the increasing growth of the Internet of Things (IoT) and its applications, there is a greater need than ever for an efficient platform to process big data (Laroui et al. 2021). Various computing techniques, such as cloud computing, edge computing, and fog computing, are used to process big data. The primary challenge in a fog computing environment is to minimize energy consumption and processing time while providing services (Ni et al. 2017). Resource allocation techniques are applied to virtual machines (VMs) to minimize energy consumption and decrease latency in fog servers. In this context, service allocation in the fog environment is considered a nonlinear programming problem (NP-hard). Several algorithms can be used to solve the NP-hard problem (Atlam, Walters, and Wills 2018). The wireless sensor networks produce a substantial volume of data. The data gathered from all the devices linked to the network may prove valuable, although it may also include unnecessary duplication. The sheer magnitude of data may inundate the data storage systems and the data analysis software. The elimination of extraneous data must be a contextually sensitive procedure (Aazam, Zeadally, and Harras 2018). Therefore, the sensors would need to transmit the data gathered to computer equipment capable of executing operations of analysis, aggregation, and storage (Puliafito et al. 2019). In many instances, every patient necessitates a substantial quantity of sensors, therefore rendering the establishment of a specialized infrastructure for each person impractical. Therefore, the IoT offers an alternate methodology for using sensor devices inside a shared infrastructure. Subsequently, these sensor devices can transmit the data to a cloud server (Paul et al. 2018).

The concept of the IoT is becoming more prevalent as an increasing number of physical objects are being connected at an unprecedented rate (Al-Fuqaha et al. 2015). This internetworking of various objects and network connectivity allows for seamless communication and data exchange between these objects. These objects include sensors, smart meters, smartphones, smart vehicles, RFID tags, PDAs, and other items embedded with electronics, software, and actuators (Gubbi et al. 2013). The interconnection of these devices enables the development of advanced IoT applications such as product tracking, environment monitoring, patient surveillance, and energy management. It also expands the automation capabilities in our daily lives. One notable IoT application is the smart home, which enables residents to automate tasks such as opening the garage upon arrival, controlling the air conditioning, preparing coffee, and managing lights, TV, and other appliances. IoT also plays an increasingly significant role in other domains, such as smart cities, smart grids, e-healthcare, intelligent transportation, industrial automation, and disaster response. It paves the way for innovative interactions between “things” and humans, offering new opportunities for applications, infrastructures, and services that enhance the quality of our daily lives.

To solve the system of nonlinear algebraic equations resulting from NP-hard modeling (Aazam, Zeadally, and Harras 2018), various methods such as heuristic, meta-heuristic, and gradient algorithms can be used. Among these, heuristic and meta-heuristic algorithms, which do not depend on specific knowledge of the problem, can be considered suitable options for solving nonlinear programming problems. Numerous innovative and metaheuristic algorithms, such as the cheetah algorithm, gray wolf algorithm, particle swarm optimization, and gravitational search algorithm (GSA), have been invented and developed (Sabireen and Neelanarayanan 2021). Additionally, combined algorithms, such as particle swarm optimization and gravitational search, and hybrid algorithms for gray wolf optimization and cuckoo search, have also been developed. The primary advantage of heuristic and meta-heuristic algorithms is that they do not require any restrictions to optimize the function, such as derivability or continuity. During the search process, they only need to determine the value of the target function at different points within the specified domain. Therefore, it can be utilized in various linear, nonlinear, continuous, or discrete problems and readily adapted to different scenarios. According to the discussion, to address the resource allocation problem and minimize the criterion function, the study will utilize the cheetah algorithm, the gray wolf algorithm, the particle swarm-gravitational search algorithm, and the gray wolf-cuckoo search algorithm (Alrawais et al. 2017).

The manuscript delves into a compelling exploration of meta-heuristic algorithms applied to resource allocation challenges within fog computing environments for IoT applications. Focusing on the Cheetah algorithm, Gray Wolf algorithm, Particle Swarm-Gravitational Search algorithm, and Gray Wolf-Cuckoo Search algorithm, the study employs MATLAB in a simulation environment to compare their efficacy. By emphasizing the minimization of the criterion function, total time, and energy consumption in IoT applications, preliminary findings reveal that the Cheetah algorithm consistently outperforms the Gray Wolf algorithm, as well as the combined Particle Swarm-Gravitational Search and Gray Wolf-Cuckoo Search algorithms. These promising results underscore the potential effectiveness of the Cheetah algorithm for optimizing resource allocation in the dynamic and resource-constrained context of IoT applications within fog computing environments. The manuscript provides valuable insights into the comparative performance of these meta-heuristic algorithms, setting the stage for further advancements in IoT resource allocation optimization strategies within fog setups. This research uses the aforementioned algorithms to optimize resource allocation and minimize total time and energy consumption for IoT applications in the fog computing environment. The mentioned algorithms are implemented in MATLAB software using a simulator. The results indicate that the statistical average of the cheetah algorithm outperforms the gray wolf algorithm, as well as the combined particle swarm-gravity search algorithm and the combined gray wolf-cuckoo search algorithm. This research contributes novel insights by demonstrating the superior performance of the Cheetah algorithm in optimizing resource allocation for IoT applications within fog computing environments, surpassing traditional and combined meta-heuristic algorithms in minimizing total time and energy consumption. The methodology is illustrated in the second section, and the selected algorithms are explained in the third section. The dataset is specified in the fourth section, and the results are discussed in the fifth section. The final findings and suggestions for future work are drawn in the sixth section.

Literature Review

The amalgamation of presently accessible disjointed solutions toward comprehensive healthcare is an imperative need and simultaneously a promising prospect in the realm of IoT. This connection enables data synchronization with cloud-based applications from wearable and implantable devices (Jiang et al. 2014). An essential aspect of attaining this integration is the architectural framework that facilitates such interoperability. An ordinary method is to directly link the sensor devices to Cloud services. Nevertheless, as a result of the limitations in resources of the end-user devices and monitoring and actuating devices, an architecture with an intermediary processing layer is increasingly being adopted as the prevailing solution. The intermediary stratum, sometimes referred to as Fog computing or edge computing (Rahmani et al. 2015), offers a range of general and specialized services to devices to augment usability, dependability, efficiency, and scalability, among other factors. Negash et al. (2018) centered on developing an intelligent e-health gateway designed for use in the Fog computing layer. It facilitates the interconnection of a network, including these gateways employed in domestic and medical settings. Simple healthcare scenarios were offered to demonstrate the use of the services. The characteristics of the gateway in the fog deployment were deliberated and assessed. Quy et al. (2022) provided a prevalent architectural framework based on fog computing for applications related to the Internet of Health Things (Fog-IoHT). In addition, the authors also highlighted potential use cases and obstacles in the integration of fog computing into IoT Healthcare applications. The investigation findings demonstrated a substantial capacity for Internet of Health Things (IoHT) applications founded on fog computing. It was anticipated that this work would serve as a significant reference for the future advancement of fog-based Healthcare IoT applications. Verma et al. (2022) presented FETCH, which seamlessly interacted with edge computing devices to operate on cutting-edge deep learning technology and automated monitoring, providing a very valuable framework for real-world healthcare systems, including but not limited to heart disease and other medical conditions. The suggested Fog-enabled cloud computing system utilized FogBus, showcasing efficacy in power consumption, network bandwidth utilization, jitter reduction, latency minimization, process execution time optimization, and their corresponding precision. Al Mudawi (2022) put forward a sophisticated IoT-based system for monitoring patients in the Intensive Care Unit (ICU). The primary objective of this system was to assist medical professionals and healthcare facilities in continuously monitoring patients, enabling them to make prompt and informed choices. The method could assess various bodily parameters of patients, such as temperature, SpO2, heartbeat, blood pressure, ECG, as well as glucose, lactate, blood circulation, red blood cells, white blood cells, calcium, and potassium levels in the patient’s fluids, all in real-time. In the event of abnormal values in these parameters, the device notified the designated physician and the hospital’s Emergency Care Unit (ECU). In another work, Kishor, Chakraborty, and Jeberson (2021) proposed a novel FC framework alongside cloud computing and IoT sensors to enhance latency in the field of healthcare. In this context, we use a random forest (RF) machine learning methodology to classify patient data effectively and enhance the response time using fog computing. The primary objective of the suggested endeavor was to provide individualized attention to the patient within a minimal timeframe in the real-time realm. In order to do this, RF classifiers were trained and correlated with data gathered by IoT sensors. This strategy minimized the superfluous visits of patients to various physicians’ clinics, and it conserved both time and money. The model attained a 92%-95% overall decrease in latency when compared to the previous body of work.

With the advancement of IoT, fog computing has been introduced to bring services closer to end users by pooling computing, storage, and networking resources at the network’s edge. It is a decentralized computing infrastructure that utilizes IoT devices or near-user edge devices to collaboratively handle communication, control, storage, and management tasks. By establishing connections between fog nodes and devices, fog computing can alleviate the processing burden on resource-constrained devices, meet the latency requirements of time-sensitive applications, and overcome bandwidth limitations for centralized services. Fog computing provides on-demand services and applications near devices, ensuring dense geographical distribution and low-latency responses. This results in an enhanced user experience and increased redundancy in the event of failure. Cloud-based IoT architecture can be categorized into two layers: the top layer and the bottom layer. The top layer, known as the data storage and control layer, utilizes the cloud to manage and integrate IoT services effectively. It accomplishes this by leveraging the devices and data collected from these devices to implement IoT applications. The cloud provides centralized storage, processing, and access for large-scale data and offers a wide range of applications and services through virtualization techniques. Doing so simplifies the implementation process by bridging the gap between objects and applications, concealing the complexity and functionalities involved. On the other hand, the bottom layer consists of countless IoT devices interconnected with each other and the cloud. The widespread presence of these devices in our surroundings enables us to measure, infer, understand, and reconstruct the environment. These devices encompass sophisticated gadgets like mobile phones, smart glasses, cameras, vehicles, and everyday objects such as appliances, furniture, food, clothing, and artwork (Botta et al. 2016). Communication mediums and equipment like gateways, routers, and bridges facilitate the communication between the two layers. They exchange data using standard communication protocols (Li, Dong, and Ota 2015). To address the latency problem associated with these applications, a FC paradigm was developed by Sallam et al. (2021) whereby cloud services were extended to the network edge to minimize the delay. Many challenges related to resource allocation and work scheduling in FC are still in their early stages. Nevertheless, fog devices situated at the periphery of the network were constrained by limited resources. A sophisticated fog computing scheduling model that provided service-provisioning for IoT while minimizing latency was proposed. A case study was presented featuring a crucial healthcare application (namely, an electrocardiogram (ECG)). Quy et al. (Vu Khanh et al. 2023) proposed a comprehensive computational framework that amalgamates diverse computing technologies within real-time intelligent healthcare domains. Subsequently, taking into account the efficacy of the suggested solution via the use of the queue network model tool, the authors provided suggestions for the most advantageous deployment of network infrastructure based on the size of the hospital’s patient population. The proximity of FC to the end user and its lack of dependence on centralized design provide the reliability that time-sensitive smart healthcare systems need. Due to the crucial nature of healthcare data, it is essential to implement enhanced security and privacy measures for fog computing, with trust being of paramount significance. The issue of trust in fog, which relies on the context, remains an unresolved research topic. Therefore, the objective of this study is to provide a trust solution that is adaptable to the context of smart healthcare settings, using a Bayesian methodology and similarity metrics. The trust model that has been suggested has been simulated in Contiki, and Cooja, and an application based on Java has been created to assess our findings.

Al-Khafajiy et al. (2019) conducted an article aimed to address the inefficiencies of fog computing by introducing the FRAMES collaboration model, which optimized load balancing among fog nodes based on their processing capabilities and offloaded incoming requests. The proposed FRAMES model demonstrated the technical feasibility of collaborative fog computing, enhancing load distribution and resource utilization among fog nodes, and provided an innovative approach to load balancing in fog networks, improving overall system performance and responsiveness by distributing workloads effectively. Despite its benefits, FRAMES faced challenges related to implementation complexity, scalability, and adaptability to diverse IoT environments.

Maamar et al. (2018) established a federation-as-a-service model that brought together necessary IoT devices based on specific needs and requirements which demonstrated the technical feasibility of thing federation-as-a-service by implementing a system for patient emergency transfer following a tunnel closure, showcasing the potential of collective behavior in emergency scenarios. Yousefpour et al. (2018) introduced a general framework for IoT-fog-cloud applications and proposed a delay-minimizing collaboration and offloading policy for fog-capable devices that aimed to reduce the service delay for IoT applications. Al-Khafajiy et al. (2019) tackled the issue of fog congestion through a request offloading algorithm and Sharing fog’s overload across multiple fog nodes improved the efficacy of the fog nodes, as demonstrated by the outcome. Maamar et al. (2021) provided a detailed discussion from both technological and social perspectives. Specifically, it aimed to address different challenges, key issues related to IoT, and architectural considerations also it explored how IoT can revolutionize future technology by connecting physical objects with sensors and actuators, enabling digital monitoring and control. However, the are many limitations that were not overcome in the past.

The primary novelty of this work lies in its in-depth exploration and comparison of heuristic and meta-heuristic algorithms, specifically the Cheetah algorithm, Gray Wolf algorithm, Particle Swarm-Gravitational Search algorithm, and Gray Wolf-Cuckoo Search algorithm, for addressing resource allocation challenges in IoT applications within fog computing environments. By implementing and evaluating these algorithms in a simulation environment using MATLAB, our study provides a comprehensive analysis of their performance metrics, focusing on minimizing total time and energy consumption. The key contribution is the identification of the Cheetah algorithm’s superior efficiency in adapting to dynamic IoT settings, surpassing the combined approaches of other algorithms. This study fills a crucial gap in the literature by offering a detailed examination of algorithmic adaptability and effectiveness in the context of fog computing, laying the groundwork for future research and practical implementations. The limitations addressed in previous works, such as the lack of a unified approach to algorithm comparison and insufficient exploration of algorithmic adaptability, are mitigated through our thorough investigation, providing a more nuanced understanding of these algorithms in the specific domain of IoT resource allocation in fog computing environments.

Methodology

Each host has varying computing resources in a cloud computing server, including main memory, bandwidth, secondary storage, and the number of CPU cores. We assume that p virtual machines are running on q hosts. Also, assume that there are n services, and each service with a specific workload requires CPU, bandwidth, and main memory. Each service request must be assigned to one or more virtual machines based on the requirements. For this purpose, a matrix should be created to determine the expected time for completion or calculation (ETC) as the calculation time for each service (in virtual memory). In the ETC matrix, the rows represent the virtual machines, and the columns represent the services. The matrix mentioned here includes the execution time of each service on the machine. For example, the length of the first row and the first column of the ETC matrix represents the expected time to perform the first service on the first VM.

The size and value of the matrix depend on the number of virtual machines (VMs) and the number of services. Here, “m” represents the total number of virtual machines (VMs), and “n” represents the total number of services. So, variable i changes from 1 to m, and variable j changes from 1 to n. The total execution time (ETj) for all services assigned to the jth virtual machine (VM) is calculated using Equation (1)(1) $\mathit{E}{T}_j=\sum _{\mathit{i}=1}^n{D}_i\mathit{j}\ast \mathit{ET}{C}_{\mathit{ij}}$(1) .

(1) $\mathit{E}{T}_j=\sum _{\mathit{i}=1}^n{D}_i\mathit{j}\ast \mathit{ET}{C}_{\mathit{ij}}$(1)

The total energy consumption of virtual memory is represented by (Evj), which is calculated by Equation (2)(2) $\mathit{E}{v}_j=\mathit{E}{T}_j\ast b_j+\left(\mathit{M}-\mathit{E}{T}_j\right)\ast a_j\ast \mathit{MIP}{S}_j$(2) :

(2) $\mathit{E}{v}_j=\mathit{E}{T}_j\ast b_j+\left(\mathit{M}-\mathit{E}{T}_j\right)\ast a_j\ast \mathit{MIP}{S}_j$(2)

Here, the terms bj and aj are considered for evaluation as follows:

$b_j={10}^{-8}$*$\mathit{MIPS}{j}^2$

$a_j=0.6\ast b_{\mathit{j}}\mathit{Joules}/\mathit{sec}$

The total energy consumption in the entire system (E) is defined by Equation (3).(3) $\mathit{E}=\sum _{\mathit{j}=1}^m{E}_{\mathit{vj}}$(3)

(3) $\mathit{E}=\sum _{\mathit{j}=1}^m{E}_{\mathit{vj}}$(3)

The total transmission time (TVj) for all services assigned to the jth VM is defined by Equation (4)(4) $\mathit{T}{V}_j=\sum _{\mathit{i}=1}^m{D}_{\mathit{ij}}\ast \mathit{T}{T}_{\mathit{ij}}$(4) .

(4) $\mathit{T}{V}_j=\sum _{\mathit{i}=1}^m{D}_{\mathit{ij}}\ast \mathit{T}{T}_{\mathit{ij}}$(4)

The time required to send all data from virtual machines is calculated using Equation (5)(5) $\mathit{TL}=\sum _{\mathit{i}=1}^m\mathit{T}{V}_j$(5) .

(5) $\mathit{TL}=\sum _{\mathit{i}=1}^m\mathit{T}{V}_j$(5)

The total cost function is the sum of the expected time for completion or calculation, the total energy consumption of the system, and the total transfer time, which is calculated by equation (6)(6) $X_{i,j}^{t+1}=x_{i,j}^t+{\hat{r}}_{\mathit{i},\mathit{j}}^{-1}.{\alpha }_{i,j}^t$(6) using the weighting coefficients p, q, and r. In this case, the importance of each of the above goals is equal, so the weight coefficients have the same value of 0.33. After modeling, the problem is solved using the optimizer algorithm. In this study, several metaheuristic algorithms were employed to evaluate the performance of different algorithms on the proposed model.

In this study, MATLAB software serves as the primary computational tool for implementing and simulating the proposed fog computing resource allocation model. MATLAB provides a robust and versatile environment for algorithm development, numerical analysis, and simulation. Leveraging its powerful capabilities, the Cheetah algorithm, Gray Wolf algorithm, Particle Swarm-Gravitational Search algorithm, and Gray Wolf-Cuckoo Search algorithm are implemented and compared within a simulated fog computing environment. MATLAB’s rich set of functions and toolboxes enable the researchers to model the fog infrastructure, define virtual machine specifications, simulate task execution, and evaluate the performance of the proposed resource allocation algorithms. The use of MATLAB ensures accuracy and efficiency in assessing the model, facilitating a comprehensive analysis of the algorithms’ effectiveness in optimizing resource allocation for Internet of Things applications within fog computing environments. More details regarding the components of the work are considered as follows:

IoT Devices

• Representation: Small circles or nodes in the diagram.

• Functionality: These are the edge devices that generate data and send requests for processing.

• Role: IoT devices are the initial point where data is generated, and they communicate with fog nodes for data processing.

Fog Nodes (Virtual Machines)

• Representation: Larger circles or rectangles in the diagram.

• Functionality: Corresponding to the virtual machines described in your specifications (Small, Medium, Large, Xlarge). Fog nodes act as intermediaries between IoT devices and the cloud (if applicable).

• Processing Tasks: Fog nodes execute services and tasks on behalf of IoT devices. The choice of fog node depends on the specific characteristics of the tasks and the virtual machine specifications.

Communication Links

• Representation: Lines connecting IoT devices to Fog Nodes.

• Functionality: Represent data transfer and communication channels between IoT devices and fog nodes. The communication links illustrate the connections that facilitate the flow of data from devices to fog nodes.

Cloud (Optional)

• Representation: A large cloud symbol in the diagram.

• Functionality: This represents a cloud computing infrastructure that may be part of the overall architecture. It’s optional and depends on the specific design requirements.

• Role: The cloud node, if present, can handle tasks that require extensive processing power, storage, or services not suited for fog nodes.

Task Flow

• Representation: Use arrows to illustrate the flow of tasks from IoT devices to Fog Nodes.

• Functionality: The direction of the arrows indicates the data flow and processing sequence. Tasks move from IoT devices to fog nodes for processing, and potentially to the cloud for more resource-intensive tasks.

Data Storage

• Representation: Symbols like a database icon.

• Functionality: Represents storage components, such as databases or file systems, associated with fog nodes or cloud nodes.

• Role: Used for data persistence, storing results of processed tasks, or providing data to support ongoing operations.

Algorithm Selection

Cheetah Optimizer (CO)

The cheetah is the primary species of cat and the fastest land animal found in the central regions of Iran and Africa. The cheetah can reach speeds of more than 120 kilometers per hour. The cheetah’s agility and speed are among its physical characteristics, including a long tail, long and thin legs, and a light and flexible spine. Cheetahs are swift animals capable of stealthy movement, rapid retreats when hunting, and distinctive spotted coats. However, these visual predators cannot maintain their high-speed performance for long. So, the chase should last less than half a minute. Also, their speed drops significantly from 93 km/h (58 mph) to 23 km/h (14 mph) in just three steps after catching the prey. Due to the mentioned limitations, to maintain their speed, cheetahs closely observe their environment from small branches or hills to identify their prey. These large felines can also effortlessly camouflage themselves in tall, dry grass thanks to their distinctive coat. These hunters typically pursue gazelles, particularly Thomson’s gazelles, impalas, antelopes, rabbits, birds, rodents, and calves of the legendary herd animals. First, they slowly move toward the prey in a crouched position to hide and reach the minimum distance. Then, they stand hidden and wait for the prey to approach the hunter (Akbari et al. 2022). If the prey sees the predator, they will stop hunting. The minimum distance mentioned is approximately 60–70 meters or 200–230 feet. However, it is determined to be 200 meters or 660 feet if it needs to be properly concealed. The chase lasts 60 seconds, covering an average distance of 173 meters (568 feet) to 559 meters (1834 feet). The prey is off balance after the cheetah slams its rump with its front paw, eventually bringing the predator down. It twists its prey with excessive force, causing the prey to struggle to escape. The back-and-forth movement of the cheetah’s muscular tail helps it make sharp turns. It is much easier to hunt animals that stray from their herd or are less cautious. It should be noted that various factors determine hunting success, including the maturity and sex of the prey, the number of hunters involved, and the recklessness of the prey. Additionally, coalitions or mothers with cubs tend to hunt larger animals successfully. According to biological research, it has been found that cheetahs have significant flexibility in their spines and long tails, which contribute to their physical balance. In addition, they have shoulder blades that are separated from the clavicle, which facilitates shoulder movement. All of the aforementioned characteristics make these large felines formidable hunters. However, not all hunts are successful.

A cheetah can detect prey when patrolling or scanning its surroundings. When a cheetah spots its prey, it may remain stationary and wait for the prey to come closer before initiating the attack. The attack mode consists of rush and grab phases. A cheetah may abandon its prey for various reasons, such as energy limitations or the rapid escape of the prey. It may then return home to rest and prepare for a new hunt. A cheetah can select one of these strategies by evaluating the prey’s position, location, and distance, as illustrated in Figure 1. The CO algorithm is generally based on the intelligent utilization of hunting strategies during hunting periods (Sait et al. 2023). Figure 1 elucidates the proposed solution’s architecture, illustrating the IoT layer with integrated Fog computing and cloud computing. Notably, cloud computing is not considered in this paper. The diagram encompasses IoT devices, represented by sensors, actuators, and smart devices, connected to strategically positioned Fog nodes. Network connections delineate data flow between IoT devices, Fog nodes, and the centralized cloud infrastructure. Data processing is visualized at both Fog nodes and the cloud, while dynamic resource allocation, facilitated by optimization algorithms such as the Cheetah algorithm, Gray Wolf algorithm, Particle Swarm-Gravitational Search algorithm, and Gray Wolf-Cuckoo Search algorithm, adapts to changing conditions in the IoT environment. This comprehensive visualization provides clarity on the network topology and resource optimization strategies within the proposed solution.

Figure 1. The IoT layer with integrated fog computing and cloud computing (Ma et al. 2019).

Cheetahs hunt for prey using two different methods. Either sit or stand to scan the environment or actively patrol around it. The scanning mode is more suitable when the prey is densely packed and grazing while walking in the plains. It should be noted that opting for the active mode, which requires more energy than the scanning mode, is preferable when the bait is dispersed and active. Thus, during the hunting period, depending on the condition of the prey, the coverage of the area, and the condition of the cheetahs themselves, the cheetah may choose a combination of these two search modes. To mathematically model the cheetah’s search strategy, let us consider $x_{i,j}^t$ as the current position of the ith cheetah (i = 1, 2, … , n) in the arrangement j (j = 1, 2, … , D). Here, n represents the number of cheetahs in the population, and D represents the dimension of the optimization problem. In fact, each cheetah encounters different situations when dealing with various prey. Each prey location is represented as a decision variable corresponding to the best solution, while the cheetah states (other arrangements) comprise a population. To update the new position of cheetah i in each formation based on their current position and desired step size, a stochastic search equation is proposed as follows:

(6) $X_{i,j}^{t+1}=x_{i,j}^t+{\hat{r}}_{\mathit{i},\mathit{j}}^{-1}.{\alpha }_{i,j}^t$(6)

where $X_{i,j}^{t+1}$ and $x_{i,j}^t$ represent the next and current positions of cheetah i in arrangement j, respectively. The index “t” indicates the current time of hunting, and “t” represents the maximum duration of hunting. Also, ${\hat{r}}_{\mathit{i},\mathit{j}}^{-1}$and ${\alpha }_{i,j}^t$ represent the randomization parameter and stride length for cheetah i in arrangement j, respectively. The second term refers to the randomization term, where the random parameter ˆr_i,j typically consists of random numbers distributed from a standard normal distribution. The stride length ${\alpha }_{i,j}^t$ >0 can typically be set to t/T × 0.001 in most cases, as cheetahs are known to be slow-walking foragers. Cheetahs may swiftly flee and alter their direction when confronted by other predators (enemies). To account for such behavior as well as near/far target search mode, a random number ${\hat{r}}_{\mathit{i},\mathit{j}}^{-1}$ is used for each cheetah in different hunting periods. In some cases, ${\alpha }_{i,j}^t$ can be adjusted based on the distance between cheetah i and its neighbor or leader. The position of a cheetah (referred to as the leader) in each cheetah arrangement is updated by assuming ${\alpha }_{i,j}^t$ to be equal to t/T × 0.001 multiplied by the maximum step size (defined based on the constraint variables, such as the upper limit minus the lower limit). For each pair of cheetahs, the value of ${\alpha }_{i,j}^t$ in the arrangement is calculated by multiplying the distance between the positions of cheetah i and a randomly selected cheetah.

Cuckoo Search Optimization (CSO)

Cuckoos exhibit a remarkable ability to carefully select the nests of specific bird species to lay their eggs. They mimic the color and pattern of each nest’s existing eggs, ensuring the newly laid eggs blend seamlessly with their surroundings. In doing so, the cuckoos effectively act as true hosts, fooling the unsuspecting host birds. Interestingly, female cuckoos possess individual specialties when it comes to selecting their target bird species. Some host birds have developed the ability to recognize cuckoo eggs within their nests and remove them, while others abandon the compromised nest and construct a new one. It is worth noting that host birds also adapt to the constant refinement in the cuckoos’ imitation of their nests’ eggs. The ongoing struggle for survival between these various bird species and cuckoos perpetuates this fascinating phenomenon (Nebagiri and Hnumanthappa 2024).

The “cuckoo algorithm,” a widely recognized global search technique, draws its inspiration from the behavioral patterns of the cuckoo bird. Similar to other evolutionary algorithms, the initial population of the Cuckoo Optimization Algorithm (COA) consists of a group of cuckoo birds. Within this population, some cuckoos exhibit the peculiar behavior of laying their eggs in the nests of specific host birds. The renowned global conscious search method, referred to as the “cuckoo algorithm,” finds its inspiration from the behavioral patterns exhibited by the avian species known as the cuckoo bird. The initial composition of the cuckoo algorithm encompasses a population similar to that of other evolutionary algorithms, representing a community of cuckoo birds. Amidst this particular population, certain cuckoos display a curious habit of depositing their eggs in the nests of specific host birds. It is more likely that some of these eggs, which resemble the eggs of the host bird, will eventually develop into adult cuckoos. To sustain their offspring, the host bird identifies and eliminates any foreign eggs in its nest. The number of matured eggs provides a measure of the suitability of the nest, reflecting the capacity for egg survival. Therefore, the COA seeks to optimize this parameter by focusing on the scenario where the highest number of eggs can be salvaged. To maximize the chances of their eggs surviving, cuckoos search for the most suitable area. They randomly choose nests of host birds that have previously laid eggs within the designated radius of the ELR. The visual representation of this range can be seen in the accompanying Figure 2 (Ansari 2024).

Figure 2. Random ovipositional in ELR, the central red star is the cuckoo’s primary habitat with five eggs.

The pink stars are the new nest of eggs, and the flowchart of the cuckoo algorithm is presented in Figure 3.

Figure 3. Cuckoo algorithm flowchart (Shair et al. 2015).

Gray Wolf Optimization (GWO)

GWO is a nature-inspired metaheuristic algorithm inspired by gray wolves’ social hierarchy and hunting behavior. This optimization technique mimics the collaborative hunting strategy of wolf packs to solve complex optimization problems. In GWO, the algorithm models the leadership hierarchy among alpha, beta, delta, and omega wolves, representing potential solutions. The alpha wolf, beta wolf, and delta wolf positions are updated based on the prey’s location, symbolizing the exploration phase, while the omega wolf’s position represents the exploitation phase by converging toward the optimal solution. By imitating wolves’ hunting behavior, GWO iteratively refines potential solutions, facilitating a balance between exploration and exploitation to navigate search spaces efficiently and converge toward optimal or near-optimal solutions for various optimization problems. According to Figure 4, the pseudo-code of the gray wolf algorithm is as follows (Liang et al. 2024):

1. Pseudo code of the GWO algorithm

2. Initialize the gray wolf population Xi (i = 1, 2, …, n)

3. Initialize a, A, and C

4. Calculate the fitness of each search agent

5. Xα = the best search agent

6. Xβ = the second best search agent

7. Xδ = the third best search agent

8. while (t < Max number of iterations)

9. for each search agent

10. Update the position of the current search agent by equation (3.7)

11. end for

12. Update a, A, and C

13. Calculate the fitness of all search agents

14. Update Xα, Xβ, and Xδ

15. t = t + 1

16. end while

17. return Xα

Figure 4. The algpseudocode of GWO (Jokar, Mosleh, and Kheyrandish 2022).

Standard Gravitational Search Algorithm (GSA)

The GSA algorithm is a novel heuristic optimization method introduced by E. Rashedi et al. in 2009 (Amoozegar and Rashedi 2014). The foundational physical theory that inspired the GSA algorithm is Newton’s law, which states that every particle in the universe attracts every other particle with a force directly proportional to the product of their masses and inversely proportional to the square of the distance between them. The distance between them is inversely proportional. The GSA algorithm can be considered a set of candidate solutions, each with masses proportional to the value of the fitness function of the problem. During the process of updating (generation), all the masses are attracted to each other by the force of gravity. A heavier mass exerts a greater gravitational force. Therefore, heavier masses likely to be near the global optimum attract other masses in proportion to their distances (Sabri, Puteh, and Mahmood 2013).

The strategy of the GSA algorithm can be expressed mathematically as follows. Consider a system with N agents. The algorithm begins by randomly placing all agents in the search space. In each period (repetition), the gravitational force of agent j on agent i at a specific time t is defined as follows:

(7) $F_{ij}^d\left(\mathit{t}\right)=\mathit{G}\left(\mathit{t}\right)\frac{{\mathit{M}}_{\mathit{pi}}\left(\mathit{t}\right)\times M_{\mathit{aj}}\left(\mathit{t}\right)}{R_{\mathit{ij}}\left(\mathit{t}\right)+\mathit{\epsilon }}\left(x_j^d\left(\mathit{t}\right)-x_i^d\left(\mathit{t}\right)\right)$(7)

Here, $M_{\mathit{aj}}\left(\mathit{t}\right)$ represents the gravitational mass associated with the j-th factor. M_pi represents the gravitational mass of the i-th inactive agent, G(t) denotes the gravitational constant at time t, ε is a small constant, and $R_{\mathit{ij}}\left(\mathit{t}\right)$ stands for the Euclidean distance between agents i and j. The gravitational constant at time t (G(t)) is calculated by equation (8)(8) $\mathit{G}\left(\mathit{t}\right)=G_0\times \mathit{exp}\left(-\mathit{\alpha }\times \mathit{iter}/\mathit{maxiter}\right)$(8) .

(8) $\mathit{G}\left(\mathit{t}\right)=G_0\times \mathit{exp}\left(-\mathit{\alpha }\times \mathit{iter}/\mathit{maxiter}\right)$(8)

Here, α and G0 are the descending coefficient and the initial value, respectively, variable iter is the current iteration and maxiter is the maximum number of iterations. In the problem space with dimension d, the total amount of force acting on factor i is calculated by the following equation:

(9) $F_i^d\left(\mathit{t}\right)=\sum _{\mathit{j}=1,\mathit{j}\ne 1}^N\mathit{ran}{d}_j{F}_{ij}^d\left(\mathit{t}\right)$(9)

Here $\mathit{ran}{d}_j$ is a random number within the interval [0,1]. According to the law of motion, the acceleration of an object is proportional to the applied force and inversely proportional to its mass. Therefore, the acceleration of all objects can be calculated using the following formula:

(10) $\mathit{a}{c}_i^d\left(\mathit{t}\right)=\frac{F_i^d\left(\mathit{t}\right)}{M_{\mathit{ii}}{\left(\mathit{t}\right)}^{,}}$(10)

Here, “t” represents the time characteristic, and $M_i$ represents the mass of object i. The speed and position of the agents can be calculated as follows:

(11) $\mathit{ve}{l}_i^d\left(\mathit{t}+1\right)=\mathit{ran}{d}_i\times \mathit{ve}{l}_i^d\left(\mathit{t}\right)+\mathit{a}{c}_i^d\left(\mathit{t}\right)$(11)

(12) $x_i^d\left(\mathit{t}+1\right)=x_i^d\left(\mathit{t}\right)+\mathit{ve}{l}_i^d\left(\mathit{t}+1\right)$(12)

Here, $\mathit{ran}{d}_i$ is a random number in the interval [0,1]. In the GSA algorithm, all masses are first initialized with random values. Each mass is a potential solution. After initialization, the velocities for all masses are calculated using (10). Meanwhile, the gravitational constant, total applied forces, and accelerations for particles are calculated using equations (4)(4) $\mathit{T}{V}_j=\sum _{\mathit{i}=1}^m{D}_{\mathit{ij}}\ast \mathit{T}{T}_{\mathit{ij}}$(4) , (5(5) $\mathit{TL}=\sum _{\mathit{i}=1}^m\mathit{T}{V}_j$(5) ), and (6(6) $X_{i,j}^{t+1}=x_{i,j}^t+{\hat{r}}_{\mathit{i},\mathit{j}}^{-1}.{\alpha }_{i,j}^t$(6) ), respectively. The position of masses is calculated using equation (8)(8) $\mathit{G}\left(\mathit{t}\right)=G_0\times \mathit{exp}\left(-\mathit{\alpha }\times \mathit{iter}/\mathit{maxiter}\right)$(8) . Finally, the GSA will be terminated upon meeting the end criterion.

Particle Swarm Optimization (PSO)

PSO is a population-based stochastic optimization algorithm inspired by the social behavior of bird flocks or fish schools. In PSO, particles, a group of potential solutions navigate through the search space to find the optimal solution. Each particle adjusts its position based on experience, the best-known position in its neighborhood, and the overall best-known position in the entire swarm. Through this iterative process, particles move through the solution space, adjusting their positions in a way that exploits promising areas while exploring new regions. PSO effectively balances exploration and exploitation by encouraging particles to converge toward the best solutions found by the swarm while also allowing for exploring new areas, making it a versatile and efficient optimization technique for various problem domains (Marini and Walczak 2015).

In examining the proposed algorithm, it is crucial to delve into its complexities to gain a comprehensive understanding of its computational intricacies. The algorithm introduces several parameters and intricate mechanisms, such as the fine-tuning of virtual machine specifications, task characteristics, and the intricate interplay between various heuristic and meta-heuristic algorithms. One notable aspect is the balancing act required to optimize the criterion function while minimizing total time and energy consumption for IoT applications. Additionally, the algorithm’s convergence behavior, sensitivity to initial conditions, and scalability must be carefully considered. These complexities contribute to the nuanced nature of the proposed approach, and a detailed discussion of these aspects is imperative for a thorough evaluation and comprehension of its practical applicability in dynamic fog computing environments

Simulation Procedure

To assess the suggested model and algorithm, this study presents simulation results and experimental implementation of the proposed approach. In this context, virtual machines are regarded as autonomous entities within the fog infrastructure, functioning as fog nodes to execute services and tasks (incoming requests) on behalf of IoT devices. The specifications of virtual machines for a fog infrastructure are presented in Table 1.

Table 1. The characteristics of virtual machines in the FC.

ID	RAM (MB)	Bandwidth (Mb/s)	CPU (MIPS)	Storage Size (MB)	MPIS	Type
1	512	1000	10000	10000	1000	Small
2	512	1000	10000	10000	1000	Small
3	512	1000	10000	10000	1000	Small
4	512	1000	10000	10000	1000	Small
5	512	1000	10000	10000	1000	Small
6	512	2000	20000	20000	2000	Medium
7	512	2000	20000	20000	2000	Medium
8	512	2000	20000	20000	2000	Medium
9	1024	4000	40000	40000	3000	Large
10	1024	4000	40000	40000	3000	Large
11	1024	8000	80000	80000	4000	Xlarge

Examples of tasks are presented in the table below. The number of requests and their types at any moment are different depending on the user of the IoT system. An example of a set of 30 of these tasks is shown in Table 2.

Table 2. The dataset considered for conducting the tasks.

ID	Size	Type	Info
4	8148	D	Body temperature
9	2196	I	Temperature-Hypoxemia-Blood pressure
8	12219	H	Temperature-Blood Glucose Level
6	6402	F	Blood pressure - temperature
9	5373	I	Temperature-Hypoxemia-Blood pressure
5	13101	E	Blood pressure - Blood Glucose Level
4	7764	D	Body temperature
7	1690	G	Blood pressure - Hypoxemia
7	17682	G	Blood pressure - Hypoxemia
1	12537	A	Blood pressure
5	10233	E	Blood pressure - Blood Glucose Level
1	10321	A	Blood pressure
2	1583	B	Hypoxemia
1	7511	A	Blood pressure
4	7369	D	Body temperature
6	6720	F	Blood pressure - temperature
7	6233	G	Blood pressure - Hypoxemia
3	11145	C	Blood Glucose Level
1	7576	A	Blood pressure
6	1517	F	Blood pressure - temperature
2	3425	B	Hypoxemia
4	13678	D	Body temperature
5	1564	E	Blood pressure - Blood Glucose Level
3	19867	C	Blood Glucose Level
5	7369	E	Blood pressure - Blood Glucose Level
2	18981	B	Hypoxemia
4	12528	D	Body temperature
7	8443	G	Blood pressure - Hypoxemia
3	9305	C	Blood Glucose Level
6	9867	F	Blood pressure - temperature

The previous discussion highlighted that the ETC matrix consists of values that represent the ratio between task duration and virtual memory speed. These values are derived through the application of the following equation.

(13) $\mathit{ET}{C}_{\mathit{ij}}=\frac{\mathit{Length}-\mathit{of}-\mathit{tasks}}{\mathit{V}{\mathit{M}}_{\mathit{mips}}}$(13)

The service cost in the simulation is determined by utilizing the exchange time and network resources. Equation (9)(9) $F_i^d\left(\mathit{t}\right)=\sum _{\mathit{j}=1,\mathit{j}\ne 1}^N\mathit{ran}{d}_j{F}_{ij}^d\left(\mathit{t}\right)$(9) is employed to calculate the transmission time required for delivering the service in the fog computing environment. Consequently, the transfer time is defined as the quotient of the data size and the bandwidth (bw) allocated to each service on every virtual machine.

(14) $\mathit{ET}{C}_{\mathit{ij}}=\frac{\mathit{Length}-\mathit{of}-\mathit{tasks}}{\mathit{V}{\mathit{M}}_{\mathit{mips}}}$(14)

The calculation of transfer time is essential for every service on each virtual machine. The total delay of services is determined by adding the processing time and communication time together. The completion time for a service is influenced by the product of TT_ij and 2. The transmission matrix, which consists of the transmission time for each service and the TTm list of virtual machines, represents this aforementioned matrix. Now, the virtual machines will be assigned services by employing the suggested service allocation approach in conjunction with meta-heuristic algorithms. If the service i-m is allocated to the virtual machine i-m, its assigned value will be one, whereas if it is not allocated, its assigned value will be zero.

The simulation process for evaluating the performance of the selected meta-heuristic algorithms in the context of Fog computing and IoT resource allocation involves several key steps. Firstly, a simulation environment is set up using MATLAB software. This environment emulates the conditions and dynamics of Fog computing scenarios, considering factors such as network latency, data processing capabilities at Fog nodes, and communication between IoT devices and the Fog layer. Next, the algorithmic implementations, including the Cheetah algorithm, Gray Wolf algorithm, Particle Swarm-Gravitational Search algorithm, and Gray Wolf-Cuckoo Search algorithm, are integrated into the simulation. The parameters and variables relevant to each algorithm are configured based on established guidelines and considerations. To assess the algorithms’ performance, a set of representative scenarios is defined, encompassing varying conditions of IoT workload, data distribution, and Fog computing resources. The simulation runs multiple iterations for each algorithm under these scenarios, capturing metrics such as convergence speed, solution quality, and resource utilization. Throughout the simulation process, data is collected, and the algorithms’ performance is analyzed. Statistical measures such as mean, standard deviation, and convergence plots are employed to provide a comprehensive evaluation of each algorithm’s efficiency and effectiveness in optimizing IoT resource allocation within the Fog computing environment. It’s important to note that the simulation process is iterative, allowing for the refinement of algorithmic parameters and configurations to achieve optimal results. The outcomes of the simulation provide valuable insights into the comparative performance of the algorithms and contribute to the overall understanding of their applicability in Fog computing scenarios for IoT resource allocation optimization.

Results and Discussion

The simulation outcomes for a collection of N services alongside a compilation of M resources are presented in Figures 5–8. The presented results are based on 250 repetitions with an initial population of 50, employing four methodologies: the Cheetah Algorithm, Gray Wolf Algorithm, Cuckoo Search, and a combined Particle Swarm-Gravity Search Algorithm.

Figure 5. Comparison between the selected models in terms of convergence.

Figure 6. Comparison between the selected models in terms of task and VM.

Figure 7. Comparison between the selected models in terms of objective value.

Figure 8. Comparison between the selected models in terms of speed.

According to Figure 7, investigating heuristic and meta-heuristic algorithms for resource allocation in IoT fog computing environments has unveiled compelling findings. The comparison among the Cheetah algorithm, Gray Wolf algorithm, Particle Swarm-Gravitational Search algorithm, and Gray Wolf-Cuckoo Search algorithm showcased the Cheetah algorithm’s superior performance in minimizing total time and energy consumption. This superiority signifies the Cheetah algorithm’s capability to efficiently allocate resources in dynamic IoT settings, where rapid decision-making and optimized resource utilization are imperative. Notably, while the other algorithms demonstrated considerable effectiveness, their combined approaches could not surpass the individual prowess exhibited by the Cheetah algorithm. This suggests that the Cheetah algorithm’s unique adaptability and optimization power are specifically tailored to the complexities inherent in fog computing environments.

As shown in Figure 8, the results signify a pivotal shift in resource allocation strategies for IoT applications in fog computing, emphasizing the significance of algorithmic adaptability and efficiency. The Cheetah algorithm’s dominance in minimizing resource consumption highlights its potential as a cornerstone for future IoT resource allocation frameworks. Understanding its strengths and leveraging its adaptability could revolutionize resource management in fog computing, where real-time decision-making and optimized resource usage are pivotal. These findings not only accentuate the effectiveness of heuristic algorithms but also provide a clear direction for harnessing advanced algorithms like the Cheetah algorithm to address resource allocation challenges in IoT-driven fog computing landscapes, paving the way for enhanced system performance and resource utilization efficiency.

In addition to the comprehensive analysis presented in the Results and Discussion section, a supplementary paragraph aims to shed light on the observed trends in algorithmic behavior and convergence during the simulations. The iterative nature of the Cuckoo Search algorithm is particularly noteworthy, as, after numerous iterations, the entire population converges toward the most favorable habitat, symbolizing the completion of the algorithm. This observation underscores the algorithm’s efficacy in navigating solution spaces to identify optimal configurations, a crucial aspect in the context of resource allocation for IoT applications in fog computing. The distinct behavior of each algorithm, as evident in the convergence, objective value, and speed comparisons, further emphasizes their unique characteristics and performance nuances. These insights provide additional depth to the understanding of how these algorithms operate in dynamic and resource-constrained environments, offering valuable considerations for future refinement and application in real-world scenarios.

Due to the findings, after numerous iterations, the entire population of cuckoos eventually migrates to the most favorable habitat that closely resembles the egg characteristics of host birds and offers an ample supply of food resources. This specific habitat proves to be the most profitable ever observed. Within this exceptional habitat, egg loss is minimized to the highest degree. The fact that more than 95% of the entire cuckoo population converges toward a single habitat marks the completion of the COA.

The paper investigates the application of heuristic and meta-heuristic algorithms in fog computing environments for IoT resource allocation. Specifically, the Cheetah algorithm, Gray Wolf algorithm, Particle Swarm-Gravitational Search algorithm, and Gray Wolf-Cuckoo Search algorithm are implemented and compared using MATLAB in a simulation environment. The primary objectives include minimizing the criterion function, total time, and energy consumption in IoT applications. The preliminary results reveal noteworthy trends in algorithm performance. On average, the Cheetah algorithm demonstrates superior efficacy compared to the Gray Wolf algorithm, as well as the combined Particle gravitational search and Gray Wolf-Cuckoo Search algorithms. While specific figures are not presented in this abstract, the observed patterns suggest a promising direction for further investigation. These preliminary findings offer valuable insights into the comparative performance of the algorithms, paving the way for a detailed analysis with comprehensive numerical results in the full manuscript. This exploration contributes to the broader understanding of meta-heuristic approaches for optimizing resource allocation in IoT applications within fog computing environments.

Conclusion

In conclusion, exploring heuristic and meta-heuristic algorithms for optimizing resource allocation in IoT applications within fog computing environments has yielded significant insights. This study revealed the Cheetah algorithm’s remarkable efficacy in minimizing total time and energy consumption through meticulous experimentation and analysis, outperforming established and combined meta-heuristic approaches like the Gray Wolf algorithm and the Particle Swarm-Gravitational Search algorithm. The findings underscore the potential of the Cheetah algorithm as a powerful tool for addressing resource allocation challenges in dynamic IoT environments, paving the way for further enhancements in resource optimization strategies within fog computing paradigms. This research emphasizes the importance of adaptive, efficient algorithms in mitigating resource constraints and enhancing performance in IoT applications, offering valuable directions for future advancements in this field.

Nomenclature

$\mathit{ETC}$	=	Express time to complete/compute
$\mathit{E}{T}_j$	=	Total Execution time
$\mathit{VMs}$	=	Virtual Machines
$\mathit{T}{T}_{\mathit{ij}}$	=	Transmission time
$\mathit{ET}$	=	Execution time
$\mathit{F}$	=	Fitness value
$E_{\mathit{vj}}$	=	Energy Consumption of $\mathit{V}{M}_j$
$\mathit{E}$	=	Total Energy Consumption
$\mathit{M}$	=	Makespam
$\mathit{T}{T}_m$	=	Transmission Matrix
$D_{\mathit{ij}}$	=	Allocation Matrix
$\mathit{BW}$	=	Bandwidth
$\mathit{MIPS}$	=	Million of Instructions per second

Disclosure Statement

No potential conflict of interest was reported by the author(s).

Data Availability Statement

This research did not involve the use of specific datasets. The findings and conclusions presented in this study are based on analysis, interpretation, and synthesis of existing literature, theoretical frameworks, and/or simulations. As no primary data were collected, there are no additional datasets associated with this research.