Federated multi-cloud task scheduling with load balancing using multi-objective NSGA-II and reinforcement learning

Abstract

Task scheduling in federated multi-cloud environments is challenging owing to heterogeneous service-level agreements, decentralized resource control, and dynamic workload characteristics. The existing hybrid optimization approaches lack real-time adaptability across cloud providers also assumes centralized coordination. To work with these issues, this paper proposes Multi-Objective Non-Dominated Sorting Genetic Algorithm with Q-Learning (MO-NSGAQ). This is a hybrid multi-objective scheduling framework that tightly integrates Non-dominated Sorting Genetic Algorithm II (NSGA-II) with Q-learning within a federated broker architecture. This proposed framework simultaneously optimizes execution cost, makespan, load imbalance, and resource utilization while adapting to inter-cloud heterogeneity. Extensive simulations are done using synthetic workloads, such as Google Cloud job traces, and IoT-based workloads. These simulations demonstrate that MO-NSGAQ reduces makespan by up to 18–32%, improves resource utilization by 10–22%, and achieves better load balance compared to existing baselines. The results confirm the proposed framework effectiveness for adaptive and scalable federated cloud scheduling.

Introduction

Federated cloud computing has emerged from the expansion of dispersed cloud infrastructures, as multiple independent cloud providers work together to deliver scalable services while retaining control over their local resources. For managing latency-sensitive applications and geographically scattered data across multiple locations and providers, federated clouds are crucial. Efficient task scheduling in such situations achieves optimization of load balancing, reduction of execution time (makespan), and improvement of resource utilization without violating SLAs. The central control assumptions made by Round-Robin and FCFS, which are two widely used scheduling algorithms for cloud tasks, make them inadequate in federated systems since they cannot handle heterogeneity between providers or dynamic load distributions¹.

To work with these issues, recent research has used multi-objective optimization algorithms. These algorithms take into account some competing goals, including makespan, cost, and power consumption, all at once². Some promising hybrid strategies for managing complex and changing cloud-fog scheduling include moth-flame optimization³, cat swarm optimization, and some models based on reinforcement learning⁴. Federated task scheduling adds further complexity due to the need for inter-cloud negotiation, knowledge of real-time resource availability, and adaptive intelligence in decision-making. The scheduler may learn the best allocation strategies from prior choices and dynamic feedback by incorporating reinforcement learning (RL) into such systems. RL-based frameworks like Reinforcement Learning-based Fog Scheduler (RLFS) and adaptive Q-learning schedulers have demonstrated better energy efficiency and faster response times in federated or fog-based systems⁵.

This study suggests a new hybrid framework, termed MO-NSGAQ. This framework combines Q-learning, which dynamically guides scheduling in federated cloud systems, with the NSGA-II for multi-objective optimization. Maximizing resource utilization and load balancing across multiple cloud domains is the goal of this proposed framework, while minimizing makespan and cost are also important considerations. While several existing studies work with hybrid optimization for cloud and fog environments, federated multi-cloud scheduling remains insufficiently addressed, particularly in terms of tightly integrating evolutionary optimization with online learning mechanisms. FCFS and Max-Min are involved as existing baselines to provide a lower-bound performance comparison, while advanced hybrid methods serve as primary benchmarks. The contributions of the proposed framework are as follows:

• A novel hybrid scheduling framework termed MO-NSGAQ framework is proposed for federated cloud environments which addresses the existing hybrid models limitations comprising centralized control and limited inter-cloud adaptability. This framework supports multi-objective optimization and combines NSGA-II with Q-learning under dynamic and heterogeneous conditions.

• By minimizing communication overhead, this work creates a federated broker-based architecture that assigns jobs across multiple IaaS clouds. This architecture also overcomes decentralized resource ownership and inter-cloud coordination challenges.

• Enhanced load balancing mechanism is created by including a dynamic load index (DLI) in the model to guarantee that workloads are distributed fairly between real servers and virtual machines (VM). This approach also addresses the imbalance issues in existing hybrid scheduling approaches.

• Comprehensive performance evaluation is done by using three different workload categories including synthetic, Google Cloud jobs, and real IoT traces, and an in-depth simulation using CloudSim Federation. This demonstrates the framework’s robustness under diverse and dynamic execution scenarios.

• By comparison with state-of-the-art baselines the proposed framework outperforms FCFS, MOPSO, Max Min, and Multi-Objective Artificial Bee Colony with Q-Learning (MOABCQ), in critical QoS metrics. The QoS metrics includes makespan, cost, load balance, and resource utilization.

The rest of the paper is organized as follows: Sect.  2 reviews state-of-the-art task scheduling and optimization algorithms in federated and multi-cloud environments, with a focus on multi-objective methods and RL-based models. Section  3 describes the architecture and implementation of the MO-NSGAQ algorithm, including the NSGA-II operator structure and Q-learning integration. Section  4 discusses datasets, simulation parameters, and evaluation metrics, followed by a comparison with baseline methods. Section  5 summarizes the key findings and outlines potential directions including DQN integration, SLA-aware scheduling, and energy-aware improvements.

Related work

Efficient task scheduling in cloud systems has long been a research goal, but the rise of federated and multi-cloud computing poses unique issues such as inter-cloud heterogeneity, SLAs across providers, and load balancing at scale.

Task scheduling in federated and multi-cloud systems

Schedulers that can handle multiple providers with decentralized control are essential for federated clouds. When it comes to fog computing task allocations Ibrahim, Media Ali, and Shavan Askar⁶, put forth a scheduler that uses deep reinforcement learning (DRL) and NSGA-II for multi-objective optimization. Peng et al.⁷ created a hybrid model for microservice scheduling in cloud-edge cooperation situations using Q-learning and NSGA-II. Latency control and QoS trade-offs in their system were promising.

Zhang et al.⁸ introduced a method termed Reward-Modulated Double Deep Q-Network (RMDDQN), which combines deep Q-learning with dynamic reward adaptation, made offloading in vehicular fog-cloud networks possible. Their approach is well-suited to federated settings since it takes energy efficiency and load balancing into account.

Multi-objective optimization techniques (NSGA-II and variants)

Due to its strong Pareto dominance strength, NSGA-II has seen extensive usage in multi-objective task scheduling. Alsadie and Deafallah⁹ for scheduling Internet of Things (IoT) workloads in the fog-cloud in real-time, introduced a D-NSGA-II method improved with Q-learning. Likewise, Salehnia et al.,² developed a multi-objective moth-flame optimization model that aims to optimize hybrid cloud-fog topologies with respect to makespan and energy trade-offs.

To improve scheduling in different types of clouds while considering delays and errors, Felsy, C., and R. Isaac Sajan et al.¹⁰ used Actor-Critic DRL models along with NSGA-II. Nematollahi et al.¹¹ improved the NSGA-II mutation method to better handle scheduling challenges in IoT-based settings.

Reinforcement learning for dynamic task scheduling

Reinforcement learning, in particular Q-learning, has been shown to be effective in generating optimum policies in dynamic cloud settings. Faraji-Mehmandar et al.¹² implemented fuzzy Q-learning for adaptive resource provisioning in fog networks which works well than static models when it came to workload sensitivity. By Kalusivalingam et al.¹³ a study was conducted on work with distributed systems’ energy-aware load balancing. This study combined Q-learning and genetic search to work with this issue.

In Wang et al.⁵, researchers presented an RL-based scheduler for energy-efficient federated cloud operations, aiming to promote sustainable practices. Jayanetti et al.¹⁴ utilized NSGA-II in conjunction with deep Q-learning to schedule workflows on the edge cloud, achieving good results while adhering to SLA restrictions. Reinforcing the flexibility of RL in dynamic, multi-tier systems, recent research by Yaraziz, Mahdi Safaei, and Richard Hill¹⁵, has examined federated reinforcement learning for IIoT task scheduling and resource allocation utilizing Q-learning variations inside dispersed edge-cloud topologies.

Hybrid and emerging approaches

To take advantage of exploration and adaptation, newer models focus for the need of integrating RL with metaheuristics. This approach by Salehnia et al.,² aims to achieve improved load balancing in IoT fog-cloud environments by utilizing fuzzy controllers and deep Q-learning. Ammavasai, and Sandana Karuppan¹⁶ to manage offloading latency and schedule edge tasks, used deep recurrent Q-networks.

By Pakmehr et al.¹⁷ according to some models, NSGA-II is combined with fuzzy Q-learning and load predictors based on auctions; examples of these are RMDDQN by Zhang et al.,⁸ and Probabilistic Q-Learning-based Load Balancer (PQ-LB). To further enhance load distribution in multi-clouds, Sefati et al.¹⁸ introduced a probabilistic task allocation model that incorporates deep Q-learning and heuristic sampling. This model shows significant flexibility in adapting to variations in user demand and the heterogeneity of resources. Table 1 reviews the existing works in details.

Table 1.

Literature review table.

Authors (year)	focus area	Method(s) used	Environment	Strengths	Limitations
Wang et al.5	Federated Cloud	RL (Sustainability focus)	Federated	Energy-efficient scheduling	Focuses mainly on energy efficiency; other objectives such as load balance and makespan are not jointly optimized.
Ibrahim et al.6	Fog Scheduling	Deep RL + NSGA-II	Fog	Pareto-based task distribution	Designed for fog environments and does not explicitly address federated multi-cloud coordination.
Peng et al.7	Microservices in Edge	Q-learning + NSGA-II	Cloud-Edge	QoS-aware collaborative scheduling	Targets cloud–edge systems; inter-cloud scheduling in federated clouds is not considered.
Zhang et al.8	Vehicular Fog	RMDDQN + Adaptive Rewards	Fog	Energy-aware dynamic offloading	Evaluated in vehicular fog scenarios; applicability to large-scale federated clouds is unclear.
Alsadie and Deafallah9	IoT-Fog	D-NSGA-II + Q-learning	Fog	Heuristic scheduler for IoT tasks	Assumes limited infrastructure scale and centralized fog control.
Felsy et al.10	Cloud	Actor-Critic + NSGA-II	Cloud	Fault-aware adaptive scheduling	Developed for single-cloud environments without inter-cloud coordination.
Nematollahi et al.11	IoT Cloud	Improved NSGA-II	Cloud	Enhanced Pareto solutions	Uses evolutionary optimization only and lacks runtime learning-based adaptation.
Faraji-Mehmandar et al.12	Fog-IoT	Fuzzy Q-learning	Fog	SLA-aware resource provisioning	Limited to fog–IoT systems and does not address federated cloud scheduling.
Kalusivalingam et al.13	Cloud	Q-learning + GA	Cloud	Load-balanced infrastructure optimization	Considers centralized cloud scheduling; federated environments are not evaluated.
Jayanetti et al.14	Edge-Cloud	NSGA-II + Deep QL	Hybrid	Workflow-aware edge task distribution	Focuses on edge–cloud workflows; scalability in federated clouds is not analyzed.
Ammavasai, Sandana Karuppan16	Edge Cloud	RNN + Q-learning	Edge	Adaptive scheduling in offloading	Addresses edge offloading only and does not consider multi-cloud federation.
Pakmehr et al.17	Fog Computing	Q-learning + auction logic	Fog	Cost, delay, energy optimization	Auction-based model may introduce high communication overhead at large scale.
Sefati et al.18	Multi-Cloud	Probabilistic Deep QL	Multi-cloud	Balanced load assignment using RL sampling	Focuses on probabilistic load balancing without evolutionary multi-objective optimization.

Though the existing approaches has significant advances in hybrid task scheduling approaches, it also faces some limitations during application to federated multi-cloud environments. Most hybrid metaheuristic–RL solutions design is for centralized or edge–fog systems and assume homogeneous resource control, which limits their adaptability to decentralized inter-cloud coordination. Furthermore, these approaches rarely address SLA heterogeneity across cloud providers or dynamically adapt to inter-cloud latency and pricing variations at runtime. Also, the addition between evolutionary optimization and learning agents is often loosely coupled. This results in limited responsiveness to real-time workload and infrastructure changes. These gaps motivate the need for a broker-based hybrid framework, tightly integrated, which should work with adaptive, multi-objective decision-making under federated constraints.

While NSGA-II and Q-learning have shown good individual performance, few studies have effectively combined them within a unified scheduling framework tailored for federated cloud systems. Furthermore, current hybrid models often neglect important trade-offs, including SLA heterogeneity, inter-cloud latency, and dynamic resource availability. These gaps highlight the necessity for an adaptive, multi-objective framework like MO-NSGAQ. This framework captures the strengths of NSGA-II and Q-learning and also aligns well with the federated multi-cloud scheduling of complex demands.

Proposed methodology

Figure 1 illustrates how the MO-NSGAQ framework is designed to manage multiple tasks in federated cloud environments. The first step is the task profiling module, which evaluates computational tasks given by users according to their projected execution time, resource needs, and deadlines. The Q-learning engine receives all of this profiling data at the same time and uses it to continually improve its knowledge of the best virtual machine picks based on scheduling performance in the past.

Fig. 1.

Proposed flow diagram.

Simultaneously, in a federated cloud setting, a federated broker, representing the decision-making organization, receives the profiled tasks. All of the collaborating cloud providers’ information, such as virtual machine specifications, operating expenses, and availability, is accessible to this broker. To facilitate communication between optimization logic and cloud resources, the broker mediates. Subsequently, the Multi-Objective Optimization (NSGA-II) module processes the VMs information and tasks. This module aims to optimize four competing goals such as resource usage, makespan reduction, cost minimization, and load imbalance minimization, in order to produce a population of task-VM mapping solutions that it subsequently analyzes. To determine the solution quality, the Q-learning agent refers to the Q-values which is updated.

Ultimately, the selected mappings generate Task-VM Assignments, which then become executable scheduling decisions. The federated cloud architecture accomplishes these judgments, and thus provides the Q-learning model with performance measurements to either reward or punish the actions. The system is able to respond instantly to shifting workloads and resource dynamics because of this tight feedback loop.

Hybrid scheduling framework (MO-NSGAQ)

This paper introduces MO-NSGAQ, a scheduling framework that mixes Q-learning with the NSGA-II for managing multiple tasks in a federated cloud environment. The goal is to optimize many competing goals, which includes makespan, cost, load balance, and resource consumption, while dynamically distributing computing tasks to VMs among different cloud providers. By following the Pareto front convergence, NSGA-II improves the best task-VM mappings, while Q-learning adjusts the selection chances in real time based on performance results from previous scheduling rounds. A central broker manages the system and has access to metadata from all federated clouds. The components of a scheduling cycle include task arrival and profiling, VMs status and cost retrieval, execution of NSGA-II on task–VM pairs, Q-learning-based reward adjustment for mappings, selection and allocation of tasks to VMs, and feedback update based on observed makespan, cost, and DLI.

To solve the issue of task scheduling in federated cloud settings, the proposed framework, MO-NSGAQ, employs a hybrid approach that combines evolutionary optimization with RL. Finding a balance between conflicting Quality of Service (QoS) metrics, including execution time, load distribution, energy usage, and operational expenses, is the objective. By integrating NSGA-II, which is widely regarded for its strength in non-dominated sorting and maintaining solution diversity, with Q-learning, which enables adaptive decision-making through trial-and-error learning. Thus, MO-NSGAQ is able to intelligently assign tasks to appropriate virtual machines across multiple cloud domains. The system is able to make use of metaheuristics’ global search capabilities and adapt to changes in the environment via reinforcement signals because of this synergy. The pseudocode for this algorithm is given below.

Algorithm 1.

MO-NSGAQ for federated cloud task scheduling.

Federated scheduling environment

Independent cloud service providers work together in a cooperative framework to supply computing resources in a loosely connected form in a federated cloud computing environment. Federated architectures allow for the separation of resources, rather than monolithic cloud systems. Due to the heterogeneity in virtual machine designs, cost structures, latency fluctuations, and SLA limitations, the task scheduling issue in this situation becomes substantially more difficult. A federated broker is brought in to handle this complexity; it is a central coordinating agent that gathers information about resources in real-time from all cloud domains and decides how to distribute tasks based on it.

The broker checks the data location, service cost, and latency thresholds before sending tasks to the right virtual machine pool. This configuration enables scalable, policy-aware scheduling that can span geographic borders while still providing the best possible service. The federated setup includes m number of VMs distributed across k cloud providers. Each cloud exposes VMs specs and usage cost and task pool arrives at the federated broker. When delegating tasks, the following such as SLA pricing agreements, data transit across providers, and cross-cloud latencies should be considered.

Mathematical problem formulation

This work represents the fundamental scheduling issue as a limited multi-objective optimization problem, balancing four opposing objectives. Both the minimization and maximization objectives are given in the scheduling problem. Here, resource utilization is maximized whereas, makespan, cost, and load imbalance are minimized. Min–max normalization is done normalize all metrics to handle these conflicting objectives uniformly. This process scales each objective to a range between 0 and 1. For maximization objectives, the normalized value is converted into a minimization form by subtracting it from one. This normalization ensures that every objectives are comparable and can be effectively optimized using NSGA-II without bias toward any specific metric.

To guarantee consumers get a prompt answer, initially makespan is decreased, which is the overall time needed to complete all tasks. Second, taking into account the price of individual VMs and the durations of tasks minimizes the overall cost of VMs consumption. As a third point, computing the divergence of per-VM workloads from the system-wide average helps decrease load imbalances and promote fair resource utilization. Lastly, to decrease idle time and increase total system throughput, resource utilization is optimized. Strict limitations like exclusive task-to-VM mapping, VMs capacity restrictions, and latency ceilings across cloud boundaries delay the achievement of these goals. The model makes sure that each task is allocated to a single VMs, that no VMs goes above its processing limit, and that inter-cloud latency stays below acceptable thresholds. The NSGA-II optimizer relies on this mathematical framework to provide reliable plans for distributing tasks.

Here \:T is is denoted as the set of tasks, \:V is denoting set of VMs, is the processing power of VM \:i, is required resources for task \:j, is estimated execution time of task \:j on VM \:i, is cost per second for using VM \:i and is 1 if task \:j is assigned to VM \:i, else 0. The first objective is to minimize makespan and is denoted as in Eq. (1):

1

The second objective is to minimize total cost and is formulated as in Eq. (2)

2

The third objective is to minimize Load Imbalance (DLI) and is equated ad in Eqs. (3) and (4).

3

4

The fourth objective is to maximize utilization for which the mathematical formulation is equated in Eq. (5).

5

The constraints for this work are equated in Eq. (6) by which each task is assigned to exactly one VM.

6

The VM Capacity Constraint is equated as in Eq. (7)

7

The Inter-cloud latency constraint (federated) is equated in Eq. (8)

8

Optimization problem statement

The hybrid objective of this research is defined by using the following Eq. (9)

9

Q-learning focuses on rewarding mappings that have historically excelled in balancing cost, load, and latency trade-offs, while NSGA-II is responsible for managing Pareto-based population evolution. Every iteration updates the Q-values according to the conventional rule. This conventional rule is equated in Eq. (10).

10

Where \:s is system state that is the VM status, \:a is chosen VM, \:r is reward from scheduling outcome, is learning rate and is discount factor. By considering multiple performance objectives, the reward function guides the learning agent toward better scheduling decisions. It combines makespan, execution cost, and load imbalance into a single reward value. Initially, normalization is done of each of this objective to ensure fairness, and then weighted as per its importance. The reward function is defined as:

11

where , , and represent the normalized makespan, cost, and DLI, respectively. The weights and controls each objective contribution and satisfies . A higher reward value shows a improved scheduling decision. Searching for optimal task-VM mappings across the federated cloud infrastructure is done using the NSGA-II algorithm. A comprehensive mapping of tasks to VMs is represented by each person in the first population of possible solutions. The four objective functions that are previously created are used to assess these individuals. NSGA-II uses mutation and crossover to create new generations and sorts solutions into groups called Pareto fronts. To keep the best solutions from becoming too similar, a crowding distance measure is employed. A collection of high-quality task scheduling plans that provide various trade-offs between makespan, cost, DLI, and utilization are the result of NSGA-II. After that, the Q-learning module receives these solutions and selects the best one based on historical reward data.

Adaptive scheduling with Q-learning

Complex, decentralized task allocation scenarios have shown the potential of hierarchical reinforcement learning systems. When¹⁹ used a multi-level RL model to improve resource scheduling in federated IoT hierarchies, it validated the advantages of decentralized learning. The optimization model gains an adaptive layer with the addition of Q-learning, which enables the system to learn from its experiences. A reward is computed based on performance metrics including real makespan, incurred cost, and load imbalance, which are tracked after each cycle of task scheduling. The Q-value of the selected action, that is, the particular VM used for a certain task, is updated by this reward as per the Bellman equation. The Q-table finally conforms to the projected long-term usefulness of various task-VM pairs worked under diverse scenarios. As a result of this learning process, the scheduler is able to take advantage of allocations with large rewards and avoid making the same unused errors again. The Q-learning agent allows for quick adjustments without having to redo the entire NSGA-II evolution. This makes scheduling more responsive when workloads change quickly or when VM availability varies.

The proposed MO-NSGAQ framework computational complexity results from the combination of NSGA-II and Q-learning. NSGA-II being a population-based optimization, where the main computational cost comes from fitness evaluation and non-dominated sorting. The Q-learning component updates the Q-values based on observed rewards, which incurs low overhead owing to a discretized and compact state space usage. Since both the population size and learning parameters are within bounds, the overall computational cost remains manageable. Thus, the proposed framework is suitable for simulation-based federated cloud scheduling and scalable to moderate-sized cloud environments.

Although DRL approaches including DQN and Actor–Critic offer greater representational capacity, they typically require higher computational overhead, large training datasets, and complex hyperparameter tuning. In contrast, tabular Q-learning is suitable for simulation-based federated scheduling scenarios and its offers faster convergence, lower training complexity, and improved sample efficiency, making it suitable for simulation-based federated scheduling scenarios. Hence, the state space representation is given using VM load and availability categories, which enables Q-learning to scale efficiently across federated providers. Existing DRL-based schedulers have demonstrated effectiveness in Spark and hybrid cloud systems. However, their training and runtime costs may limit practical deployment in federated multi-cloud brokers^20,21. Thus, Q-learning provides a balanced trade-off between adaptability and computational efficiency in the proposed framework.

Results and discussion

The experimental results given in this section confirms the superior performance of the proposed MO-NSGAQ framework in optimizing task scheduling across federated cloud environments. It achieved lower makespan, reduced cost, improved resource utilization, and better load balance compared to existing algorithms which includes MOPSO, FCFS, and Max-Min. The simulations of this work are conducted using CloudSim-Federation 1.0 running on a Windows 11 system with Intel Core i7 11th Gen CPU, and 16 GB RAM. The statistical consistency across multiple workload types and evaluation runs shows the robustness and generalizability of the proposed framework under different operating conditions. These outcomes confirm MO-NSGAQ as a scalable and adaptive solution for dynamic cloud scheduling.

Experimental setup

Simulation environment

Using CloudSim-Federation, which is an extension of the widely recognized CloudSim framework, several simulation tests are carried out. This simulation assesses the performance and scalability of the proposed MO-NSGAQ framework. CloudSim-Federation allows the user to create models of cloud providers located in different places, each with different resources, and supports flexible actions. These actions include moving VMs between clouds, managing services based on agreements, and scheduling tasks while considering delays. This platform is important for testing federated task scheduling algorithms, as it can imitate real-world cloud conditions, which include different types of VMs, network delays, and changing prices.

Under the same configuration each experiment was repeated 10 independent times to ensure the reliability of the experimental results. The reported results represent the average values obtained from these runs, along with the corresponding standard deviation to capture performance variability. This approach helps reduce the impact of randomness introduced by metaheuristic optimization and reinforcement learning components.

Workload datasets

The tests in this research run on three different types of workloads, which ensures the proposed framework’s robustness and generalizability. The three different workload types are.

• Synthetic Workload: The dataset is custom-made and includes 1000–5000 tasks with CPU and memory requirements that are randomly allocated. The heterogeneous job complexity is approximated by using a homogeneous distribution of task sizes, which is between 1000 and 10,000 million instructions (MI).

• Google Cloud Jobs (GoCJ): The dataset presents real-time cluster utilization data available from Google. This dataset provides realistic insights on task submission trends, delays in execution, and timings for VM provisioning. Over a million task entries that span various data centers are included in this dataset.

• IoT and Real-Time Stream Workload: This is a simulated workload that is based on actual IoT usage in edge cloud settings that is data from smart city sensors and focuses on short tasks that need quick responses. Asymmetric VM access restrictions and bursty task arrivals are part of it.

Each of these three workloads represents a distinct operational context, from data-heavy cloud settings to latency-sensitive edge-federated hybrid models to actual production traces.

Datacentre and VM configuration

Three separate datacentres, or “federated cloud providers,” make up the simulated federated cloud system. Ten to thirty VMs with varying degrees of expertise in the following areas make up each datacentre. The datacentre details are tabulated in Table 2.

Table 2.

VM configuration.

Details	Range
Processing Power	Ranges between 500 to 2500 MIPS
RAM	2048 to 8192 MB
Storage	50 to 500 GB
Bandwidth	1 to 10 Gbps
VM Cost per Second	Varies across datacentres to reflect pricing models

The three clouds are distributed at random to each virtual machine type. The cloud dynamically adjusts network latency, with an average inter-cloud latency of 50–200 ms, based on geographic location tags including local, regional, and global. For each experimental run, the simulation duration is set to a continuous 1000 s.

Then parameter setting for the proposed framework is also done. For this, the NSGA-II and Q-learning parameters are fine-tuned by applying sensitivity analysis to previously published research. The parameters employed in NSGA-II is employed in Table 3. Also, the parameters which are utilized for Q-learning is tabulated in Table 4.

Table 3.

NSGA-II parameters.

Parameters	Range
Population Size	50
Number of Generations	100
Crossover Rate	0.9
Mutation Rate	0.1
Selection	Tournament selection
Archive Size	25 (for Pareto front retention)

Table 4.

Q-learning parameters.

Parameters	Range
Learning Rate (α)	0.7
Discount Factor (γ)	0.9
Exploration Probability (ε)	Initially 0.2, decays to 0.01
Q-table State Definition	Based on VM load and availability status
Reward Function	Weighted based on cost, makespan, and DLI

During the evolutionary search, these parameters make sure that there is enough population diversity and that there is a fair trade-off between exploring and exploiting.

Evaluation metrics

Using these five key performance metrics, the proposed MO-NSGAQ framework is compared with other scheduling models. The evaluation metrics include makespan, total cost, DLI, resource utilization and throughput. Here, make span is the total amount of time needed to do each task. Total cost is the entire cost of executing each task across all data centers is involved. DLI is a variance in task demands among virtual machines. Resource utilization is the average percentage of CPU and memory utilization is calculated. Throughput is the quantity of tasks completed in a given amount of time. The average results are presented to decrease variance after repeating each experiment 10 times under randomized task distributions.

Results and discussion

This section, looks at how the proposed MO-NSGAQ framework stacks up against four other scheduling algorithms such as MOPSO, MOABCQ, Max-Min, and FCFS and share the results from the tests. Using similar workloads and system setups, the comparison is carried out across five key performance metrics such as make span, total cost, DLI, resource utilization, and throughput.

Quantitative analysis

In Table 5 we can see the findings are summarized. With all three workloads, MO-NSGAQ consistently records the lowest makespan: 180s (Synthetic), 195s (GoCJ), and 165s (IoT). This confirms the proposed framework’s ability to balance task allocation and resource availability even under unpredictable or real-time conditions. FCFS and Max-Min, being static and non-adaptive, yield the highest makespan. Particularly, FCFS performs worst in the GoCJ workload (285s), where task queuing and variability are complex and bursty. MOPSO and MOABCQ perform moderately well, with MOABCQ slightly performing better than MOPSO in the synthetic and IoT workloads. The dynamic learning capacity of MO-NSGAQ by using Q-learning helps it adapt task placements over time, which reduces scheduling delays even when workloads are randomized or time-sensitive.

Table 5.

Performance metrics comparison.

Workload	Algorithm	Makespan (s)	Cost ($)	DLI	Utilization (%)	Throughput
Synthetic	MO-NSGAQ	180.0	35.0	0.18	88.0	240.0
	MOPSO	210.0	42.0	0.25	78.0	210.0
	FCFS	275.0	50.0	0.37	65.0	185.0
	Max-Min	260.0	47.0	0.32	70.0	190.0
	MOABCQ	200.0	39.0	0.23	82.0	230.0
GoCJ	MO-NSGAQ	195.0	39.0	0.21	85.0	225.0
	MOPSO	215.0	43.0	0.28	76.0	200.0
	FCFS	285.0	52.0	0.39	63.0	175.0
	Max-Min	265.0	48.0	0.34	69.0	185.0
	MOABCQ	205.0	41.0	0.26	80.0	220.0
IoT	MO-NSGAQ	165.0	32.0	0.15	90.0	255.0
	MOPSO	195.0	38.0	0.22	81.0	220.0
	FCFS	245.0	46.0	0.33	68.0	195.0
	Max-Min	235.0	44.0	0.29	72.0	200.0
	MOABCQ	185.0	36.0	0.20	86.0	240.0

The MO-NSGAQ framework is the most cost-effective with three workloads at $35 for Synthetic, $39 for GoCJ, and $32 for IoT, showing its strength in selecting cheaper yet effective VM configurations. FCFS shows the highest cost in all cases, since it does not consider cost-awareness or load during scheduling. MOABCQ shows slightly better cost efficiency than MOPSO in the IoT and synthetic cases owing to its built-in cost-based objective function. The cost-aware reward structure in Q-learning helps the MO-NSGAQ framework to iteratively improve selections and avoid expensive VMs unless necessary.

MO-NSGAQ has the lowest DLI of 0.18 (Synthetic), 0.21 (GoCJ), and 0.15 (IoT), indicating a well-balanced distribution of workloads. FCFS and Max-Min again perform poorly, especially in the GoCJ workload, where DLI reaches 0.39 and 0.34, respectively. MOABCQ provides decent DLI values due to its bio-inspired search behaviour. The multi-objective design of NSGA-II naturally aims for balance, while Q-learning learns from past imbalance penalties, improving long-term fairness.

With Resource Utilization MO-NSGAQ frameworks show better performance again with 88% for Synthetic, 85% for GoCJ, and 90% for IoT, reflecting efficient task packing and minimal idle time. FCFS underutilises VMs heavily (63–68%) owing to its non-optimized task queues. MOABCQ is the closest competitor to MO-NSGAQ, especially in the IoT workload, where it reaches 86% utilization. MO-NSGAQ’s dual engine (evolution + learning) enables it to allocate resources more tightly and reactively than static policies.

MO-NSGAQ delivers the highest throughput: 240 (Synthetic), 225 (GoCJ), and 255 (IoT), showing superior task processing performance under all conditions. FCFS has the lowest throughput (175–195), confirming its unsuitability for real-time or high-frequency task environments. MOABCQ again shows competitive results, particularly for IoT workloads (240), highlighting the strength of hybrid swarm models in stream-heavy contexts. The learning loop in Q-learning helps prioritize shorter, more urgent tasks, especially in IoT, while NSGA-II ensures the optimization doesn’t compromise fairness or long-term system stability.

Thus, across the three workloads, such as randomized (synthetic), real-world (GoCJ), and latency-critical (IoT), the proposed MO-NSGAQ framework outperforms all other existing schedulers in every major performance metric. Its hybrid design allows it to rapidly adapt to workload dynamics, balance efficiency and fairness, reduce cost and idle time, and scale gracefully across federated, heterogeneous VM environments. This comprehensive superiority reinforces the suitability of MO-NSGAQ for real-world deployment in federated, multi-cloud, and edge-integrated platforms.

For each workload and performance metric, to further highlight the effectiveness of the proposed MO-NSGAQ framework, percentage improvements were calculated with respect to baseline algorithms. This analysis provides a clearer understanding of the MO-NSGAQ, especially by makespan reduction, cost savings, and improved resource utilization across different workload scenarios.

Visual interpretation

This line graph, Fig. 2a, shows how each scheduling algorithm performs across five metrics, such as makespan, cost, DLI, Utilization, and throughput for the synthetic workload. Here, MO-NSGAQ delivers the best balance across all metrics. FCFS performs the worst in DLI and Utilization. MOABCQ comes close to MO-NSGAQ in throughput and load balance. Figure 2b represents metric trends across algorithms for the GoCJ workload. This graph represents performance for Google Cloud Jobs (GoCJ), a real workload trace. By this figure, MO-NSGAQ shows resilience to real-world task spikes, keeping makespan and DLI low. MOPSO and MOABCQ show moderate improvements. FCFS exhibits high cost and the worst load balance, failing to handle burstiness in task arrivals.

Fig. 2.

Comparison of every metrics (a) synthetic workloads, (b) GoCJ workload, and IoT and stream workload.

Figure 2c represents metric trends across algorithms for IoT workloads. This chart displays scheduling performance under IoT and stream workloads, known for short-lived, time-critical tasks. Here, MO-NSGAQ again leads, especially in makespan (165 s) and throughput (255), due to its learning-based adaptability. MOABCQ performs well in utilization (86%) and DLI (0.20). FCFS continues to struggle under latency-sensitive conditions.

The synthetic workload tests algorithmic robustness under randomized and unstructured task distributions. As illustrated in the first heatmap, the MO-NSGAQ framework outperforms others with the lowest makespan (180 s), lowest cost ($35), and highest resource utilization (88%). The existing schedulers like FCFS suffer under these unpredictable conditions, yielding a high imbalance of DLI with 0.37 and poor throughput of 185. Real-world job traces from Google challenge the scheduling models with bursty arrivals and diverse VM configurations. The proposed MO-NSGAQ framework performs best, though it is slightly behind the performance of synthetic workload. It achieves a 195-second makespan, a $39 cost, and 85% utilization. MOPSO and MOABCQ are very close to the MO-NSGAQ framework, but the other existing static methods like Max-Min and FCFS face issues such as high cost and poor load distribution (Fig. 3).

Fig. 3.

Heatmap metric intensities for each algorithm (a) synthetic workloads, (b) GoCJ workload, and (c) IoT and stream workload.

The third workload mimics latency-sensitive, short-lived IoT tasks. Here, the MO-NSGAQ framework excels with the lowest makespan of 165s and highest throughput of 255. The proposed framework’s ability to quickly learn and adapt through Q-learning makes it work well for stream-orientated scheduling. FCFS again performs the worst due to its lack of prioritization and latency handling.

The line plot and heatmap show that MO-NSGAQ’s hybrid intelligence makes it more adaptable to dispersed and dynamic workloads. NSGA-II guarantees convergence across many objectives, while Q-learning aids learning from performance history. In complex federated situations, it’s becoming more obvious that models like MOABCQ and MOPSO, which only use metaheuristics, lack the ability to adapt based on the context. There is a clear need for learning-based models in cloud scheduling research, since static schedulers (FCFS, Max-Min) have a hard time handling load imbalance and underutilization.

Discussion

The findings provide evidence of the strategic benefit of joining evolutionary multi-objective optimization with RL in complicated scheduling settings. The MO-NSGAQ framework proposed makes use of the characteristics of both paradigms. NSGA-II effectively works with the possible solutions while balancing different goals, including total time, cost, uneven load, and how well resources are used, resulting in a set of optimal task-VM pairings. In contrast, Q-learning offers a robust learning mechanism that sequentially adjusts methods for task allocation in response to real-time performance analysis. This capacity for learning allows the system to detect and take advantage of repetitive patterns in the distribution of workloads, the dynamics of virtual machine pricing, and the emergence of bottlenecks among federated cloud providers.

The combination of these two features allows for the development of a scheduling engine that optimizes itself and can deal with the unpredictable components of federated cloud systems. By gathering information over time, the Q-learning module helps the NSGA-II population focus on areas of the search space that have worked well in the past, unlike traditional metaheuristics that lack awareness of context or memory. In federated systems, where task workloads, VM availability, inter-cloud latencies, and SLA terms might fluctuate unexpectedly across datacentres and over time, this adaptive guidance loop becomes even more important.

Furthermore, MO-NSGAQ’s exceptional performance across varied workload circumstances demonstrates its scalability and generalizability.

Although large-scale scalability experiments were not explicitly conducted, the scalability of the proposed framework can be inferred from its design. MO-NSGAQ relies on bounded population sizes in NSGA-II and a discretized state space in Q-learning, which limits computational growth as the number of tasks increases. Furthermore, the broker-based federated architecture enables distributed decision-making without excessive inter-cloud communication. These characteristics indicate that the proposed framework can scale effectively to moderate and large federated cloud environments.

The framework is strong at handling IoT tasks that need quick responses and real-time data while also being able to adjust to large, demanding cloud jobs (like those from Google). According to these results, MO-NSGAQ works well with many contemporary computing paradigms, such as edge-cloud hybrid systems, where the placement of tasks has to dynamically balance the availability of computational resources with the limits imposed by latency.

The minimization of makespan and load imbalance indirectly contributes to energy efficiency by reducing idle time and avoiding resource over-provisioning, though an explicit energy consumption model implementation is not done. Some existing studies including^22–25 have shown strong correlations between reduced power consumption and balanced resource utilization in cloud infrastructures. So, the improvements achieved by MO-NSGAQ in utilization and load balance specifies its capacity for energy-efficient operation in federated environments.

Furthermore, MO-NSGAQ is a strong contender for environmentally conscious computing and infrastructures that prioritize sustainability because of the energy efficiency it indirectly promotes via improved resource utilization and load balancing. Intelligent schedulers, such as MO-NSGAQ, may be essential in lowering energy waste without compromising performance, which is becoming more important as cloud providers include carbon-conscious operations in their service-level planning. The experimental evaluation focuses on scheduling effectiveness metrics, but do not consider the additional practical considerations including inter-cloud communication overhead and SLA violation rates. However, the broker-based design minimizes communication by relying on aggregated VM metadata. Also, the computational overhead of MO-NSGAQ remains limited owing to the moderate NSGA-II population size as well as lightweight Q-learning update.

Conclusion and future work

This research introduced the hybrid scheduling framework MO-NSGAQ to address the challenges of task scheduling in federated cloud settings. It combines NSGA-II with Q-learning. By combining multi-objective optimization with RL, MO-NSGAQ effectively balances trying new things and learning, unlike traditional schedulers that rely on fixed rules or only evolutionary techniques. The proposed framework dynamically adapts to changing workloads, resource restrictions, and inter-cloud heterogeneity owing to this hybrid combination. The proposed framework provided better results when compared with existing approaches, including MOPSO, MOABCQ, Max-Min, and FCFS. Comprehensive simulation runs are conducted on three different datasets, such as synthetic workloads, Google Cloud traces, and real-time IoT workloads. With high throughput, MO-NSGAQ improved significantly in other metrics such as makespan reduction, cost efficiency, load balancing, and resource utilization. Adaptability and intelligent feedback are important in complicated, multi-provider environments, where the performance increases are most considerable. A wide variety of distributed computing systems benefit from MO-NSGAQ’s design, not just federated cloud scheduling. It can be used in edge-cloud hybrid systems, smart grid task management, fog computing, and managing sustainable data centres, where there are often conflicting goals and situations. It is a flexible option for intelligent infrastructure of the future because of its learning-driven flexibility and Pareto-optimal reasoning. In the future there are several ways this study may have a greater impact, including deep reinforcement learning integration, SLA-aware scheduling, energy and carbon-aware optimisation, real-time deployment in federated testbeds, and multi-agent Q-learning extensions. Future work will also include comparisons with existing DRL-based schedulers, as well as obvious evaluation of inter-cloud communication overhead, SLA violation rates, and scheduling decision latency to assess real-world deployability.

Author contributions

Author’s ContributionW.G. Conceptualisation, methodology, software, validation, writing—original draft preparationH.A. and W.G.; formal analysis, investigation, writing—review and editing, supervision, Project administration: W.G. and H.A. All authors have read and agreed to the published version of the manuscript.

Data availability

The Google Cloud trace dataset used during the current study is publicly available at [https://github.com/google/cluster-data](https:/github.com/google/cluster-data) .

Code availability

The results presented in this study were generated using the code described in the Simulation Environment section. The complete implementation has been uploaded to a public GitHub repository. The code²⁶ is openly accessible at the following link: https://github.com/HIND2028/Federated-Multi-Cloud-Task-Scheduling.git.

Declarations

Competing interests

The authors declare no competing interests.