Federated Learning-Driven IoT Request Scheduling for Fault Tolerance in Cloud Data Centers

Abstract

Cloud computing is a virtualized and distributed computing model that provides resources and services based on demand and self-service. Resource failure is one of the major challenges in cloud computing, and there is a need for fault tolerance mechanisms. This paper addresses the issue by proposing a multi-objective radial kernelized federated learning-based fault-tolerant scheduling (MRKFL-FTS) technique for allocating multiple IoT requests or user tasks to virtual machines in cloud IoT-based environments. The MRKFL-FTS technique includes Cloud RAN (C-RAN) and Virtual RAN (V-RAN). The proposed MRKFL-FTS technique comprises four entities, namely, IoT devices, cloud servers, task assigners, and virtual machines. Each IoT device generates several service requests and sends them to the control server. At first, radial kernelized support vector regression is applied in the local training model to identify resource-efficient virtual machines. After that, locally trained models are combined, and the resulting model is fed into the global aggregation model. Finally, using a weighted round-robin method, the task assigner allocates incoming IoT service requests to virtual machines. This approach improves resource awareness and fault tolerance in scheduling. The quantitatively analyzed results show that the MRKFL-FTS technique achieved an 8% improvement in task scheduling efficiency and fault prediction accuracy, a 36% improvement in throughput, and a 14% reduction in makespan and time complexity. In addition, the MRKFL-FTS technique resulted in a 13% reduction in response time. The energy consumption of the MRKFL-FTS technique is reduced by 17% and increases the scalability by 8% compared to conventional scheduling techniques.

1. Introduction

The cloud comprises data centers established by connecting various large-scale physical devices to provide user-required services through the Internet. Implementing an effective IoT strategy in the cloud requires consideration of application requirements, resource availability, and the dynamic nature of IoT workloads. It involves a balance between efficiency and cost-effectiveness. Request scheduling in the context of IoT and cloud computing involves allocating and coordinating tasks to optimize resource utilization, enhance system performance, and ensure timely responses to IoT-generated requests. Fault tolerance in cloud computing is usually classified into proactive and reactive mechanisms. The proactive mechanism desires more data concerning cloud computing and its mechanisms in a probabilistic method. The proactive strategy in cloud computing minimizes the failure time and improves the throughput and capacity. The reactive fault tolerance reduces the impact of failure on the execution of applications.

Federated learning is achieving better accuracy beyond data partitioning. It allows for the training of models on different datasets while maintaining data privacy and minimizing the requirements for extensive data transfer. Federated learning also allows for examining different procedures when using the collective model. Once it collects this data, it updates the model. Federated machine learning offers numerous substantial benefits, including improved user privacy and protection, compliance with authorized observation, enhanced accuracy and different models, improved bandwidth efficiency, and better scalability. The federated learning method has been applied to the scheduling method. Federated learning has been optimized to different scheduling methods, namely, Random Reshuffling (RR) with gradient compression, which performs well with and without-replacement sampling of gradients.

The hybrid fault-tolerant scheduling algorithm (HFTSA) was developed in [1], focusing on independent tasks with deadlines. However, achieving efficient scheduling with a reduced makespan proved to be a challenging issue. The Fault-Tolerant and Data-Oriented Scientific Workflow Management and Scheduling System (FD-SWMS), as designed in [2], efficiently selects suitable resources based on data transfer time. However, implementing fault-tolerant techniques for big data applications in task-oriented scheduling is not considered.

An integer linear programming (ILP) optimization technique was developed in [3] with the aim of minimizing the makespan of tasks within a cloud data center. However, it did not consider heterogeneous resources within the cloud environment. A customized implementation of the genetic algorithm (GA) was introduced in [4] to schedule IoT requests to minimize overall latency. This implementation did not incorporate multi-objective optimization functions. As a result, the GA implementation might have reduced latency but potentially at the cost of suboptimal resource utilization, leading to inefficiencies in overall system performance.

A three-tier computing architecture was designed in [5] to schedule a maximum number of requests based on their deadline requirements. However, the scheduling model for IoT devices posed a significant challenge in cloud computing. A deep Q-learning algorithm was developed in [6] to detect near-optimal workflow task scheduling. However, it did not achieve improved performance when incorporating predictive fault-tolerant strategies. A failure-aware task scheduling approach was formulated in [7] to improve resource utilization performance for task execution. However, deep learning prediction models were not employed for precise task scheduling in the cloud.

Machine learning (ML) and deep learning (DL) techniques are increasingly essential in task scheduling within cloud computing environments due to their ability to handle complexity, uncertainty, and dynamic changes effectively. These algorithms can analyze large volumes of data to identify patterns and make predictions, which is crucial for tasks like predicting failure rates or optimizing scheduling decisions. A new artificial intelligence-driven, energy-aware, proactive, fault-tolerant scheduling method was developed in [8] to predict the failure rate of arriving tasks. However, the issue of larger-scale scheduling remained unaddressed. A fault-tolerant, trust-based task scheduling method was introduced in [9] to allocate tasks to suitable virtual machines and minimize the makespan. However, machine learning integration is not considered, limiting its adaptability and efficiency in dynamic environments. A deep reinforcement learning technique was developed in [10] for fault-tolerant-aware task scheduling. However, it does not achieve a higher throughput performance, indicating the complexity of optimizing scheduling decisions in real time.

The rapid increase in IoT devices has made it challenging for the cloud computing environment to handle a large number of tasks, including processing, storing, and analyzing. However, due to the dynamic nature of cloud data centers, fault tolerance is an essential consideration because of the inherent risks of component failures, network issues, and resource deficiency. Many existing task scheduling techniques focus on maximizing performance or optimizing resource usage but ignore the ability to handle system failures efficiently. Moreover, these existing techniques are inefficient for dealing with faults, causing more latency, resource inefficiency, and compromising system reliability. This problem is particularly critical in real-time applications. These problems guide the development of a novel scheduling algorithm that handles fault tolerance without sacrificing efficiency, latency, and scalability in IoT applications. Fault tolerance is vital to maintain continuous operation during unexpected failures, but it often introduces overheads regarding resource usage and processing time. Therefore, the developed scheduling algorithm is required to minimize system latency and maximize resource utilization. Additionally, the algorithm has to adapt dynamically to handle large numbers of requests generated from the IoT device without negatively impacting the overall system performance.

Based on the dynamic environment of cloud computing, task failures can occur for various reasons, such as resource unavailability, exceeding execution costs or time limits, memory constraints, over-utilization of resources, or improper installations. These failures lead to delays in the timely delivery of user-requested applications, particularly those with time-sensitive requirements. To address this challenge, this work proposes a novel technique named MRKFL-FTS. This technique aims to ensure fault tolerance in cloud IoT environments by optimizing task scheduling, thereby enhancing the reliability and efficiency of cloud services for users’ applications.

This work aims at the following main contributions:

• A method is proposed to improve the fault tolerance and task scheduling efficiency developed in the cloud.
• A multi-objective radial kernelized federated learning approach is designed to classify the resource-optimal virtual machines for task scheduling.
• A novel radial kernel support vector regression is utilized in a local training model within federated learning to perceive the resource-efficient virtual machine. The stochastic steepest descent function is employed to reduce loss and improve the accuracy in finding resource-efficient virtual machines.
• The proposed MRKFL-FTS is integrated with a task assigner that allocates tasks to the appropriate virtual machine using a weighted round-robin scheduling method.
• The comprehensive and comparative experiments show that the MRKFL-FTS technique increases task scheduling efficiency and fault prediction accuracy by 7%, minimizes makespan and time complexity by 13%, and improves throughput by 32%. Moreover, the MRKFL-FTS technique also minimizes the response time complexity by 11%.

This paper is organized as follows: Section 2 introduces the related works. Section 3 outlines the MRKFL-FTS with a clear architecture diagram. Section 4 investigates the experimental settings and provides details about the dataset, and Section 5 presents the proposed algorithm’s performance evaluation, comparing it with established scheduling techniques across various metrics. Section 6 discusses the overall performance analysis results for various parameters. Section 7 illustrates the case study of the MRKFL-FTS technique with Amazon cloud data centers. Lastly, Section 8 includes the conclusions derived from this work.

2. Related Works

A real-time and dynamic fault-tolerant scheduling (ReadyFS) algorithm was developed in [11] to execute scientific workflows. This algorithm ensures deadline constraints and enhances resource utilization. Hybrid optimization algorithms were developed in [12] to establish an efficient scheduling and fault-tolerant mechanism. However, the scheduling process did not achieve the desired higher throughput performance.

An efficient adaptive fault-tolerant model (AFTM) was introduced in [13] to address the optimization of the job scheduling problem using Particle Swarm Optimization (PSO). A dynamic, time-sensitive scheduling algorithm was developed in [14]. However, it did not ensure the efficient integration of fault-tolerant techniques.

A quality of service (QoS)-aware scheduling algorithm was developed in [15] to enhance the fault tolerance during task execution. However, the algorithm was found to be inefficient in accurately scheduling tasks. Bi-objective optimization was developed in [16] to schedule tasks with the goal of minimizing both energy consumption and makespan. However, it did not address the challenge of energy- and quality of service (QoS)-aware scheduling for workflow applications in the cloud. The M/M/n queuing model, designed by [17], was based on a priority assignment algorithm for addressing task scheduling in cloud computing.

A rank-based, resource-aware, fault-tolerant method was developed in [18] for cloud platforms. However, it proved to be inapplicable for microservice-based cloud applications. An adaptive fault detector method was developed in [19] based on Improved Differential Evolution (IDE) to minimize the energy consumption, makespan, and task fault ratio. The Elastic pull-based Dynamic Fault-Tolerant (E-DFT) scheduling approach was designed [20], aiming to reduce response times in the multiple failures of independent tasks. However, it did not enhance the efficiency of the scheduling approach.

A scheduling approach with linear scaling-crow search optimization was developed in [21] as a multi-objective framework. However, this approach encountered limitations in incorporating advanced neural networks to optimize workflow scheduling efficiently. A dynamic task scheduling approach was developed in [22] to minimize energy consumption.

An integer linear programming (ILP) method was developed in [23] for scheduling tasks with minimal consumption of computational resources. A fuzzy self-defense method was developed in [24] for multi-objective task scheduling to improve efficient resource utilization. However, it did not enhance the performance of task scheduling. A multi-objective algorithm incorporating Q-learning was introduced in [25] to minimize the makespan, enhance throughput, and optimize average resource utilization. An energy-efficient, fault-tolerant scheduling method was developed in [26] to enhance system processing capacity while improving resource utilization.

The fault-tolerant approach was developed in [27] to achieve deadline-constrained task scheduling. Two semi-greedy-based algorithms were developed in [28] to map IoT tasks with a minimal makespan efficiently. A practical and adaptive fault-tolerant scheduling method was designed in [29] to provide error-free task scheduling. An efficient heuristic algorithm was designed for fault-tolerant virtual network placement in [30].

The Task Scheduling–Decision Tree (TS-DT) method was introduced in [31] to execute tasks with a lesser makespan. A new fault-tolerant scheduling approach was designed in [32] to efficiently increase the resource utilization of the cloud while guaranteeing fault tolerance.

The Energy-Aware Fault-Tolerant (EAFT) method was developed in [33] for efficiently scheduling tasks to optimize resource utilization. However, it did not consider the trade-off between energy consumption and fault tolerance within multi-level redundant data center networks.

The Fault-Tolerant Elastic Resource Management (FT-ERM) approach was introduced in [34] for mapping tasks to the selected server. A lightweight task scheduling approach was developed for cloud and edge platform applications in [35]. However, this approach was inefficient in geographically distributed scenarios. A quality of service (QoS)-based resource allocation and scheduling method was developed in [36] using swarm-based ant colony optimization.

An enhanced task scheduling approach was introduced in [37] to optimize task execution efficiency and reduce energy consumption. The modified version of the Heterogeneous Earliest Finish Time (HEFT) algorithm was developed in [38] to optimize task scheduling within a shorter time period. The Cost-based Job Scheduling (CJS) method was developed in [39] to enhance the overall performance of distributed scheduling by minimizing the makespan. An Energy- and Performance-Efficient Task Scheduling method was introduced in [40] for a heterogeneous virtualized cloud to address energy consumption issues. However, the approach did not consider multi-objective task scheduling. An improved squirrel search algorithm (SSA) was designed in [41] with the aim of scheduling the tasks by contributing the multiple objective functions’ makespan, throughput, and resource utilization. A simple scheduling method was designed in [42] for heterogeneous computing systems to minimize the task running time and complexity.

An optimal hybrid metaheuristic algorithm was designed in [43] to enhance the task scheduling efficiency and reduce the makespan. An enhanced load balancing method was developed in [44] to address the issue of dynamically distributing tasks with minimal resource utilization. A novel hybrid multi-objective optimization algorithm was developed in [45] to address the scheduling problem and efficiently allocate resources. However, it was not suitable for a hybrid cloud computing model. A hybrid genetic algorithm was designed [46] for reliable and cost-efficient task scheduling within various cloud environments. However, the dynamic failure-aware task scheduling remained unaddressed. A hybrid optimization algorithm was developed in [47] for scheduling tasks with minimal energy consumption.

Machine learning inference-serving models were developed in [48] to optimize the inference and improve the scalability and system efficiency with minimal latency. However, they failed to integrate serverless platforms and various machine learning frameworks. A detailed taxonomy of several serverless computing models was developed in [49] for handling the cold start latency by optimizing the loading time and resource usage. However, high efficiency was a major concern. Function placement approaches were developed in [50] for serverless computing to improve the system efficiency. However, the execution time, resource consumption, and cost were not reduced. The Q-learning Auto-scaling Offloading (QLAO) method was introduced in [51] to minimize latency, cost, and energy computation. However, load prediction was not performed. A review of the content caching approach was analyzed in [52] for an edge computing environment. However, the model had limited storage capacity compared to centralized cloud servers. Cold start latency mitigation approaches were developed in [53] for serverless computing platforms. The algorithm minimizes the response time, but the resource utilization is not minimized.

Scheduling approaches were developed in [54] for serverless computing across different computing environments, such as cloud, edge, and fog. The model performed more energy-efficient and deadline-aware scheduling. But the latency was a major issue. Function offloading methods were developed in [55] for serverless computing to improve the system’s efficiency and minimize the latency. However, the throughput performance did not improve. A hybrid task scheduling technique was designed in [56] using fuzzy logic and a deep reinforcement learning algorithm to enhance the performance of the makespan, energy consumption, cost, and fault tolerance. However, high throughput performance was not achieved. A trust- and reliability-aware task scheduler with an Actor–Critic (RTATSA2C) model was developed in [57] for dynamic resource scaling. The designed algorithm reduced the makespan while improving reliability, fault tolerance, trust, and scalability. However, the efficiency of the algorithm was not improved.

Integration of a hybrid EMD-Transformer-BiLSTM prediction model with a blockchain-backed federated learning mechanism was designed in [58] for providing secure, tamper-proof decentralized model updates. But the accuracy was not improved. A federated hybrid CC system based on an extension of Apache Virtual Computing Lab (VCL) was developed in [59]. The proposed system provided an independent open-source implementation, greater configuration flexibility, and methodological improvements. However, the cost was not minimized. A fault-tolerant IIoHT framework based on digital twin (DT) federated learning-enabled fog-cloud models was designed in [60]. However, it did not consider reducing the response time. A federated learning (FL) system was designed in [61] that includes a reputation mechanism to help manufacturers leverage customer data to train machine learning models. However, the efficiency of the algorithm was not improved. A novel approach was developed in [62] for resource prediction for cloud network load balancing, incorporating federated learning within a blockchain framework for secure and distributed management. But the energy consumption was not minimized.

Despite significant advancements in task scheduling and fault tolerance strategies within cloud computing, the existing approaches still exhibit several limitations. Prior methods, such as the HFTSA, FD-SWMS, ILP, and genetic algorithms, have primarily focused on optimizing individual metrics, like the makespan, throughput, or latency. However, these models often fail to account for the complex interplay of multiple objectives, particularly under heterogeneous cloud environments with large-scale IoT workloads. Most notably, these techniques lack a robust mechanism for accurately classifying resource-efficient virtual machines while simultaneously minimizing computational overhead. Furthermore, recent hybrid or federated approaches do not effectively integrate fault tolerance with predictive learning models, leading to suboptimal performance in terms of energy efficiency, response time, and task failure rate. Additionally, many conventional solutions do not preserve data privacy during VM classification, which is increasingly critical in distributed cloud systems. These shortcomings highlight the need for a scalable, multi-objective framework that not only ensures accurate VM selection through intelligent learning but also adapts efficiently to real-time, fault-prone cloud environments.

Table 1. Parameter descriptions and performance goals.

Parameter	Description	Superiority/Inferiority
L	Latency	Achieve minimum latency
EC	Energy Consumption	Obtain minimum energy consumption
MEM	Memory	Achieve minimum memory
CC	Computational Cost	Obtain minimum computational cost
RT	Response Time	Attain minimum response time
M	Makespan	Achieve minimum makespan
Th	Throughput	Attain higher throughput
E	Efficiency	Attain higher efficiency
FPA	Fault Prediction Accuracy	Achieve enhanced accuracy
P	Precision	Attain higher precision
R	Recall	Obtain higher recall
F1	F1 Score	Achieve higher F1 score

provides a list of key performance parameters used for evaluating task scheduling methods, such as the latency (L), energy consumption (EC), memory usage (MEM), computational cost (CC), response time (RT), makespan (M), throughput (Th), efficiency (E), and fault prediction accuracy (FPA), along with the precision (P), recall (R), and F1 score.

Table 2. Summary of literature review with objectives, advantages, limitations, and results.

No.	Method Name	Objective	Advantages	Limitations	L	EC	MEM	CC	RT	M	Th	E	FPA	P	R	F1
[11]	ReadyFS algorithm	Fault-tolerant scheduling	Enhances resource utilization	Lack of minimizing makespan	✓	✓			✓
[12]	Hybrid optimization algorithms	Efficient task scheduling	Enhances scheduling efficiency	Throughput was not improved		✓	✓		✓				✓
[13]	AFTM	Address job scheduling problem	Enhances scheduling efficiency	Latency was high				✓	✓				✓
[14]	Dynamic, time-sensitive scheduling algorithm	Task scheduling	Reduces computation time	Lack of addressing fault tolerance	✓	✓	✓		✓	✓	✓
[15]	Quality of service (QoS)-aware scheduling	Fault tolerance during task execution	Enhance throughput	Inefficient in accurately scheduling tasks	✓		✓					✓
[16]	Bi-objective optimization	Task scheduling	Minimizes energy and makespan	Lack of improving the QoS-aware scheduling	✓	✓		✓	✓
[17]	M/M/n queuing model	Task scheduling	Minimizes response time	More resource utilization	✓	✓			✓		✓	✓
[18]	Rank-based, resource-aware fault-tolerant method	Task scheduling	Increases the system efficiency	Inapplicable for microservice-based cloud applications	✓	✓	✓			✓		✓	✓	✓	✓	✓
[19]	Adaptive fault detector method	Task scheduling	Minimizes the energy consumption and makespan	High time complexity	✓	✓	✓	✓	✓	✓	✓
[20]	E-DFT scheduling	Fault tolerance task scheduling	Reduces response times	Failed to improve the efficiency	✓	✓	✓	✓	✓		✓
[21]	Scheduling approach with linear scaling-crow search optimization	Workflow scheduling	Improves scheduling efficiently	Failed to enhance the security and scalability of medical data management systems		✓	✓			✓					✓
[22]	Dynamic task scheduling approach	Task scheduling	Minimizes the energy consumption	High time consumption		✓	✓
[23]	ILP method	Task scheduling	Minimizes computational resource utilization	High computational cost	✓	✓	✓	✓		✓
[24]	Fuzzy self-defense method	Multi-objective task scheduling	Efficient resource utilization	Inefficient to enhance task scheduling performance	✓			✓	✓		✓	✓	✓	✓	✓
[25]	Multi-objective algorithm incorporating Q-learning	Task scheduling	Minimizes makespan and enhances throughput	High latency	✓	✓	✓	✓	✓	✓	✓
[26]	Energy-efficient, fault-tolerant scheduling method	Fault-tolerant scheduling	Improves resource utilization	Less throughput	✓	✓	✓	✓
[27]	Fault-tolerant approach to achieve deadline-constrained task scheduling	Task scheduling	Minimizes the response time	Lack of improving scheduling efficiency	✓				✓	✓
[28]	Two semi-greedy-based algorithms	Map IoT tasks	Minimizes makespan	Higher latency	✓				✓	✓
[29]	Effective and adaptive fault-tolerant scheduling method	Error-free task scheduling	Enhances the throughput	Time consumption was not reduced	✓				✓	✓	✓
[30]	Heuristic algorithm	Fault-tolerant virtual network placement	Efficient resource utilization	High response time	✓		✓		✓		✓	✓
[31]	Task Scheduling–Decision Tree (TS-DT) method	Task scheduling	Minimizes makespan	Less throughput	✓			✓	✓		✓
[32]	Fault-tolerant scheduling approach	Fault-tolerant scheduling efficiently	Increases the resource utilization	More time complexity	✓							✓	✓
[33]	EAFT method	Task scheduling	Improves efficiency	High resource utilization	✓				✓		✓	✓
[34]	FT-ERM approach	Task scheduling	Improves efficiency	More time consumption	✓				✓			✓
[35]	Lightweight task scheduling approach	Task scheduling	Reduces the response time	Inefficient in geographically distributed scenarios	✓				✓	✓
[36]	QoS-based resource allocation and scheduling	Task scheduling	Minimizes the delay	High response time	✓	✓	✓	✓			✓
[37]	Enhanced task scheduling approach	Task scheduling	Improves execution efficiency and reduces energy consumption	Makespan was not minimized	✓	✓			✓	✓
[38]	HEFT algorithm	Task scheduling	Minimizes the time consumption	High memory consumption	✓			✓	✓	✓
[39]	Cost-based Job Scheduling	Job scheduling	Enhances the distributed scheduling	Inefficient resource utilization	✓							✓
[40]	Energy- and Performance-Efficient Task Scheduling method	Task scheduling	Minimizes energy consumption	High response time	✓	✓		✓
[41]	SSA	Task scheduling	Minimizes makespan and improves throughput and resource utilization	Failed to reduce latency	✓	✓	✓		✓	✓
[42]	Simple scheduling method	Task scheduling	Minimizes the task running time and complexity	Lack of efficient resource utilization	✓			✓	✓
[43]	Optimal hybrid metaheuristic algorithm	Task scheduling	Enhances task scheduling efficiency and reduces makespan	Less efficiency		✓	✓			✓
[44]	Enhanced load balancing methods	Dynamic task distribution	Minimizes resource utilization	High latency	✓	✓	✓		✓	✓
[45]	Hybrid multi-objective optimization algorithm	Task scheduling	Allocates the resources efficiently	Failed to apply hybrid cloud computing model	✓	✓	✓	✓		✓	✓
[46]	Hybrid genetic algorithm	Task scheduling	Reliable and cost-efficient task scheduling	Dynamic failure-aware task scheduling remained unaddressed	✓	✓	✓	✓
[47]	Hybrid optimization algorithm	Task scheduling	Minimizes energy consumption	High response time	✓	✓			✓	✓
[48]	Machine learning inference-serving models	To optimize inference and improve scalability	Improves system efficiency with minimal latency	Failed to perform integration between serverless platforms and ML frameworks	✓			✓	✓
[49]	Detailed taxonomy of several serverless computing models	Handling the cold start latency	Optimizes loading time as well as resource usage	Lack of improving efficiency	✓				✓	✓
[50]	Function placement approaches	Serverless computing	Improves system efficiency	Execution time, resource consumption, and cost were not reduced	✓				✓		✓
[51]	Q-learning Auto-scaling Offloading	To enhance offloading	Minimizes latency, cost, and energy	Computation load prediction was not performed	✓	✓	✓	✓			✓
[52]	Review of content caching approach	Edge computing environment	Enhances processing performance	Model has limited storage capacity	✓	✓			✓	✓	✓
[53]	Cold start latency mitigation approaches	Serverless computing platforms	Minimizes response time	Resource utilization was not minimized	✓	✓		✓	✓
[54]	Scheduling approaches	Serverless computing	More energy-efficient and deadline-aware scheduling	Less efficiency	✓	✓					✓
[55]	Function offloading methods	Serverless computing	Improves system efficiency and reduces latency	Throughput was not improved	✓			✓	✓	✓
[56]	Hybrid task scheduling technique	Task scheduling	Enhances makespan, energy, cost, and fault tolerance performance	Lesser throughput	✓		✓		✓		✓	✓
[57]	RTATSA2C	Resource-efficient task scheduling	Reduces makespan and improves reliability, fault tolerance, trust, and scalability	Efficiency of the algorithm was not improved	✓			✓			✓	✓	✓	✓

summarizes various literature methods, highlighting their objectives, strengths, and limitations with respect to the parameters listed in Table 1.

3. Proposal Methodology

Cloud computing is a virtualized and scalable computing model that dynamically offers diverse resources and services. It operates through a network of servers, employing numerous physical machines known as virtual machines to distribute cloud services. Due to the dynamic arrival of computing task flows in the cloud computing environment, task failures may occur due to the unavailability of resources, execution cost and time exceeding, system running out of memory, over-utilization of resources, and improper installation. These faults cause cloud computing to fail to deliver on the time-sensitive requirements of user-requested applications. Therefore, a novel MRKFL-FTS technique has been developed to guarantee the fault-tolerant cloud IoT for task scheduling.

The main objective of the paper is to enhance resource-efficient, fault-tolerant IoT request scheduling in dynamic cloud environments. To achieve this objective, the MRKFL-FTS technique is introduced, which includes two methods, namely, Multi-objective Radial Kernelized Federated Learning (MRKFL) and the weighted round-robin scheduling method. The MRKFL method determines resource-efficient virtual machines based on factors, such as energy, memory, CPU time, and average failure rate. After classifying the resource-efficient virtual machines, the server assigns incoming IoT requests to the appropriate virtual machines using the weighted round-robin scheduling method. Figure 1 illustrates the proposed MRKFL-FTS technique for IoT-aware resource-optimized scheduling in cloud environments. The inputs to the system include IoT service requests from users, while the outputs are the scheduled allocation of these requests to virtual machines based on resource efficiency and fault tolerance. The MRKFL technique involves a machine learning approach that combines multiple objectives to select the most suitable virtual machine for task scheduling. It leverages federated learning across decentralized edge devices to enhance the scheduling process. The system measures various parameters such as the energy consumption, memory usage, and CPU performance of virtual machines to determine their efficiency and suitability for task allocation. Then, fault tolerance mechanisms are used to ensure reliable task scheduling even in the presence of failures or disruptions. The local training model evaluates the performance of virtual machines based on factors like energy consumption, memory usage, CPU performance, and failure rate using Radial Kernelized Support Vector Regression(RKSVR). Locally trained models are combined to create a global aggregation model that represents the overall performance and suitability of virtual machines for task scheduling. Thus, the system identifies virtual machines that are both resource-efficient and have a minimal failure rate, ensuring optimal task allocation and fault tolerance. The task assigner schedules incoming IoT service requests to the selected virtual machine using a weighted round-robin scheduling method, optimizing resource utilization and enhancing fault tolerance in the scheduling process. By following these steps, utilizing the MRKFL-FTS technique, the system aims to improve the efficiency, reliability, and fault tolerance of IoT request scheduling in cloud environments.

3.1. Cloud IoT Environment Model

The proposed MRKFL-FTS technique involves two models, namely, C-RAN and V-RAN. C-RAN is a centralized, cloud computing-based architecture for radio access networks that enables large-scale deployment and real-time virtualization capacity. V-RAN (virtualized radio access network) is responsible for connecting IoT devices to the cloud server network. In a C-RAN environment, multiple servers $S=S_1,S_2,S_3,\dots ,S_y$ where $S_j\in S$ are present, with each server including several virtual machines $VM=V{M}_1,V{M}_2,V{M}_3\dots ,V{M}_n$ where $V{M}_i\in VM$. In a V-RAN, the cloud incorporates numerous IoT devices to connect these devices to the cloud server network for scheduling. Initially, cloud IoT devices or users submit incoming tasks/requests $T=T_1,T_2,T_3,\dots ,T_b$, where $T_g\in T$ to be executed on cloud servers. Upon receiving the request, the proposed MRKFL-FTS identifies the resource-efficient and minimal failure-prone virtual machine. Subsequently, the task assigner schedules incoming IoT tasks to the resource-efficient virtual machine with a minimal failure rate.

3.2. Multi-Objective Radial Kernelized Federated Learning

Federated learning is a machine learning technique that allows a model to be trained across multiple decentralized edge devices (such as IoT devices or other local servers) without exchanging raw data. It involves training an algorithm locally across multiple resources and obtaining a global aggregation model. In the local training phase, a task assigner evaluates various objective functions of the virtual machine, such as the energy consumption, memory usage, CPU performance, and failure rate, by applying kernelized support vector regression. Then, the locally trained models are combined, and the resulting model is fed into the global aggregation model.

Figure 2 illustrates the structure of the Multi-objective Radial Kernelized Federated Learning (MRKFL) technique. In the figure, three visually identical input blocks and their corresponding local training models are depicted. While these models appear similar, they are deliberately designed to represent three distinct sets of input tasks arriving from different IoT users or application domains. Each input block corresponds to a unique batch of IoT-generated tasks that are dynamically received by the cloud server. These task batches differ in characteristics, such as resource demand, execution priority, and deadline constraints. Once received, each batch is processed independently by a dedicated local training model. These models employ RKSVR to classify the available virtual machines (VMs) based on multiple resource-oriented objectives, including energy availability, memory usage, CPU time, and average failure rate.

Although the three local models share an identical structure, the key distinction lies in the heterogeneity of their input task profiles. Each model is trained on different data, reflecting the unique demands of the incoming requests. After local training, each model outputs its classification of resource-efficient VMs. These locally optimized results are then forwarded to the global aggregation model, which combines them to produce a unified, optimized task scheduling decision.

Let us consider the virtual machines $VM=V{M}_1,V{M}_2,V{M}_3\dots ,V{M}_n$ in a cloud datacenter and the consumption of energy, memory, and CPU time, and the average failure rates across virtual machines. Proper management of energy resources in virtual machines can lead to improved sustainability and cost-effectiveness. Memory allocation and optimization among the virtual machines are critical for maintaining system stability and preventing resource contention. Effective distribution of CPU time among the virtual machines is necessary for achieving optimal processing power and performance for various applications running on the cloud infrastructure. Monitoring and addressing the average failure rates in virtual machines are vital for ensuring service delivery and minimizing downtime. Thus, cloud providers can enhance the overall performance of cloud computing services.

Energy plays a major role in task scheduling. Therefore, managing the energy consumption of virtual machines is crucial for optimizing resource utilization and reducing operational costs. First, the energy availability is estimated as follows

$$E_{ai}=E_{ki}-E_{ci}$$

(1)

where $E_{ai}$ indicates the energy availability of the virtual machine $V{M}_i$, $E_{ki}$ indicates the total energy of the virtual machine $V{M}_i$, and $E_{ci}$ denotes the consumed energy of the virtual machine $V{M}_i$.

Memory is a significant resource in task scheduling, measured by the amount of storage space needed to execute tasks. Therefore, memory availability is evaluated to find a virtual machine’s storage capacity.

$${\mu }_{ai}={\mu }_{ki}-{\mu }_{ci}$$

(2)

where ${\mu }_{ai}$ designates the memory availability of the virtual machine $V{M}_i$, ${\mu }_{ki}$ indicates the total memory capacity of the virtual machine $V{M}_i$, and ${\mu }_{ci}$ indicates the memory consumption of the virtual machine $V{M}_i$.

The available CPU time within $V{M}_i$ is within a specific time window B.

$$t_{ai}=\sum _{g=1}^{b^{\prime }}{t}_{g_i}-B$$

(3)

where $t_{ai}$ denotes the available CPU time of the virtual machine based on the allocated tasks within the time window B. This is calculated by discretizing time where $t_{gi}$ represents the execution time of task g in $V{M}_i$, and $b^{\prime }$ represents the number of allocated tasks in $V{M}_i$.

Following that, the average failure rate of a virtual machine is calculated as the ratio of the number of tasks that have previously failed to be executed by the machine to the total number of tasks submitted for execution on the machine. This is expressed by the following formula:

$$AF{R}_i={\displaystyle \frac{{\omega }_i^f}{{\omega }_i^s}}$$

(4)

where $AF{R}_i$ denotes an average failure rate of the virtual machine, ${\omega }_i^f$ indicates a number of failed tasks of the virtual machine $V{M}_i$, and ${\omega }_i^s$ indicates a number of submitted tasks of the virtual machine $V{M}_i$. After computing the multi-objective functions, RKSVR is employed to select the virtual machine.

Radial kernelized Support Vector Regression (RKSVR) is a machine learning technique used to find a hyperplane that categorizes the input into different classes based on the relationships between the resources of a virtual machine and the corresponding threshold value.

The optimal hyperplane $H{P}_i$ is the decision boundary that is used to make predictions. Therefore, the optimal hyperplane is estimated as follows:

$$R_i=W_{E_{ai}}{E}_{a_i}+W_{{\mu }_{a_i}}{\mu }_{a_i}+W_{t_{a_i}}{t}_{a_i}\forall i$$

(5)

$$H{P}_i\to w.R_i+\beta =0$$

(6)

From Equation (5), $R_i$ denotes the resource metrics of $V{M}_i$. The equations specify weights for each performance metric. $W_{E_{a_i}}$ represents the weight of the energy efficiency metric within $V{M}_i$. Similarly, $W_{{\mu }_{a_i}}$ represents the weight metric of the available memory on $V{M}_i$ and $W_{t_{a_i}}$ represents the weight of the available CPU time on $V{M}_i$.

Equation (6) represents the hyperplane, which implies the value derived from Equation (5) for $R_i$ and $\beta$ represents a bias. Following that, the two marginal hyperplanes are selected either above or below the decision boundaries as defined by Equations (7) and (8).

$$M_{1i}\to R_i+\beta >0$$

(7)

$$M_{2i}\to R_i+\beta <0$$

(8)

where $M_{1i}$ and $M_{2i}$ indicate marginal hyperplanes for classifying $V{M}_i$. If the value from Equation (7) $M_{1i}$ is greater than 0, then $V{M}_i$ is classified as resource-efficient (i.e., +1). If the value from Equation (8) $M_{2i}$ is less than 0, then $V{M}_i$ is classified as not resource-efficient (i.e., −1).

Hyperplanes use the radial kernel function to measure the similarity between the estimated resources of the virtual machine and its threshold value. The similarity is estimated as given in Equation (9).

$$R{K}_i=exp\left(-{\displaystyle \frac{1}{2{\sigma }^2}}\mid R_i-TH{\mid }^2\right)$$

(9)

from Equation (9), $R{K}_i$ is the radial kernel function of $V{M}_i$, $\mid R_i-TH\mid$ is the difference between the resource of virtual machine $R_i$ and threshold $TH$, and $\sigma$ indicates a deviation parameter $\sigma >0$. The output results of the radial kernel function vary between 0 and 1. Based on the similarity, the hyperplanes classify $V{M}_i$ if it is above or below the decision boundary. If the output is 1, then the hyperplanes classify $V{M}_i$ as $M_{1i}$. If the kernel output is 0, then the hyperplane classifies $V{M}_i$ as $M_{2i}$.

Figure 3 illustrates the classification results generated by the radial kernelized support vector regression (RK-SVR) model using actual test data obtained from the MRKFL-FTS framework. In this output, real virtual machine (VM) metrics—such as CPU utilization, memory usage, and task execution patterns—are used as input features to train and test the classifier. The RK-SVR model applies a radial kernel to map these input features into a higher-dimensional space where a separating hyperplane can be constructed. This hyperplane effectively distinguishes between resource-efficient and non-efficient virtual machines. In this context, a classification value of +1 indicates that the virtual machine is resource-efficient and suitable for scheduling tasks, while a value of −1 denotes that the machine does not meet the efficiency criteria. Unlike a schematic diagram, this figure visualizes actual classification boundaries and support vectors derived from empirical data, providing a more accurate and realistic view of how the model behaves in practice. The resulting plot shows a clear separation between the two classes, validating the effectiveness of the MRKFL-FTS in identifying optimal VMs for task assignment in a dynamic cloud environment. This contributes directly to minimizing computational overhead and improving scheduling efficiency.

A cross-entropy loss function is employed to evaluate the model’s performance. This loss function measures the difference between the actual and predicted probabilities for the classification task. Specifically, it quantifies the uncertainty in the predictions made by the radial kernelized model from Equation (9), where the output is either resource-efficient or not resource-efficient. The cross-entropy loss function, denoted as L, is defined as follows:

$$L_{R_i}=-{\displaystyle \frac{1}{n}}\sum _{i=1}^n\left[R{K}_i]·log\left(\widehat{R{K}_i}\right)+(1-R{K}_i)·log(1-\widehat{R{K}_i})\right]$$

(10)

$L_{R_i}$, the cross-entropy loss function, measures the error between the actual and predicted classifications of the virtual machine’s $V{M}_i$ resource efficiency. $R{K}_i$ represents the actual classification label (resource-efficient or not) for virtual machine $V{M}_i$. $R_i^K$ is the predicted probability that the virtual machine $V{M}_i$ is resource-efficient, and n is the total number of virtual machines being evaluated.

In the proposed MRKFL-FTS technique, the global aggregator model is essential to unify the outputs from $V{M}_i$ trained with local IoT service data. Each VM computes its radial kernel output, reflecting localized insights into task scheduling and fault tolerance. The global aggregator combines these outputs using a weighted average to create a more generalized model that enhances classification accuracy across all VMs. This aggregation process addresses the challenge of data heterogeneity among VMs, ensuring that the model benefits from diverse training data while preserving data privacy. Furthermore, the global model minimizes the cross-entropy loss function, reducing discrepancies between predicted and actual classifications for resource-efficient task assignments. By incorporating the global aggregator, the MRKFL-FTS technique achieves robust and resource-aware task scheduling, enabling efficient IoT service management even in the presence of faults or non-uniform data distributions across VMs.

$$A=\sum _{i=1}^{n}R{K}_i\ast {\alpha }_i$$

(11)

where A represents the global aggregator model, $R{K}_i$ is the radial kernel output of the virtual machine $V{M}_i$, and ${\alpha }_i$ denotes a weight of the local model result for the virtual machine $V{M}_i$.

The federated learning framework aims to minimize the global loss function across all virtual machines. This objective function optimizes the overall learning accuracy.

$$Z=min{L}_{R_i}\forall R_i$$

(12)

where Z denotes a global objective function. $L_{R_i}$ denotes the cross-entropy loss function, which measures the difference between the actual and predicted resource-efficient classifications, i.e., the loss function that the aggregation model aims to reduce the losses in the federated learning process. The term $min$ is a mathematical notation that identifies the parameter values (resource allocation strategies or weights) that minimize the global loss function $L_{R_i}$. Minimizing this loss ensures that the aggregated model optimizes its performance in terms of resource efficiency. By reducing the loss, the system iteratively improves its predictions for resource-efficient scheduling, leading to a balanced utilization of energy, memory, and CPU time. This minimization process is critical to ensuring that the federated learning framework not only enhances classification accuracy but also operates effectively within the constraints of the cloud IoT environment.

A stochastic steepest descent function is employed to optimize the loss. In this process, each virtual machine $V{M}_i$ is associated with a weight ${\alpha }_t$ at time t, which reflects its efficiency or suitability for handling incoming IoT service requests. The weight is iteratively updated using gradient descent to minimize the loss $L_{R_i}$ specific to that VM. The update rule is defined as follows:

$${\alpha }_{t+1}={\alpha }_t-\eta \left[{\displaystyle \frac{\partial L_{R_i}}{\partial {\alpha }_t}}\right]$$

(13)

Here, ${\alpha }_{t+1}$ denotes the updated weight for $V{M}_i$, ${\alpha }_t$ is the current weight, and $\eta$ represents the learning rate ($\eta <1$), controlling the update step size. The term ${\displaystyle \frac{\partial L_{R_i}}{\partial {\alpha }_t}}$ refers to the partial derivative of the local loss function $L_{R_i}$ with respect to ${\alpha }_t$, which quantifies how sensitive the loss is to the weight adjustment for $V{M}_i$. This process is repeated iteratively until convergence or the maximum number of iterations is reached. By applying this adaptive update mechanism, the model continuously refines its classification of resource-efficient virtual machines. Consequently, after identifying the most efficient VM, the task assigner schedules the incoming IoT service requests to this selected VM, thereby improving overall resource utilization, reducing the execution loss, and enhancing the fault-tolerant scheduling in cloud environments.

Algorithm 1 describes the processing steps for efficient IoT task scheduling in cloud computing using a Multi-objective Radial Kernelized Federated Learning (MRKFL) technique. The federated learning process begins with deploying a local training model across a set of virtual machines. Within the local training model, support vector regression constructs a hyperplane as a decision boundary for analyzing the resources of each virtual machine and determining a threshold value based on the radial kernel function. Depending on the kernel outcome, the hyperplane categorizes a virtual machine as either resource-efficient or not. The global aggregation model then combines all the local training output results through a weighted average model. For each output result, an objective function is defined. The weights are updated based on the loss value. The updated model weight is sent back to the local training model for training on the newly generated input. Finally, the classification of resource-efficient virtual machines is obtained.

Algorithm 1 Multi-objective Radial Kernelized Federated Learning (MRKFL)

1: Input: Number of virtual machines $V{M}_i=V{M}_1,V{M}_2,V{M}_3,\dots ,V{M}_n$ 2: Output: Classification of virtual machines 3: Begin 4: for each incoming IoT request $T_g$ 5:    for each virtual machine $V{M}_i$ 6:       Estimate resources $E_{ai}$, ${\mu }_{ai}$, $t_{ai}$, $AF{R}_i$ 7:       Apply MRKSVR in local training 8:       Construct hyperplane $H{P}_i$ 9:       Find two marginal hyperplanes $M_{1i}$, $M_{2i}$ 10:     Measure the radial kernel between the resource and threshold using (9) 11:     if $R{K}_i>0$ 12:        Virtual machine is classified as resource-efficient 13:     else 14:        Virtual machine is classified as not resource-efficient 15:     end if 16:     Find global aggregation model by weighted average using Equation (11) 17:     Minimize the loss function for the local training model using Equation (12) 18:     Update the weight ${\alpha }_{t+1}$ using Equation (13) 19:     if Minimum of loss is reached 20:          Convergence is met 21:     else 22:          Go to Step 16 23:     end if 24:       Return: Output results (Classified Virtual Machines) 25:   end for 26:   End

3.3. Weighted Round-Robin IoT Request Scheduling

This section introduces the integration of the classified resource-efficient virtual machines with an allocation technique. As this paper’s contribution focuses on the classification mechanism presented in Section 3.2, the integration shall improve scheduling solutions in cloud computing. To demonstrate the impact of the proposed MRKFL classification on the quality of the solution provided, we integrate it with the well-known round-robin technique.

We denote the resource-efficient virtual machine obtained by the MRKFL technique specified in Section 3.2 as $V{M}^{\prime }=V{M}_1,V{M}_2,\dots V{M}_u$, where $u\le n$. To incorporate the classical round robin with MRKFL, a weight is assigned to each virtual machine based on the resource efficiency classification, which is based on the three dimensions of energy, memory, and CPU time produced by the proposed MRKFL technique presented in Algorithm 1. Throughout the paper, we will refer to the classical round-robin integration with the proposed MRKFL as the weighted round robin (WRR).

The WRR algorithm integrates a queue mechanism to manage the incoming workload systematically. Tasks from users are placed in a queue, where they are processed in a first-in, first-out order. The tasks are assigned to VMs based on their weights. If a task is not completing its execution, it is moved to the back of the queue, allowing the next task to proceed. This cyclic scheduling ensures effective utilization of available resources, prevents overloading any single VM, and balances the workload while maintaining a seamless flow of task execution.

Algorithm 2 describes the weighted round-robin IoT request scheduling method, which allocates tasks to resource-efficient virtual machines $V{M}^{\prime }$. For each virtual machine from $V{M}^{\prime }$, a weight is assigned based on its resource efficiency. IoT requests are then fetched from the task queue and scheduled to the appropriate VM based on their weight. If a task is executed successfully, the scheduling for that task is marked as complete. If the task is not executed, it is returned to the queue. This process continues iteratively for each VM, ensuring the execution of all tasks.

Algorithm 2 Weighted Round-Robin IoT Request Scheduling

1: Input: Resource-efficient virtual machines $V{M}^{\prime }=V{M}_1^{\prime },V{M}_2^{\prime },V{M}_3^{\prime },\dots ,V{M}_u^{\prime }$, where $u\le n$, Incoming tasks/IoT requests $T=T_1,T_2,T_3,\dots ,T_b$, where $T_g\in T$ 2: Output: Allocated IoT requests to $V{M}^{\prime }$ 3: Begin 4: for each resource-efficient virtual machine $V{M}_i^{\prime }$ do 5:     Allocate weight to $V{M}_i$ based on resource efficiency 6: end for 7: while there are IoT requests in the task queue do 8:     for each resource-efficient virtual machine $V{M}_i^{\prime }$ do 9:          if a task is available in the queue then 10:              Assign the task $T_g$ to $V{M}_i^{\prime }$ with the highest weight. 11:              if the task completes successfully then 12:                  Mark the task as completed 13:              else 14:                  Reinsert the task into the queue for rescheduling 15:             end if 16:         end if 17:     end for 18: end while 19: End

4. Experimental Setup

The experimental analysis of the MRKFL-FTS technique and the existing methods HFTSA [1] and FD-SWMS [2] and the hybrid EMD-Transformer-BiLSTM prediction model [58] has been implemented in the Java programming language using the CloudSim simulator. To conduct the experiment, Personal Cloud Datasets were considered and collected from Supplementary File and the features description discussed in

Table 3. Dataset features and descriptions.

S.No	Feature	Description
1	row id	Unique identifier for each row entry
2	account id	Identifier assigned to each user account
3	file size (task size)	Size of the file associated with the task (in bytes or MB)
4	operation_time_start	Start time of the task operation
5	operation_time_end	End time of the task operation
6	time zone	Time zone in which the operation occurred
7	operation_id	Unique identifier for the operation performed
8	operation type	Type of task operation (e.g., upload and download)
9	bandwidth trace	Bandwidth usage trace data during the operation
10	node_ip	IP address of the node executing the task
11	node_name	Name of the server or node used for processing
12	quoto_start	Initial allocated quota/storage at the start of the task
13	quoto_end	Remaining quota/storage at the end of the task
14	quoto_total	Total storage capacity allocated
15	capped	Whether the storage was capped (Yes/No or Boolean)
16	failed	Flag indicating if the task failed (1 = failed; 0 = successful)
17	failure info	Detailed information about failure, if any

. The primary objective of this dataset is to schedule workloads or IoT requests within a cloud environment. The dataset comprises 17 attributes and 66,245 instances. These attributes include significant information such as unique identifiers for rows and accounts, task sizes, operation start and end times, operation types, bandwidth traces, node details including IP addresses and names, allocated quotas with start and end times, storage capacities, failure indicators, and failure information. The dataset is divided into the training dataset and the testing dataset. The training dataset is 70% and the testing dataset is 30%.

Table 4. Experimental settings and requirements.

Simulation Settings
Number of tasks used in simulation	1000–10,000
Number of virtual machines	10–50
Network bandwidth of VMs	10,000 Kbps
Memory of VMs	4096 MB
Energy of VMs	100 kWh
Operating system	Windows 7 and above
Software used	CloudSim 3.0, Java
Simulation environment	CloudSim 3.0
Physical Node Specifications
Processor	Intel® Core™ i3
RAM	16 GB
Hard disk capacity	1 TB
Java Software and Hardware Requirements
Operating system	Windows 10 and above
Programming language	Java
System	Intel Core i3 processor
RAM	4 GB
Hard disk	512 GB
Mouse	Logitech
Keyboard	110 keys enhanced

shows the experimental setup used for the proposed algorithm and the existing algorithms.

4.1. Experimentation Results

The Experimentation Results section presents the findings obtained from a series of controlled experiments designed to evaluate the performance and effectiveness of the proposed methodology. The primary objective of these experiments is to assess the impact of the MRKFL technique and its performance measure. This section analyzes the captured classification accuracy results, average resource utilization rates, and average waiting time using the proposed MRKFL-FTS technique with the existing HFTSA [1] and FD-SWMS methods [2] and the hybrid EMD-Transformer-BiLSTM prediction model [58].

4.1.1. Classification Accuracy

Resource-efficient virtual machine classification aims to accurately predict the appropriate virtual machine to optimize resource usage, such as CPU, memory, and energy, in cloud computing environments. The classification accuracy refers to correctly categorizing the VMs based on resource utilization.

$$Accuracy=\left({\displaystyle \frac{Numberofcorrectlyclassifiedvirtualmachines}{Totalnumberofvirtualmachines}}\right)\times 100$$

(14)

where $Accuracy$ denotes the classification accuracy. It is measured in terms of %.

Figure 4 and

Table 5. Experimental results of classification accuracy.

VMs	MRKFL-FTS	HFTSA	FD-SWMS	Hybrid EMD-Transformer-BiLSTM
10	98	94	92	90
20	97	93	90	89
30	99	93	91	90
40	98	92	90	88
50	97	93	92	90

illustrate the experimental results of the classification accuracy for four techniques: the proposed MRKFL-FTS, HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM prediction model [58]. Classification accuracy refers to the ability of the technique to correctly categorize virtual machines (VMs) as resource-efficient or not, which is essential for enhancing task and request scheduling in cloud computing environments. As shown in Table 5, the MRKFL-FTS technique consistently outperforms the other methods across different numbers of VMs. For instance, with 10 VMs, the MRKFL-FTS achieves an accuracy of 98%, while the HFTSA, FD-SWMS, and hybrid model achieve 94%, 92%, and 90%, respectively. When the number of VMs increases to 30, the MRKFL-FTS reaches its peak performance at 99%, whereas the accuracies of the HFTSA, FD-SWMS, and hybrid model remain at 93%, 91%, and 90%, respectively. Overall, the MRKFL-FTS technique maintains a high classification accuracy (between 97% and 99%) across all the tested VM counts (10 to 50), clearly demonstrating its robustness and scalability. This superior performance is attributed to its use of radial kernelized support vector regression (RK-SVR), which enhances the ability to identify resource-efficient virtual machines accurately.

4.1.2. Average Resource Utilization

It is a measure of how efficiently resources such as CPU, memory, storage, and network bandwidth are being utilized by virtual machines in a cloud environment. It represents the proportion of a resource’s utilization by each virtual machine to the total number of virtual machines.

$$Average=\left({\displaystyle \frac{Sumofresourceutilizationforallvirtualmachines}{Totalnumberofvirtualmachines}}\right)\times 100$$

(15)

where $Average$ denotes the average resource utilization. It is measured in percentage (%).

The experimental settings for evaluating average resource utilization across different virtual machine configurations are outlined in

Table 6. Experimental results of average resource utilization (%).

VMs	MRKFL-FTS	HFTSA	FD-SWMS	Hybrid EMD-Transformer-BiLSTM
10	18	22	25	28
20	25	30	33	35
30	33	40	44	46
40	40	45	50	55
50	51	56	60	62

. The simulation considers between 1000 and 10,000 tasks, with the number of virtual machines (VMs) ranging from 10 to 50. As presented in Figure 5 and Table 6, the MRKFL-FTS technique demonstrates efficient and scalable resource utilization. It starts at 18% for 10 VMs and increases steadily, reaching 51% for 50 VMs. In comparison, the HFTSA [1] shows higher initial utilization at 22% with 10 VMs, rising to 56% with 50 VMs. The FD-SWMS [2] starts at 25% and increases to 60%, exhibiting a steeper rise but lacking the consistency of the MRKFL-FTS. Meanwhile, the hybrid EMD-Transformer-BiLSTM prediction model [58] achieves the highest utilization across all the VM counts, starting at 28% and peaking at 62%. Although the hybrid model achieves the highest resource utilization, the MRKFL-FTS offers a better balance between efficiency and predictability. Its consistent performance across increasing VM counts suggests a more controlled and optimized resource management process. Unlike the FD-SWMS and HFTSA, whose performance may fluctuate with scale, the MRKFL-FTS maintains a gradual and stable improvement, making it a more dependable solution for resource optimization in dynamic cloud computing environments.

4.1.3. Average Waiting Time

It refers to the mean amount of time that tasks spend waiting in the queue before they are scheduled to resource-efficient virtual machines. It is measured in milliseconds (ms).

$$AverageWaitingTime=\left({\displaystyle \frac{Sumofwaitingtimesofalltasksinqueue}{Totalnumberoftasks}}\right)\times 100$$

(16)

The experimental results presented in Figure 6 and

Table 7. Average waiting time (ms) for different time slices.

Time Slice t (ms)	MRKFL-FTS	HFTSA	FD-SWMS	Hybrid EMD-Transformer-BiLSTM
0	0	0	0	0
1	4	6	8	9
2	5	7	9	10
3	7	8.9	10.2	11.2
4	9	11.7	12.8	13.8
5	8.5	12.4	14.5	15.5
6	11.2	13.8	15.2	16.2
7	9.7	11.4	13	14
8	8.5	10.5	12.8	13.8
9	9.8	11.9	14.2	15.2
10	10.7	13	15.8	16.8

illustrate the average waiting time (in milliseconds) for four scheduling techniques—namely, the proposed MRKFL-FTS, HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM prediction model [58]—across 11 time slices ranging from 0 ms to 10 ms. The simulation involves scheduling 1000 tasks across these time slices, with the waiting time measured as the delay each task experiences before being allocated to a resource-efficient virtual machine. At time slice 0, all the methods show a waiting time of 0 ms, as no tasks are yet present in the queue. As the time slices increase, the waiting times rise across all the methods, but the MRKFL-FTS consistently achieves the lowest waiting time. For instance, at time slice 1, the MRKFL-FTS records 4 ms, while the HFTSA, FD-SWMS, and hybrid model report 6 ms, 8 ms, and 9 ms, respectively. By time slice 10, the MRKFL-FTS maintains the lowest average waiting time at 10.7 ms, compared to 13 ms for the HFTSA, 15.8 ms for the FD-SWMS, and 16.8 ms for the hybrid model. These results clearly indicate that the MRKFL-FTS outperforms the other techniques in minimizing task queuing delays. This effectiveness becomes more pronounced as the task load increases over time slices, confirming MRKFL-FTS as a more efficient and scalable scheduling approach for cloud environments.

4.1.4. Computation Overhead

Computation overhead in data transmission refers to the total time it takes for data to travel from its sender node to the receiver node.

$$CO=\sum _{j=1}^m{M}_i·T$$

(17)

where $CO$ indicates the computation overhead, M represents the number of virtual machines, and T denotes the task execution time. The computation overhead is measured in milliseconds (ms).

The experimental results shown in

Table 8. Computation overhead (ms) for different virtual machine configurations.

Number of VMs	MRKFL-FTS	HFTSA	FD-SWMS	Hybrid EMD-Transformer-BiLSTM
10	65.0	72.0	80.6	82.6
20	70.3	75.8	82.8	84.8
30	75.8	82.6	90.6	95.6
40	80.2	90.3	98.5	100.5
50	90.3	104.5	112.6	114.6

and Figure 7 present the computation overhead (measured in milliseconds) for four task scheduling techniques—the MRKFL-FTS, HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM prediction model [58]—across increasing numbers of virtual machines (VMs), ranging from 10 to 50. As the number of virtual machines increases, the computation overhead also increases for all the methods, which is expected due to the higher volume of task assignments and resource coordination. However, the MRKFL-FTS technique consistently exhibits lower computation overhead compared to the other methods at each scale. For example, at 10 VMs, the MRKFL-FTS records a computation overhead of 65 ms, while the HFTSA, FD-SWMS, and hybrid model report 72 ms, 80.6 ms, and 82.6 ms, respectively. As the scale increases to 30 VMs, the MRKFL-FTS maintains a moderate increase to 75.8 ms, whereas the HFTSA reaches 82.6 ms, the FD-SWMS climbs to 90.6 ms, and the hybrid model peaks at 95.6 ms. At 50 VMs, the MRKFL-FTS shows an overhead of 90.3 ms, which is significantly lower than the HFTSA (104.5 ms), the FD-SWMS (112.6 ms), and the hybrid model (114.6 ms). These results demonstrate that the MRKFL-FTS is more efficient in handling computation load, especially in large-scale cloud environments. Radial kernelized support vector regression is a machine learning technique used to find a hyperplane that categorizes the input into different classes based on the relationships between the resources of the virtual machine and the corresponding threshold value. Computation overhead is not minimized in existing methods; therefore, a Radial Kernelized support vector regression approach is used to identify the most efficient virtual machine, which helps reduce this overhead. This method minimizes redundant processing and intelligently distributes tasks by combining federated learning with Radial Kernelized approach.

4.1.5. Result Analysis of Precision, Recall, and F1 Score

Precision: In the context of virtual machine (VM) classification, precision refers to the effectiveness of a classification algorithm in accurately predicting specific characteristics of VMs based on various factors, such as resource usage. It is mathematically computed as follows:

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

(18)

where $TP$ (true positive) denotes the number of VMs correctly identified as resource-efficient, and $FP$ (false positive) refers to the VMs incorrectly identified as resource-efficient.

Recall: Also known as sensitivity, recall is a key metric that measures the ability of a classification model to identify resource-efficient virtual machines. In VM classification, recall refers to the proportion of actual positive cases that are correctly identified by the model:

$$\mathrm{Recall}={\displaystyle \frac{TP}{TP+FN}}$$

(19)

where $FN$ (false negative) represents the VMs that are actually resource-efficient but were not correctly identified as such by the classifier.

F1 Score: The F1 score is the harmonic mean of the precision and recall, combining both metrics into a single performance measure. It is especially useful when there is an uneven class distribution and a balance between precision and recall is needed:

$$\mathrm{F}1\mathrm{Score}=2\times {\displaystyle \frac{\mathrm{Precision}\times \mathrm{Recall}}{\mathrm{Precision}+\mathrm{Recall}}}$$

(20)

Figure 8, Figure 9 and Figure 10 present the comparative analysis of the precision, recall, and F1 score for four classification methods—the MRKFL-FTS, HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM prediction model [58]—across varying numbers of virtual machines (VMs) ranging from 10 to 50. The results indicate that the MRKFL-FTS technique consistently achieves the highest values for all three metrics, demonstrating its effectiveness in classifying virtual machines as resource-efficient. For instance, at 10 VMs, the MRKFL-FTS records a precision of 0.963, a recall of 0.948, and an F1 score of 0.955. These values are superior to the HFTSA (0.942, 0.926, and 0.933), FD-SWMS (0.926, 0.911, and 0.918), and hybrid model (0.916, 0.910, and 0.915), respectively.

As the number of VMs increases, the MRKFL-FTS continues to maintain robust performance. At 50 VMs, it achieves a precision of 0.965, a recall of 0.957, and an F1 score of 0.960, while the other methods show slightly lower scores. Although the hybrid EMD-Transformer-BiLSTM shows competitive performance, especially in recall (e.g., 0.910 at 10 VMs and 0.901 at 50 VMs), its precision and F1 score remain slightly below those of the MRKFL-FTS. These findings demonstrate the superiority of the MRKFL-FTS technique in balancing both precision and recall, as reflected in its consistently high F1 scores. This indicates its ability to accurately and reliably identify resource-efficient virtual machines, which is essential for optimizing task scheduling and improving overall system performance in cloud computing environments.

5. Performance Analysis

This section presents the experimental assessment of the MRKFL-FTS technique, and the existing methods HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM [58], with a focus on task scheduling efficiency, makespan, throughput, response time, fault prediction accuracy, and time complexity. The performance of these parameters is analyzed using tables and graphical representations.

5.1. Task Scheduling Efficiency

The task scheduling efficiency parameter, also called the success ratio, refers to the ratio of successfully allocated tasks to the total number of submitted tasks. This efficiency is calculated using Equation (17):

$$Efficiency=\left({\displaystyle \frac{\mathrm{Correctly}\mathrm{Scheduled}\mathrm{Tasks}}{\mathrm{Total}\mathrm{Tasks}}}\right)\times 100$$

(21)

where $Efficiency$ represents the task scheduling efficiency. It is measured in terms of percentage (%).

Figure 11 and

Table 9. CPU cost and task scheduling efficiency for various techniques.

Number of Requests	CPU Cost (AED)	Task Scheduling Efficiency (%)
		MRKFL-FTS	HFTSA	FD-SWMS	Hybrid EMD-Transformer-BiLSTM
1000	0.000137	96.2	93.5	91.2	90.2
2000	0.000156	97.75	91.2	89.25	88.25
3000	0.000155	97.73	93.33	90.5	89.5
4000	0.000146	96.4	91.3	89.125	88.125
5000	0.000140	97.3	92.66	88.2	86.2
6000	0.000159	96.41	92.75	90.2	88.2
7000	0.000158	97.72	93.21	90.35	89.35
8000	0.000149	96.42	91.56	89.45	87.45
9000	0.000139	97.91	90.02	88.03	86.03
10,000	0.000159	96.25	89.69	87.15	86.15

illustrates the efficiency of task scheduling with varying numbers of IoT requests, ranging from 1000 to 10,000, as extracted from the dataset. The comparison involves four different scheduling algorithms, namely, the MRKFL-FTS technique and existing methods HFTSA [1], FD-SWMS [2], and a hybrid EMD-Transformer-BiLSTM prediction model [58]. The figure clearly shows that the MRKFL-FTS technique achieved higher scheduling efficiency. This observation is achieved through statistical evaluation. In an experiment conducted with 1000 user requests, the MRKFL-FTS technique achieved an efficiency of 96.2%. In contrast, the efficiencies of the existing methods were observed as 93.5%, 91.2%, and 90.2%, respectively. Similar results were obtained for each method. The performance outcomes of the proposed MRKFL-FTS technique are systematically compared to the existing methods. Overall, the comparison results demonstrate that the MRKFL-FTS technique enhances task scheduling efficiency by 6% compared to [1], 8% compared to [2], and 10% compared to [58]. Incorporating the federated learning technique in the MRKFL-FTS technique identifies resource-efficient and fault-tolerant virtual machines based on resource availability, employing kernelized support vector regression. The regression technique identifies resource-efficient virtual machines. The task assigner utilizes the weighted round-robin scheduling to assign the incoming IoT requests, resulting in an increase in efficiency.

As the number of requests increases, the task scheduling efficiency also improves. Similarly, when the cost increases, it reflects a higher CPU usage level, which contributes to achieving better task scheduling efficiency. Scenario-based testing involves simulating real-world situations and user interactions to evaluate the system’s functionality and behavior. On the other hand, context-driven testing focuses on adapting testing strategies based on the specific project context, environment, and constraints. In scenario-based testing, the user sends a request to the server, and task scheduling is then performed. During this process, resources such as the CPU are utilized, and, for example, the CPU cost may start at 0.000137. When a large number of requests are processed, the CPU cost increases accordingly, indicating higher resource usage and demand.

5.2. Makespan

It refers to the overall time required to complete a number of IoT requests or tasks. The objective is to minimize the time required to complete each task. The makespan formula is used to calculate the total time taken to complete a set of IoT tasks. The formula for calculating the makespan is in Equation (18),

$$Makespan=min\left(max\sum _{i=1}^n\sum _{g=1}^b{X}_{ig}\ast C_{ig}\right)$$

(22)

where $Makespan$ represents the makespan, n is the number of IoT resources, b is the number of IoT tasks, $C_{ig}$ indicates the completion time of the task of g in resource i, and $X_{ij}$ is a decision variable that is 1 if task g is allocated to resource i and 0 otherwise. It is measured in milliseconds (ms).

Figure 12 depicts the graphical representation of the makespan for request scheduling using four methods, namely, the MRKFL-FTS technique and existing HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM prediction model [58]. The graph illustrates that the makespan increases with the growing number of user requests. However, in experiments involving 1000 requests, the MRKFL-FTS technique achieved a completion time of ‘112 ms’. The overall makespan was observed to be 125 ms, 133 ms, and 135 ms for the existing methods, respectively. After conducting the experiments, diverse results were observed for each method. The comparison results indicate that the makespan performance using the MRKFL-FTS technique is reduced by 18%, 7%, and 16% compared to the existing methods. The MRKFL-FTS technique utilizes multi-objective radial kernelized federated learning to analyze the resource status of a virtual machine based on the energy, memory, CPU, and failure rate. In the event of a fault, the virtual machine tolerates the fault and continues processing, thereby minimizing the time required to complete user requests.

5.3. Throughput

It is referred to as the number of completed tasks or requests in a specified period of time. The throughput is mathematically computed as Equation (19):

$$Throughput={\displaystyle \frac{NumberofIoTrequestssuccesfullycompleted}{Specifiedperiodoftime}}$$

(23)

where $Throughput$ indicates a throughput. It is measured in terms of requests per second (requests/s).

Figure 13 illustrates a comparative performance analysis of the throughput versus the number of IoT requests. The horizontal axis represents the number of IoT requests, and the vertical axis indicates the throughput performance of four different methods. The analysis highlights that the proposed MRKFL-FTS technique achieved improved performance, resulting in higher throughput. To ensure the robustness of the MRKFL-FTS technique, ten different comparisons were conducted for each method. The average of these ten comparisons reveals that the throughput performance using the MRKFL-FTS technique improved by 21% compared to [1], 43% compared to [2], and 44% compared to [58], respectively. This enhancement is achieved through the selection of resource-efficient virtual machines. Consequently, these selected resource-efficient virtual machines have the ability to complete numerous requests within a specific time frame.

5.4. Response Time

It is defined as the duration it takes to respond to a user-requested task. It includes a submission time, waiting time, and processing time. The formula for calculating the response time is calculated as Equation (20),

$$\mathrm{Response}\mathrm{Time}=\sum _{g=1}^b\left({\rho }_g^{\mathrm{sub}}+{\rho }_g^{\mathrm{wait}}+{\rho }_g^{\mathrm{proc}}\right)$$

(24)

where $Response$ indicates a response time, and ${\rho }_g^{sub}$ is the submission time of the gth task. ${\rho }_g^{wait}$ is the waiting time of the gth task. ${\rho }_g^{proc}$ is the processing time of the gth task by a virtual machine. The time is measured in milliseconds (ms).

Figure 14 depicts the experimental outcomes of the response time for various IoT requests, ranging from 1000 to 10,000. As the number of IoT requests increases, the response time also increases for all three methods. However, the proposed MRKFL-FTS technique achieves a lower response time compared to the existing methods. For instance, with 1000 IoT requests, the response time for the MRKFL-FTS technique was observed to be 125 ms, while [1,2,58] exhibited response times of 136 ms, 145 ms, and 147 ms, respectively. The overall performance results of the MRKFL-FTS technique are then compared to the existing methods, revealing that the MRKFL-FTS technique minimizes the response time by 8%, 13%, and 18% compared to [1], [2], and [58], respectively. This is because the MRKFL-FTS technique performs fault tolerance in the task scheduling process. This helps to effectively minimize both waiting and processing times for all IoT requests.

5.5. Fault Prediction Accuracy

It is defined as the ratio of the number of IoT requests for predicting the absence or presence of a fault to the total number of tasks. The fault prediction accuracy is calculated as

$$Faul{t}_{acc}=\left({\displaystyle \frac{Numberofcorrectlypredictedtasks}{Totalnumberoftasks}}\right)\times 100$$

(25)

where $Faul{t}_{acc}$ represents the fault prediction accuracy; the fault prediction accuracy is measured in terms of percentage (%).

Figure 15 illustrates the fault prediction accuracy with varying numbers of IoT requests, ranging from 1000 to 10,000, as extracted from the dataset. The comparison involves four different scheduling algorithms, namely, the MRKFL-FTS technique and the existing methods HFTSA [1], FD-SWMS [2], and a hybrid EMD-Transformer-BiLSTM prediction model [58]. The figure clearly shows that the MRKFL-FTS technique achieved higher fault prediction accuracy. This observation is achieved through statistical evaluation. In an experiment conducted with 1000 user requests, the MRKFL-FTS technique achieved an efficiency of 97.2%. In contrast, the efficiencies of [1,2,58] were observed as 95.5%, 92.35%, and 90.35%, respectively. Similar results were obtained for each method. Overall, the comparison results demonstrate that the MRKFL-FTS technique enhances fault prediction accuracy by 5% compared to [1], 9% compared to [2], and 11% compared to [58].

5.6. Energy Consumption

It is measured as the amount of energy consumed by the server for processing the number of tasks.

$$EC=\sum _{j=1}^m{T}_j·EC\left(T\right)$$

(26)

where $EC$ represents the total energy consumption, $EC\left(T\right)$ denotes the energy consumed for each task, and $T_j$ indicates the number of IoT requests or tasks. Energy consumption is measured in joules (J).

Figure 16 illustrates the performance results for energy consumption using the MRKFL-FTS technique, and the existing HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM prediction model [58]. The number of user requests varies from 1000 to 10,000. The energy consumption in task scheduling is performed in cloud data centers. From the result analysis, the MRKFL-FTS method reduces the energy consumption for scheduling a large number of tasks compared to the existing [1,2,58] methods, respectively. The average of ten comparison results shows that the energy consumption using the MRKFL-FTS method was reduced by 11%, 19%, and 21% compared to the existing methods.

5.7. Scalability

It refers to the capacity of the system to efficiently manage an increasing number of tasks.

$$\mathrm{Scalability}={\displaystyle \frac{S{E}_H}{S{E}_B}}$$

(27)

where $S{E}_H$ denotes the efficiency under a high task load, and $S{E}_B$ indicates the efficiency of the baseline task.

Figure 17 illustrates the graphical results of scalability versus the number of tasks, ranging from 1000 to 10,000. As shown in the graph, the various scalability results were obtained for all three methods. For each method, ten different scalability results were observed. The results of the MRKFL-FTS method were compared to those obtained using the methods in [1,2,58]. The average of ten comparison results shows that the scalability using the MRKFL-FTS method was improved by 6%, 9%, and 9% compared to the existing methods.

5.8. Time Complexity

Time complexity refers to the amount of time required by the algorithm to utilize virtual machines for processing IoT tasks. It depends on the number of tasks assigned to each virtual machine and the time required by the virtual machine to complete them. The MRKFL-FTS algorithm is designed for fault-tolerant task scheduling by reducing the overall time complexity compared with the other existing algorithms. Figure 18 describes the graphical representation of time complexity for request scheduling using four methods, namely, the MRKFL-FTS technique and the existing HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM prediction model [58]. The graph illustrates that the time complexity reduces with the number of user requests. However, in experiments involving 1000 requests, the MRKFL-FTS technique achieved a completion time of 105 ms. The overall makespan was observed to be 112 ms, 125 ms, and 130 ms for [1], [2], and [58], respectively. After conducting the experiments, diverse results were observed for each method. The comparison results indicate that the time complexity performance using the MRKFL-FTS technique is minimized by 9%, 16%, and 18% compared to the existing methods.

5.9. Cost

The cost of task scheduling in a cloud environment refers to the total monetary expense incurred for executing and managing tasks across the various virtual machines (VMs). It is calculated based on the consumption of compute resources such as the CPU, memory, and network bandwidth during task execution. In the MRKFL-FTS framework, the cost is minimized by intelligently allocating tasks to virtual machines using fault tolerance and efficiency-based strategies. The total cost is measured as follows:

$$TC=C(\mathrm{CPU}+D+\mathrm{MEM}+\mathrm{BW})$$

(28)

where $TC$ denotes the total cost, $CPU$ denotes the CPU cost, D denotes the data cost, $MEM$ denotes the memory, and $BW$ indicates the bandwidth. As the size increases, the task scheduling efficiency also increases. An increase in cost implies that the CPU usage level has also increased, which helps achieve better results in task scheduling efficiency.

Scenario-based testing focuses on simulating real-world situations and user interactions to estimate the system’s functionality and behavior. In this approach, users send task requests to the server, which then schedules these tasks across available virtual machines (VMs). The scheduling process involves consuming multiple resources including CPU, memory, data transfer, and bandwidth—each contributing to the overall operational cost.

As shown in

Table 10. Total cost estimation using MRKFL-FTS method.

VMs	Tasks	CPU Cost (AED)	Data Cost (AED)	Memory Cost (AED)	Bandwidth Cost (AED)	Total Cost (AED)
1	100	0.000135	0.001600	0.000016	0.0180	0.01975
2	200	0.000155	0.003200	0.000025	0.0350	0.03838
3	300	0.000152	0.005300	0.000026	0.0540	0.05948
4	400	0.000144	0.007200	0.000018	0.0740	0.08136
5	500	0.000165	0.009000	0.000025	0.0900	0.09919

, the MRKFL-FTS method demonstrates how these individual cost components contribute to the total cost for different tasks and VM configurations. For instance, for a single VM handling 100 tasks, the CPU cost is AED0.000135, the data cost is AED0.0016, the memory cost is AED0.000016, and the bandwidth cost is AED0.0180, resulting in a total cost of AED0.01975. As the number of VMs and tasks increases, the total cost rises correspondingly due to higher resource consumption. At 5 VMs and 500 tasks, the total cost increases to AED0.09919.

This demonstrates that although CPU cost starts small (e.g., AED0.000135), when a large number of tasks are scheduled simultaneously, CPU utilization grows, leading to a higher overall cost. The MRKFL-FTS method helps effectively estimate and minimize this cost by optimizing the allocation of tasks based on resource efficiency. This makes it particularly suitable for dynamic cloud environments where scalability and cost-awareness are critical.

5.10. Space Complexity

Space complexity is measured as the amount of memory space consumed for managing virtual machines in cloud IoT-based environments. The formula for calculating the space complexity of the proposed MRKFL-FTS technique is defined as follows:

$$SC=O(d+K)$$

(29)

where $SC$ denotes the space complexity, d represents the global model and aggregation weights, and K indicates the number of clients.

In the proposed federated learning process, the number of clients is considered to be 66,245 and the global model and aggregation weight is 15. Therefore, the overall space complexity of MRKFL-FTS is

$$SC=O(15+66245)=O\left(66260\right)$$

(30)

The space complexity formulas for the comparison techniques are as follows:

• HFTSA [1]:

  $$SC=O\left(n^2\right)$$

  (31)

  where n is the number of virtual machines, indicating quadratic space complexity.
• FD-SWMS [2]:

  $$SC=O\left(K\right)\mathrm{or}SC=O(min(n,K\left)\right)$$

  (32)

  where n denotes the number of virtual machines, and K represents the number of clients.
• Hybrid EMD-Transformer-BiLSTM [58]:

  $$SC=O\left(b^{d/2}\right)$$

  (33)

  where b is the base of the exponential function, and d is the data dimensionality.

Table 11. Space complexity for various techniques with formulas and values.

Technique	Space Complexity Formula	Evaluated Space Complexity
MRKFL-FTS	$SC=O(d+K)$	$O(15+66245)=O\left(66260\right)$
HFTSA [1]	$SC=O\left(n^2\right)$	$O\left({1000}^2\right)=O\left(1000000\right)$
FD-SWMS [2]	$SC=O\left(K\right)$ or $O(min(n,K\left)\right)$	$O\left(66245\right)$ or $O\left(1000\right)$
Hybrid EMD-Transformer-BiLSTM [58]	$SC=O\left(b^{d/2}\right)$	$O\left(2^{15}\right)=O\left(32768\right)$

shows the space complexity analysis of various techniques.

6. Overall Performance Analysis

The overall performance analysis of the MRKFL-FTS method reveals significant enhancements in various parameters, including task scheduling efficiency, fault prediction accuracy, makespan, throughput, response time, and time complexity, demonstrating its effectiveness in improving overall performance compared to the existing methods.

Figure 19, Figure 20, Figure 21 and Figure 22 illustrate the overall performance results of nine parameters such as the task scheduling efficiency, makespan, throughput, response time, fault prediction accuracy, time complexity, and space complexity, energy consumption and scalability for four methods, namely, the proposed MRKFL-FTS technique, HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM prediction model [58]. From these results, it is evident that the performance of all the parameters is improved using the proposed MRKFL-FTS technique compared to the existing methods. When the experiment was conducted, the average task scheduling efficiency was observed to be 97%, 91.92%, 89.34%, and 85.34% for the MRKFL-FTS technique and existing methods. Similarly, the average makespans were observed to be 163.7 ms, 180.89 ms, 193.2 ms, and 195.2 ms for the MRKFL-FTS technique, [1], [2], and [58], respectively. Moreover, the average throughputs were observed to be 650.8 requests/sec, 552.3 requests/sec, 478.5 requests/sec, and 474.5 requests/sec for the MRKFL-FTS technique and the existing methods. The average response times for the MRKFL-FTS technique, [1], [2], and [58] were observed to be 187.85 ms, 204.3 ms, 217 ms, and 237 ms, respectively. The average fault prediction accuracies for the MRKFL-FTS technique and the existing methods were observed to be 97.83%, 93.45%, 89.98%, and 85.98%, respectively. The average time complexities for the MRKFL-FTS technique and existing methods were observed to be 153 ms, 168.3 ms, 182.2 ms, and 185.2 ms, respectively. The average space complexities for the MRKFL-FTS technique and existing methods were observed to be 160.8 MB, 171.2 MB, 178.6 MB, and 180.6 MB, respectively. The average energy consumption of the MRKFL-FTS technique and [1,2,58] was observed to be 143.1 Joule, 160.5 Joule, 175.8 Joule, and 179.8 Joule, respectively. Finally, the average scalability of the MRKFL-FTS technique and existing methods was observed to be 0.969, 0.918, 0.893, and 0.843, respectively. From the results, it is concluded that the MRKFL-FTS technique maximizes the performance of task scheduling efficiency, throughput, and fault prediction accuracy while minimizing makespan, response time, time complexity, space complexity, energy consumption, and scalability compared to the existing methods.

6.1. ANOVA TEST

ANOVA (Analysis of Variance) is a statistical test used to assess whether there is a significant difference between two groups (i.e., two classes) within a dataset. In the context of resource-efficient virtual machine classification for the cloud, ANOVA is applied to determine if the mean values of predictive variables like memory and $CPU$ differ significantly between two groups, such as resource-efficient and non-efficient ones. The formula for calculating the F-statistics is given below,

$$SB=n_1{({\mu }_1-{\mu }_T)}^2+n_2{({\mu }_2-{\mu }_T)}^2$$

(34)

$$SW=\sum _{i=1}^n{(V{M}_i-{\mu }_T)}^2$$

(35)

where $SB$ denotes the sum of the square differences between the classes; $SW$ indicates the sum of the square differences within the class; ${\mu }_1$ and ${\mu }_2$ denote the means of class 1 and class 2, respectively; ${\mu }_T$ denotes the grand total mean of both classes; and $n_1$ and $n_2$ denote the number of virtual machines in each class.

$$D{F}_{bet}=k-1$$

(36)

$$D{F}_w=n-k$$

(37)

where $D{F}_{bet}$ denotes the degree of freedom between the classes, $D{F}_w$ denotes the degree of freedom within the classes, and k denotes the number of classes (i.e., resource-efficient and resource non-efficient).

Further, the mean square error is calculated as follows:

$$MS{E}_{bet}={\displaystyle \frac{SB}{D{F}_{bet}}}$$

(38)

$$MS{E}_w={\displaystyle \frac{SW}{D{F}_w}}$$

(39)

where $MS{E}_{bet}$ and $MS{E}_w$ denote the mean square error between and within the class, respectively.

Further, the F-statistics are computed as follows:

$$\mathrm{F}\text{-}\mathrm{statistics}={\displaystyle \frac{MS{E}_{bet}}{MS{E}_w}}$$

(40)

Table 12. ANOVA test summary.

Source	Sum of Squares	df	Mean Square	F-Statistics	p-Value
Between the class	SB = 8.715	$d{f}_{\mathrm{bet}}$ = 1	$MS{E}_{\mathrm{bet}}$ = 8.715	86.283	0.00000413
Within the class	SW = 0.808	$d{f}_w$ = 8	$MS{E}_w$ = 0.101	-	-
Total Mean	50.5100

and Figure 23 presents the results of the ANOVA statistical test. The p-value is derived from the F-statistic and the degrees of freedom. If the p-value is lower than the significance level (0.05), it indicates that there is a statistically significant difference between the two class values of the resource-efficient and non-efficient virtual machines.

6.2. Performance of MRKFL-FTS Technique Under Network Fluctuations or Varying Conditions

Network fluctuations have a significant impact on the performance of task scheduling in distributed computing environments. While the proposed scheduling technique works well under stable conditions, it may experience performance degradation when subjected to network disruptions, such as fluctuating bandwidth, high latency, or task loss. These challenges result in task transmission delays, poor resource allocation, and inefficient task execution, which reduces the overall system throughput. Therefore, the performance of network throughput in task scheduling under the network fluctuation is measured using the proposed MRKFL-FTS technique and existing HFTSA [1], FD-SWMS [2], and hybrid EMD-Transformer-BiLSTM prediction model [58].

Figure 24 illustrates a performance analysis of the throughput versus the number of IoT requests, ranging from 1000 to 10,000, under varying network conditions or network fluctuations. The horizontal axis represents the number of IoT requests, and the vertical axis indicates the throughput performance of three different methods. As network conditions fluctuate, with variables such as bandwidth, latency, and request loss, these factors affect the system’s overall throughput. Under stable network conditions, the throughput is relatively high, with fewer delays in the processing and transmission of IoT requests. However, in network fluctuations, the throughput may decrease due to longer task execution times, misallocated resources, or task retransmissions.

The analysis demonstrates that the proposed MRKFL-FTS technique delivers improved performance, achieving higher throughput compared to the existing methods. However, under network fluctuations, the throughput performance slightly decreased compared to the stable conditions when using the MRKFL-FTS technique. In contrast, the existing methods experienced a more significant decrease in throughput under fluctuating network conditions. This improvement is achieved by the MRKFL-FTS technique, which selects resource-efficient virtual machines for scheduling multiple tasks. As a result, these selected virtual machines can effectively handle a larger number of incoming requests within a specific time frame.

Bandwidth-efficient virtual machines are prioritized for task scheduling in the presence of network fluctuations. If fluctuations are detected, the scheduler assigns tasks to the VM with better bandwidth stability and efficiency. For instance, when 100 tasks are performed, the bandwidth required is approximately 0.0180 Kbps per task. As the available bandwidth increases, the system achieves lower latency and higher throughput.

Table 13. Impact of bandwidth vs. throughput.

Bandwidth (Kbps)	Throughput (requests/s)
180	192
200	233
300	321
510	514

and Figure 25 illustrate the impact of bandwidth on throughput. In Figure 25, the blue color represents the bandwidth, while the brown color indicates the throughput. It can be observed that as the bandwidth increases, the throughput also increases correspondingly.

7. Case Study of MRKFL-FTS Technique with Amazon Cloud Data Centers

Amazon is the world’s largest e-commerce platform that applies cloud computing for real-time task scheduling. The Amazon cloud infrastructure is highly reliable, scalable, and capable of handling millions of tasks daily. These tasks include everything from updating product inventories, processing customer orders, and tracking shopping behaviors to scheduling maintenance tasks across its massive infrastructures. In this case study, task scheduling in Amazon cloud data centers is discussed based on optimal performance, resource utilization, and fault tolerance for users.

Let us consider the 10 users who send their requests or tasks to the Amazon cloud data centers. Each user’s request may represent a different type of task. The main aim is to perform the task scheduling in Amazon’s cloud data centers with better scalability, fault tolerance, and high availability. The cloud data centers receive the incoming user tasks and apply a multi-objective radial kernelized federated learning technique to Amazon’s infrastructure to enhance task scheduling by analyzing resources of virtual machines, such as energy, memory, CPU time, and average failure rate. Based on the resource analysis, the radial kernel support vector regression categorizes a virtual machine as either resource-efficient or not. The global aggregation model of federated learning then combines all the local training regression output results. The global aggregation model provides an accurate classification of virtual machines.

Once the resource-efficient virtual machine is determined, the task assigner performs the user requests with the help of weighted round-robin scheduling. This scheduling method is used to allocate resources to different tasks or virtual machines based on the weight assigned to each virtual machine. In Amazon’s cloud infrastructure, this technique helps ensure that higher-priority tasks are assigned to resource-efficient virtual machines. This results in optimized resource usage, scalability, and cost-effectiveness, making weighted round-robin scheduling an essential technique for Amazon’s cloud-based systems and services.

8. Conclusions

In this paper, the significant issue of providing fault-tolerant IoT request scheduling to cloud components is addressed by introducing a novel technique called MRKFL-FTS. This scheduling technique aims to reduce makespan and enhance resource utilization between IoT users and servers, and improve the quality of service. The MRKFL-FTS technique leverages multi-objective radial kernelized federated learning to select a resource-efficient virtual machine for scheduling multiple IoT requests with increased efficiency, employing radial kernelized support vector regression. The weighted round-robin method is employed to enhance the scheduling efficiency of IoT requests. Experimental analysis is conducted to assess the performance of the MRKFL-FTS technique, comparing it with conventional scheduling methods using various metrics, such as task scheduling efficiency, makespan, throughput, response time, fault prediction accuracy, and time complexity. The implementation results demonstrate that the proposed MRKFL-FTS technique achieved an 8% improvement in task scheduling efficiency and fault prediction accuracy and 36% improvement in throughput while reducing the makespan and time complexity by 14% compared to the existing methods. Additionally, the MRKFL-FTS technique minimizes the response time by 13% compared to the existing methods. Finally, the energy consumption of the MRKFL-FTS technique is reduced by 17% and increases the scalability by 8%.

Future work may extend the MRKFL-FTS framework to support heterogeneous IoT devices with varying capabilities and integrate it with edge computing environments to enable enhanced, real-time processing. Additionally, the framework can be optimized for energy-constrained devices, making it suitable for low-power IoT networks. Furthermore, advanced security and privacy-preserving mechanisms can be incorporated into the federated learning process to ensure secure and trustworthy model training.