Internet of Things Data Cloud Jobs Scheduling Using Modified Distance Cat Swarm Optimization

Abstract

IoT cloud computing provides all functions of traditional computing as services through the Internet for the users. Big data processing is one of the most crucial advantages of IoT cloud computing. However, IoT cloud job scheduling is considered an NP-hard problem due to the hardness of allocating the clients’ jobs to suitable IoT cloud provider resources. Previous work on job scheduling tried to minimize the execution time of the job scheduling in the IoT cloud, but it still needs improvement. This paper proposes an enhanced job scheduling mechanism using cat swarm optimization (CSO) with modified distance to minimize the execution time. The proposed job scheduling mechanism first creates a set of jobs and resources to generate the population by randomly assigning the jobs to resources. Then, it evaluates the population using the fitness value, which represents the execution time of the jobs. In addition, we use iterations to regenerate populations based on the cat’s behaviour to produce the best job schedule that gives the minimum execution time for the jobs. We evaluated the proposed mechanism by implementing an initial simulation using Java Language and then conducted a complete simulation using the CloudSim simulator. We ran several experimentation scenarios using different numbers of jobs and resources to evaluate the proposed mechanism regarding the execution time. The proposed mechanism significantly reduces the execution time when we compare the proposed mechanism against the firefly algorithm and glowworm swarm optimization. The average execution time of the proposed cat swarm optimization was 131, while the average execution times for the firefly algorithm and glowworm optimization were 237 and 220, respectively. Hence, the experimental findings demonstrated that the proposed mechanism performs better than the firefly algorithm and glowworm swarm optimization in reducing the execution time of the jobs.

1. Introduction

The computation cloud is an emerging paradigm that enables users to access and utilize computational resources through the Internet, such as storage, software, and processing power [1]. This allows users to access and utilize computational resources on demand without the need to own or maintain the underlying hardware. IoT cloud computing services are divided into three main types: software as a service (SaaS), platform as a service (PaaS), and infrastructure as a service (IaaS) [2,3,4]. SaaS provides IoT cloud-based software applications to users [5], PaaS provides cloud-based platforms that include programming languages, software tools, and other resources [3,4,5], and IaaS provides cloud-based computing infrastructure, such as storage, CPUs, and networking. Each cloud computing service allows different levels of control and customization for users, with SaaS providing the least control and IaaS providing the most [5]. Resource management and job scheduling are essential challenges in cloud computing as they are crucial in ensuring the efficient and effective utilization of cloud resources [3,4,5]. Resource management involves allocating and management of available resources, such as storage and processing power, to meet the users’ needs while maximizing resource utilization, as shown in Figure 1. On the other hand, job scheduling involves allocating and scheduling tasks or jobs submitted by users to the appropriate resources [6,7,8,9,10]. These challenges arise due to the dynamic and heterogeneous nature of cloud resources, as well as the varying requirements of the users.

To address these challenges, researchers have proposed various solutions [10,11,12,13] using metaheuristics and optimization methods, such as particle swarm optimization [11], ant colony/firefly optimization [11], and cat swarm optimization, which are effective in improving the performance of the IoT cloud job scheduling [14,15]. However, the execution time still needs to be improved for job scheduling. In addition, some optimization techniques are proposed for scheduling the workflow on cloud computing, such as the cat swarm optimization [14,15], multi-objective cat swarm optimization [15,16,17], and hybrid cat swarm optimization mechanism techniques [7]. Moreover, to the best of our knowledge, the cat swarm optimization mechanisms discussed in the literature are designed for workflow scheduling and consider the static mode of scheduling.

This paper proposed an enhanced job scheduling mechanism based on cat swarm optimization (CSO) with a modified distance to minimize the job execution time in cloud computing. To evaluate the proposed mechanism using the CloudSim simulator, the proposed cat swarm optimization for IoT cloud job scheduling aims to enhance the IoT cloud job execution times. The proposed cat swarm optimization mechanism is based on the modified distance representation for the optimization process. The proposed mechanism considers a dynamic job scheduling model.

This paper’s main contributions are to emphasize the novel aspects that distinguish our research from traditional cat swarm optimization (CSO) and other existing methods. Unlike prior CSO applications in workflow scheduling, which primarily focused on static scheduling modes, our work presents a significant departure by introducing a dynamic job scheduling model tailored to the ever-changing landscape of IoT cloud computing. The core contribution of this paper lies in developing an innovative CSO-based job scheduling mechanism enhanced through a modified distance representation. This enhancement optimizes the allocation of IoT cloud jobs and seeks to minimize the execution times. Importantly, we rigorously evaluate this proposed mechanism using the CloudSim simulator to provide empirical evidence of its effectiveness. The convergence of these unique elements forms the bedrock of our paper’s contributions.

Our contributions are multi-faceted and offer distinctive advantages over existing algorithms.

1.1. Reduction in Execution Times

Our primary contribution lies in the implementation of the cat swarm optimization (CSO) mechanism to significantly minimize the execution times. The execution time is a key performance metric for cloud-based applications, and our work focuses on enhancing the efficiency of job execution within IoT cloud environments. While various scheduling algorithms exist, our adaptation of CSO showcases its efficacy in addressing this specific concern, ultimately leading to shorter execution times and improved system performance.

1.2. NP-Hard Problem Solving

Furthermore, our work addresses the NP-hard problem of distributing resources to jobs in the context of data clouds. This is a substantial challenge, as it involves finding optimal resource allocations within a computational system. The proposed CSO mechanism is tailored to handle this complexity, offering a practical solution to a problem that has been the focus of extensive research due to its computational difficulty.

1.3. Modification of Distance Calculation in CSO

We contribute by modifying the distance calculation within the CSO mechanism. This modification allows for more efficient and accurate resource allocation, further improving the overall job scheduling process. By enhancing this aspect of CSO, our work provides a unique angle for optimizing scheduling algorithms.

1.4. IoT Cloud Focus

Unlike many existing studies that target general cloud environments, our work is specifically tailored to the emerging domain of IoT clouds. The inclusion of IoT in our architecture recognizes the growing importance of IoT in modern computing. We acknowledge the unique characteristics and demands of IoT cloud applications and adapt our approach to suit these requirements.

1.5. Continuation of Research on Job Scheduling

Finally, we contribute to ongoing research in the area of job scheduling in the cloud, which remains a vibrant and evolving field. Our work adds to the body of knowledge and offers insights into the suitability of CSO for addressing these challenges.

In summary, our research offers a multi-faceted contribution. It leverages the power of CSO to reduce the execution times, solves the NP-hard problem of resource allocation in cloud systems, modifies the distance calculation for improved accuracy, focuses on IoT cloud environments, and continues the exploration of job scheduling within cloud computing. Each of these contributions is an essential building block that collectively advances state of the art in cloud job scheduling, making it an exciting and relevant endeavour in the context of contemporary cloud computing.

This paper contains five sections. Section 2 reviews the related works. Section 3 illustrates the proposed scheduling mechanism. Section 4 is the evaluation and experimentation part. Finally, we concluded Section 5.

2. Related Works

Several research studies addressed the challenge of scheduling jobs in cloud computing [16,17,18,19]. The authors in [20] proposed an approach named MRFOSSA, which relies on utilizing SSA to enhance the local search capability of MRFO, which typically increases the speed of convergence towards the optimal solution. A new scheduling mechanism called the adaptive energy-aware mechanism was introduced to minimize makespan and energy consumption in cloud job scheduling. This mechanism considers various factors such as communication among jobs, the distance between computers, energy values of virtual machines, and energy consumption predictions [11].

The firefly algorithm is a metaheuristic algorithm based on the flashing behaviour of fireflies, and it has been applied to various optimization problems, including job scheduling in IoT cloud computing [12]. The algorithm simulates the flashing of fireflies, where the attractiveness of a firefly is proportional to its brightness, and fireflies tend to move towards brighter ones [21,22,23,24]. In the context of job scheduling, the firefly algorithm can be used to optimize the execution time of jobs by assigning them to appropriate virtual machines in the IoT cloud. Similarly, the glowworm swarm optimization algorithm is inspired by the behaviour of glowworms, where they emit light to attract mates and prey. The algorithm was applied to various optimization problems, including job scheduling in IoT cloud computing. The glowworm swarm optimization algorithm simulates the interaction between glowworms, where they emit light based on their fitness value, and other glowworms move towards the brightest ones [12,25]. In the context of job scheduling, the glowworm swarm optimization algorithm can be used to optimize the execution times of jobs by assigning them to appropriate virtual machines in the IoT cloud.

A new study presented a cognitive or intelligent mechanism of a bio-inspired method. The study employed a bio-inspired method to enhance the IoT cloud job scheduling for IoT applications. The selection process of genes based on natural methods revealed that simply the fittest kinds survive at the end of the process [17]. The research in [26] introduced the ions motion optimization (IMO) algorithm for IoT cloud job scheduling. The IMO mechanism includes two stages, namely the liquid and crystal phases, which work together to strike a balance between quick convergence and avoiding the local optima, thus enhancing the algorithm’s performance [26]. Job scheduling mechanisms for IoT cloud computing using optimization techniques based on shark smell optimization and chemical reaction optimization are introduced to enhance the job scheduling process [27,28].

Cat swarm optimization is proposed for scheduling the workflow on IoT cloud computing [8]. Furthermore, multi-objective cat swarm optimization approaches are presented for scheduling jobs in IoT cloud computing [14,15,29]. The hybrid cat swarm optimization mechanism combines cat swarm optimization with other optimization techniques such as genetic algorithms, simulated annealing, and firefly algorithm [30,31,32]. The existing optimization techniques tried to minimize the execution time of the job scheduling in the IoT cloud, but they still need to be improved for job scheduling. In addition, these techniques are designed to consider the static mode of scheduling.

3. The Proposed Modified Distance Cat Swarm Optimization for Data IoT Cloud Job Scheduling

This paper introduced a new cat swarm optimization for a data IoT cloud job scheduling mechanism. This study applied the cat swarm optimization mechanism to optimize the allocation of submitted IoT cloud jobs to suitable IoT cloud provider resources.

The cat swarm optimization method is a type of swarm intelligence metaheuristic optimization technique that takes inspiration from the behaviour of cats. Cats spend their lives in two modes: resting and hunting. During the resting mode, cats observe their surroundings and move towards the best position they detect. Once the best position is found, they switch to hunting mode, rapidly chasing after prey or any moving object. Thus, the cat swarm optimization metaheuristics method is composed of two modes inspired by the natural behaviour of cats, as mentioned previously. These modes are the seeking mode (SM), which occurs when the cat is at rest and observing its surroundings, and the tracing mode (TM), which happens when the cat is actively chasing its prey by following its velocity [33,34]. To integrate these two modes in the CSO algorithm, a mixture ratio (MR) was defined. Each cat in the algorithm is characterized by its position, velocity, and a flag that specifies the mode it is in [14,35,36]. The seeking and tracing modes are further explained in the following subsections.

3.1. Seeking Mode

The seeking mode in cat swarm optimization determines the cat’s next position. This mode models the cat’s natural behaviours, such as looking around, resting, or being alert. The seeking mode consists of four critical factors: seeking memory pool (SMP), seeking a range of selecting dimensions (SRD), count of dimension to change (CDC), and self-position consideration (SPC). The seeking memory pool (SMP) determines the number of copies of a cat produced in the seeking mode within the cat population. The seeking range of selecting dimension (SRD) sets the upper and lower bounds of the seeking range. The count of dimensions to change (CDC) specifies the number of dimensions to be modified in each iteration. Finally, the self-position consideration (SPC) is a Boolean variable that determines whether the present position is a candidate solution [14,35,36].

3.2. Tracing Mode

The tracing mode in cat swarm optimization imitates the cat’s natural behaviour of tracing targets and searching for food. This mode is related to the local search technique used in the optimization process. When a cat enters the tracing mode, it moves based on its local velocity [37].

In the cat swarm optimization method for I task scheduling, each cat represents a job scheduling solution that allocates the jobs’ openjobs $\overrightarrow{X_{ij}},i=(\mathrm{1,2},3,\dots .,n)j=(\mathrm{1,2},3,\dots .,k)$. Each element within the cat’s population vector represents a randomly generated number between 1 and s, where:

• s represents the number of resources.
• n represents the number of cats.
• k represents the number of jobs and serves as the length of each cat in the population.

As depicted in Figure 2, the suggested cat swarm optimization (CSO) approach for the IoT cloud task scheduling begins with IoT devices generating tasks. These tasks encompass extensive data collected from IoT sensors and actuators. Subsequently, these tasks originating from IoT devices are submitted to the IoT cloud scheduling system. Within this framework, the IoT cloud scheduler employs the proposed CSO mechanism to seek out the most advantageous schedule within the solution search space. Once the optimal solution is derived through the proposed algorithm, it is transmitted to the cloud server to facilitate the efficient scheduling of incoming tasks.

This paper identified data IoT cloud providers’ resources as a vector that stores the speed of each resource $\overrightarrow{R_i},i=(\mathrm{1,2},3,\dots .,s)$. Furthermore, the clients’ jobs are presented as a vector for integer numbers; each number represents the length of the job openjob $\overrightarrow{J_i},i=(\mathrm{1,2},3,\dots .,k)$. The proposed mechanism assigns the initial velocity Vi, $i=(\mathrm{1,2},3,\dots .,n)$ equal values for each cat. The next step is the calculation of the fitness values for each cat.

The fitness values are computed by dividing each job length by the speed of the resource it is assigned to, as indicated by the jobs and resources vectors. The algorithm then finds the division values’ summation and obtains the highest fitness representing the best position. As the cats in tracing mode move to these positions, these values are kept in position. The cat with the highest fitness may move randomly or remain in place. The cats in the solution population are divided into two modes: seeking mode ($SM$) and tracing mode ($TM$).

This division process is performed by assigning a random value for each cat, either 0 or 1, as a vector $\overrightarrow{{flag}_i},i=(\mathrm{1,2},3,\dots .,n)$. Distributing cats into seeking mode if a cat has a flag equal to 0 and cats in tracing mode have a flag value equal to 1. In the seeking mode, the proposed mechanism assigns $SMP$, $SRD$, $CDC$, and $SPC$ values. $SMP$ is the number of candidate points. $SPC$ is a Boolean variable to determine whether the position of cat k is within the candidate points; if so, the value of $SPC$ is true; otherwise, it is false. $CDC$ is the number of dimensions, which varies for each candidate’s points. $SRD$ is the value that controls the dimensions change of the candidate points.

The following steps are taken to create j copies of the current position of cat k:

• j is equal to SMP, where SMP is the number of copies.
• If the value of SPC (a Boolean value indicating whether to consider the current position as a candidate) is true, then j is set to (SMP – 1).
• The current position is returned as one of the candidates.
• For each copy, the values are randomly increased or decreased by SRD percent (as specified by CDC, the parameter for controlling the degree of randomness), and the old values are replaced.

Then, the algorithm calculates the fitness function F($\overrightarrow{X_{ij}}$) for all candidate points. If all finesses are not precisely equal, the algorithm selects the maximum and minimum fitness and then calculates each solution point’s choosing probability using Equation (1). Then, the algorithm assigns each cat’s determined probabilities as equal to 1.

$$\mathrm{pi}=\frac{\left|f_i-f_{best}\right|}{f_{max}-f_{min}},where0<i<j$$

(1)

where ${\mathrm{f}}_{\mathrm{best}}$ is the maximum fitness.

The next step in the proposed mechanism is to randomly select one of the candidate points and use it to update the position of cat k.

In tracing mode, the velocity of each cat is updated using Equation (2)

V’i = Vi + r1c1(Xbest,j – Xij)

(2)

where xbest, j represents the position of the cat with the highest fitness value. Xij represents the position of cat n, c1 represents a constant, and r1 is a random value between 0 and 1.

Then, the algorithms check whether the new velocity is beyond the range of the speed limit. If so, the algorithm changes it to equal the velocity limit. Otherwise, the algorithm keeps the new velocity. Finally, the algorithm updates the position using Equation (3):

X’ij = Xij + V’i

(3)

3.3. Pseudo Code of the Proposed CSO Algorithm

A pseudo code of the proposed cat swarm optimization mechanism for scheduling jobs on the data IoT cloud is given as follows. The pseudo-code describes in detail the steps of the proposed Algorithm 1 to achieve its goals.

Algorithm 1 Modified Distance Cat Swarm Optimization for Cloud Task Scheduling
1:	Begin
2:	Initialize parameter: n,k,s,t, iter_max,c1,r1,SMP,CDC,SPC,SRD.
3:	Start with initial random population
4:	$\overrightarrow{X_{ij}},i=(\mathrm{1,2},3,\dots .,n)j=(\mathrm{1,2},3,\dots .,k)$.
5:	The number of iterations = iter_max.
6:	iter = 1
7:	calculate the execution times Exec ($\overrightarrow{X_{ij}})$
8:	Find the maximum fitness and keep the position of the cat that has maximum fitness
9:	Randomly select the flag value for each cat to be 0 or 1.
10:	for each cat do
11:	If the value of flag = 0
12:	then set cat in SM.
13:	Else
14:	set cat in TM.
15:	end for
16:	set j = SMP.
17:	for each cat in SM do
18:	for each copy do
19:	Randomly select a number of CDC diminution to change their values.
20:	Compute fitness function F$(\overrightarrow{X_{ij}})$
21:	end for
22:	Find the minimum fitness fmin and maximum fitness fmax
23:	Set the best fitness fbest = fmax
24:	for each copy do
25:	If the fitness values are not equal for all solutions   pi = $\frac{\left|f_i-f_{best}\right|}{f_{max}-f_{min}}$
26:	else
27:	Set pi = 1
28:	end if
29:	end for
30	Find the highest probability.
31:	Move the cat to the cat that has the highest probability.
32:	end for
33:	for each cat in TM do
34:	Update the velocities (V) and the position Xij for every cat
35:	V’i = Vi + r1c1(Xbest,j – Xij)
36:	if the new velocity is out of range
37:	Set it to be equal to the limit
38:	else
39:	Set the velocity of cat = new velocity
40:	end if
41:	X’ij = Xij + V’I     //movement of cats
42:	end for
43:	iter←iter + 1
45:	end while

3.4. The Proposed Modified CSO for IoT Data Cloud Job Scheduling

i.

Scenario Introduction:

We present the following scenario to illustrate the functionality of the proposed cat swarm optimization (CSO) intelligence in the context of job scheduling within cloud computing.

ii.

Resource Speed and Job Length Tables:

Assume a scenario with 10 jobs and 5 available resources, with job lengths and resource speeds detailed in

Table 1. Speed of resources.

Resources	R1	R2	R3	R4	R5
Speed in MIPS	4	8	7	5	6

and

Table 2. Length of jobs.

Jobs	J1	J2	J3	J4	J5	J6	J7	J8	J9	J10
Length in MI	20	10	22	15	6	14	30	10	16	30

, respectively.

iii.

Allocation of Jobs to Resources:

Table 3. Cat swarm optimization parameters.

Parameter	Experiments Value
Population size	20
Iterations	10
SMP	5
CDC	0.8
SPC	0/1

defines the allocation of jobs to available resources in vectors. Each vector represents a valid solution or “cat.” The five vectors constitute the CSO population. The allocation of jobs to resources is described in Equation (4).

$$\left(\begin{array}{c}{cat}_1\\ {cat}_2\\ {cat}_3\\ {cat}_4\\ {cat}_5\end{array}\right)=\left(\begin{array}{cccccccccc}{R}_1& R_4& R_1& R_4& R_3& R_4& R_5& R_4& R_1& R_5\\ R_1& R_3& R_4& R_1& R_1& R_3& R_5& R_1& R_1& R_5\\ R_4& R_4& R_1& R_5& R_5& R_2& R_1& R_4& R_2& R_4\\ R_4& R_4& R_3& R_3& R_5& R_3& R_5& R_1& R_1& R_1\\ R_5& R_3& R_3& R_1& R_1& R_2& R_2& R_3& R_2& R_2\end{array}\right)$$

(4)

iv.

Fitness Calculation:

Calculate the fitness for each cat in Table 4, where the fitness values are determined based on the job-to-resource allocations, aiming to minimize the execution time. The fitness of cats is described in Equation (5):

$$fitness(f_i)=\left(\begin{array}{c}{cat}_1\\ {cat}_2\\ {cat}_3\\ {cat}_4\\ {cat}_5\end{array}\right)=\left(\begin{array}{c}0.0286\\ 0.02891\\ 0.0292\\ 0.0300\\ 0.0387\end{array}\right)$$

(5)

cat₅ has the highest fitness value of 0.0387.

Table 4. The simulation results for ten iterations in the first scenario.

Iteration	1	2	3	4	5	6	7	8	9	10
Execution Times	421	294	275	266	255	242	242	234	234	234

Table 4. The simulation results for ten iterations in the first scenario.

Iteration	1	2	3	4	5	6	7	8	9	10
Execution Times	421	294	275	266	255	242	242	234	234	234

v.

Mode Assignment (Seeking and Tracing):

Divide the cats into two modes, namely the seeking mode ($SM$) and tracing mode ($TM$), by assigning a random flag (0 or 1) to each cat. An example flag assignment: ${cat}_1$ and ${cat}_2$ are assigned flag = 1, indicating that they are in tracing mod. ${cat}_3$, ${cat}_4$, and ${cat}_5$ are assigned flag = 0, signifying they are in seeking mode. This indicaes the number of candidate points needs to be created from each cat. Generate copies of each cat based on $SMP$ to introduce candidate points, for instance, create copies of cat₃ as described in Equation (6).

$$two\left(\begin{array}{c}{copy}_1\\ {copy}_2\end{array}\right)=\left(\begin{array}{cccccccccc}{R}_4& R_4& R_1& R_5& R_5& R_2& R_1& R_4& R_2& R_4\\ R_4& R_4& R_1& R_5& R_5& R_2& R_1& R_4& R_2& R_4\end{array}\right)$$

(6)

Then, randomly modify the dimensions of the candidate points by setting $CDC$ (change dimensions count) to 2 and setting $SRD$ (random value range) set to 2. Randomly select some dimensions to change their values, according to $CDC$. Randomly add plus or minus one to $SRD$ to change the dimensions. The new position of each copy as stated in Equation (7).

$$\left(\begin{array}{c}{copy}_1\\ {copy}_2\end{array}\right)=\left(\begin{array}{cccccccccc}{R}_4& R_4& R_1& R_5& R_3& R_2& R_1& R_4& R_2& R_4\\ R_2& R_4& R_1& R_5& R_5& R_2& R_1& R_4& R_2& R_4\end{array}\right)$$

(7)

The next step is to calculate the fitness for each copy. The fitness of copy₁ is 0.0293, and the fitness of copy 2 is 0.0305.

Determine the maximum and minimum fitness among the copies. The maximum fitness is 0.0305 and the minimum fitness is 0.02931.

vi.

Probability Calculation:

Given the differing fitness values among the copies, calculate the probabilities for each copy. Probabilities are calculated based on fitness disparities, with higher fitness copies receiving higher probabilities. Example: copy₁ has a probability of 1.0, while copy₂ has a probability of 0.0. The maximum probability (1.0) designates cat₃ moving to copy₁, adopting its position. The new position of cat₃ is described in Equation (8).

$$\left(\begin{array}{c}{copy}_3\end{array}\right)=\left(\begin{array}{cccccccccc}{R}_4& R_4& R_1& R_5& R_3& R_2& R_1& R_4& R_2& R_4\end{array}\right)$$

(8)

Similarly, this process continues for each cat in seeking mode.

vii.

Tracing Mode (TM):

In $TM$, update the velocity and position for each cat. The velocity and position updates are executed according to the CSO algorithm, incorporating constants (c1 and r1) and random values. The new position of cat₁ and cat₂ is described in Equation (9).

$$\left(\begin{array}{c}{cat}_1\\ {cat}_2\end{array}\right)=\left(\begin{array}{cccccccccc}{R}_2& R_5& R_5& R_3& R_5& R_1& R_3& R_5& R_2& R_5\\ R_2& R_1& R_4& R_5& R_3& R_1& R_2& R_3& R_5& R_2\end{array}\right)$$

(9)

The new population of cats is described in Equation (10).

$$\left(\begin{array}{c}{cat}_1\\ {cat}_2\\ {cat}_3\\ {cat}_4\\ {cat}_5\end{array}\right)=\left(\begin{array}{cccccccccc}{R}_2& R_5& R_5& R_3& R_5& R_1& R_3& R_5& R_2& R_5\\ R_2& R_1& R_4& R_5& R_3& R_1& R_2& R_3& R_5& R_2\\ R_4& R_4& R_1& R_5& R_3& R_2& R_1& R_4& R_2& R_4\\ R_4& R_4& R_3& R_3& R_2& R_3& R_5& R_1& R_1& R_1\\ R_5& R_3& R_3& R_1& R_1& R_2& R_2& R_3& R_2& R_2\end{array}\right)$$

(10)

viii.

Iteration and best solution selection:

The process iterates for a predefined number of iterations or until a specified fitness value is achieved. In each iteration, cats switch between modes, create candidate points, update positions, and strive to optimize fitness. At the end of iterations, the best cat is selected based on the highest fitness, representing the optimized job scheduling solution.

ix.

Population Update:

The final population consists of the cats generated in the last iteration, reflecting the optimized job scheduling configuration. This process repeats for a specified number of iterations or until a predefined fitness threshold is reached, ultimately selecting the best job scheduling solution based on the CSO algorithm’s principles.

4. Performance Evaluation

The study has conducted several simulation experiments to evaluate the proposed cat swarm optimization mechanism for data IoT cloud job scheduling. The CloudSim simulator is utilized as an evaluation platform to study the proposed data scheduling mechanism [38,39]. Several scenarios were investigated to study the features of the proposed cat swarm optimization mechanism. The experimentation’s circumstances and configuration are allocated based on the data IoT cloud job scheduling literature. The simulation experiments considered three cases based on the number of jobs and resources in each experiment. The findings in this paper were derived from a simulation scenario run using the CloudSim simulator.

Three cases were considered to evaluate the proposed cat swarm optimization mechanism. The first case involved a scenario with 120 jobs, 50 resources, and a population of 30 cats. The second case considered a comparison between the proposed cat swarm optimization, firefly algorithm (FA), and glowworm swarm optimization (GSO) [13,33]. In the second case for the three mechanisms, the number of jobs and resources were 80 and 30, respectively.

In the third case, a comparison was made between the proposed cat swarm optimization and the firefly algorithm and glowworm optimization using varying numbers of jobs and resources.

The representation of jobs in the CloudSim simulator is mapped to cloudlet classes with attributes such as the ID and length of the jobs. For example, a virtual machine in the CloudSim simulator represents the data IoT cloud provider resources with the attributes’ ID and the speed of the virtual machine.

4.1. Experimental Settings

To carry out the experiments, the researchers created a software application utilizing the CloudSim simulator to implement the proposed cat swarm optimization mechanism.

The CloudSim simulator was set up on a DELL server equipped with an Intel i7-2760QM CPU with a clock speed of 2.70 GHz, 8 cores, and 8 GB of memory. The simulation emphasized the execution time as a simulation benchmark. The simulation was conducted within a private IoT cloud data framework hosted by the IoT cloud provider, consisting of two processing servers: AMD and Intel.

4.2. Optimization Parameter Settings

The CloudSim configurations for cat swarm optimization are designed based on the standard parameter setting for cat swarm optimization [12,14,17,34], as described in Table 3.

4.3. Simulation Scenarios

The simulation process considered the following simulation scenarios in the evaluation process.

4.3.1. The First Scenario

In the first scenario, the study implemented the simulation experiments for the proposed IoT data cloud jobs scheduling using modified distance cat swarm optimization. The experiment was conducted with 120 jobs and 50 resources. Ten iterations for the optimization process were considered. The execution time is calculated for each iteration as stated in Table 4 and Figure 3.

Table 4 and Figure 3 show that the execution time started with 421 in the first iteration and continue to increase until it reaches the last one.

Iteration No 1: In the first iteration of the proposed IoT data cloud jobs scheduling using modified distance cat swarm optimization, the execution of the submitted tasks took 421 units of time. This means that it took 421 units of time to complete the processing of the 120 jobs with the available 50 resources in the first scenario.

Iteration No 2: During the second iteration, the execution time decreased to 294 units. This indicates an improvement in the efficiency of task execution compared to the first iteration, demonstrating the effectiveness of the modified distance cat swarm optimization approach.

Iteration No 3: In the third iteration, the execution time further decreased to 275 units, showing continued enhancement in the algorithm’s efficiency and reinforcing the effectiveness of the customized optimization technique.

Iteration No 4: The fourth iteration recorded an execution time of 266 units, signifying that the modified distance cat swarm optimization algorithm continued to excel in improving the task execution efficiency.

Iterations 5–10: Subsequent iterations (from 5 to 10) displayed execution times that remained relatively stable, fluctuating between 255 and 234 units. This stability suggests that the proposed modified distance cat swarm optimization approach had likely reached a state of optimal or near-optimal task execution efficiency for the given scenario. This consistency in results underscores the reliability and effectiveness of the custom optimization method in handling complex scenarios involving 120 jobs and 50 resources.

4.3.2. The Second Scenario

This scenario mainly focusses on comparing the proposed cat swarm optimization model with the GSO and firefly algorithm. The results of the comparison process are presented in

Table 5. Comparison between CSO, GSO, and firefly algorithm.

Mechanism	GSO	Firefly Algorithm	CSO
Execution times	478.05	205.37	186.92

and Figure 3. The comparison considered 80 jobs and 30 resources.

As shown in Table 5 and Figure 4, the proposed cat swarm optimization mechanism achieved a better performance than FCFS and the random mechanism. The proposed cat swarm optimization mechanism solution has the shortest execution time (186) seconds. Additionally, the random mechanism performed better than the GSO and firefly algorithm scheduling process.

4.3.3. The Third Scenario

In the third scenario, various job and resource numbers were considered to assess the proposed cat swarm optimization mechanism. This scenario aims to analyse the performance of the proposed CSO mechanism under different workloads and from various angles. Five experiments were conducted in the third scenario, as described in

Table 6. Simulation results for the third scenario.

Scenario	1	2	3	4	5
No. of jobs	20	60	100	120	150
No. of resources	10	30	50	80	100
FA execution times	36	159	327	323	337
GSO execution times	36	152	287	292	331
CSO execution times	31	99	172	149	205

and Figure 5.

Table 6 and Figure 5 compare the proposed cat swarm optimization with glowworm swarm optimization and the firefly algorithm. The simulation results revealed that the proposed cat swarm optimization has the shortest execution time compared to the firefly algorithm and glowworm swarm optimization. In the first scenario, the execution time of the proposed CSO was 31 compared to 36 for the firefly algorithm and glowworm swarm optimization. In the subsequent scenarios, the execution times for the proposed CSO gradually increased, starting from 99 to 205 in the last scenario. In contrast, the firefly algorithm and glowworm optimization execution times increased faster than the proposed CSO. In the second scenario, the execution times of FA and GSO were 159 and 152, respectively. In the last scenario, the execution times of FA and GSO were was 337 and 331, respectively. These results show that the proposed CSO performance is better than FA and GSO in all scenarios. When considering the high workload of jobs, the differences in execution times between the proposed CSO, FA, and GSO are increased. The performance of the proposed CSO is becoming more effective when the load of the data IoT cloud system is heavy.

The primary focus of Figure 4 is to illustrate the execution time comparisons between these three algorithms across various scenarios. Here, the key points to note are:

Execution time comparison: The figure showcases a clear comparison of execution times for each algorithm in different scenarios. It begins with the first scenario, where CSO has an execution time of 31, while FA and GSO have execution times of 36. This illustrates that CSO outperforms FA and GSO in terms of speed in the initial scenario.

Gradual increase in execution times: As we progress through subsequent scenarios, the execution times for CSO gradually increase, ranging from 99 to 205 in the last scenario. On the other hand, both FA and GSO show faster increases in execution times as the scenarios advance.

Consistent performance advantage of CSO: The key takeaway is that the proposed CSO consistently exhibits a better performance than FA and GSO across all scenarios. Even as the workload of jobs increases, the differences in execution times between CSO, FA, and GSO become more pronounced. This underlines the effectiveness of CSO, especially under heavy data workloads from the IoT cloud system.

Impact of workload: It is worth noting that the performance advantage of CSO becomes more evident and impactful as the workload on the IoT cloud system grows heavier. This suggests that CSO is well suited for scenarios with high job workloads.

In summary, Figure 5 provides a comprehensive view of the comparative experimental results, highlighting CSO’s consistent superiority in terms of execution time over FA and GSO across varying scenarios. This information aids in understanding the performance dynamics of these optimization algorithms under different workload conditions.

The relationship between the first, second, and third experimental scenarios is as follows:

First scenario (baseline): In the first scenario, this study conducted simulation experiments to evaluate the performance of the proposed IoT data cloud jobs scheduling using modified distance cat swarm optimization. This baseline scenario involved a specific configuration with 120 jobs and 50 resources, and the optimization process was run for ten iterations. The execution time for each iteration was recorded and presented in Table 4 and Figure 3.

Second scenario (comparison): The second scenario focused on comparing the proposed cat swarm optimization model with two other optimization algorithms, namely glowworm swarm optimization (GSO) and the firefly algorithm. To make meaningful comparisons, this scenario uses a different configuration compared to the first scenario, with 80 jobs and 30 resources. The objective is to assess how the proposed CSO mechanism performs relative to other algorithms under these different conditions. The results of this comparison are presented in Table 5 and Figure 4. Third scenario (workload and performance analysis):

The third scenario aims to assess the proposed cat swarm optimization mechanism under various workloads and from different angles. Unlike the first two scenarios, this one involves multiple experiments, with varying numbers of jobs and resources. Five different experiments are conducted in this scenario to analyse how the proposed CSO mechanism adapts to different job-resource configurations. The results of these experiments are described in Table 6 and Figure 5.

In summary, the first scenario serves as the baseline experiment, and it provides a reference point for evaluating the performance of the proposed modified distance cat swarm optimization algorithm. The second scenario introduces a comparison with other optimization algorithms under different conditions. The third scenario further extends the analysis by exploring various job and resource configurations to assess the flexibility and adaptability of the proposed CSO mechanism. Together, these scenarios provide a comprehensive evaluation of the optimization approach in different contexts and workloads.

Table 7. Comparison of average execution times.

Mechanism	GSO	Firefly Algorithm	CSO
Average execution times	220	237	131

and Figure 6 provide valuable insights into the performance of the proposed cat swarm optimization (CSO) mechanism when compared to two other well-established optimization algorithms, including the firefly algorithm (FA) and glowworm swarm optimization (GSO).

The average execution times presented here are not derived from a single isolated run but are the result of a thorough evaluation process that involved multiple runs of each scheduling mechanism. This approach was employed to ensure that the results are robust and representative of the algorithms’ performance under different conditions and inputs. It is worth noting that the average execution times were calculated after reaching a state of result saturation, signifying that the algorithms had converged to a stable performance level. In examining the average execution times, a striking pattern emerges: the proposed cat swarm optimization mechanism consistently demonstrates a superior performance. Specifically, the average execution time for CSO was measured at 131 units. In contrast, the firefly algorithm exhibited an average execution time of 237 units, and the glowworm swarm optimization had an average execution time of 220 units. These results unequivocally demonstrate that the proposed cat swarm optimization mechanism significantly outperforms both the firefly algorithm and glowworm swarm optimization in terms of execution time. This indicates that CSO is exceptionally efficient in the context of job scheduling for IoT data cloud applications. Its ability to consistently achieve shorter execution times underscores its effectiveness in optimizing task scheduling, which is critical for meeting the stringent performance demands of IoT cloud systems. The significance of these findings extends beyond the mere comparison of execution times; they underscore the practical advantages of employing the proposed CSO mechanism in real-world scenarios. With its demonstrated efficiency, CSO is well suited to handle the complexities and variations that often characterize IoT data cloud environments. This enhanced performance positions CSO as a valuable tool for optimizing resource allocation and job scheduling in IoT cloud systems, ultimately contributing to improved system efficiency and responsiveness.

In conclusion, the results presented in Table 7 and Figure 6 affirm the superiority of the proposed cat swarm optimization mechanism in terms of average execution times when compared to the firefly algorithm and glowworm swarm optimization. This performance advantage underscores the potential of CSO as a powerful optimization tool for IoT data cloud job scheduling, with practical implications for enhancing the overall efficiency and responsiveness of IoT cloud systems.

4.4. Results Discussions

The results in the first two scenarios proved that the proposed CSO algorithm optimizes the job scheduling solutions by increasing the fitness values. Furthermore, the increased fitness values by the proposed CSO mechanisms imply that the execution times for the submitted jobs are decreased.

The results in the third scenario with different workloads revealed the superiority of the proposed cat swarm optimization over the firefly algorithm and glowworm swarm optimization.

The initial and final results revealed that the proposed CSO algorithm performs better than FA and the GSO in scheduling jobs to resources. In addition, the performance of the proposed CSO is becoming more effective when the data load of the IoT cloud system is heavy.

5. Conclusions

This paper introduced a modified distanced cat swarm optimization (CSO) for IoT cloud job scheduling to reduce execution times. This study began with a mapping procedure that linked the data IoT cloud job scheduling problem to the cat swarm optimization (CSO). Each job scheduling solution in the mapping process represents a cat in the optimization method. A set of solutions, or cats, was randomly selected to serve as the initial population of cats in the optimization process. The optimization fitness value for each schedule (cat) is the execution time of that schedule (cat). The proposed CSO mechanism divided cats into seeking and tracing modes. In each iteration, cats that represent the job schedules move based on the current mode of the cat to a new position to improve the fitness value. This study chooses the cat with the best fitness value to identify the best schedule in each iteration. The proposed CSO approach was evaluated and tested using the CloudSim simulator. Multiple experiments were carried out with varying configurations to assess the performance of the proposed CSO mechanism. Empirical results proved that the proposed cat swarm optimization mechanisms outperformed the firefly algorithm and glowworm swarm optimization. Furthermore, the proposed CSO performs better in decreasing the execution time in a heavy workload schedule. In conclusion, the Cat Swarm Optimization (CSO) algorithm, as applied to the job scheduling challenges of the Internet of Things data cloud, offers several distinct advantages. It excels in efficiently allocating resources and optimizing job schedules, thereby significantly reducing the execution times. Furthermore, CSO demonstrates robust performance, even under heavy workload scenarios, making it a reliable choice for enhancing the overall efficiency and responsiveness of IoT data cloud systems.