Cloud-fog computing consists of three layers: (1) the IoT layer, (2) the fog layer, and (3) the cloud layer. These three layers are interconnected through wireless devices such as LoRa, Bluetooth, and Wi-Fi. The first layer contains the IoT devices, enabling them to send data to the other layers for processing. IoT devices can also communicate with each other, generating crucial information needed for quick responses. Once data is generated by the first layer, it is passed to the second layer, which contains two nodes: the task receiver and the task controller, also referred to as the fog node and fog analyzer. Fog nodes have limited computational power and storage capacity, which helps reduce transmission latency and network overhead. However, certain tasks require additional computational power and storage capacity, prompting the fog node to transmit the data to the cloud server for processing. In each scenario, the task is received by the task receiver (fog node) and directly forwarded to the controller. When the fog node receives a task, it further divides it into subsets for estimation analysis and task scheduling, depending on the task requirements. The fog layer (fog controller) incorporates the proposed algorithm to make optimal task scheduling decisions, considering objectives such as energy consumption and delay. The third layer consists of computational servers with significant computational power. This layer is responsible for processing the tasks and sending them back to the fog layer after completion. The working operation of the proposed task scheduling algorithm is shown in Fig. 1.

CO algorithm is a new meta-heuristic optimization algorithm, inspired by the hunting behavior of Cheetahs. It is primarily designed for tackling complex real-world optimization problems, not only in the field of computer science, but also in other fields like electronics [41], engineering [42], and medical science [43], etc. It is one of the fastest land animals that can run at a speed of 120 km/h. A cheetah is capable of detecting prey upon patrolling its surroundings. When prey is detected, the Cheetah tries to hide himself or on small breaches or hills. In this case, Cheetah does not directly attack the prey, but instead it sits and waits for the prey to come close as much as possible. Cheetah tries to maintain this minimum distance, and once it is within the range, Cheetah attempts to attack the prey. Overall, the hunting strategy of CO is divided into three phases, i.e., (i) search strategy (ii). sit and wait strategy and (iii) attacking strategy. Fig. 2 presents the arrangements of the Cheetah population according to these strategies. Each arrangement of Cheetah in the swarm indicates a solution to the problem. For example, in our case, each arrangement represents a unique task scheduling strategy. Each arrangement is further evaluated to compute the fitness value. Among the population, the best location is considered as the prey, i.e., the best solution. Cheetahs arrange their locations according to the location of the prey. The description of each strategy is given below:

Search phase: In the search phase, Cheetah scans the surrounding area in search of the prey. The searching can be done either sitting or standing, or actively patrolling the environment.

Sit and wait phase: The movement of the Cheetah can lead to the escape of the prey. Therefore, Cheetah needs to be very careful while approaching the prey. To avoid being caught, Cheetahs hide themselves from the prey and sit in a hidden place and wait for the prey to come nearer.

Attack phase: In this phase, there are two important steps (i) Rushing (ii) capturing. Rushing is when Cheetahs decide to attack the prey; they quickly run towards the prey with maximum speed. In capturing, the Cheetahs used flexibility to capture the prey by approaching the prey with maximum speed. The mathematical modelling of each phase of the CO algorithm is given in (19).

Mult-objective Cheetah Optimizer (MoCO) is extension of the CO, designed to solve multi-objective optimization problems which encompasses two or more competing objectives that are to be solved simultaneously. Unlike single-objective optimizers, multi-objective optimization problems generate multiple solutions because of multiple conflicting objectives. Mathematically, it is represented as below: (1)S=[S1S2⋮Sn,]=[s1,1s1,2…s1,ds2,1s2,2…s2,d⋮⋮⋮⋮sn,1sn,2…sn,,d] (2)F(S)=[F(S1)F(S2)⋮F(Sn,)]=[F(s1,1)F(s1,2)…F(s1,d)F(s2,1)F(s2,2)…F(s2,d)⋮⋮⋮⋮F(sn,1)F(sn,2)…F(sn,,d)] (3)Z=[Z1Z2⋮Zn]=[z1,1z1,2…z1,dz2,1z2,2…z2,d⋮⋮⋮⋮zn,1zn,2…zn,,d]where S is the population size with n number of solutions, with d is the dimension. The objective function F is applied on multiple solutions, i.e., F(S), and multiple Z objective values are generated.

The solutions can either dominate or be non-dominant over one another based on specific conditions.

Two solutions s₁ and s₂ are non-dominating over each other if they have the same fitness values, and any fitness value of s₁ is either better than s₂ or worse than s₂.

All the non-dominating solutions are stored in an external archive and arranged in a population and ranked based on dominance. The first rank consists of the best non-dominating solutions. The subsequent rank contains solutions dominated by higher-ranked ones. All the solutions in the archive are called Pareto-optimal solutions and form the Pareto-optimal front. When a new solution dominates the existing one in the archive, then the existing solution is replaced by the new solution, ensuring the archive maintains only the most optimal solutions.

In the context of the fog computing, the system model encompasses fog devices FD = {FD₁, FD₂, FD₃, ... FD_n}, set of heterogenous cloud servers represented as C_s = {C_s1, C_s2, C_s3, ... C_sm}, the number of IoT end nodes denoted as EN = {EN₁, EN₂, EN₃, ... EN_l} and the set of search agents represented as S_A = {S_A1, S_A2, S_A3, ... S_Ah}. Here, we make an assumption that the capacity of cloud computational resources is more than the computation capacity of fog nodes and IoT devices. Similarly, the energy consumption of cloud computational resources is more than that of fog nodes and IoT devices. The scheduling of each incoming task is performed by the fog broker. In the system model, the search agents play the role of candidate solutions that contain a set of tasks, offloaded to various computational resources (fog node or cloud server). The evaluation of solutions is performed by the fitness function that determines the best candidate solution. Afterward, other candidate solution repositions themselves to get closer to the best solution.

In this phase, all the candidate solutions, i.e., Cheetahs, are randomly populated within the search space along with the initialization of fog nodes, cloud servers, and devices. The search space allows the candidate solution to cooperatively search for the potential optimal solution, i.e., optimal task allocation.

In our solution, each candidate solution can be represented by an RxT binary matrix, where R is the number of available computing nodes and T is the number of tasks to be scheduled. In the matrix, if Yki=1, it means that the task k is allocated to computing node i, otherwise if Yk=0, it signifies that the task k is not yet allocated to any computational node. Search agents intelligently take into account the various important parameters during allocation of each task (e.g., scheduling objectives, network condition, required resources, and available resources). A task is assigned to a computing node only if the available computational resources meet the task requirements. The creation of the candidate solution must be in accordance with the following constraints:

Each task is allocated to only one computational node

Solution mutation performs a critical role in enhancing the diversity of the solution. To this end, we used the Inverse Mutation Technique (IMT) in which the position of two candidate solutions (i.e., task schedules) is interchanged with each other upon meeting the specified criteria. In Mutation, the solution is selected randomly; for instance, if C1 and C2 are selected, their position is swapped if C1 is greater than C2. Otherwise, no swapping occurs. This procedure is illustrated in Fig. 3.

The fitness function provides a means of evaluating the search agents’ solutions, which represent the allocation of tasks to the computing nodes. This fitness function computes fitness values of all search agent solutions and it is based on the delay and energy consumption. The fitness function determines the optimal computing node for a task based on the optimal objective values. The fitness function for evaluating each search agent solution is given below: (4)F=β∗φD+(1−β)∗ σEwhere σE, φD, and β are the system total energy consumption, communication delay, and weight factor, respectively. Weight factor determines the priority of each objective during the allocation of tasks to the computing nodes, and its value must be in between 0 and 1, i.e., β=[0,1]. In case of weight factor equals to 0.5, i.e., β=0.5, then equal priority is given to each objective during the optimization process. If β<0.5, then, high priority is given to energy consumption. In this case, the optimization algorithm may delay the task to achieve minimal energy consumption. Conversely for β>0.5,a higher priority is given to delay, allowing the algorithm to take immediate action during the task allocation process. In MEC environments, tasks are distributed among three levels of computing nodes, i.e., terminal devices or end-user devices, middleware devices or fog nodes, and cloud servers. The availability of computational resources and task processing capability in each layer is different. Therefore, the computation of objective parameters is necessary at each level. Terminal devices are usually less energy-efficient because of their small battery capacity. Middleware devices provide moderate transmission latencies with moderate energy consumption, while cloud servers offer a vast computational capability at the cost of network latency. In the subsequent section, we compute the energy and delay at each computing level.

Non-dominated solutions are called Pareto-optimal solutions, which are stored in a repository whose size is equal to the number of candidate solutions. MoCO uses non-dominating sorting to arrange the solution in a repository found in each iteration. In some cases, the repository may contain the same ranked non-dominated solution, so it is necessary to replace the solution with the new non-dominated solution. This can lead to reducing the exhaustive search and increasing the diversity of the solutions. To replace the solution, we used a predetermined crowding distance value, which is also used to determine the number of neighboring solutions. Mathematically, it is calculated as below: (16)D=MaxF−MinFRep(size)where MaxF and MinF indicate the maximum and minimum values of all objectives. Rep(size) is the size of the repository. If a solution has a high crowding distance value, then the solution has a high probability of being replaced. High crowding distance solution contributes more to the diversity of solutions and reduces the chance of local optimality. Alternatively, a solution with a low crowding distance value has a low probability of being replaced.

Cheeta Optimizer has shown its effectiveness in solving various complex, large-scale real-world optimization problems. However, CO suffers from premature convergence and computation time. To address these shortcomings, CO is modified, namely Enhanced Cheeta Optimizer (ECO) to improve convergence speed and reduce computation time. The attacking strategy of ECO encompasses three phases, i.e., search phase, sit and wait phase, and attack phase.

Algorithm 1 contains the pseudo-code of the proposed algorithm. The process begins by initializing essential system parameters, including several fog nodes, end devices, cloud servers, task count, required and available computational resources, etc. In lines # 1–4, the algorithm initializes the search space by randomly populating it with search agents. Each search agent constructs a solution by scheduling N heterogeneous tasks to various computational nodes. Subsequently, the algorithm evaluates each solution using a fitness function. Lines # 6–7 involve sorting the solution by the search agent based on its fitness value. The second-best solution is designated as the leader’s location, while the optimal solution is defined as the prey’s location. Lines # 8–17 are a nested loop in which each search agent creates a new solution by allocating each task to the appropriate computational nodes and then scheduling the offloaded task based on task priorities. Each solution is evaluated using a fitness function, and a solution with the minimum fitness value is selected as the best solution. In line 16, the best solution is updated if it outperforms the previous one. Lines # 18–19, store the non-dominated solution in the external repository and arranges the solution using non-dominated sorting. Lines # 20–23, check the size of the repository; if it is equal to the number of search agents, then the solution with the low crowding distance measure is replaced with the high crowding distance measure. Lines # 24–27 implement a loop in which the location of each search agent is updated as per the search and attack strategy defined by the proposed ECO algorithm. In Lines # 38–42, new solutions are formed after the repositioning of search agents, which are then re-evaluated using the objective function. Line # 40, stores the non-dominated solution in the repository after re-evaluation. The solution with the best objective value from the repository is selected as the best and global optimal solution. In Line # 44, the global optimal solution is returned, which contains a binary matrix of the best computation offloading and task scheduling strategy. The flowchart of the proposed scheduling framework is given in Fig. 4.

The implementation of the proposed algorithm requires terminal nodes, fog nodes, communication links, and cloud servers. Each terminal node generates either energy-intensive or delay-intensive tasks. The number of tasks generated by a terminal node varies with the computational demands of the device. Each task is analyzed at the fog controller to determine its resource requirements and execution constraints. Based on this analysis, the fog controller constructs a matrix representing joint task offloading and scheduling strategies. Each strategy is treated as a potential candidate solution (search agent) and evaluated using the defined objective function. Afterward, the mathematical model of MoECO is applied to identify the best offloading and scheduling strategy that minimizes both the energy consumption and transmission latency. The computing network then process according to the selected optimal strategy.

We compute the computational complexity of each phase and then represent the cumulative complexity of the entire algorithm.

Initialization: The computational complexity of initializing the search space mainly depends on population size. If m search agents are initialized within the search space with the problem dimension D, then the initialization phase takes O (m × D).

Task assignment phase: In this phase, the tasks are offloaded to the suitable computing nodes, either fog device (FD_n) or cloud server (C_sm) by determining task requirements and availability of computational resources. If T_k represents the total number of tasks, then task assignment phase takes O (m × T_k × (FD_n × C_sm)).

Fitness evaluation and sorting phase: Each iteration performs fitness computation for m solutions and sort them to identify the optimal solution in the current iteration. The evaluation takes O (m × C_f). The sorting phase takes O (B + m log m) because of non-dominated sorting. So, the total complexity of this phase is O (m × C_f (B + m log m)) or O (m² log m). C_f is the cost associated with the fitness evaluation, and B is the number of objectives.

Position update phase: Each search agent updates its position based on adaptive operators (attack, search, sit-and-wait) that involve a constant number of arithmetic operations. The computational complexity of this phase is O(m).

Iterative process: The above phases (2–4) are repeated for T iterations. So, the computational complexity of all the important steps with iterations T is O (T × (m × T_k × (FD_n × C_sm) + m × C_f (B+ m log m)).

Total computational complexity: The simplified total computational complexity of the proposed algorithm for T iterations and m search agents is O (T × (m × D + m × T_k × (FD_n × C_sm) + m × C_f (B+ m log m))), which collapses to O (T (m² log m + m (DT_k × C_f FD_n × C_sm).

Table 2 unfolds the computational complexities of the proposed and other baseline methods. This analysis demonstrates that the proposed algorithm is capable of solving multi-objective optimization problems effectively, as it provides a better balance between different and mutually exclusive factors such as energy, delay, fairness index, and throughput. Although the computational complexity of this algorithm is slightly higher, this increase is due to the archive non-dominated sorting process, which can affect the performance to some extent in large networks. The computational complexity of ACO and GA algorithms is similar and they are mostly suitable for single-objective optimization. Nevertheless, they require relatively more iterations to reach the optimal solution.

On the other hand, the time complexity of the GWO algorithm is quadratic, which is effective for single-objective problems such as energy consumption or delay, but it often suffers from the problem of premature convergence.

In the first setup, we evaluated the proposed algorithm to measure the total delay of each processed task at levels 50–250, while keeping the number of fog nodes fixed at 5. The performance of the proposed task scheduling algorithm was compared with the original CO and other baseline methods, which improves the searching capability of both exploration and exploitation search phases by adjusting various variables, e.g., step length and interaction factor. This improves the computation time and convergence speed of the proposed algorithm. Consequently, the total transmission delay of the system is minimized through smart resource utilization. The proposed approach dynamically offloads tasks to either fog nodes or cloud servers based on the capacity, bandwidth, and task requirements (e.g., delay sensitive or computation sensitive). Additionally, the proposed algorithm reduces total delay by prioritizing task scheduling based on task completion deadline and energy utilization, implementing load balancing to prevent workload bottlenecks. The results in Fig. 5a demonstrate that our proposed solution exhibits linear behavior against the increasing number of IoT tasks. This signifies that our scheme is stable and efficient when the workload on the system is high.

Fig. 5b illustrates the analysis of the same experimental setup with different simulation parameters, i.e., we increase the number of tasks from 300 to 500 while the computation nodes, i.e., fog nodes, increase to 10. Here, the proposed algorithm also performs efficiently compared to the state-of-the-art baseline methods in terms of achieving minimum transmission delay. From the results (Fig. 5a,b), we can conclude that our proposed MoECO scheduling algorithm is ideal for a real-time environment where task needs an immediate response, like the Internet of Medical Things (IoMT).

In this experimental setup, we evaluate the performance of the proposed algorithm by analyzing its energy consumption under varying workloads (50–500). The network bandwidth and CPU frequency of a computing node contribute to the energy consumption of a device. The results depicted in Fig. 6a,b demonstrate that the proposed task scheduling algorithm consumes less energy than other approaches, while also extending the lifetime and resource utilization of the network. Compared to the state-of-the-art benchmark schemes, our proposed solution reveals better energy utilization in a complex dynamic fog computing. Unlike baseline methods, which involve higher computational time and low convergence speed to achieve an optimal solution, the proposed ECO scheduling algorithm has high convergence speed, low network overhead, and low computation time. This minimizes the number of iterations to reach the optimal solution, reducing energy consumption.

In this experimental setup, we evaluate the energy consumption at each tier of the architecture across varying numbers of fog nodes (5–50) under the workload of 200 and 300 tasks. It is observed that an increase in the number of fog nodes results in higher energy consumption due to the operational, communication, and data transmission demands of computational nodes. However, an effective resource allocation and scheduling technique can significantly optimize the overall network’s energy consumption. The outcomes, as illustrated in Fig. 7a,b, demonstrate that the proposed algorithm achieves superior energy optimization compared to the baseline algorithms. The proposed scheme dynamically and intelligently identifies the computational requirements of tasks, ensuring that only computationally intensive tasks are offloaded to the cloud server, while others are processed locally on fog nodes. This strategic approach reduces unnecessary data transmission and leverages local processing capabilities, leading to significant energy savings.

The simulation is performed to evaluate the performance of the proposed scheduling algorithm in terms of transmission delay against the number of nodes under the workload fixed at 200 and 300 tasks. Generally, an increase in fog nodes leads to improved processing capabilities but can also introduce challenges related to task allocation and communication overhead. Effective scheduling techniques are essential to minimize delay and ensure the timely processing of tasks. The simulation results, in Fig. 8a,b, reveal the operational efficacy of our proposed algorithm in reducing transmission delay. By leveraging its efficient convergence speed and computation time, the workloads are effectively distributed among computation nodes, escalating response time and thereby minimizing total transmission delay. In contrast, baseline methods exhibit higher delays due to their comparatively slower convergence and less adaptive resource allocation mechanisms. The efficient results of the proposed algorithm demonstrate the effectiveness in achieving low latency, making it an ideal choice for delay-sensitive applications in fog-cloud computing environments.

TCR indicates the percentage of successfully processed tasks within a given deadline relative to the total number of tasks. In this experimental setup, we calculate the TCR against the number of tasks. The number of tasks varies from 50–500 while the computational nodes are kept constant. The simulation results in Fig. 9a, reflect the efficiency and reliability of the task scheduling algorithm in terms of achieving high TCR compared to the state-of-the-art similar benchmark algorithms. As observed, TCR decreases with the increase in the workload, this trend is expected because with the increase in the workload, the scheduling complexity increases. Moreover, resource contention and deadline violation also affect the task completion rate. The efficient performance of the ECO scheduling algorithm is attributed to high convergence speed, low computation time, and efficient investigation of local and global search capabilities.

Throughput measures how many tasks are completed per unit of time. It assesses the speed and efficiency of the system, i.e., how fast the system can process tasks. In this simulation, we compute the throughput of the proposed MoECO against the number of tasks varying from 60–500. The simulation results in Fig. 9b demonstrate the efficient performance of the proposed algorithm in terms of obtaining high throughput compared to the baseline methods. The results were normalized by a scaling constant to facilitate comparative visualization. A higher throughput value indicates faster task processing capability and improved scalability under increased workloads.

The fairness index assesses how fairly tasks are distributed among computational nodes (i.e., fog nodes and cloud servers). The allocation of resources among tasks must be fair and in accordance with the policy to prevent resource starvation of low-priority tasks. The imbalanced utilization of resources can lead to task drop-offs and reduce system performance. Eq. (23) is used to calculate the fairness index.

(23)FI=(∑i=1TRi)2T∑i=1TRi2where Ri indicate the allocation of resource R to task i, T is the total number of tasks. A high value of the fairness index indicates the fair utilization of resources among tasks, preventing overload on specific computational nodes and underutilization of other computational nodes. Whereas a low fairness index value indicates the uneven distribution of computational resources among tasks. Fig. 9c demonstrates the analyses of the fairness index of the MoECO algorithm against similar competitors. The simulation results reveal the efficiency of the proposed algorithm in obtaining high FI values against the total number of tasks ranging from 50–500. This means that the resources are efficiently distributed among IoT tasks, preventing resource starvation and resource bottlenecks.

Tables 4 and 5 unfold the comparative and performance analysis of MoECO and similar benchmark algorithms, respectively. The numerical data reveals that the proposed algorithm performs well, with improvements of up to 20% in terms of transmission latency, energy consumption, task completion rate, and fairness index. In Fig. 10, the convergence behavior of MoECO and baseline scheduling algorithms is presented. The results show that our proposed scheduling algorithm exhibits fast, stable, and reliable convergence behavior while reaching the best fitness value (optimal solution). Particularly, the MoECO algorithm obtains the optimal fitness value much faster than the competitors. This implies that our proposed solution has a high convergence speed compared to other algorithms.

To validate the reliability of the observed performance improvements, Table 6 demonstrates the statistical significance test result between proposed scheme and other baseline methods across two performance metrics, i.e., energy consumption and transmission latency. We employed an MANOVA test to jointly evaluate the differences in both performance metrics, while Cohen’s d was used to measure the magnitude of improvement (effect size). The p-values indicate that MoECO demonstrates statistically significant improvements (p < 0.05) over all compared algorithm. The effect size (Cohen’s d) values complement these results by quantifying the magnitude of improvement. Overall, both statistical significance and effect size analyses confirm that MoECO achieves statistically reliable and practically meaningful improvements over benchmark methods.

Table 7 presents the convergence behavior of the proposed and baseline methods. In this table, we record the most important parameters of convergence behavior, i.e., minimum fitness value (columns 4th and 8th), maximum fitness value (columns 3rd and 7th), and standard deviation (columns 5th and 9th). These values are recorded for 5 and 10 computational nodes under a workload of 100 and 300 tasks. The convergence behavior of the algorithm indicates the reliability and stability of its performance, where a decrease in standard deviation is an argument that our proposed solution consistently and quickly converges to the optimal solution across different iterations. These features are crucial for task scheduling in fog computing environments, where consistent and reliable performance is required to optimize resource allocation and workload balancing.

These capabilities of the presented algorithm make it an efficient and robust solution for solving complex scheduling in a dynamic computing environment.

To measure the scalability of the proposed scheduling algorithm, both the number of computational nodes and tasks are progressively increased within the cloud-fog hierarchy. Based on the results, as the workloads increased exponentially (50–500), the proposed algorithm maintained a monotonically increasing behavior with a gradual increase in energy consumption and transmission latency. Upon increasing the workloads, MoECO manage such increase via multi-objective decomposition and parallel execution mechanism. This enables the algorithm to compute the objective values one by one instead of computing altogether in one massive problem. The comparative baseline methods demonstrate a sharp rise in energy consumption and delay after 300 tasks, while MoECO scales in a linear-fashion, sustain convergence stability and ensures consistent task distribution across all the computational nodes. This is attributed to the adaptive step-length control and leader–follower coordination mechanism, which prevent premature convergence and ensure balanced exploration across distributed search agents. For large scale IoT networks, this characteristic is particularly valuable because IoT environments often experience bursty workloads, the proposed algorithm can efficiently manage such variation without the loss of convergence stability.

From the results, we conclude that our proposed algorithm efficiently addressed the NP-hard optimization problem, i.e., task scheduling in fog computing. Its success is due to the high convergence speed, low computation time, and diversity in local and global search capabilities. This helps the algorithm to provide the global optimal solution. Given the efficient results of the proposed algorithm, we can successfully apply it to real-world problems. For instance, we can employ the algorithm (after required modifications) in the IoMT environment, where tasks need an immediate response and must be completed within the required deadline. As our proposed solution provides minimum delay and a higher task completion rate, we can efficiently utilize the algorithm in the medical environment for patient monitoring.