A Hybrid Multi-Objective Bat Algorithm for Solving Cloud Computing Resource Scheduling Problems

Abstract

To improve the service quality of cloud computing, and aiming at the characteristics of resource scheduling optimization problems, this paper proposes a hybrid multi-objective bat algorithm. To prevent the algorithm from falling into a local minimum, the bat population is classified. The back-propagation algorithm based on the mean square error and the conjugate gradient method is used to increase the loudness in the search direction and the pulse emission rate. In addition, the random walk based on lévy flight is also used to improve the optimal solution, thereby improving the algorithm’s global search capability. The simulation results prove that the multi-objective bat algorithm proposed in this paper is superior to the multi-objective ant colony optimization algorithm, genetic algorithm, particle swarm algorithm, and cuckoo search algorithm in terms of makespan, degree of imbalance, and throughput. The cost is also slightly better than the multi-objective ant colony optimization algorithm and the multi-objective genetic algorithm.

1. Introduction

As a new type of computing model, cloud computing has fundamentally changed the delivery method of computing services and the convenience of resources provided through the Internet. The cloud computing resource scheduling problem is considered as difficult as the non-deterministic polynomial optimization problem, that is, an NP-hard problem. With the continuous development and complexity of cloud computing, this problem has become more challenging. Moreover, the scheduling optimization problem has become an indispensable and very important academic topic in academia. Therefore, one of the urgent problems to be solved is how to make cloud resource scheduling achieve a balance between availability and low cost, that is, to meet the availability of methods and technologies at a low cost. This requires optimizing load balance, improving scheduling performance, and improving resource utilization, while also reducing costs and increasing cost-effectiveness, so as to save energy and achieve good and fast sustainable development.

In the cloud computing environment, the objective function of resource scheduling is more focused on the goals of cloud providers and cloud users. The optimal resource scheduling generally considers the following goals, including service availability, computing cost, load balancing, makespan, and throughput. Therefore, the optimization problem can be transformed into mapping candidate solutions to fitness measurement functions, $R^n\to R$, and obtaining the optimal solution $z\in R^n$ from all feasible solutions, thereby satisfying the function minimization problem.

$$f\left(x\right)<f\left(y\right),\forall (x,y)\in R^n$$

(1)

The main contributions of this paper are as follows. First, a novel multi-objective optimization bat algorithm is proposed to solve the cloud-computing resource scheduling problem. The bat‘s population is divided into two types, namely the search-type population and the captive population. In addition, the loudness and pulse emission rate of the original bat algorithm are improved and optimized using the Back Propagation based on the mean square error and Conjugate Gradient Method. Aiming at the optimization of feasible solutions, this paper uses lévy flight to improve the step length of the algorithm to achieve Pareto optimization. Second, we extend the objective functions to makespan, imbalance, cost, and throughput, and develop a resource scheduling model to meet the needs of cloud users and improve the resource utilization of cloud providers. Finally, these performances are compared and analyzed, and cloudlets or tasks are assigned to the virtual machine with the shortest time to prove the effectiveness of the proposed optimization model. It also verifies the superiority of the proposed algorithm compared with other meta-heuristic algorithms.

The rest of the paper is organized as follows: Section 2 shows the related works which deal with existing objective function of resource scheduling and scheduling techniques in the cloud environment. Section 3 deals with the proposed model. Section 4 discusses the proposed algorithm. Section 5 deals with performance evaluation and Section 6 consists of the conclusion and future work.

2. Related Works

With the vigorous development of big data, cloud users are increasingly demanding cloud computing platforms. How to schedule resources according to demand has become an important research topic.

In terms of parameters for measuring scheduling effectiveness, domestic and foreign scholars mainly focus on issues such as resource optimization, energy consumption, makespan, cost, and load balancing. To achieve optimal resource scheduling and reduce the energy consumption of cloud computing systems, Hao et al. [1] proposed a resource scheduling algorithm based on the execution of tasks in the cloud system. Further, Prakash [2] proposed a new dependency and time-based scheduling algorithm. Due to the types of clients and services provided in the cloud computing system, scheduling issues and energy consumption issues are the most required challenges for the system. Pirozmand et al. [3] proposed a two-step hybrid method for finding search and time tasks, genetic algorithm, and genetic algorithm-based neurological scheduling. Also, in order to ensure budget constraints in cloud computing while minimizing the completion time of workflows, Yao et al. [4] proposed a scheduling algorithm based on task repetition to optimize the completion time of budget-constrained workflows in cloud platforms. And Sardaraz [5] proposed a multi-objective scheduling algorithm for scheduling scientific workflows in cloud computing, which is based on a genetic algorithm for completion time, monetary cost, and load balancing. While Chen [6] proposed a real-time scheduling algorithm based on makespan and cost. It can be seen that most scholars use factors such as makespan, degree of imbalance, and cost as the objective function of cloud resource scheduling problems.

Currently, meta-heuristic algorithms used for cloud computing scheduling problems mostly focus on simulated annealing (SA), genetic algorithm (GA), particle swarm optimization algorithm (PSO), artificial bee colony algorithm (ABC), and ant colony algorithm (ACO). To fill the gap between resource dynamics and on-demand consumer application requirements, Attiya [7] proposed an improved Harris hawks optimization algorithm based on simulated annealing, while Muthulakshmi et al. [8] proposed a hybrid ABC-SA algorithm. Further, Velliangiri et al. [9] proposed a hybrid electronic search based on a genetic algorithm to improve task scheduling behavior by considering parameters such as completion time, load balance, resource utilization, and multi-cloud cost. Yu et al. [10] proposed a particle position weight calculation method based on particle fitness value classification, and applied the algorithm to the task scheduling of cloud computing platforms, and found the task scheduling with the shortest time-consuming and the most balanced computing resource load in the cloud platform Program. To minimize the completion time and balance the load, Kruekaew [11] also uses the artificial bee colony algorithm and the virtual machine with the largest job priority to schedule and manage cloud resources. Further, Sanaj [12] proposed a chaotic squirrel search algorithm to optimize multi-task scheduling in an infrastructure-as-a-service cloud environment. Hence, to solve the VM integration problem, Xiao [13] proposed a multi-objective method based on dual thresholds and ant colony system. At the same time, Vinu [14] proposed a hybrid queue an ant colony-artificial bee colony optimization algorithm.

3. Problem Formulation

Like other scheduling problems, resource scheduling in cloud computing is suitable for a valuable cloud resource to meet the cloud provider’s needs for cloud users. It is mostly used to balance the load and ensure equal distribution of resources based on demand. And it gives some priority according to the set rules to ensure that cloud computing can meet the requests of all cloud users. Equation (2) for the resource scheduling problem is as follows:

$$RS=\sum _{x=1}^{m,n}\left(R_x+S_x+\dots +N_x\right)\times T_x\to U_x^z$$

(2)

where, it assign m cloudlets/task $T=\left(T_1,T_2\dots ,T_m\right)$ to convert n available material resources into cloud data center $R=\left(R_1,R_2,\dots ,R_n\right)$, $S=\left(S_1,S_2,\dots ,S_n\right)$, even $N=\left(N_1,N_2,\dots ,N_n\right)$. Here, the target fitness function is set as $F=\left(F_1,F_2,\dots ,F_z\right)$, and cloud users are represented by $U=\left(U_1,U_2,\dots ,U_n\right)$. Assuming that there is a set of cloudlets/task $T_i=\left(T_1,T_2,\dots ,T_n\right)$ required by cloud users, the agent is responsible for assigning the cloudlets/tasks to the necessary virtual resources $V_j=\left(V_1,V_2,\dots ,V_m\right)$ as Virtual resources with the shortest completion time. The expected completion time (ETC) is described as the expected time for all cloudlets/tasks to be executed on certain virtual resources obtained through the use of the ETC matrix. Its elements are expressed as $ETC\left(T_i,V_j\right)$, and (3) is as follows:

$$ETC(T_i,V_j)=\left[\begin{array}{cccc}{T}_1{V}_1& T_1{V}_2& \cdots & T_1{V}_m\\ T_2{V}_1& T_2{V}_2& \cdots & T_2{V}_m\\ ⋮& ⋮& & ⋮\\ ⋮& ⋮& & ⋮\\ T_n{V}_1& T_n{V}_2& \cdots & T_n{V}_m\end{array}\right]$$

(3)

However, in reality, cloud resources cannot be fully utilized due to poor scheduling allocation. Therefore, the problem of determining the minimum cost resource utilization and constraining the completion time is a multi-objective optimization problem.

Table 1. Options for multi-objective resource scheduling problems.

Type	Cost (RMB)	Time (min)
A	100	570
B	90	700
C	80	600
D	70	850
E	60	820

illustrates the complexity of the situation. Assuming that cloud users need IaaS cloud resources, these resources have the cheapest cost and the least execution time, which is impossible for cloud providers to fully realize.

Table 1 shows the options and decisions that take the least time and cost and means that the objective function can maximize the use of the least completion time and consume the least cost. But in real life, it is difficult to balance and perfect the time and cost. Comparing A and B, it can be found that A has a lower cost but takes longer, while B has a higher cost but takes less time. Similarly, if A and C are compared, the time is too long or the cost is high, both are non-dominant. In the multi-objective scheduling problem, the main goal is to find a non-dominated curve or solution [15]. These parameters are based on calculation, network, and storage, including availability, bandwidth/speed, cost, degree of imbalance, execution time, memory, performance, priority, reliability, response time, SLA, temperature, throughput, time, and utilization [16].

Therefore, the following part takes makespan, the degree of imbalance, cost, throughput, and performance as the objective function of cloud computing optimal resource scheduling, and calculates the corresponding values by using formulas (4)–(8). The minimum makespan, the minimum throughput, cost, and the smooth and stable imbalance degree can show that the multi-objective bat algorithm in this paper is more efficient. The goal is to reduce the makespan of specific cloudlets/tasks on all VMs during resource scheduling and obtain the least makespan, throughput, cost, and the most stable degree of imbalance.

3.1. Makespan Model

The makespan is defined as the longest completion time used to determine the execution of the task. If the makespan of cloudlets or task exceeds the needs of cloud users, these requirements will not be completed on time [17]. Therefore, it is necessary to reduce the makespan of all task mappings on the VM defined in (4).

$$f\left(x\right)=max\bigcup _{i=1}^m{T}_i,\forall i\in N,i=1,2,\dots ,m$$

(4)

3.2. Degree of Imbalance Model

To check the unbalanced load on the VM, the degree of imbalance is introduced [15]. Its role is to describe the amount of load distribution among VMs regarding their execution capabilities. Therefore, it is necessary to consider a stable average degree of imbalance to obtain better resource scheduling performance. Equation (5) is as follows:

$$\begin{array}{c}f\left(x\right)=\frac{{\bigcup }_{i=1}^{m}max{T}_i-{\bigcup }_{i=1}^{m}min{T}_i}{avg{T}_i}\\ \forall i\in N,i=1,\dots ,m\end{array}$$

(5)

3.3. Cost Model

As reducing the cost of cloud users, the cost is defined as the total amount of resource usage or resource utilization paid by cloud users to cloud providers. In this way, it also effectively enhances the profit and revenue of cloud providers [5,18]. Assume that the real-time time identified by the cloud provider and the feedback description of the VM constitute the cost of the VM, and the result fluctuates accordingly. Therefore, (6) represents the computational cost of completing a specific VM task.

$$\begin{array}{c}f\left(x\right)=\sum _{i=1}^m\mathrm{resource}{}_i\left(C_i\times T_i\right)\\ \forall i\in N,i=1,\dots ,m\end{array}$$

(6)

where $C_i$ represents the resource cost per unit time and $T_i$ represents the time of resource utilization.

3.4. Throughput Model

In cloud computing, throughput is defined as the total number of tasks that have been successfully executed. This is equivalent to the number of certain tasks completed in a certain period. Furthermore, it can be known that task scheduling in cloud computing requires minimum throughput [15]. Equation (7) expresses the throughput that defines the total number of tasks mapped on the VM.

$$f\left(x\right)=\sum _{i=1}^m{T}_i,\forall i\in N,i=1,2,\dots ,m$$

(7)

3.5. Performance Improvement Rate

In the cloud computing resource scheduling problem, the definition of performance improvement rate (PIR) is used to estimate the performance improvement percentage of the i-th algorithm compared to the k-th algorithm [15]. Usually, it is expressed as a percentage (%).

$$PIR(\%)=\frac{{\sum }_{k}PM-{\sum }_{i}PM}{{\sum }_{i}PM}*100$$

(8)

4. Materials and Methods

Bat Algorithm is a new meta-heuristic swarm intelligence algorithm proposed by Yang in 2010 inspired by bats’ search behavior [19]. This algorithm has unique advantages in solving multi-objective optimization and nonlinear global optimization problems. However, when looking for a feasible solution to a specific issue, the bat algorithm is prone to fall into a local optimum, leading to premature convergence. Under ideal conditions, the bat algorithm is improved mainly by adjusting the pulse frequency f, loudness $A_i$, and pulse emission rate $r_i$. Because solving the resource scheduling problem of cloud computing involves four indicators, it belongs to the multi-objective problem. To make it easily distinguished from the original bat algorithm and other meta-heuristic algorithms, the algorithm proposed in this paper is named the hybrid multi-objective bat algorithm.

4.1. The Idealized Rules of Original Bat Algorithm

Under ideal circumstances, a new type of swarm intelligence algorithm is designed to simulate the changes in the frequency, loudness, and pulse emission rate of the pulses emitted by bats when foraging.

When proposing the bat algorithm, Yang gave the following idealized rules for the echolocation characteristics of simulated bats:

• IR1: All bats use echolocation to perceive distance, and can also “know” the difference between prey or things and obstacles in a way that we do not;
• IR2: The bat flies at will at a fixed frequency at a position and at a speed, looking for food with different wavelengths and loudness. They can adjust the wavelength or frequency of the pulses they emit and adjust the rate of pulse emission according to their proximity to their targets;
• IR3: Although loudness is unpredictable in many ways, we assume that loudness decreases from a positive maximum value to a minimum constant value.

4.2. A Hybrid Bat Algorithm Based on Multi-Objective

4.2.1. Habitat Initialization

To solve the resource allocation problem, the bat algorithm generates initial candidate habitats in the form of a matrix of size $N_{\mathrm{pop}}\times n$, where $N_{pop}$ and n are the size and the number of the initial population, respectively. Assuming that the bat sets a frequency f in the solution, each frequency f in the solution represents a solution, and the frequency f is a virtual resource or virtual machine reserved for a mapping task in a cloud environment. For bat $i=1,2,\dots n$, assuming that the position of the bat is $x_i$ and the velocity is $v_i$. In the D-dimensional space, the position of the bat i at time is $x_i^t$, the speed is $v_i^t$, and there is

$$f_i=f_{min}+\left(f_{max}-f_{min}\right)\beta$$

(9)

$$v_i^t=v_i^{t-1}+\left(x_i^t-x_{*}\right)f_i$$

(10)

$$x_i^t=x_i^{t-1}+v_i^t$$

(11)

4.2.2. Population Classification

The optimization process is divided into two stages. The first stage is that when the individual bat is in a better search position and is close to the optimal solution, its loudness and pulse emission rate reach the best state. This process is called the search phase, its population is called the search-type population. And the second stage is the population of bats in a disadvantaged search position, that is, the capture population, so two populations with different functions are obtained. After each iteration, by updating the search direction and step length, the loudness and pulse emission rate of the bat algorithm are improved to find the optimal solution. By adjusting the weights and deviations of the network, the difference between the average value and the standard deviation of the bat algorithm can be minimized.

Search-Type Population

The combination of Back Propagation (BP) algorithm based on Mean Square Error (MSE) and gradient descent method minimizes the mean square error [20]. The formula based on the mean square error measurement is shown in (12):

$$MSE(d,y)=\frac{1}{N}\sum _{n=1}^N{(d\left(n\right)-y\left(n\right))}^2$$

(12)

where $d\left(n\right)$ represents the n-th element of the required signal, and $y\left(n\right)$ represents the nth actual output. In the training process, the weight vector in the $(t+1)$ iteration is updated by (14). Where $\alpha$ is the learning rate or step length, ${\mathcal{W}}_t$ is the weight vector of the previous iteration and $g_t$ is the gradient vector, which can be calculated by (13) and (14).

$$w_{t+1}=w_t-\alpha g_t$$

(13)

$$g_t={\left.\frac{\partial e}{\partial w}\right|}_{w=w_t}=\left[\frac{\partial e}{\partial w_{11}}\cdots \frac{\partial e}{\partial w_{ij}}\dots \frac{\partial e}{\partial w_{nn}}\right]$$

(14)

In (14), e is the MSE error output in the t-th step of the training process and $\partial \mathrm{e}/\partial \mathrm{w}$ is derived from the MSE error on each element of the w vector. The weight is expressed as $w_{t+1}=w_t-{\alpha }_t{g}_t$, ${\alpha }_t$ will be adjusted to an appropriate value to achieve better convergence. At this time, suppose the probability pops of the search-type population, its loudness and pulse emission rate are updated to:

$$A_i^{t+1}={\alpha }_t\times A_i^t$$

(15)

$$r_i^{t+1}=r_i^o\left(1-e^{-wt}\right)$$

(16)

Captive Population

As a branch of the gradient descent method, the Conjugate Gradient method (CG) is applied to nonlinear unconstrained optimization problems. This method has strong local and global convergence [21]. According to the cloud computing resource scheduling problem, the CG method uses (17) to generate a weight sequence:

$$w_{t+1}^{\prime }=w_t^{\prime }+{\alpha }_t^{\prime }d$$

(17)

where ${\alpha }_t^{\prime }$ is the result of the line search method, which can be an exact line search or an inaccurate line search, which is expressed as a step size here. In (17), $d_t$ is in the descending direction, which is expressed as the search direction here, and its formula is shown in (18):

$$d_{t+1}=-g_{t+1}+{\beta }_t{d}_t$$

(18)

In (18), ${\beta }_t$ is the conjugate parameter, $g_{t+1}$ is the gradient of the objective function concerning the weight at step $t+1$, and represents the direction of the last step, and the first step is $d_0=-g_0$.

In the iterative process, the loudness $A_i$ and the pulse emission rate $r_i$ will also change. As the bat gets closer to its prey, its loudness will decrease, and the pulse emission rate will increase. At this time, the probability of the catching population is $po{p}_h$ and $po{p}_s+po{p}_h=1$. In summary, the loudness and pulse emission rate of the bat algorithm are updated to

$$A_i^{t+1}={\alpha }_t^{\prime }\times A_i^t$$

(19)

$$r_i^{t+1}=r_i^o\left(1-e^{-w^{\prime }t}\right)$$

(20)

4.3. Bat Algorithm Based on Lévy Flight

In the resource scheduling optimization problem of cloud computing, feasible solutions have some unavoidable limitations, such as lower accuracy and slower speed. Moreover, the reference [22] confirms that for the situation where the target position of the “no priority direction” is unknown and the target cannot be supplemented, and lévy flight is the best search mode. To improve the solution, compared with the standard Gaussian distribution algorithm, the bat algorithm is combined with lévy flight. Here $x_i^t$ is the current solution, $x_i^{t+1}$ is the new solution, then

$$x_i^{t+1}=x_i^t+\mathrm{round}(\alpha \otimes L\left(\lambda \right))$$

(21)

where $\alpha$ represents the step vector, ⊗ represents the Hadamard multiplication operator, $round\left(o\right)$ represents the rounding operation, $L\left(\lambda \right)={\left[l_1\left(\lambda \right),\dots ,l_t\left(\lambda \right)\right]}^T$ is the length of the random step, and $l_i\left(\lambda \right)$ follows the lévy flight, $l_i\left(\lambda \right)\sim t^{-\lambda },1<\lambda \le 3$. Here, $\lambda$ is the parameter that affects the random step size.

4.4. The Steps of Multi-Objective Bat Algorithm

In the cloud computing resource scheduling problem, the individual position in the bat algorithm can be mapped to the solution of the problem, that is, the optimal path. The task can be decomposed into several subtasks according to the requirements of resource allocation, and each subtask can be determined by the candidate solution. Or execute the corresponding service selected centrally in the feasible solution. The optimal individual position can be mapped to the optimal solution of the optimization problem. The fitness value of the habitat can be mapped to the quality of the solution to the problem. The dimension of habitat can be mapped to the number of subtasks of the problem. In summary, the steps of the hybrid bat algorithm are as follows. The flow chart of the proposed algorithm is shown in Figure 1.

• Step 1: Determine the objective function
  Set the bat population size ($N_{pop}$), maximum number of iterations ($gen$), frequency range ($[fmin,fmax]$), step vector ($\alpha$) and stop condition ($tol$).
• Step 2: Initialize the habitat
  In the feasible region, randomly generate the initial habitat ($habitat$), frequency ($f_i$), initial pulse emission rate ($r_i$) and loudness ($A_i$).
• Step 3: Calculate the fitness value
  Calculate the fitness value of the objective function RS and update the optimal position ($p_i$) and the optimal global position ($p_g$).
• Step 4: Set the initial iteration loop
  Set $t=1,tt=1$.
• Step 5: Update the positions of all individuals
  If $t<\mathrm{GEN}$, update the positions of all individuals, the current optimal position $p_{current}$ and the global optimal position $p_{global}$; otherwise, go to step 8.
• Step 6: Update iteration loop
  Update $t=t+1,tt=tt+1$.
• Step 7: Calculate the new population fitness value
  If $tt<tol$, return to step 5; otherwise, calculate the current optimal position of the individual and generate a new population, and sort according to the individual fitness value. The new population is divided into two parts. One part includes a better search-type population with a number of $po{p}_s*n$, and the other part is a search-type population with a number of $\left(1-po{p}_s\right)*n$. According to Section 4.2, new and better individuals are generated through local search.
• Step 8: Calculate the fitness value of the new search-type population
  Set $tt=1$; otherwise, return to step 5.
• Step 9: Output the optimal solution.

5. Results and Discussion

This part describes the parameter settings, the implementation of the multi-objective bat algorithm(MOBA), and other meta-heuristic algorithms for optimizing IaaS cloud computing resource scheduling. The test comes from the CUTEr database [23]. The numerical experiments were performed using MATLAB r2020a software on a computer with 12.0 GB RAM, running professional Microsoft Windows 10. And creating a data set based on the uniform distribution and the normal distribution. The former includes an equal number of small, medium, and large tasks, and the latter includes fewer small, fewer large tasks, and more medium tasks, denoted by S01 and S02, respectively. In IaaS cloud computing, the MOBA algorithm is compared with other meta-heuristic algorithms, and a set of parameters is selected, including makespan, throughput, imbalance, cost, and performance improvement rate. In simulation analysis, after 50 simulation runs, the average value, standard deviation, and optimal value are obtained to compare performance indicators.

5.1. Parameter Setting

Based on the literature [24,25,26,27],

Table 2. Simulation parameter settings in cloud computing for resource scheduling.

Number	Entities	Parameters	Values
1	User	Number of users	25
		Number of brokers	5
2	Cloudlet	Number of cloudlets	100–2000
		Length	60,000
		File size	400
3	Host	RAM	2048
		Storage	10,000
		Bandwidth	10,000
4	VM	Number of VMs	25
		Type of policy	Time shared
		RAM	512
		Bandwidth	10,000
		MIPS	1000
		Size	10,000
		Operating system	Windows
		Number of CPUs	1 on each
5	Data center	Number of data centers	2

shows this problem’s parameter settings.

The parameter settings of the metaheuristic algorithm are shown in

Table 3. In resource scheduling, the parameter setting of meta-heuristic algorithm.

Algorithms	Parameters	Values
MOACO	Number of ants	10
	Vaporization factor	0.4
	Pheromone tracking weight	0.3
	Heuristic information weight	1
	Pheromone updating constant	100
MOGA	Population size	1000
	Max iteration	1000
	Crossover rate	0.5
	Mutation rate	0.1
MOPSO	Population size	1000
	Max iteration	1000
	Crossover rate	0.5
	Mutation rate	0.1
	Particle size	100
	Self-recognition coefficients	2
	Uniform random number	[0, 1]
	Max iteration	1000
	Inertia weight	[0.4, 0.9]
MOCSO	Population size	1000
	Abandon probability	0.25
	Max iteration	1000
	Step size	[0.1, 1]
MOBA	Population size	1000
	Max iteration	1000
	Frequency	[0, 1]
	Loudness	[1, 2]
	Pulse emission rate	[0, 1]
	Step vector	[0, 1]

. The parameter values of the ant colony optimization algorithm (MOACO) are based on [26,28]. The MOACO has strong robustness and the ability to search for better solutions in solving performance, and is easy to implement in parallel. However, it has the shortcomings of slow convergence speed, easy to fall into local optimum, and lack of initial pheromone. Moreover, the search time of the algorithms is too long, and it is prone to stagnation. The parameter values of the genetic algorithm (MOGA) are based on [29]. The Multi-objective genetic algorithms have good global search ability and can quickly search out all solutions in the solution space without falling into the trap of rapid decline of locally optimal solutions. By using its inherent parallelism, distributed calculations can be carried out conveniently and the solution speed can be accelerated. However, the local search ability of genetic algorithms is poor, which leads to the greater time consumption of pure genetic algorithms. The search efficiency is low in the later stage of evolution, and the problem of premature convergence is prone to occur. The parameter values of particle swarm optimization (MOPSO) are based on [30,31]. MOPSO has a very fast approach to the optimal solution, and can effectively optimize the parameters of the system. Its advantage lies in solving some optimization problems of continuous functions. However, it is prone to premature convergence, especially when dealing with complex multi-peak search problems, and the local optimization ability is poor. The Cuckoo Algorithm (MOCSO) are [32,33]. There are few parameters, the convergence speed is not sensitive to parameter changes, it is not easy to fall into the local optimum, and it is easy to couple with other algorithms. It also has good versatility and strong robustness, but slow convergence speed and lack of vitality.

5.2. Simulation Results

This part elaborates and discusses the simulation results of statistical analysis, and evaluates the performance of the proposed MOBA in cloud computing resource scheduling. Here, the $mean$ means the average, $std$ is the standard deviation and $best$ is the optimal value.

5.2.1. Optimization Test Problems

Four standard functions are selected in Test Functions and Datasets as shown in

Table 4. Four standard functions.

Function	Type	Dimension	Search Scope	The Optimal Value
Ackley	Local Minima	100	[−32.768, 32.768]	0
Griewank	Local Minima	100	[−600, 600]	0
Sphere	Bowl-Shaped	100	[−5.12, 5.12]	0
Rosenbrock	Valley-Shaped	100	[−5, 10]	0

. The algorithm proposed in this paper and the original bat algorithm (BA) are used to solve the four standard functions to test the optimization performance of the algorithm. The parameters are set as follows, the population size is 100, the maximum number of iterations is 50, the maximum frequency is 1, the minimum frequency is 0, the loudness is 0.9, and the pulse emission rate is 0.9. In addition, the step vector of MOBA takes a value of 0.9. According to the above parameter settings, each algorithm runs 50 times.

Table 5. Optimization results of algorithms for four standard functions.

Function	Algorithm	The Optimal Value	Worst Value	$\mathbf{Mean}$	$\mathbf{std}$
Ackley	BA	5.81	7.12	6.19	0.99
	MOBA	5.25	6.64	5.97	1.23
Griewank	BA	1.03	1.05	1.05	0.0029
	MOBA	0.91	1.054	0.9537	0.095
Sphere	BA	126.74	213.16	161.32	45.19
	MOBA	120	270.23	157.96	86.56
Rosenbrock	BA	0.6 × 10${}^5$	1.52× 10${}^5$	1.16× 10${}^5$	0.52× 10${}^5$
	MOBA	0.55× 10${}^5$	2.01× 10${}^5$	0.68× 10${}^5$	0.78× 10${}^5$

shows the optimization results of the two algorithms for the four standard functions.

It can be seen from the table that compared with the original bat algorithm, the algorithm proposed in this paper has better optimal value, worst value, average value, and standard deviation for these four benchmark functions. The original bat algorithm only has a higher optimization result for the simple test function Griewank.

To fully illustrate the performance of the algorithm in this paper, Figure 2 shows the optimal convergence curves of the two algorithms for the four benchmark functions. It can be seen from the figure that the overall optimization performance of the original bat algorithm (BA) and the algorithm proposed in this paper (MOBA) are similar in the four benchmark functions, and the optimization effect on high-dimensional complex spaces is acceptable. However, in the optimization test of the multimodal function Ackley, as the number of iterations increases, the objective function value of the original bat algorithm decreases too slowly. Moreover, its optimization accuracy is not good, and the convergence speed is too slow.

The improved bat algorithm in this paper shows good performance in the entire range of iterations, regardless of the unimodal function Sphere, Rosenbrock, or the multimodal function Ackley and Griewank functions. It can be clearly seen that the curve of the objective function value drops fast and the optimization accuracy is high. With the increase in the number of iterations, the optimal value can be obtained in the optimization.

5.2.2. Makespan

Table 6. After 50 runs, the makespan statistics table.

Algorithm	Cloudlets	S01
		100	500	1000	2000
MOACO	mean	1562.73	2002.73	3213.22	5846.9
	std	4.18	21.64	33.81	21.23
	best	1558.9	1974.87	3153.32	5781.03
MOGA	mean	1533.18	3011.76	4768.28	5865.64
	std	7.57	149.28	8.84	24.9
	best	1518.29	2953.06	4755.65	5759.9
MOPSO	mean	1528.49	1993.4	2582.26	5828.15
	std	8.09	17.03	19.02	22.02
	best	1337.81	1973.25	2562.36	5761.02
MOCSO	mean	1296.12	1721.55	2255.55	5687.5
	std	2.51	1.6	0.91	14.41
	best	1290.43	1719.07	2253.74	5641.2
MOBA	mean	1290.6	1490.94	1940.56	5324.02
	std	2.22	1.41	0.8	0
	best	1124.56	1488.74	1938.96	5632.02
Algorithm	Cloudlets	S02
		100	500	1000	2000
MOACO	mean	719.02	954.25	1457.44	1349.2
	std	1.92	10.88	16.85	32.72
	best	717.26	941.73	1428.03	1307.8
MOGA	mean	718.26	1374.29	2174.43	1292.34
	std	3.53	67.96	4.05	31.35
	best	711.33	1339.27	2168.42	1239.34
MOPSO	mean	711.97	1036.11	1346.02	1406.06
	std	8.55	11.25	16.05	31.52
	best	624.55	1022.8	1327.28	1357.46
MOCSO	mean	704.35	935.51	1219.35	1069
	std	1.36	0.87	0.49	17.15
	best	701.27	934.17	1218.37	1013.9
MOBA	mean	565.08	745.84	970.76	1004
	std	1.11	0.7	0.4	0
	best	562.56	744.74	969.96	1004

shows that after running 50 times, when the number of the cloudlets is 100, 500, 1000, and 2000, the optimal value of the makespan of all algorithms is very close to the average value. It can also be clearly seen that as the number of the cloudlets increases, the standard deviation of MOBA becomes smaller and smaller, indicating that the larger the data scale, the greater the advantage of the proposed algorithm and the better its superiority. Compared with other algorithms, the standard deviation of MOBA is the smallest. When the cloudlet is 2000, its value is zero, indicating that the divergence and deviation of the data are the smallest, and the time consumed is the smallest.

Figure 3 shows that as in a uniform distributed environment, it can be seen that the green color represents different values of MOBA under different conditions of cloudlets’ values, and its makespan is always lower than the other several meta-heuristic algorithms. Especially when the cloudlet is 1000, the value is much lower than MOGA represented by orange. And under the normal distribution, when the cloudlet’s values are 100 and 2000, the degree of change of all algorithms is small. While the values are 500 and 1000, the makespan of MOGA is the longest, the makespan of MOBA proposed in this paper is the best. It shows that in these two distributions, MOBA has better effectiveness and superiority.

5.2.3. Degree of Imbalance

Table 7. Statistics of the degree of imbalance after running 50 times.

Algorithm	Cloudlets	S01
		100	500	1000	2000
MOACO	mean	0.5026	0.5529	0.5552	0.5541
	std	0.0726	0.0828	0.0878	0.0854
	best	0.5092	0.5404	0.5192	0.5289
MOGA	mean	0.5006	0.5229	0.5334	0.5282
	std	0.0723	0.0755	0.077	0.0763
	best	0.505	0.5308	0.5428	0.5369
MOPSO	mean	0.5132	0.5511	0.5682	0.5597
	std	0.0763	0.0811	0.0873	0.0853
	best	0.5128	0.5447	0.5405	0.5437
MOCSO	mean	0.4944	0.5048	0.5144	0.5107
	std	0.0714	0.0729	0.0742	0.0736
	best	0.4998	0.5135	0.5237	0.5197
MOBA	mean	0.4942	0.5048	0.5147	0.5096
	std	0.0714	0.0728	0.0743	0.0734
	best	0.4987	0.4987	0.4987	0.5004
Algorithm	Cloudlets	S02
		100	500	1000	2000
MOACO	mean	0.5023	0.5593	0.5628	0.5611
	std	0.0725	0.0837	0.0887	0.0873
	best	0.5089	0.5471	0.5272	0.5373
MOGA	mean	0.498	0.5081	0.5186	0.5136
	std	0.072	0.0734	0.0749	0.0742
	best	0.5023	0.5157	0.5277	0.5217
MOPSO	mean	0.5076	0.5891	0.6056	0.5974
	std	0.0771	0.0864	0.092	0.0892
	best	0.5044	0.5839	0.5798	0.5819
MOCSO	mean	0.4935	0.5037	0.5109	0.5084
	std	0.0713	0.0727	0.0737	0.0743
	best	0.4996	0.5124	0.5201	0.5163
MOBA	mean	0.4942	0.5048	0.5147	0.5098
	std	0.0714	0.0727	0.0743	0.0746
	best	0.4897	0.4897	0.5143	0.5002

shows that after running 50 times, in the case of uniform distribution and normal distribution, when the cloudlet is 1000, the standard deviation of all algorithms reaches the maximum value. At the same time, it can also be seen that the average and optimal value of MOBA’s imbalance degree are almost the same, and the standard deviation is almost the same. Compared with other algorithms, the standard deviation of MOBA still reaches the minimum which shows that the MOBA algorithm has significant characteristics and is more superior to other meta-heuristic algorithms when considering the degree of imbalance.

Figure 4 shows that in the case of uniform distribution, similar to Table 5, the value of its cloudlet fluctuates very little, which also reflects the performance of examining the degree of imbalance. The change under uniform distribution is not as strong as the normal distribution. In a normal distribution environment, it can be analyzed that MOPSO has the worst imbalance. Moreover, the degree of imbalance of MOBA is the best, and the results of MOCSO are comparable to those of MOBA.

5.2.4. Cost

As it is a cost calculation, the smaller the result, the better. It can be observed from

Table 8. After running 50 times, the cost statistics table.

Algorithm	Cloudlets	S01
		100	500	1000	2000
MOACO	mean	99.66	157.16	194.66	271.01
	std	2.02	2.83	3.4	7.8
	best	95.3	150.53	185.31	249.65
MOGA	mean	42.76	69.54	76.53	118.9
	std	0.98	1.73	1.76	4.08
	best	40.47	65.56	70.66	107.03
MOPSO	mean	28.53	54.98	61.25	95.71
	std	0.94	1.554	1.95	3.28
	best	27.44	43.15	55.19	85.15
MOCSO	mean	22.51	34.09	40.47	62.55
	std	0.38	0.8	1.02	2.6
	best	21.43	25.42	27.61	54.68
MOBA	mean	35.54	59.38	67.87	103.55
	std	0.84	1.45	1.69	3.6
	best	33.87	51.32	59.54	92.75
Algorithm	Cloudlets	S02
		100	500	1000	2000
MOACO	mean	1.55	35.1	66.47	132.88
	std	0.24	4.89	9.73	14.93
	best	1.13	28.98	54.65	101.7
MOGA	mean	0.55	12.09	23.59	47.09
	std	0.3	2.88	5.47	8.91
	best	0.29	9.36	18.97	36.39
MOPSO	mean	0.22	9.09	17.96	35.97
	std	4.26	4.27	4.28	7.61
	best	0.32	6.61	12.89	29.06
MOCSO	mean	0.31	5.16	10.02	26.97
	std	0.14	0.62	1.1	3.1
	best	0.18	4.96	9.74	23.6
MOBA	mean	0.43	10.43	20.27	42.69
	std	1.48	2.73	4	7.06
	best	0.32	8.35	16.42	34.18

that in uniform distribution and normal distribution, as the number and scale of the cloudlets increase, the cost of all algorithms also increases. It can be seen from the standard deviation that MOBA is generally smaller than the standard deviation of MOACO, MOGA, and MOPSO, and larger than the standard deviation of MOCSO. It can also be obtained that the cost of MOACO is the highest, while the cost of MOCSO is the lowest.

It can be clearly seen from Figure 5 that regardless of the uniform distribution or the normal distribution, MOBA is better than MOACO and MOGA, and worse than MOPSO and MOCSO. We can also see that as the number of the cloudlets changes, MOACO fluctuates the most, indicating that its cost investment is the largest, and the changes and fluctuations are large. It means that the consumption in terms of energy-saving is also the largest, and it is not conducive to the improvement of resource utilization.

5.2.5. Throughput

For non-concurrent application systems, throughput is strictly inversely proportional to response time. Therefore, in a concurrent system, throughput is usually used as a performance indicator. It shows that the resource allocation is reasonable, and the throughput seen by each user does not increase linearly with the increase of the cloudlets.

Table 9. After 50 runs, the throughput statistics table.

Algorithm	Cloudlets	S01
		100	500	1000	2000
MOACO	mean	6371.82	9847.10	13,957.38	15,894.51
	std	64.81	35.06	144.45	144.53
	best	5793.41	9798.30	13,685.52	15,680.74
MOGA	mean	5184.74	12,163	20,442.70	21,761.99
	std	69.34	904.29	202.46	762.69
	best	5132.40	11,270.98	20,243.09	21,034.24
MOPSO	mean	5277.80	16,289.42	22,394.57	25,814.19
	std	72.07	162.10	119.43	212.55
	best	4120.10	15,968.72	22,231.03	25,491.36
MOCSO	mean	4565.69	5490.20	7428.87	8637.573
	std	33.25	125.61	265.67	285.71
	best	4482.67	5247.46	6991.34	8184.06
MOBA	mean	4029.61	4912.45	6141.06	7393.87
	std	29.49	111.40	235.63	256.21
	best	3955.97	4912.45	6141.06	7393.87
Algorithm	Cloudlets	S02
		100	500	1000	2000
MOACO	mean	2830.04	7296.57	9938.45	11,517.43
	std	87.72	125.98	202.85	246.64
	best	2573.14	7260.42	9744.86	11,364.27
MOGA	mean	2300.5	5396.79	9070.54	9672.307
	std	30.77	401.24	389.83	554.80
	best	2277.28	5001	8981.97	9349.40
MOPSO	mean	2431.91	7249.37	9966.38	11,504.59
	std	28.67	72.14	253.15	244.28
	best	1845.91	7106.65	9893.60	11,360.92
MOCSO	mean	2481.16	18.04	2436.12	1663.53
	std	2983.80	68.34	2851.83	1974.20
	best	4037.46	144.61	3799.56	2656.87
MOBA	mean	2015.81	2457.45	3072.06	3713.76
	std	14.75	55.73	117.87	143.15
	best	1978.97	2457.45	3072.06	3713.76

shows the mean, standard deviation, and optimal of the throughput. After 50 runs, the number of cloudlets is 100, 500, 1000, and 2000. It can be seen from Table 9 that in the throughput analysis of the MOBA algorithm, the standard deviation value is not as prominent as the makespan and cost data. However, compared with the other four algorithms, the standard deviation of MOBA has a significant advantage. In particular, when the cloudlet is 100 and 200, the value of MOBA is one-third of MOACO.

It can be analyzed from Figure 6 that in the case of uniform distribution, as the number of the cloudlets increases, the throughput also increases. This shows that throughput will affect the efficiency and utilization of resource scheduling, thereby further affecting the sustainable development of cloud computing and the issues of energy conservation and emission reduction. In addition, we can see from the figure that the throughput of MOBA has always been close to MOCSO in a uniform distribution, but has been roughly smaller than MOCSO in a normal distribution. In the large-scale case of the cloudlets of 1000 and 2000, the throughput of MOBA is much smaller than the three meta-heuristic algorithms of MOACO, MOGA, and MOPSO. This also verifies the conclusions in Table 9. It has to be said that in terms of throughput, MOBA still has strong advantages and good performance.

5.3. Performance Comparison

In summary, firstly, after 50 runs, the average value, standard deviation, and optimal value of MOBA are all very significant in terms of makespan, degree of imbalance, cost, and throughput. The saliency analysis proves that the MOBA algorithm is more robust and has a stronger Pareto optimal solution ability. Secondly, the MOBA algorithm has good robustness under the conditions of uniform distribution and normal distribution, and the ability to reach close to the optimal value in almost all operations. Therefore, this paper discusses the calculation results of simulations formulated using statistical significance analysis to evaluate the performance of the proposed MOBA algorithm for multi-objective resource scheduling in an IaaS cloud computing environment.

Table 10. Comparison of performance in terms of Makespan.

Algorithm	MOACO	MOGA	MOPSO	MOCSO	MOBA
Total Makespan	16,862.94	20,445.26	15,966.53	14,772.15	13,465.54
PIR over MOACO		−21.24	5.32	12.40	20.15
PIR over MOGA			21.91	27.75	34.14
PIR over MOPSO				7.48	15.66
PIR over MOCSO					8.85

,

Table 11. Comparison of performance in terms of DI.

Algorithm	MOACO	MOGA	MOPSO	MOCSO	MOBA
Degree of imbalance	4.22	4.18	4.39	4.11	4.01
PIR over MOACO		0.84	−4.11	2.68	4.85
PIR over MOGA			−4.99	1.86	4.05
PIR over MOPSO				6.53	8.61
PIR over MOCSO					2.23

,

Table 12. Comparison of performance in terms of Cost.

Algorithm	MOACO	MOGA	MOPSO	MOCSO	MOBA
Total Cost	867.25	348.73	259.81	167.62	296.75
PIR over MOACO		59.79	70.04	80.67	65.78
PIR over MOGA			25.50	51.93	14.91
PIR over MOPSO				35.48	−14.22
PIR over MOCSO					−77.04

and

Table 13. Comparison of performance in terms of Total Throughput.

Algorithm	MOACO	MOGA	MOPSO	MOCSO	MOBA
Total Throughput	75,900.66	83,290.36	98,018.29	41,544.03	33,625.59
PIR over MOACO		−9.74	−29.14	45.27	55.70
PIR over MOGA			−17.68	50.12	59.63
PIR over MOPSO				57.62	65.69
PIR over MOCSO					19.06

show that the relative performance improvement rate of MOBA algorithm based on makespan, the imbalance degree, cost and throughput compared with MOACO, MOGA, MOCSO, and MOPSO algorithm. The conclusions are as follows:

• In terms of total makespan, the value of MOBA is 13,465.54, which is the smallest among these algorithms. It can be seen from Table 10 that the performance comparison analysis with MOACO, MOGA, MOPSO, and MOCSO shows that the results are 20.15%, 34.14%, 15.66%, and 8.85%, respectively. Moreover, the performance comparison result between MOGA and MOACO is −21.24%, which also verifies the conclusion of Figure 3. The conclusion is that MOGA has the longest makespan and the worst performance. Furthermore, this also fully shows that MOBA has strong advantages and superiority in solving the problem of makespan. In terms of makespan, the MOBA algorithm was compared and analyzed with the MOACO, MOGA, MOPSO, and MOCSO algorithms, and the results obtained were shortened by 10.07%, 25.82%, 5.02% and −2.66%, respectively.
• For the degree of imbalance, the values of these algorithms do not differ greatly. It can be seen from Table 11 that the total imbalance is in the interval of $[4,5]$, and the result of MOBA is 4.01%, which is the smallest among these meta-heuristic algorithms. Even so, it can be accurately seen that the comparison results of MOBA with other meta-heuristic algorithms are 4.85%, 4.05%, 8.61%, and 2.23%, and the comparison results of MOPSO with MOACO and MOGA are −4.11% and −4.99%, respectively. From this, it can be clearly affirmed that the performance of MOBA in the degree of imbalance is the most stable, and the most unstable algorithm is MOPSO. This also verifies the conclusion of Figure 4.
• In terms of cost, it can be clearly seen that the total cost of MOBA is 296.75, which is much lower than MOCAO and MOGA, but higher than MOPSO and MOCSO. Moreover, in the performance comparison, it can also be seen that the results of comparison between MOBA and other meta-heuristic algorithms in terms of cost are 65.78%, 14.91%, −14.22% and −77.04%, respectively. This also coincides with the conclusion of Figure 5. This proves that MOBA is unsatisfactory in terms of cost and is not very prominent.
• As we all know, throughput is related to the rationality of resource allocation and resource utilization. Overall, the throughput result of MOBA is 33,625.59, compared with other meta-heuristic algorithms, the results are 55.70, 59.63, 65.69, 19.06, respectively. In addition, it can also be analyzed to compare MOGA with MOACO, and compare MOPSO with MOACO and MOGA, and the results are all negative. This shows that in terms of throughput comparison, MOGA and MOPSO are both unsatisfactory results, especially MOPSO is the worst. In comparison, MOBA is the best performance.

It can be seen that the MOBA algorithm accelerates the convergence speed and enhances its ability to handle optimization of resource scheduling problems in IaaS cloud computing, which also proves the effectiveness and robustness of the MOBA algorithm.

6. Conclusions

Resource scheduling is an NP-hard problem in the cloud computing environment. This paper outlines the problem of resource scheduling, proposes the MOBA algorithm, and discusses and analyzes its convergence and performance. It also compares and analyzes the performance of other meta-heuristic algorithms, including MOACO, MOGA, MOPSO, and MOCSO algorithms for solving and optimizing resource scheduling problems in cloud computing. The research motivation is to discuss the problem of multi-objective resource scheduling by maximizing the utilization of resources in the cloud computing environment. Therefore, the MOBA proposed in this paper effectively utilizes resources through makespan, degree of imbalance, cost, and throughput. The simulation results are obtained with the help of graphs and statistical analysis, indicating that the proposed MOBA algorithm is more effective and has better performance than the existing meta-heuristic algorithm in optimizing resource scheduling in the cloud computing environment.

(1) Through the classification of MOBA populations, the search range of the algorithm is expanded, and the ability to solve feasible solutions is increased. Therefore, the search for better target areas can be achieved more effectively, and the completion time of the cloudlet in cloud computing can be reduced. It can also maintain the load balance of the nodes.

(2) The loudness and pulse emission rate of the original bat algorithm were improved and optimized using the back-propagation based on the mean square error and conjugate gradient methods. MOBA effectively overcomes the phenomenon of local optima and premature convergence, improves the solution accuracy and convergence speed, makes the resource utilization of cloud computing more balanced and reasonable, and achieves a good and fast sustainable development effect.

(3) Through the use of lévy flight to optimize and improve the feasible solution, the Pareto optimization of the bat algorithm is realized, which effectively reduces the cost and energy consumption required for cloud computing, and greatly reduces the cost of the cloudlet. The degree of balance makes it more stable and balanced, and the resource scheduling ability of cloud computing has been greatly improved, which is good at optimizing resources and rationally scheduling resources, thereby improving the efficiency of resource allocation.

It is worth mentioning that this algorithm can also be used to solve other optimization problems in cloud computing environments and other discrete optimization problems in different fields. Therefore, in subsequent research, we will first pay more attention to solving other optimization problems of cloud computing, such as task scheduling or green cloud computing environment. Secondly, we will also combine the bat algorithm with other heuristic algorithms, and it may also prove to be a very effective optimization algorithm in the cloud computing environment. In the future research process, we will pay more attention to the research direction of environmental protection and sustainable economic development, such as the dual-carbon economy and green management.