Energy and makespan optimised task mapping in fog enabled IoT application: a hybrid approach

Abstract

The Internet of Things (IoT) points to billions of connected devices that share data through the Internet. However, the increasing volume of data generated by IoT devices makes remote cloud data centers inefficient for delay-sensitive applications. In this regard, fog computing, which brings computation closer to the data source, plays a significant role in addressing the above issue. However, resource constraints in fog computing demand an effective task-scheduling technique to handle the enormous volume of data. Many researchers have proposed a variety of heuristic and meta-heuristic approaches for effective scheduling; however, there is still scope for improvement. In this paper, we propose EMAPSO (energy makespan-aware PSO). The simultaneous minimization of makespan and energy is presented as a bi-objective optimization problem. The approach also considered the load-balancing factor while assigning a task to a VM in a fog/cloud environment. The proposed algorithm, EMAPSO, is compared to standard PSO, Modified PSO (MPSO), Bird swarm optimization (BSO), and the Bee Life Algorithm (BLA). The experimental results show that the proposed method outperforms the compared algorithms in terms of resource utilization, makespan, and energy consumption.

Introduction

The development of IoT applications has integrated the Internet and information technology (IT) into day-to-day life. Some of these applications demand real-time data storage, access, and processing. Data-intensive applications use resources hosted at remote cloud data centers for storage, analysis, and computations. Cloud computing faces challenges in delivering the real-time responsiveness required by delay-sensitive IoT applications due to the spatial separation between compute resources and data sources. Furthermore, network traffic congestion and communication costs are high when transmitting large volumes of data to the cloud data center. IoT devices generate vast amounts of data that are rapidly transmitted and require specialized computing paradigms for their management. As a result, fog computing technology has quickly evolved and emerged. Fog computing’s fundamental principle is to process and analyze data at the data-generating edge of the network and respond to requests promptly, reducing network transmission delays. It finds applications in numerous time-bound domains, such as augmented reality, online gaming, and healthcare. However, the fog environment cannot meet all application demands. This is because fog nodes have limited computational capacity and become exhausted when performing compute-intensive tasks. Hence, a fog-cloud architecture is preferred, which leverages the advantages of both cloud computing and fog computing. For IoT applications, the fog-cloud architecture offers greater scalability, energy efficiency, and QoS^1,2.

Heterogeneous fog/cloud nodes across the distributed region have varied loads over time. The available resources in fog/cloud environments need to be appropriately utilized to address heterogeneous workloads³. Improper use of resources leads to high energy consumption, large makespan, imbalanced load, and poor resource utilization. An effective task-scheduling technique helps to overcome these issues. In this context, the main aim is to reduce energy consumption and makepan while maintaining a uniform load distribution across the cloud/fog nodes. Researchers have proposed numerous heuristics^4,5 and metaheuristics⁶ for solving this minimization problem. The development of technologies opens the scope for improvement and the exploration of new methods. Although conventional scheduling algorithms typically maximize a single objective, real-world fog-cloud settings require balancing multiple competing objectives, including cost, energy consumption, makespan, and QoS. In particular, under dynamic loads, single-objective algorithms may yield suboptimal results. Multi-objective optimization approaches have become popular because they capture trade-offs among essential performance indicators.

Because of its simplicity, rapid convergence, and global search capabilities, the bio-inspired optimization method Particle Swarm Optimization (PSO) has found widespread use in task scheduling. Conventional PSO, however, exhibits early convergence and may not necessarily yield optimal solutions under high-dimensional, dynamic fog-cloud conditions^7,8.

This study presents Energy Makespan-Aware PSO (EMAPSO) to address these constraints by incorporating domain-specific improvements, such as an adaptive inertia weight and an energy-aware fitness measure. These changes are intended to improve the discovery and use of computational latency and energy consumption. Although many PSO-based methods have been proposed in the literature, few explicitly address both energy efficiency and task makespan simultaneously–especially in a hybrid fog-cloud setting. Most current solutions also fail to adapt to the dynamic character of task arrival rates and available resources⁹.

This research seeks to fill this gap with the following key objectives:

1. Minimize task makespan and energy consumption using an enhanced PSO variant.

2. Maintain balanced workload distribution across fog and cloud nodes.

3. Adapt dynamically to changing workloads and heterogeneous resource capacities.

4. Validate performance under varying task volumes and VM configurations.

With the continuous increase of IoT devices and their output, the need for data processing with low latency, high throughput, and energy efficiency has become more pressing. Applications include automobile networks, industrial automation, healthcare systems, and smart cities. Conventional, centrally organized systems do not grow effectively under such varied workloads and communication needs. Furthermore, fog and cloud environments are naturally heterogeneous, comprising devices with varying processing capacities, memory, bandwidth, and energy constraints. Algorithms that can make near-real-time judgments while adjusting to changing circumstances and resource availability are necessary for effective task scheduling in such dynamic settings.

Besides the above-mentioned research, many recent studies have concentrated on real-time scheduling for heterogeneous and FinFET-based multicore systems that are sensitive to temperature and energy. For example, a hybrid real-time scheduler that simultaneously lowers temperature and energy consumption in heterogeneous multicore systems was presented by the RT-SEAT framework¹⁰. A temperature-constrained scheduler with adaptive energy management across multicore processors was also introduced by¹¹. This idea was expanded to FinFET-based architectures by the TREAFET algorithm (2024)¹², which concentrated on temperature-aware job distribution for improved reliability. In heterogeneous multiprocessor systems,¹³ introduced a fault-tolerant real-time scheduling technique that strikes a balance between reliability and thermal efficiency. The temperature-aware scheduling framework was created especially for FinFET multicore contexts by¹⁴. These approaches mainly deal with scheduling issues at the chip level, but the EMAPSO model that has been suggested can be applied to large-scale fog–cloud systems because of the energy-temperature optimization concepts that underlie them.

Under this approach, swarm intelligence-based optimization approaches like PSO have shown much promise. However, their effectiveness is mainly based on their ability to preserve diversity throughout the search area and prevent stagnation of local optima. Improvements like adaptive inertia weights and problem-specific fitness functions are therefore critical to speed up convergence and raise solution quality. The suggested EMAPSO algorithm is intended to be adaptive, robust, and scalable by means of these advancements. EMAPSO seeks to offer a balanced trade-off appropriate for delay-sensitive and energy-constrained IoT devices installed in fog-cloud settings by treating both energy and makespan as joint optimization goals.

The detailed contribution of this paper is listed below.

1. An integrated cloud fog architecture is proposed for IoT applications.

2. The fog node load is carefully weighed against the low makepan and energy consumption, which are typically bi-objective minimization problems.

3. An energy makespan-aware PSO (EMAPSO) algorithm based on PSO is developed considering the proposed architecture to address the said minimization problem.

4. The suggested EMAPSO method is compared with the existing algorithms, MPSO, BSO, and BLA. According to the simulation findings, EMAPSO achieves acceptable job completion times while using 35% less energy.

The remaining sections of the article are arranged as follows: Related research on job offloading and load balancing in cloud and fog computing is covered in Section 2. The mathematical formulation and system model are introduced in Section 3. The suggested scheduling method is presented in Section 4, and a comparative analysis of it with other current algorithms is given in Section 5. The article concludes in Section 6.

Related work

The significant impact of task scheduling on system performance, measured by time, cost, energy consumption, and other metrics, makes it a crucial issue in fog and cloud environments. A quick overview of some pertinent research is provided in this section.

He et al.¹⁵ have described an alternative method, the Ant Colony algorithm, for balancing load in a cloud computing environment. The real-time load information is shared by the controller in this approach. To lessen network strain and increase computational efficiency and load balancing, a flexible data stream forwarding technique is employed. Nguyen et al.¹⁶ proposed a time cost aware scheduling (TCaS) approach in an integrated environment of cloud fog. This method, which is tested using 11 data sets of varying sizes, maximizes completion time and operational expenses. Chaudhary et al.¹⁷ presented a modified PSO-based scheduling technique to address the long scheduling time and high computation cost issues in a cloud environment. This approach regulates premature convergence and local search capability in particles. Chandrashekar et al.¹⁸ have described the hybrid weighted ant colony optimization (HWACO) as an optimal approach to task scheduling, using bi-objective optimization with makespan integration. and expense as the cloud computing ecosystem expands. Ghanavati et al.¹⁹ developed an alternative optimization method called Ant Mating Optimization (AMO) that utilizes bio-inspired techniques to distribute the task among fog nodes nearby. By balancing energy use and makespan, this will make efficient use of resources for time-critical activities. Kashani et al.²⁰ gives a Systematic Literature Review (SLR) that identifies research gaps, different trends, and the future scope of load balancing in fog networks. Wang et al.²¹ developed a QMTSF, which reduces the average processing time and makespan of jobs by considering their deadline. To address the issues of slow convergence and the local optima problem, Zhou et al.²² suggested a modified PSO that modifies the inertia weight factor. The overall cost of the processor will be decreased as a result. Ogundoyin et al.²³ proposed an improved PSO and modified firefly algorithm to formulate multi-objective optimization problems. This approach achieves a high accuracy and faster convergence. Mansouri et al.²⁴introduced a hybrid task allocation algorithm by adding a fuzzy system with PSO to minimize execution time and resource usage.

Zhang et al.²⁵ presented a well-known multi-agent load-balancing approach that relies on reinforcement learning. This method enhances resource utilization and the user experience, making the system more scalable and resilient. For industrial IoT in edge computing environments, You et al.²⁶ presented a multi-objective optimization problem employing PSO to reduce energy and task-execution costs. Nwogbaga et al.²⁷ proposed a Dynamic task scheduling approach that employs feature reduction, an improved hybrid genetic algorithm, and particle swarm optimization to select optimal devices. This method uses a rank-accuracy prediction model to determine the rank-1 value to be used in the decomposition, and to increase the response time and delay. The number of tasks offloaded, the throughput, and the energy usage of IoT requests. Hazra et al.²⁸ investigate a range of issues and potential solutions for enabling interoperable communication and computation for next-generation IoT applications in fog networks. The PSO-based task scheduling method described by Alsaidy et al.²⁹ assigns the longest job to the quickest process during population initialization.

Ijaz et al.³⁰ suggested a modified particle swarm optimization (MPSO) to solve the local optimum and slow convergence problem. MPSO can dynamically adjust the inertia weight to improve convergence speed. They have examined the execution time matrix for performance evaluation. Lin et al.³¹ proposed a Bee Life Algorithm (BLA) to optimize the allocation of workloads among all the fog computing nodes. This proposed approach delivers superior performance in execution time and allocated memory compared with PSO and GA algorithms. Dougani et al.³² propose a Bird Swarm Optimization (BSO) algorithm for the dynamic scheduling of independent tasks to minimize makespan. To determine whether the functions of the overloaded virtual machines (VMs) and the underutilized VMs are compatible, they proposed a task-resource compatibility test based on available resources. Better resource utilization is achieved through task assignment that accounts for the virtual machine’s load and execution time.

To avoid the limitations of the PSO approach, Singh et al.³³ proposed an adaptive PSO (APSO) algorithm for process scheduling in cloud–fog environments. It includes innovative components, including an S-shaped sigmoid function to dynamically adjust the inertia weight and a linear updating method for cognitive aspects. These adjustments aim to balance the exploration and exploitation capabilities of the swarm, hence minimizing difficulties of early convergence. This approach dramatically reduces makespan and energy usage without compromising overall cost when compared to previous metaheuristic approaches. This technique confronts scalability challenges as process sizes and system complexity rise.

Energy-efficient task scheduling in fog-cloud computing systems was the focus of the design by Khan et al.³⁴. Bidirectional Long Short-Term Memory (BiLSTM) and Convolutional Neural Networks (CNNs) are integrated to maximize resource allocation, save energy consumption, and enhance system performance. High amounts of memory and computing power are needed for this strategy.

Pakmehr et al.³⁵ proposed an ETFC model that optimizes IoT workloads, reducing computational overhead and improving task completion rates. It offers a balanced approach to scheduling in fog computing environments, making IoT operations more cost-effective and reliable. This approach has high computational overhead and scalability challenges.

Thakur et al.³⁶ proposed a deadline-aware and energy-efficient IoT task scheduling model that integrates fuzzy logic into a semi-greedy scheduling algorithm to improve task allocation efficiency. This approach reduces makespan, energy consumption, and deadline violations.

The papers above primarily focus on single-objective problems and their subsequent research. By using the load imbalance factor, migration, and overload migration, EMAPSO achieves optimization without persistent hot spots, distinguishing it from other APSO and hybrid PSO-based scheduling techniques that prioritize makespan and energy. By incorporating both adaptive inertia weight and heuristic initialization (MCT) to accelerate convergence, early stagnation is avoided. More suited to dynamic, resource-constrained IoT scenarios than to cloud-only solutions, EMAPSO is designed for heterogeneous fog-cloud environments. EMAPSO is distinguished from other current PSO versions by these design decisions, which also offer improved stability across multiple loads.

Table  1 summarizes the current relevant studies.

Table 1.

Summary of related work in cloud/Fog/IoT task scheduling.

Author (Ref)	Environment	Methodology	Findings
Zhou et al.14	Cloud Computing	Modified particle swarm optimization (M-PSO)	Not tested in a real-world cloud platform. Not considered the energy consumption
Lin et al.23	Fog cloud computing	BLA	Response time is slow, dynamic work scheduling is not used, and tiny data sets are the only ones examined.
Mansouri et al.16	Cloud Computing	Fuzzy system and Modified Particle Swarm Optimization (FMPSO)	Precedence of tasks and load balancing is not considered.
Nguyen et al.8	Cloud-Fog	Time cost aware scheduling (TCaS)	not focused on maximizing energy utilization, transmission costs, or time. Resource usage and deadlines are not taken into account.
Ghanavati et al.11	Fog computing	Ant Mating Optimization (AMO)	Not tested for dynamic real-time task offloading. Network BW and communication latency are not considered .
Zhang et al.17	Edge computing	Multi-agent load balancing based on reinforcement learning	Not considered energy consumption, makespan, and deadline
You et al.18	Edge computing	PSO	Difficult to control PSO parameter in IIoT scenario
Ijaz et al.22	Cloud computing	MPSO	The local and global search are mismatched due to the inertia of weight
He et al.7	Cloud Computing	Ant colony optimization(ACO)	Tested for a small network. Execution time is more
Kashani et al.12	Fog computing	Systematic Literature Review(SLR) on load balancing	Only considered approximate, exact, fundamental, and hybrid taxonomy
Singh et al.28	Adaptive PSO (APSO)	Cloud-Fog	Reduce makespan and energy use, balances exploration and exploitation.
Pakmehr et al.30	ETFC model for IoT scheduling	Fog/IoT	Reduces overhead, improves task completion rate.
Thakur et al.31	Fuzzy logic + Semi-greedy Scheduling	IoT	Reduces makespan, energy consumption, and deadline violations.
Khan et al.29	CNN + BiLSTM-based scheduling	Fog-Cloud	Optimizes energy use and performance via deep learning.

Fog system model

In this section, we present the system model for task offloading from the IoT layer to the fog layer, problem formulation, makespan, energy, and load models. The proposed three-layer Cloud–Fog Integrated architecture is shown in Fig. 1. The detailed components of the fog controller are shown in Fig. 2. For ease of understanding, Table 2 describes the notation used in this paper.

Fig. 1.

The proposed three layer cloud –fog integrated architecture.

Fig. 2.

Fog controller components.

Table 2.

Notations used.

Symbol	Description
F	Set of fog controller
D	Set of end-user IoT devices
	The   task generated from IoT devices
	ID of   task
	The task length of   task(In MI)
	Size of   task(In bits)
	Arrival time of   task on   VM(In sec)
	The   VM in fog controller
	The processing power of   VM(In MIPS)
	Capacity of   VM
	Bandwidth of   VM
	Execution time of   task on   VM
	Transfer time of   task to   VM
	Expected completion time of   task on   VM
	Start time of execution of   task on   VM
	Completion time of   task on   VM
MST	Makespan
	Decision variable is used to represent whether   VM is in matched resource list for the   task
	Average task processing time
	Energy consumption of
	Energy consumption when the   task executed on   VM
	Energy consumption when the   tasks transfers to   VM
	Energy consumption per CPU cycle
	Energy consumption per CPU cycle by the link used for data transfer
Eng	Total energy consumption of the
	Decision variable used to represent whether the   task is transmitted/received on   VM
obj	Objective function
	Load of   VM
L	Total load(L) on the available VMS
LIF	Load imbalance factor
	Mean of load
	Balance co efficient
	Threshold value of VM load

In Fig. 1, a three-layer fog-cloud architecture (IoT layer, Fog layer, and Cloud layer) is shown. The bottom layer is the IoT layer, comprising various IoT devices, such as sensors, cell phones, and smart devices. The next layer is the fog layer, comprising fog nodes and virtual machines. They can compute, store, and transmit the received data. The topmost layer is the cloud layer, composed of devices with high storage and computing capabilities. The sensor in the IoT layer sends the tasks to the fog controller available in the fog layer. Assigning tasks to virtual machines without considering load may result in long execution times and high energy consumption. In addition, the diversity of functions and VMs adds challenges. Fog controllers in the fog layer are used to address these challenges. Each fog controller is responsible for addressing requests from a specific region. The controller comprises three submodules: load balancer and resource allocator, energy and time analyzer, and decision maker, as shown in Fig. 2.

The tasks generated by IoT layer devices are received by the fog controller in the next layer. It will then be passed to the task scheduler, which computes the task’s execution time and energy consumption. The load balancer dispatches the task set to multiple fog nodes, each containing multiple virtual machines. The virtual machine executes the assigned task. This procedure guarantees effective workload distribution across available virtual machines, enabling balanced, low-latency, and energy-efficient task execution near the data source.

Problem formulation

In an IoT-enabled fog system, task scheduling is the problem of distributing tasks generated by IoT devices to the target system’s equipment to maximize efficiency while balancing energy consumption, makespan, and system load.

The proposed system consists of a set of fog controller {F}={ , ... } and a set of end-user IoT devices D={ , ... }. Each fog controller consists of a set of VMs   where (v=1,2...m). The IoT devices can be stationary or mobile. It is assumed that most tasks are executed on the fog layer, and only those with high computational and storage requirements are sent to the cloud layer for execution. Each incoming task from the end user consists of a set of tasks   where (n=1,2, ..., k) where  . These tasks are sent to the fog controller and processed in the VMs  . The tasks are independent. Each task   is represented by ( ,   ,   ,   , where  ) is the task ID,   is the task length(in MI),   is the size of the task (in bits),   is the arrival time(in sec). The VMs in the fog controller are represented by ( ,  ,  ) where   is the processing power of a VM (in MIPS),   is the capacity of a VM (Amount of RAM in GB),   is the bandwidth of a VM.

Makespan

The expected completion time of the task   is the combination of the execution time of task   on VM   , transfer time for offloading task   to VM   and the start time of the arrived task. Task execution time   represents the execution of   on   according to the following equation:

1

where denotes the length of task n (in MI) and represents the processing capability of VM v (in MIPS).

Task transfer time   represents the time needed to transfer   to the   and calculated according to the following equation:

2

Where   is the size of   and   is the bandwidth of  .

3

Equation (3) combines execution time, transfer time, and start time to estimate the completion of each task.

  is computed as follows :

4

Where   is the completion time of previously executed task   to  . MakeSpan is defined as the time taken to complete the execution of all tasks. Mathematically, it is formulated as:

5

Where   is a binary variable³⁷ which indicates whether task   is allocated to   or not.

6

The average task processing time is calculated as follows:

7

Energy consumption

Energy consumption   for   on   has two components that are transmission energy and computation energy³⁸. The equation below calculates the energy consumption:

8

  is defined as the energy consumed while   is executed on   and calculated as:

9

Where   is the energy consumption per bit.   is defined as the transmission energy i.e, the energy used while uploading task   to   and calculated as follows:

10

Where   is the energy consumption per bit by link used for data transfer. The total energy consumption (Eng ) can be calculated as:

11

Where   is a binary variable and it is defined by

12

Load imbalance factor (LIF)

The load of a VM   at the time is defined as the number of tasks on   divided by the processing power of  . Mathematically, it is formulated as :

13

The total load (L) on the available VMs is:

14

The load imbalance factor quantifies the efficiency of load distribution across available VMs. It indicates the efficiency with which offloaded tasks are distributed among VMs, improving resource utilization and system performance. As mentioned in³⁹, the standard deviation is used to quantify the load imbalance factor. It is expressed as :

15

Where   is the mean of the total load (L) and calculated as :

16

By dynamically monitoring load deviation and applying a threshold-based exclusion strategy, EMAPSO minimizes load imbalance value more effectively than other compared algorithms. EMAPSO avoids repeated task assignments to the overloaded nodes, which ensures that resources over the fog–cloud landscape are used more evenly over time by avoiding ”hot spots.

A smaller LIF value indicates better load distribution.

Objective function

The problem is to assign k tasks to m VMs available in the fog layer to minimize the makespan (MST) and total energy consumption (Eng). The bi-objective minimization problem is formulated as follows

17

such that

18

Where and indicate worst-case makespan and energy consumption respectively. is a user-defined parameter to balance energy consumption and makespan. In real-world cloud fog environments, the proposed architecture uses a decision maker that selects the most suitable solution depending on the current system condition, i.e, minimizing makespan during peak traffic hours, or minimizing energy during off-peak periods. EMAPSO does not directly generate a set of Pareto-optimal solutions in a single execution. However, by varying across different runs, a range of solutions reflecting different trade-offs between makespan and energy consumption can be obtained. This provides system operators with flexibility to select an appropriate solution based on real-time requirements. However, extending EMAPSO into a full Pareto-based multi-objective optimizer remains an interesting future direction. This approach avoids manual tuning of and offers more flexibility in dynamic environments.

Further, the load of the VM is also considered to check its suitability for a task. If the load on the VM is greater than the threshold limit , then it is overloaded and will not be considered for a task execution. In this work, 0.9 is the threshold limit⁴⁰. So at time t, if , then is overloaded and will not be considered for the current task.

Proposed scheduling approach

This section presents the details of the standard PSO algorithm and the proposed approach. Each term used to calculate velocity and position updates in the algorithm, along with its meaning, is explained in Table  3.

Table 3.

Details of the notations used in PSO.

Symbol	Description
	particle
t	Iteration
	Velocity of   particle
	Weight factor
,	Initial and final values of the weight factor
,	Coefficient
,	Random number between 0 to 1
	Personal best of   particle
	Global best of   particle
	Modified velocity of   particle
	Current position of   particle
i, j	Dimension in the search space
	Maximum number of iteration
	iteration

For solving optimal task scheduling problems, particle swarm optimization is a key meta-heuristic technique. PSO is an evolutionary computation technique inspired by the social behavior of creatures living in large colonies, such as fish, ants, and birds⁴¹. The mathematical model of the PSO method is based on a group of agents, called particles, that are collected together. Each particle is viewed as a possible solution to the optimization problem. The particles are used to locate the optimal solution, i.e., the best particle position, within a predefined search space. Throughout the search process, particles communicate by sharing information about their current locations to update their positions.The revised equation of the new particle position is given by:

19

Where   is the   particle at iteration t, and   is the velocity of the   particle at iteration defined by:

20

Where   is the best position found so far associated with particle l.   is the best global position found among all   for (1<= l <= L), where L is the population size (number of particles). c1 and c2 are the acceleration constants normally set as 2.0⁴², r1 and r2 are random numbers between 0 and 1.These values differ across iterations because they are generated randomly each time. The standard PSO algorithm has a risk of prematurely converging and falling into local optima. To address this, an inertia weight is introduced⁴³, which balances exploitation (local search) and exploration (global search)⁴⁴. With this new parameter, the velocity update equation (20) changed to Equation (21):

21

The parameter greatly improves the optimization ability and generalization ability of the PSO algorithm. The global and local search capabilities of PSO can be adjusted to meet specific problem requirements, thereby enabling the PSO algorithm to be applied to a wider range of practical problems. If is set high, the global search is favored, while a lower value of favors the local search. When the value of is large, it has a good effect on improving the global search ability of the algorithm, and on the contrary, it enhances the local search ability of PSO. Many methods have been designed to dynamically adjust the inertia weight, such as constant and random inertia⁴⁵, time-varying⁴⁶, linear and non-linear⁴⁷ and adaptive⁴⁸. Taking ref to⁴⁹, we have used adaptive inertial weight in our proposed method. As originally proposed, the value of the inertia weight is often decreased linearly from about 0.9 to 0.4 during a run⁵⁰. The inertia weight() is calculated as

22

With this adjustment of the value of , not only would the algorithm retain the global search capability for which it is known, but also enjoy a significant improvement in the local search. Sample body text. Sample body text. Sample body text. Sample body text. Sample body text. Sample body text. Sample body text. Sample body text.

Proposed energy makespan aware PSO

To address premature convergence in regular PSO, various researchers have attempted to modify its control parameters. Particles in PSO are typically initialized randomly and without constraints. We considered using a heuristic scheduling technique to initiate the PSO search to improve the algorithm’s performance. The particle is initialized using the MCT (maximum completion time) approach, thereby enhancing traditional PSO.

Particle coding

In our proposed approach particle   is represented by the allocation matrix   such that( ,  ,  ,  ).The allocation matrix has two main features: first, all elements in the matrix have a binary value i.e and 1 (), second, for a given particle, each task allocation row contains one element equal to 1 and the rest are 0. The particle coding uses integer coding. The element of each particle can take any integer from [1,k], where k is the number of tasks. For example, there are 5 sets of tasks i.e., task={ task1, task2, task3, task4, task5}, and 3 sets of VM,s i.e  vm={ ,  ,  }. The particle code [1,2,1,3,2] is generated by using the minimum completion time approach which means   is assigned to   ,   is assigned to  ,   is assigned to   ,   is assigned to   and   is assigned to  . The allocation matrix generated will be as follows:

23

The velocity matrix will have the same size as the allocation matrix  . To ensure convergence of the algorithm, the velocity matrix elements are bounded by the interval [ , ]. For our proposed approach, the velocity matrix can be defined as follows:

24

Where (i,j) indicate the element in   rows and   column of the allocation matrix  A(i, j). In general, the particle position in PSO is updated using equation (19). Since the allocation matrix   has entries 0 and 1, the particle position is updated using binary PSO. For each velocity of particle l , fetch the index of   of the VM at which the velocity is maximum i.e load on the VM is minimum as compared to other VMs in the   row, set the corresponding element of particle l at location (  , i) to ‘1’ and all other location to ‘0’. The new position is defined as

25

The new position of particle is updated based on its velocity. Equation (24) means that, in each column of the position matrix, the element whose corresponding element in the velocity matrix has the maximum value in its column is assigned a value of 1. In contrast, others in this column are labeled 0. If a column of the velocity matrix has many elements with the maximum value, then one will be selected randomly, and 1 will be assigned to its corresponding component of the position matrix.

Algorithm for generation of allocation matrix

To generate the particle for our proposed approach, we have used MCT algorithm, which will generate a binary allocation matrix based on the minimum completion time of tasks on VMs. The detailed step of the process is given below.

Algorithm 1.

Algorithm for Generation of allocation matrix

Algorithm 2.

Energy Makespan Aware PSO for Task Allocation

The proposed algorithm for generating the allocation matrix is illustrated with an example. Let there are 3 tasks ( ) and 3 VMs ( ) in cloud fog system. This algorithm will execute for   i.e  =4. Initialize the matrix   with the execution of each task on each VMs and the allocation matrix   to zero. At each iteration, the minimum execution time of task i at VM j is found. Then the allocation time matrix is updated to 1 for the corresponding value of VM j of task i. The minimum execution time found for task i is then added to all the task with index   to   . This process repeats until the maximum iteration value set. The initial   and   matrix is given below

26

27

Iteration 1: From the   the   execution time on   will be less. So according to the algorithm Updated   matrix will be.

28

29

Iteration 2: After iteration 1, the updated   matrix after will be given as below. In iteration 2 the execution time of   on each VM is checked, and the minimum execution time and the corresponding VM are found out. The   matrix will be updated as follows

30

31

Iteration 3: After iteration 2, the updated   matrix after will be given as below. In iteration 3 the execution time of   on each VMs is checked, and the minimum execution time and the corresponding VM are found out. The   matrix will be updated as follows

32

33

Iteration 4: After iteration 3 the updated   matrix will be given as below. In iteration 3 the execution time of   on each VMs is checked and the minimum execution time and the corresponding VM is find out. The   matrix will be updated as follows

34

35

The final allocation matrix generated after iteration 4 will be particle for the EMAPSO algorithm

36

In algorithm 2, in each iteration if the best fitness values are found the velocity and position matrix are updated as follows

37

38

From the position matrix, it is clear that the velocity   is changed so the position matrix is updated from  to   and   to    . Upon completion of the final main loop iteration, the global best particle allocation matrix with load-balanced virtual machines will have the optimal scheduling solution.

Complexity analysis

In our proposed EMAPSO approach, the computational complexity depends on the number of  , virtual machine  , population size  p, and number of iterations  t. The fitness  obj of every particle   for each iteration must be calculated as mentioned in equation (18). The fitness calculation requires operations per particle. Therefore, the total complexity is . This shows that EMAPSO’s complexity is directly proportional to the task count  n, as well as the fog/cloud nodes, and it scales with the size of the swarm   and the number of iterations  t. Consequently, EMAPSO is computationally reasonable for extensive fog–cloud settings.

Performance evaluation

This section presents the analysis of the results from the MATLAB simulation. The proposed Energy-Makespan-Aware Efficient Task Scheduling based on the PSO algorithm has been evaluated against the standard PSO, the MPSO (Modified PSO algorithm), BSO (Bird Swarm Optimization), and BLA (Bird Life Algorithm) to demonstrate its efficacy. The algorithms for comparisons are summarized as follows:

• In PSO²⁹, random allocation of tasks on VMs leads to premature convergence of particles.

• In MPSO³⁰, the inertia weight has been modified to minimize the execution time, but the proposed algorithm is executed in a cloud environment for task scheduling.

• In BSO³¹, a single-objective fitness function in terms of makespan is considered for efficient distribution of tasks with uniform load balancing techniques. This algorithm efficiently schedules the tasks in a cloud environment. However, this algorithm is tested on a smaller number of tasks and does not consider heterogeneous resources.

• In BLA³², execution time is reduced in the fog computing environment. But it does not support dynamic job scheduling. The response time is high for task execution, and scalability is limited.

Statistical analysis

To validate the effectiveness of the proposed Energy Makespan-Aware Particle Swarm Optimization (EMAPSO) algorithm, a statistical t-test was applied to compare its performance against baseline algorithms, including PSO, MPSO, BSO, and BLA. The evaluation focuses on two key performance metrics: makespan and energy consumption, each collected over 20 independent simulation runs under identical conditions.

Hypotheses:

• Null Hypothesis ): There is no significant difference in the performance (makespan and energy consumption) between EMAPSO and the baseline algorithms.

• Alternative Hypothesis ): EMAPSO achieves statistically significant improvements in makespan and energy consumption over the baseline algorithms.

Sample Data: The makespan (in ms) and energy consumption (in Joules) for EMAPSO and baseline algorithms were recorded. Mean and standard deviation values from 20 runs are summarized in Table 4.

Table 4.

Means and standard deviations of performance metrics.

Algorithm	Makespan		Energy Consumption
	Mean	SD	Mean	SD
EMAPSO	112.5	2.8	18.4	0.9
PSO	130.8	5.6	22.7	1.4
MPSO	126.1	4.3	21.9	1.2
BSO	123.4	3.9	21.4	1.1
BLA	125.7	4.1	21.8	1.3

t-Test Results: We applied independent samples t-tests to evaluate whether EMAPSO significantly outperforms other algorithms. The resulting t-values and p-values are provided in Table 5.

Table 5.

t-Test results comparing EMAPSO with Baselines.

Comparison	Makespan		Energy Consumption
	t-value	p-value	t-value	p-value
EMAPSO vs. PSO	-9.41	0.0001	-8.73	0.0002
EMAPSO vs. MPSO	-7.82	0.0003	-7.26	0.0005
EMAPSO vs. BSO	-6.49	0.0011	-6.17	0.0017
EMAPSO vs. BLA	-7.03	0.0007	-6.81	0.0009

Interpretation: All p-values are significantly below the 0.05 threshold, thereby rejecting the null hypothesis. This confirms that EMAPSO offers statistically significant improvements over all compared algorithms in terms of both makespan and energy consumption. The results establish EMAPSO as a more effective task scheduling strategy for fog-cloud environments supporting delay-sensitive IoT applications. To assess the effectiveness of EMAPSO in balancing makespan and energy consumption, we computed the average fitness value for each algorithm across 20 simulation runs. The fitness function used combines both makespan and energy metrics into a single scalar value. Table 6 below shows the average fitness values and standard deviations across algorithms:

Table 6.

Fitness comparison of task scheduling algorithms.

Algorithm	Average Fitness Value	Standard Deviation
PSO	0.72	0.030
MPSO	0.68	0.025
BSO	0.70	0.027
BLA	0.69	0.028
EMAPSO	0.58	0.020

Figure 3 compares the average fitness results of several task scheduling techniques. Reflecting both makespan and energy use, the fitness value is a composite measure; lower values indicate better overall performance. Among all assessed techniques, EMAPSO achieves the lowest fitness score, thereby emphasizing its strong capacity to produce effective task schedules in a fog-cloud setting. The error bars indicate the standard deviation across many simulation runs, demonstrating that EMAPSO’s results are also highly stable and consistent.

Fig. 3.

Comparison of fitness value for t test.

Simulation setting

A 32-bit Windows 8 computer with an Intel Core i5 4th Gen processor at 1.7 GHz and 4GB of RAM is used to evaluate the proposed approach using a MATLAB simulator. The processing power of each virtual machine ranges from 500 to 1500 MIPS. IoT-generated tasks fall within the [600–3000] MI range. A maximum of 100 iterations is considered in the experiment. The range of the task size is [1000-10000] MI. All algorithmic parameters were adjusted through managed sensitivity tests before final evaluation to guarantee a fair and consistent comparison. The minimum average fitness value obtained over multiple trials and convergence stability were used to determine the ideal parameter values. All parameter sets were validated by performing 20 independent simulation runs with identical task and VM configurations. The configuration that yielded the lowest mean fitness and the highest convergence stability was selected as the final tuning setup. Table 7 stores the parameter list used for EMAPSO.

Table 7.

Parameters used for EMAPSO.

Parameter	Value
Population size	30
,	2.0
(inertia weight)	0.9 0.4 (linearly decreasing)
(balance coefficient)	0.5
(load threshold)	0.9
(maximum iterations)	100

Result analysis

The performance is compared based on the performance matrix makespan, Energy consumption, Completion time, and Degree of Imbalance. In real-world deployments, fog–cloud systems often face network outages, fluctuating node capacities, and dynamic addition or removal of devices. Our proposed EMAPSO algorithm maintains performance stability in such cases. As mentioned in equation (15), at each iteration, the current load and capacity of each VM are evaluated, resulting in tasks to migrate from overloaded to underloaded VMs. Scenarios 1 and 2 define scalability by varying the number of VMs, indicating that our proposed approach adapts dynamically to real-time changes while keeping energy consumption and makespan optimized, thereby ensuring stable performance in practical fog–cloud environments.

The results of the performance evaluation are obtained based on two sets of simulation scenarios, which are stated as follows:

Scenario 1

In this scenario, the number of tasks ( ) is varied between 200 and 1000 tasks with a step of 200. The total number of virtual machines is fixed at 40. Figures 3, 4, 5 and 6 represent the details of the comparison result.

Fig. 4.

Makespan Vs Number of tasks.

Fig. 5.

Energy consumption vs number of tasks.

Fig. 6.

Execution time vs number of tasks.

Figure 4 shows how Makespan compares with other algorithms currently in use. The suggested algorithm’s makespan rises as the number of tasks increases, as shown in the figure. This is because, with a fixed virtual machine count, task completion times increase as more tasks are added. Additionally, we observe that EMAPSO has the shortest makespan among the others, and this tendency is consistent across all task counts.

Figure 5 shows the energy consumption relative to other methods currently in use, as mentioned above. As the number of tasks increases, the proposed algorithm consumes less energy than the others, as shown in the figure above. This is because the proposed technique effectively leverages virtual machines.

Figure 6 shows how the suggested algorithm’s execution time compares with that of the other existing algorithms mentioned above. As shown in the figure, the proposed algorithm runs faster than the other algorithms as the number of tasks increases. This is because the proposed approach runs more quickly when resources are used efficiently.

Figure 7 shows how the suggested algorithm’s load imbalance values compare to those of other algorithms currently in use. There is a significant discrepancy between the recorded load imbalance values for a limited number of tasks. Compared with previous algorithms, the proposed approach exhibits lower load imbalance.

Fig. 7.

Load imbalance factor (LIF) VS number of tasks.

Scenario 2

In this scenario, the number of tasks () is fixed at 500, and the number of VMs is varied from 20 to 100. Figures 7, 8, 9 and 10 represent the details of the comparison results.

Fig. 8.

Makespan Vs Number of VMS.

Fig. 9.

Energy consumption Vs number of VMs.

Fig. 10.

Execution Time Vs Number of VMs.

Figure 8 compares the proposed algorithm’s makespan with that of other existing algorithms. When the number of VMs increases, the makespan decreases gradually for a fixed task count. The proposed algorithm efficiently minimizes the makespan after load balancing. This occurs when the number of jobs is fixed but the number of virtual machines is variable. This is because the performance of the VMs declines dramatically over time.

Figure 9 shows the energy consumption of the proposed approach relative to the current algorithm, with the number of jobs fixed and the number of virtual machines varied. It is shown that as the makespan decreases, energy usage increases with the number of virtual machines (VMs).

Figure 10 compares the task execution time against the number of VMs for the proposed algorithm and other existing algorithms. As the number of tasks remains constant, the suggested algorithm’s task execution time decreases with increasing number of virtual machines (VMs), owing to efficient load balancing.

Figure 11 shows the comparison of the Load imbalance of the proposed algorithm with other existing algorithms. With effective load balancing, the proposed algorithm achieves the minimum LIF as the number of VMs increases.

Fig. 11.

Load Imbalance Factor (LIF) VS Number of VMs.

Figure 12 compares the convergence of the proposed and existing algorithms. It is observed that BLA, BSO, PSO, and MPSO expressed fast convergence after 40 iterations. After 80 rounds, the proposed approach converges, demonstrating that it finds a more optimal solution than the other algorithms currently in use.

Fig. 12.

Convergence comparison.

Figure 13 shows the impact of the balance coefficient on time and energy consumption for a task count of 200. In case , energy consumption is low, and the makespan is high. When , the makespan and energy consumption are balanced. As increases gradually to 1, the makespan decreases with increasing energy consumption. This graph illustrates how our approach can adaptively meet consumers’ needs, whether they prioritize energy savings or high-performance execution, by varying the balance coefficient .

Fig. 13.

Energy Consumption and Makespan with Changing Balance Coefficient.

Conclusion

In this research, we introduced Energy-Makespan multi-objective optimization as a scheduling algorithm to balance the competing goals of maximizing space and minimizing energy consumption. To select a processing node that minimizes task completion time and energy consumption subject to a user-defined weighting factor, a weighted bi-objective cost function is first formulated. Our proposed algorithm provides effective solutions in terms of makespan and energy conservation, with load balancing, as demonstrated by the comparison study results.In future work, we will further explore our approach by implementing advanced metaheuristics and machine–learning–based methods to improve the trade-off between makespan and energy consumption.

Author contributions

Niva Tripathy wrote the paper, Sampa Sahoo simulated the work, Norah Saleh Alghamdi analyzed the work, Wattana Viriyasitavat supervised the work, Gaurav Dhiman generated the results.

Funding

Princess Nourah bint Abdulrahman University Researchers Supporting Project number (PNURSP2026R40), Princess Nourah bint Abdulrahman University, Riyadh, Saudi Arabia.

Data availability

The data that support the findings of this study are not openly available due to reasons of sensitivity and are available from the corresponding author upon reasonable request.

Declarations

Competing interests

The authors declare no competing interests.