SCEHO-IPSO: A Nature-Inspired Meta Heuristic Optimization for Task-Scheduling Policy in Cloud Computing

Abstract

Task scheduling is an emerging challenge in cloud platforms and is considered a critical application utilized by the cloud service providers and end users. The main challenge faced by the task scheduler is to identify the optimal resources for the input task. In this research, a Sine Cosine-based Elephant Herding Optimization (SCEHO) algorithm is incorporated with the Improved Particle Swarm Optimization (IPSO) algorithm for enhancing the task scheduling behavior by utilizing parameters like load balancing and resource allocation. The conventional EHO and PSO algorithms are improved utilizing a sine cosine-based clan-updating operator and human group optimizer that improve the algorithm’s exploration and exploitation abilities and avoid being trapped in the local optima problem. The efficacy of the SCEHO-IPSO algorithm is analyzed by using performance measures like cost, execution time, makespan, latency, and memory storage. The numerical investigation indicates that the SCEHO-IPSO algorithm has a minimum memory storage of 309 kb, a latency of 1510 ms, and an execution time of 612 ms on the Kafka platform, and the obtained results reveal that the SCEHO-IPSO algorithm outperformed other conventional optimization algorithms. The SCEHO-IPSO algorithm converges faster than the other algorithms in the large search spaces, and it is appropriate for large scheduling issues.

1. Introduction

In recent decades, cloud computing has been one of the growing paradigms which dynamically virtualizes resources to provide services over web pages [1,2]. The primary objectives of cloud computing are to achieve high reliability, reputation, throughput, accessibility, scalability, and ease of use [3]. However, effective scheduling of tasks is a main concern which facilitates the execution of tasks utilizing the available resources in cloud computing environments [4]. In cloud computing, the task-scheduling problem has gained more attention among researchers due to the applications and the growth of cloud systems. Generally, the jobs scheduled by a user are assigned to capable devices in cloud systems where every job has consecutive tasks [5]. In cloud platforms, the resources are accessed in two ways: (i) using service-level agreements for resource allocation that act as an interface between the resources and applications, and (ii) brokers or users accessing the resources based on their input [6,7].

The objectives of task scheduling mainly include enhancing load balancing ability and resource utilization and reducing energy consumption and task completion time [8]. Improving the ability of load balancing prevents Virtual Machines (VMs) from resource overload, and the reduction of time for task completion improves the users’ experience [9]. In addition to this, task scheduling focuses on many Quality of Service (QoS) factors like scalability, availability, throughput, and response time. The highly appropriate resources are utilized for executing tasks based on user requirements [10,11]. In the present decades, several optimization algorithms have been implemented for task scheduling in cloud computing. The traditional optimization algorithms are ineffective in obtaining optimal task allocation due to a poor convergence rate and search ability. The ineffective task scheduling algorithms increase the execution time of the tasks and reduce the throughput of the cloud systems [12,13]. Therefore, a novel SCEHO-IPSO algorithm is proposed in this manuscript for effective task scheduling. The contributions are outlined below:

• Proposed a SCEHO-IPSO algorithm to resolve task-scheduling problems in the cloud computing platforms. In this scenario, the scheduler effectively ranks user tasks based on execution time and memory details.
• Based on the capacity criteria, the SCEHO-IPSO algorithm determines the efficient VMs to execute tasks in the queue. The SCEHO-IPSO algorithm simultaneously enhances resource utilization and decreases the makespan value.
• The SCEHO-IPSO algorithm optimizes task scheduling by identifying the optimal solutions with better convergence rates. The effectiveness of the SCEHO-IPSO algorithm is analyzed by conducting different experiments. The performance measures cost, execution time, makespan, and latency, and memory storage demonstrates the efficacy of the SCEHO-IPSO algorithm over other optimization algorithms.

This manuscript is arranged in this manner. The research papers on the topic “task scheduling” are surveyed in Section 2. The methodology details, numerical results, and the conclusion of this manuscript are denoted in Section 3, Section 4 and Section 5, respectively.

2. Literature Survey

Abualigah and Diabat [14] employed an Ant Lion Optimization (ALO) algorithm to maximize resource utilization and minimize makespan in the cloud platforms. In this literature, the traditional ALO algorithm was integrated with elite-based differential evolutions for enhancing an exploration and exploitation ability that avoids the local optima problem. The efficacy of the developed optimization algorithm was analyzed on the real-trace and synthetic databases by utilizing Cloud-Sim. The results demonstrate that the ALO algorithm outperformed the existing optimization algorithms by means of processing time.

Zhou et al. [15] integrated a greedy strategy with the Genetic Algorithm (GA) for optimizing the scheduling of tasks. The developed algorithm’s performance was analyzed using dissimilar performance measures such as QoS parameters, average response time, and total completion time. The results showed that the developed algorithm performs more effectively related to the existing task scheduling algorithms. However, the use of elite-based differential evolutions and greedy strategy did not provide optimal solutions to all issues.

In the present scenario, cloud users extensively use cloud-based applications. Kumar and Venkatesan [16] have developed a hybrid optimization algorithm, the Ant Colony Optimization (ACO) algorithm with GA, for the effective handling of cloud users’ requests. This study utilized a Utility-Based Scheduler (UBS) for identifying suitable resources and order of the tasks. Here, the ACO algorithm was utilized for enhancing the crossover operation in the GA. The extensive experimental investigation stated that the developed hybrid optimization algorithm obtained superior performance in ensuring QoS parameters and task allocation. The efficacy of the hybrid optimization algorithm was validated in light of throughput, completion time, and response time. However, the integration of the two optimization algorithms increased the time complexity. In addition to this, Mapetu et al. [17] presented a PSO algorithm with low cost and time complexity for the effective balancing and scheduling of tasks in cloud computing. However, the conventional PSO algorithm had the problem of a poor convergence rate.

Natesan and Chokkalingam [18] presented a mean Grey Wolf Optimization (GWO) algorithm to reduce makespan and energy consumption in cloud computing. The aims of the presented optimization algorithm were analyzed utilizing Cloud-Sim for standard workloads (right- and left-skewed). The GWO algorithm had high time complexity because it needed to perform four operations (attacking, encircling, judging, and searching for prey) for scheduling the tasks.

Shukri et al. [19] integrated two meta-heuristic-based optimization algorithms, the PSO algorithm and Multi-Verse Optimization (MVO) algorithm, for the effective scheduling of tasks in the cloud platforms. The obtained numerical results confirmed the effectiveness of the presented hybrid optimization algorithm, which achieved superior performance in improving resource utilization and reducing makespan time.

Velliangiri et al. [20] combined GA with electro search for enhancing task scheduling in cloud platforms by employing different parameters. Here, the electro search provided the best global optimal solutions and the GA provided the best local optimal solutions. As discussed in the earlier literature, the integration of two optimization algorithms increased the time complexity of the system.

Jacob and Pradeep [21] integrated two optimization algorithms, such as the PSO algorithm and cuckoo search algorithm, that made cloud-computing services faster. The primary objective of this literature study was to decrease the violation rate and makespan. On the other hand, Li and Han [22] implemented a discrete Artificial Bee Colony (ABC) algorithm for flexible task scheduling in the cloud platforms. The experiments conducted on the benchmark instances showed the effectiveness of the presented optimization algorithms, but the hybridization of optimization algorithms increased the time complexity.

Alsaidy et al. [23] employed a PSO algorithm for effective task scheduling. The presented optimization algorithm’s performance was evaluated by means of total energy consumption, degree of imbalance, total execution time, and makespan. Sanaj and Prathap [24] developed a chaotic-based squirrel search algorithm for optimal multi-task scheduling in the cloud atmosphere. Correspondingly, Kumar and Venkatesan [25] presented a hybrid task scheduling algorithm in order to solve NP-hard problems in cloud computing. Here, the user tasks were stored in the queue manager, and then the priority was estimated. Based on the estimated priority, the resources were allocated for the task. In this literature, the GA was integrated with the PSO algorithm for scheduling the tasks.

In addition to this, Pang et al. [26], Elaziz et al. [27], Li and Wu [28], Hasan et al. [29], Mansouri et al. [30], and Chandrashekar et al. [31] implemented several optimization algorithms like the GA, moth search algorithm, ACO algorithm, PSO algorithm, modified PSO algorithm, and hybrid weighted ACO algorithm for task scheduling in the cloud platforms. The conventional optimization algorithms have poor convergence speed in multi-objective problem statements and get trapped into local optima problems. To highlight the aforementioned concerns, an effective optimization algorithm named SCEHO-IPSO is proposed for task scheduling in cloud computing environments by considering parameters like load balancing and resource utilization.

3. Methodology

A novel optimization algorithm, SCEHO-IPSO, is introduced for task scheduling. There are several indicators utilized for evaluating the efficacy of the task-scheduling algorithm. The following goals are needed to be achieved for an efficient task-scheduling algorithm:

• Minimization of total cost: According to the user’s QoS parameters, the limited total monetary cost states that the SCEHO-IPSO algorithm is efficient.
• Maximization of the QoS parameters: The QoS parameters play a crucial role in cloud computing environments and are utilized to analyze the effectiveness of the SCEHO-IPSO algorithm. The higher QoS is superior, while other parameters remain unchanged.
• Workload balancing: Workload balancing is closely related to the resource utilization rate. If it is an excellent task-scheduling algorithm, the majority of resources should be fully used in cloud environments.
• Minimization of makespan: It represents that the proposed optimization algorithm completes the scheduling of tasks with limited execution time.
• Minimization of latency: Latency is an important measure for evaluating the proposed task-scheduling algorithm. The latency and response time should be limited if it is an excellent task-scheduling algorithm. The flow diagram of the proposed work is mentioned in Figure 1.

3.1. Resource Allocation to the VMs

In this section, resource allocation is considered as the optimization problem, which is mathematically represented in Equation (1).

$$Resource allocation=Maximize\left(\frac{P_j^{CPU}}{{VM}_i^{CPU}}+\frac{P_j^{MEM}}{{VM}_i^{MEM}}+\frac{P_j^{BW}}{{VM}_i^{BW}}\right)$$

(1)

where $P_j^{CPU},P_j^{MEM}, \mathrm{and} P_j^{BW}$ are denoted as the Computer Processing Unit (CPU), memory, and Bandwidth (BW) of physical machines. Similarly, ${VM}_i^{CPU},{VM}_i^{MEM}, \mathrm{and} {VM}_i^{BW}$ are indicated as the CPU, memory, and bandwidth of the VMs. The proposed optimization algorithm SCEHO-IPSO detects the hosts with higher units based on the following four conditions. The proposed SCEHO-IPSO algorithm detects the hosts with maximum resources.

$$\forall i{\sum }_{j=1}^m{y}_{ij}=1 \mathrm{and} \forall i{\sum }_{j=1}^n{y}_{ij}{VM}_i^{CPU}\le P_j^{CPU}$$

$$\forall i{\sum }_{j=1}^n{y}_{ij}{VM}_i^{MEM}\le P_j^{MEM} \mathrm{and} \forall i{\sum }_{j=1}^n{y}_{ij}{VM}_i^{BW}\le P_j^{BW}$$

where the binary variable is represented as $y_{ij}$, the task count is denoted as $M,$ and the number of tasks is indicated as $n$. The VMs are positioned on appropriate physical machines if the aforementioned conditions are satisfied.

3.2. Load Balancing in the VMs

The VM load status is estimated based on parameters like bandwidth, memory storage, and processor load. These parameters are responsible for pre-determining the VM load status, which is mathematically defined in Equations (2)–(5).

$$L=\left\{L_1,L_2 \mathrm{a}\mathrm{n}\mathrm{d} L_3\right\}$$

(2)

where

$$L_1=CPU usage of {VM}_i/P_j^{CPU}$$

(3)

$$L_2=Memory usage of {VM}_i/P_j^{MEM}$$

(4)

$$L_3=Bandwidth usage of {VM}_i/P_j^{BW}$$

(5)

where $L_i\left(t\right)={\sum }_{j=1}^n\frac{L_j}{n}$ is the degree of load. If the following two conditions are satisfied— $\left\{\begin{array}{c}idle, L_i\left(t\right)=L_i^{idle}\left(t\right)=0 \\ under load, L_i^{idle}\left(t\right)<L_i\left(t\right)<L_i^{min}\left(t\right)\end{array}\right\}$ and $\left\{\begin{array}{c}normal, L_i^{min}\left(t\right)<L_i\left(t\right)<L_i^{max}\left(t\right)\\ overload,L_i\left(t\right)>L_i^{max}\left(t\right)\end{array}\right\}$—the load status of the VMs is determined. In addition, $L_i^{max}\left(t\right)$ and $L_i^{min}\left(t\right)$ are represented as the maximum and minimum load in the host.

3.3. Task Scheduling

The process of allocating tasks to the VMs in cloud computing is called task scheduling. In the context of the cloud, the scheduling algorithm maximizes resource usage, reduces the total processing time, saves expenses and energy, and enhances the system’s load balance and throughput. In this section, the proposed optimization algorithm, SCEHO-IPSO, satisfies the following three conditions ($\forall i{\sum }_{j=1}^m{t}_{ij}=1,F_{t_i}\le A_{t_i}+D_{t_i}, \mathrm{and} {Et}_i+D_{t_i}\le {Ct}_i$) for effective task scheduling. The tasks allocated to the $j\mathrm{th}$ VM is represented as $t_{ij}$, $F_{t_i}$ is stated as the finishing time of task $t_i$, $A_{t_i}$ is represented as the arrival time of task $t_i$, $D_{t_i}$ is denoted as the dead-line of task $t_i$, and $E_{t_i}$ and ${Ct}_i$ are the execution and completion times of task $t_i$. The mathematical presentation of ${Ct}_i$ is presented in Equation (6).

$${Ct}_i={Et}_i+{Wt}_i$$

(6)

where ${Wt}_i$ is the waiting time of the $i\mathrm{th}$ task.

3.4. SCEHO Algorithm

The EHO algorithm is one of the effective metaheuristic-based optimization algorithms which follows the herding behavior of elephants [32,33]. The SCEHO uses a sine cosine-based clan-updating operator for updating the distance between elephants in every clan based on the matriarch elephant’s position. The SCEHO algorithm follows three rules in optimization problems: (i) elephants live peacefully in each clan under the leadership of matriarch elephant; (ii) after a specific time period, the male elephants leave their clans and live solely; and (iii) elephants are divided into many clans, where each clan has a fixed population [34,35,36].

3.4.1. Process of Clan Updating

As discussed earlier, all the elephants live together under the leadership of a matriarch elephant. Generally, the positions of the elephants are influenced by a matriarch elephant based on Equation (7). In this scenario, the sine cosine-based clan-updating operator is employed for updating the clans, which is mathematically determined in Equation (8). The use of the sine cosine-based clan-updating operator enhances the optimization algorithm’s exploration and exploitation abilities and avoids being trapped in local optima problems.

$${x_{c_i,j}^{new}}_{}=x_{c_i,j}^t+\alpha \times (x_{best,c_i}^t-x_{c_i,j}^t)\times r1$$

(7)

$${x_{c_i,j}^{new}}_{}=\left\{\begin{array}{c}{x_{c_i,j}^t+r1\times \sin \left(r2\right)\times \left|r3\times x_{best,c_i}^t-x_{c_i,j}^t\right|if r4<0.5}_{}\\ {x_{c_i,j}^t+r1\times \cos \left(r2\right)\times \left|r3\times x_{best,c_i}^t-x_{c_i,j}^t\right|if r4\ge 0.5}_{}\end{array}\right\}$$

(8)

where $\alpha$ is represented as a scaling factor, which influences the matriarch elephant on $x_{c_i,j}^t; x_{c_i,j}^{new}$ are denoted as old and new positions of the $j\mathrm{th}$ elephant in clan $c_i;x_{best,c_i}^t$ is stated as a global or best-fitted position of a matriarch elephant in clan $c_i$; $t$ is indicated as an iteration; and the random numbers $r1,r2,r3, \mathrm{a}\mathrm{n}\mathrm{d} r4$ perform uniform distribution which ranges between zero and one. On the other hand, the position of a matriarch elephant is updated based on Equation (9).

$$x_{c_i,j}^{new}=\beta \times x_{center,c_i}^t$$

(9)

where the term $\beta$ influences $x_{center,c_i}^t$ on $x_{c_i,j}^{new}$, which ranges between zero and one. The center of the clan $x_{center,c_i}^t$ in the $d\mathrm{th}$ dimensional space is mathematically determined in Equation (10).

$$x_{center,c_i}^t=\frac{1}{n_{c_i}}\times {\sum }_{j=1}^{n_{c_i}}{x}_{c_i,j,d}$$

(10)

where $n_{c_i}$ is represented as the number of elephants in clan $c_i$. The architecture of the SCEHO algorithm is mentioned in Figure 2.

3.4.2. Process of Separation

When the male elephants attain puberty, they leave the clan and live alone. The process of separation is modeled by a separating operator which helps in resolving the optimization problems. The elephants with the worst fitness are removed by using the separating operator that superiorly enhances the searching ability of the conventional EHO algorithm. The separating operator is a fitness function in this study that is mathematically denoted in Equation (11).

$$x_{worst,c_i}^t=x_{min}+(x_{max}-x_{min}+1)\times rand$$

(11)

where the lower and upper bounds of the elephant position are denoted as $x_{min}$ and $x_{max}$, $x_{worst,c_i}^t$ is stated as the worst elephants in clan $c_i$, and the term $randϵ[0,1]$ is represented as the stochastic distribution function. The assumed parameters of the SCEHO algorithm are represented as follows: the iteration number is 100, the population number is 100, $\alpha =0.5$, the upper bound is 0.9, the number of clans is 10, the set elitism is 2, the lower bound is 0.3, and $\beta =1$.

3.5. IPSO Algorithm

After finding the best local optimal solutions with the SCEHO algorithm, the best global optimal solutions are determined with the IPSO algorithm. The PSO algorithm is one of the stochastic optimization algorithms which follows swarm movement and intelligence behaviors [37,38,39]. The social interaction concept is used in the conventional PSO algorithm for resolving the optimization problems. The PSO algorithm makes use of agents (particles) which constitute the swarms that move in the search space [40,41]. For every iteration, the agents (particles) update their positions in order to obtain optimal solutions. In the swarm, every particle moves towards its prior global and personal best position. The Equations (12) and (13) are used to update the velocity and position of the agents (particles). The architecture of the IPSO algorithm is specified in Figure 3.

$$v_{id}\left(t+1\right)=I_w\times v_{id}\left(t\right)+{ac}_1\times r_1\times \left[p_{id}\left(t\right)-o_{id}\left(t\right)\right]+{ac}_2\times r_2\times [p_{gd}\left(t\right)-o_{id}\left(t\right)]$$

(12)

$$o_{id}\left(t+1\right)=o_{id}\left(t\right)+v_{id}\left(t+1\right)$$

(13)

where the random numbers are represented as $r_1 \mathrm{a}\mathrm{n}\mathrm{d} r_2$, the acceleration coefficients are denoted as $a{c}_1 \mathrm{a}\mathrm{n}\mathrm{d} a{c}_2$, and the inertia weight used to balance local and global search is specified as $I_w$. The particles’ global best position and the personal best position are denoted as $p_{gd}$ and $p_{id}$. In the IPSO algorithm, a novel Human Group Optimizer (HGO) is used to influence the agents (particles). The HGO uses an adaptive uniform mutation operator for enhancing the convergence speed of the conventional PSO algorithm. Additionally, nonlinear function $p_m$ is used in the IPSO algorithm for controlling the range and decision of the mutation on each particle. The nonlinear function $p_m$ is updated after every iteration and it is mathematically specified in Equation (14).

$$p_m=0.5\times e^{(-10\times \frac{t}{T})}+0.01$$

(14)

where $T$ indicates the maximum iteration, and $t$ denotes the total number of iterations. The assumed parameters of the IPSO algorithm are listed as follows: the iteration number is 100, the population number is 100, the cognitive constant $a{c}_2$ is two, and the social constant ${ac}_1$ is three. The numerical analysis of the proposed SCEHO-IPSO algorithm is detailed in Section 4, and the steps involved in the Algorithm 1 are described below:

Algorithm 1. SCEHO-IPSO algorithm.

Step 1: Initialize the objective functions. Step 2: Create initial population. Step 3: Evaluate fitness value. Step 4: For every task, find the best local optimal solutions using SCEHO algorithm. Step 5: For every task, find the best global optimal solutions using IPSO algorithm. Step 6: Find the hybrid solutions. Step 7: If the hybrid new solution value is higher than the current value, then Step 8: replace the current value with the hybrid new solution. Step 9: Select any resources among the population. Step 10: If the execution time is higher for the selected resource, then eliminate the respective resource and select another resource. Step 11: Update personal best and global best solutions. Step 12: Retain it and rank the best solutions. Step 13: End.

4. Simulation Results

In this manuscript, the SCEHO-IPSO algorithm is simulated utilizing a Cloud-Sim toolkit, which effectively supports on-demand resource provisioning. In addition, it offers a wide range of features, including support for multi-objective optimization scenarios, the dynamic scaling of resources, the modeling of several application characteristics, and an ability to simulate different cloud deployment models. The performance of the SCEHO-IPSO algorithm is analyzed using a system with an Intel core i9 12th generation processor, Linux-operating system, 128 GB random access memory, and 36 GB virtual storage. The load balancing on Kafka is a straightforward and simple process that is managed by the Kafka producers. The efficacy of the SCEHO-IPSO algorithm is compared with other optimization algorithms like ALO, GA, ACO, PSO, GWO, and MVO by means of cost, execution time, makespan, latency, and memory storage. The parameters considered for experimental analysis are mentioned in

Table 1. Parameters considered for experimental analysis.

Datacenter
Number of hosts	2
Number of datacenters	10
VMs
Number of processing elements	2
Bandwidth	500
Million instructions per seconds	500
Number of VMs	1000
Number of service providers	5
Task (cloud-let)
Number of tasks	1000
Task length	1000

.

4.1. Performance Measures

As mentioned earlier, the efficacy of the SCEHO-IPSO algorithm is analyzed by using performance measures like cost, execution time, makespan, latency, and memory storage. At first, the cost represents the total cost (dollars) required for task scheduling in the cloud environments and it is mathematically depicted in Equation (15). Then, makespan is the completion time of the last task to leave the system, and it is mathematically stated in Equation (16). The term $F_{t_i}$ is stated as the finishing time of task $t_i, {EC}_{t_i{r}_n}$ is denoted as the execution cost of task $t_i$ on resource $r_n,$ and $n$ is indicated as the number of tasks.

$$Cost={\sum }_{i=1}^n{EC}_{t_i{r}_n}$$

(15)

$$Makespan={\sum }_{i=1}^n{F}_{t_i}$$

(16)

The execution time of the task is defined as the time consumed by the system for executing a specific task. The mathematical formula for execution time $E_{t_i}$ is given in Equation (17). The term $P_{P_v}$ is represented as the processing power of the VMs, $S_{t_i}$ is specified as the task size, and $E_{t_i}$ is indicated as the execution time of task $t_i$ on the VMs.

$$E_{t_i}=\frac{S_{t_i}}{P_{P_v}}$$

(17)

The latency is defined as the time consumed for balancing the data load. The effectiveness of the system is improved by decreasing the latency. The mathematical formula to compute latency is specified in Equation (18). The term ${\beta }_i$ is represented as the instances generated from the source code, $k_j$ is stated as the number of instances per unit, and $u\left(t\right)$ is indicated as the total count of the workload. In addition to this, the memory storage is defined as the space required by the proposed optimization algorithm in order to execute a specific task. The execution time is minimized by reducing the memory storage.

$$Latency=\left(\frac{{\beta }_i}{k_j}\right)(u\left(t\right)+1)$$

(18)

4.2. Quantitative Analysis

The experimental results of different optimization algorithms by means of execution time and cost are presented in

Table 2. Results of different optimization algorithms in light of execution time and cost.

Execution Time (ms)
Platform	ALO	GA	ACO	PSO	GWO	MVO	EHO	SCEHO-IPSO
Storm	894	1203	910	887	978	963	834	733
Flink	873	1129	905	876	956	904	820	720
Spark	802	1082	890	864	944	896	802	652
Kafka	772	910	787	793	892	834	772	612
Cost
Platform	ALO	GA	ACO	PSO	GWO	MVO	EHO	SCEHO-IPSO
Storm	202	190	208	152	188	192	116	102
Flink	193	182	201	144	172	188	102	88
Spark	170	177	188	138	166	177	92	82
Kafka	154	173	177	122	152	152	72	62

. In addition to this, the performances of the optimization algorithms are analyzed on different platforms such as Storm, Flink, Spark, and Kafka. By inspecting Table 2, the SCEHO-IPSO algorithm is seen to obtain a minimum execution time of 612 milliseconds (ms) and a cost of 62 on the Kafka platform, which are superior compared to other optimization algorithms (ALO, GA, ACO, PSO, GWO, MVO, and EHO) and other platforms (Storm, Flink, and Spark). The two common parameters assumed in the comparative optimization algorithms are a population size of 100 and a maximum iteration of 100. The specific parameters of ALO are as follows: the number of dimensions is five, the lower bound is 0.1, and the upper bound is 0.8. The assumed parameters of GA are as follows: the mutation probability is 0.02, the crossover probability is 0.60, and the number of demes is six. The parameters of ACO are as follows: the time factor is two, the saving matrix factor is two, the visibility coefficient is three, and the pheromone concentration coefficient is one. The maximum initial velocity is 15, the minimal initial velocity is five, the alpha is 0.8, and the beta is 0.8; these are the specific parameters considered in the PSO algorithm. The assumed parameters of the GWO and MVO algorithms are as follows: the number of appliances is 12, the coefficient vector is one, the TDR is one, and the WEP is 0.2. The parameters of EHO are as follows: the alpha is 0.5, the beta is one, the upper bound is 0.9, the number of clans is 10, the set elitism is two, and the lower bound is 0.3. Generally, the highly available fault-tolerant task scheduling helps in improving the business goals. The Kafka platform includes advantages such as high enterprise security, real time analysis, effective management of clouds, platform scalability, and better processing speed over other platforms. A visual comparison of different optimization algorithms by means of execution time and cost is represented in Figure 4 and Figure 5.

The experimental results of different optimization algorithms by means of latency are presented in

Table 3. Results of different optimization algorithms in light of latency.

Latency (ms)
Platform	ALO	GA	ACO	PSO	GWO	MVO	EHO	SCEHO-IPSO
Storm	2800	2914	3018	3920	2990	2560	1982	1630
Flink	2773	2888	2822	3892	2967	2521	1928	1626
Spark	2822	2880	2902	3620	2940	2490	1802	1550
Kafka	2754	2635	2772	3450	2829	2339	1820	1510

. Similar to Table 2, the SCEHO-IPSO algorithm has a lower latency value than conventional optimization algorithms such as ALO, GA, ACO, PSO, GWO, MVO, and EHO. Here, the proposed SCEHO-IPSO algorithm has latency of 1630 ms, 1626 ms, 1550 ms, and 1510 ms on the Storm, Flink, Spark, and Kafka platforms. A visual comparison of different optimization algorithms in terms of latency is depicted in Figure 6.

Correspondingly, the experimental results of different optimization algorithms in light of makespan and memory storage are specified in

Table 4. Results of different optimization algorithms in light of makespan and memory storage.

Makespan
Platform	ALO	GA	ACO	PSO	GWO	MVO	EHO	SCEHO-IPSO
Storm	288	283	193	188	190	144	94	88
Flink	276	279	187	176	158	142	90	73
Spark	244	232	143	165	148	122	88	45
Kafka	240	212	123	142	122	110	78	44
Memory storage (kb)
Platform	ALO	GA	ACO	PSO	GWO	MVO	EHO	SCEHO-IPSO
Storm	512	538	727	721	573	698	413	338
Flink	532	521	632	658	549	690	479	336
Spark	454	477	553	630	490	532	493	322
Kafka	380	392	442	532	422	504	379	309

. As seen in Table 4, the proposed SCEHO-IPSO algorithm has minimum makespan values of 88, 73, 45, and 44 on the platforms Storm, Flink, Spark, and Kafka. On the other hand, the proposed SCEHO-IPSO algorithm has a consumed minimal memory storage of 338 kb, 336 kb, 322 kb, and 309 kb on the platforms Storm, Flink, Spark, and Kafka. The achieved results are superior when compared to traditional optimization algorithms such as ALO, GA, ACO, PSO, GWO, MVO, and EHO. Visual comparisons of different optimization algorithms in terms of makespan and memory storage are specified in Figure 7 and Figure 8.

4.3. Discussion

The extensive experimental evaluation shows that the proposed SCEHO-IPSO algorithm has achieved better task scheduling in the cloud platforms by considering parameters like load balancing and resource utilization. The traditional optimization algorithms have poor convergence speed in multi-objective problem statements and become trapped in local optima problems. Compared to existing optimization algorithms like ALO, GA, ACO, PSO, GWO, MVO, and EHO, the proposed SCEHO-IPSO algorithm has the advantages of strong search ability and faster convergence speed, particularly in the context of task scheduling. The performance measures of cost, execution time, makespan, latency, and memory storage demonstrate the efficacy of the proposed SCEHO-IPSO algorithm over other algorithms, which is specifically stated in Table 2, Table 3 and Table 4. Additionally, related to other platforms, Kafka is extremely fast and massively scalable because it efficiently decouples the data streams, which results in lower latency, cost, execution time, makespan, and sufficient memory storage. The Kafka replicates and distributes partitions across several servers that protect against server failures.

5. Conclusions

In this manuscript, a novel optimization algorithm, SCEHO-IPSO, was implemented for the effective scheduling of tasks in cloud platforms. Here, the proposed SCEHO-IPSO algorithm was implemented using a Cloud-Sim toolkit and was compared with other optimization algorithms like ALO, GA, ACO, PSO, GWO, MVO, and EHO. The proposed SCEHO-IPSO algorithm was analyzed on different platforms, namely Storm, Flink, Spark, and Kafka, and validated by means of cost, execution time, makespan, latency, and memory storage. The extensive experimental investigation states that the proposed SCEHO-IPSO algorithm has a minimum makespan of 44, a memory storage of 309 kb, a latency of 1510 ms, an execution time of 612 ms, and a cost of 62 on the Kafka platform, which are superior to other optimization algorithms and platforms. Still, the proposed SCEHO-IPSO algorithm has the two major issues of limited energy efficiency and the degree of imbalance.

As a future extension, the proposed optimization algorithm will be implemented in other applications like earth science and climate modeling. Additionally, a hybrid optimization algorithm will be developed and more parameters will be considered for comparisons like energy efficiency and degree of imbalance.