Task Scheduling Approach in Cloud Computing Environment Using Hybrid Differential Evolution

Abstract

Task scheduling is one of the most significant challenges in the cloud computing environment and has attracted the attention of various researchers over the last decades, in order to achieve cost-effective execution and improve resource utilization. The challenge of task scheduling is categorized as a nondeterministic polynomial time (NP)-hard problem, which cannot be tackled with the classical methods, due to their inability to find a near-optimal solution within a reasonable time. Therefore, metaheuristic algorithms have recently been employed to overcome this problem, but these algorithms still suffer from falling into a local minima and from a low convergence speed. Therefore, in this study, a new task scheduler, known as hybrid differential evolution (HDE), is presented as a solution to the challenge of task scheduling in the cloud computing environment. This scheduler is based on two proposed enhancements to the traditional differential evolution. The first improvement is based on improving the scaling factor, to include numerical values generated dynamically and based on the current iteration, in order to improve both the exploration and exploitation operators; the second improvement is intended to improve the exploitation operator of the classical DE, in order to achieve better results in fewer iterations. Multiple tests utilizing randomly generated datasets and the CloudSim simulator were conducted, to demonstrate the efficacy of HDE. In addition, HDE was compared to a variety of heuristic and metaheuristic algorithms, including the slime mold algorithm (SMA), equilibrium optimizer (EO), sine cosine algorithm (SCA), whale optimization algorithm (WOA), grey wolf optimizer (GWO), classical DE, first come first served (FCFS), round robin (RR) algorithm, and shortest job first (SJF) scheduler. During trials, makespan and total execution time values were acquired for various task sizes, ranging from 100 to 3000. Compared to the other metaheuristic and heuristic algorithms considered, the results of the studies indicated that HDE generated superior outcomes. Consequently, HDE was found to be the most efficient metaheuristic scheduling algorithm among the numerous methods researched.

1. Introduction

Healthcare services (HCS) based on cloud computing and IoT are now seen as one of the most significant medical fields, due to the spread of epidemics and health crises, where the best use of HCS can save many lives [1]. Through the use of cloud computing, HCS users can gain access to online computing resources, such as software, hardware, and applications that are managed in accordance with their needs. As a result, cloud computing in the context of the Internet of Things has greatly benefited all users, especially those in the healthcare services industry who wish to deliver medical services via the Internet [2]. The rapid adoption and ease of use in all industries, the proliferation of the Internet of Things concept, and the continued advancement of infrastructure and technology will all increase user demand for cloud computing, doubling the volume of data and requests from users. Task scheduling becomes a more challenging issue. Delivering resources in accordance with user requests and upholding quality of service (QoS) requirements for the end-user is a demanding task [3].

Broadly speaking, cloud computing is made up of a large number of datacenters that house numerous physical machines (host). Each host runs several virtual machines (VMs) that are in charge of executing user tasks with varying quality of services (QoS). Users are able to gain access to cloud resources on a pay-as-you-go basis, through the use of cloud service providers [4]. An IoT environment connected to a cloud computing paradigm makes efficient use of the physical resources already available, thanks to virtualization technology. Thus, multiple users of healthcare services (HCS) can store and access a variety of medical resources using a single physical infrastructure, which includes both hardware and software. One of the most significant issues with healthcare services is the task scheduling problem (TSP), which causes users of healthcare services in a cloud computing environment to experience delays in receiving medical requests. The waiting period, the turnaround time for medical requests, CPU waste, and resource waste are some of the factors that contribute to the delay in processing medical requests. TSP is a NP-hard problem responsible for allocating computing resources to application tasks in an effective manner [2].

When the size of the tasks and the number of VMs both increase, the amount of computing time required to select the best scheduling for those tasks to the VMs increases exponentially. Some classic scheduling techniques, such as first come first served (FCFS), round-robin (RR), and shortest job first (SJF), are able to provide solutions to scheduling, but cannot fulfil the demands of cloud computing because its scheduling problem is NP-hard [5,6]. As traditional scheduling algorithms are unable to solve NP-hard optimization problems, more recently, modern optimization algorithms, also known as metaheuristic algorithms, have been used instead. These algorithms can produce optimal or near-optimal solutions in a reasonable amount of time compared to traditional scheduling algorithms.

Several metaheuristic algorithms have been employed for tackling task scheduling in cloud computing environments; for example, in [6], a new variant of the classic particle swarm optimization (PSO), namely ranging function and tuning function based PSO (RTPSO), was proposed, to achieve better task scheduling. In RTPSO, the inertia weight factors were improved to generate small and large values, for better local search and global search. In addition, RTPSO was integrated with the bat algorithm for further improvements; this variant was named RTPSO-B. Both RTPSO and RTPSO have been compared with various well-established algorithms, such as the genetic algorithm (GA), ant-colony optimization algorithm (ACO), and classical PSO. This comparison showed the efficiency of RTPSO-B in terms of its makespan, cost, and the utilization of resources.

The flower pollination algorithm (FPA) was also applied to tackle the task scheduling in cloud computing. Bezdan, T. et al. [7] improved the exploration operator of the classical FPA by replacing the worst individuals with new ones generated randomly within the search space, to avoid becoming stuck in local minima at the start of the optimization process. This improved FPA was called EEFPA and employed to find the best scheduling of tasks in cloud computing environments, which will minimize the makespan as a major objective. EEFPA was the best scheduler, compared to the other similar approaches considered in the study. Choudhary et al. [8] developed a task scheduling algorithm for bi-objective workflow scheduling in cloud computing that is based on hybridizing the gravitational search algorithm (GSA) and heterogeneous earliest finish time (HEFT); this algorithm was named as HGSA. This algorithm was developed in an effort to shorten the makespan and the computational cost. However, it is possible that GSA may not perform accurately for more complicated tasks.

Raghavan et al. [9] adapted the bat algorithm (BA) to tackle the task scheduling problem in cloud computing, with an objective function for reducing the total cost of the workflow. On the other hand, BA had a subpar performance in the high dimension [6]. Tawfeek et al. [10] devised ant colony optimization to deal with task scheduling in cloud computing, with the goal of reducing the makespan. This algorithm was compared to two traditional algorithms, such as FCFS and RR, and it performed better than both of them. The problem with this algorithm is that it converges slowly, and hence will take several iterations to obtain feasible solutions. Hamad and Omara [11] proposed a task scheduling algorithm based on the genetic algorithm (GA), to find the optimal assignment of tasks in cloud computing, which will optimize the makespan and cost, as well as the resource utilization.

The grey wolf optimizer (GWO) was proposed, to schedule the tasks in cloud computing to utilize the resources more efficiently and minimize the total completion time [12]. This algorithm was compared with several scheduling methods, such as the FCFS, ACO, performance budget ACO (PBACO), and min-max algorithms. The experimental findings showed that GWO was the best-performing scheduler and PBACO was the second best. However, the performance of GWO at large scale was not evaluated and, hence, it is not preferable when the number of tasks is at a large scale. Chen, X. et al. [13] presented a task scheduler based on the improved whale optimization algorithm (IWOA). The standard WOA was improved in IWOA using two factors, namely the nonlinear convergence factor and adaptive population size. IWOA was better than the compared algorithms in terms of accuracy and convergence speed when scheduling small-scale tasks or large-scale tasks in cloud computing environments.

Alsaidy, S.A. et al. [14] proposed two variants of PSO: The first, named LJFP-PSO, is based on initializing a population using a heuristic algorithm known as longest job to fastest processor (LJFP); while the second variant, known as MCT-PSO, is based on employing the minimum completion time (MCT) algorithm to initialize the population and to achieve a better makespan, total execution time, degree of imbalance, and total energy consumption when tackling the task scheduling problem in cloud computing. The glowworm swarm optimization (GSO) was used to solve the problem of task scheduling in cloud computing. The goal of this solution was to minimize the overall execution cost of jobs, while keeping the total completion time within the deadline [15]. According to the findings of a simulation, the GSO based task scheduling (GSOTS) algorithm achieved better results than the shortest task first (STF), the largest task first (LTF), and the particle swarm optimization (PSO) algorithms in terms of lowering the total completion time and the cost of executing tasks. There are several other metaheuristics-based task scheduling algorithms in the cloud computing environment, including the cuckoo search algorithm (CSA) [16], electromagnetism optimization (EMO) algorithm [17], sea lion optimization (SLO) algorithm [18], adaptive symbiotic organisms search (ASOS) [19], hybrid whale optimization algorithm (HWOA) [20], artificial flora optimization algorithm (AFOA) [21], modified particle swarm optimization (MPSO) [22], and differential evolution (DE) [23,24,25,26,27,28,29,30].

As mentioned, the task scheduling problem is classified as a nondeterministic polynomial time (NP)-hard problem and cannot be solved using traditional methods due to their inability to find a near-optimal solution in a reasonable time. Although, metaheuristic algorithms could have a significant effect when tackling these problems, they still suffer from falling into local minima and from a low convergence speed. As a result, a new task scheduler, known as hybrid differential evolution (HDE), is presented in this study, as a solution to the task scheduling challenge in the cloud computing environment. This scheduler is based on two proposed improvements to differential evolution. The first improvement is based on expanding the scaling factor to include dynamically generated numerical values based on the current iteration, in order to improve both the exploration and exploitation operators; the second improvement is intended to improve the exploitation operator of the classical DE, in order to achieve better results in fewer iterations. To demonstrate the efficacy of HDE, multiple tests were performed using randomly generated datasets and the CloudSim simulator. HDE was compared to a number of heuristic and metaheuristic algorithms, to show that it is a strong alternative for overcoming the task scheduling problem in cloud computing. The main contributions of this study are as follows:

• Improving the scaling factor and the exploitation operator of the classical DE, to propose a new task scheduler known as hybrid differential evolution for the challenge of task scheduling in the cloud computing environment.
• Conducting several experiments using randomly generated datasets and the CloudSim simulator, to verify the efficiency of HDE.
• The experimental findings show that HDE was the most effective metaheuristic scheduling algorithm among the compared approaches.

The remaining sections of this work are structured as follows: Section 2 describes the classical differential evolution, Section 3 presents the objective function formulation, Section 4 details the steps of the proposed algorithm, Section 5 depicts the results of the experiments and performance comparison, and Section 6 presents the conclusions drawn from this study, as well as observations regarding future research.

2. Task Scheduling in the Cloud Computing Environment

Cloud computing is made up of a large number of datacenters that house numerous physical machines (host). Each host runs several virtual machines (VMs) that are in charge of executing user tasks with varying quality of services (QoS). Figure 1 depicts the task scheduling in a cloud computing environment [4]. Supposing that there are n cloudlets (Tasks), $T=T_1, T_2, T_3, \dots , T_n$, which are executed using m virtual machines (VMs), $VM=V{M}_1, V{M}_2, V{M}_3, \dots , V{M}_m$. These tasks have various lengths and the VMs are heterogonous in terms of bandwidth, RAM, and CPU time. The cloud broker makes a request to the cloud information service, to obtain details about the services needed to carry out the tasks it has been given, and then schedules the tasks on the services that have been found. The numerous variables and QoS criteria of the broker influence the choice of the tasks to be provided. The cloud broker is the key element of the task scheduling process, it mediates talks between the user and the provider and decides when to schedule tasks for certain resources. However, there are several issues that need to be considered. The tasks that users submit are first added to the top queue in the system and must wait while the resources are employed. As a result, the system’s queue grows longer, which lengthens the waiting period. However, a more effective approach than the first come first served (FCFS) principle should be used to manage this queue. Second, when the service provider manages the tasks, numerous parameters can be taken into account as multiobjective optimization or single objective optimization, such as the makespan, which directly affects resource consumption [4]. Therefore, a strong task scheduling algorithm should be created and implemented in the cloud broker, to not only meet the QoS requirements imposed by cloud users, but also to achieve good load balancing between the virtual machines, in order to improve resource utilization [4].

Figure 1. Task scheduling process in the cloud computing environment [4].

3. Differential Evolution

Storn [31] presented a population-based optimization method dubbed differential evolution (DE). DE is comparable to genetic algorithms, in terms of its mutation, crossover, and selection operators. Before commencing the process of optimization, the differential evolution generates a set of solutions, referred to as individuals, each of which has D dimensions and is randomly dispersed within the search space of the optimization problem. This takes place before the optimization procedure begins. After that, as will become clear in the following paragraphs, the mutation and crossover operators are applied, in order to search through the space available in an effort to locate more effective solutions.

3.1. Mutation Operator

This operator is applied to generate a mutant vector ${\overrightarrow{v}}_i^t$ for each solution in the population. There are several updating schemes that can be applied to generate the mutant vector, one of the most common schemes generates the mutant vector according to the following formula:

$${\overrightarrow{v}}_i^t=\overrightarrow{X_a}\left(t\right)+F\ast \left(\overrightarrow{X_k}\left(t\right)-\overrightarrow{X_j}\left(t\right)\right)$$

(1)

where $a$, k, and j stand for the indices of three individuals picked randomly from the population at the current iteration t. F is a positive scaling factor that involves a constant value greater than 0.

3.2. Crossover Operator

After generating the mutant vector ${\overrightarrow{v}}_i^t$ using the crossover operator under a crossover probability (CR), the trial vector ${\overrightarrow{u}}_i^t$ is generated using both the mutant vector and the solution of the $ith$ individual, according to the following equation:

$$u_{i, j}^t=\left\{\begin{array}{cc}{v}_{i, j}^t\hfill & if \left(r_1\le CR\Vert \right)\Vert \left(j=j_r\right)\hfill \\ X_{i, j}\left(t\right)\hfill & otherwise\hfill \end{array}\right.$$

(2)

where $j_r$ is a random integer generated between 1 and D, $j$ indicates the current dimension, and $CR$ is a constant value between 0 and 1, which specifies the percentage of dimensions copied from the mutant vector to the trial vector.

3.3. Selection Operator

Finally, this operator is presented to compare the vector ${\overrightarrow{u}}_i^t$ to vector $\overrightarrow{X_i}\left(t\right)$, with the fittest being used in the next iteration. Generally, the selection operator for a minimization problem is mathematically formulated as follows:

$$\overrightarrow{X_i}\left(t+1\right)=\left\{\begin{array}{cc}{\overrightarrow{u}}_i^t\hfill & \hfill if (f({\overrightarrow{u}}_i^t)<f(\overrightarrow{X_i}\left(t\right)))\\ \overrightarrow{X_i}(t)\hfill & \hfill otherwise\end{array}\right.$$

(3)

4. Objective Function Formulation

Supposing that there are n cloudlets (Tasks), $T=T_1, T_2, T_3, \dots , T_n$, which are executed using m virtual machines (VMs), $VM=V{M}_1, V{M}_2, V{M}_3, \dots , V{M}_m$. Then, the solutions obtained by a scheduler represent the assignment process of the tasks to the VMs in the order that will minimize the two objectives: makespan, and total execution time. Problems that have two or three objectives are classified as multiobjective. There are two methods, namely a priori or a posteriori, suggested to deal with multiobjective problems [32,33]. In the priori method, the multiobjective problems are treated as a single objective problem, by assigning a weight to each objective, based on the significance of each objective for the decision-makers. On the other hand, the posteriori method proposes that all objectives have the same significance, so it generates a set of solutions, namely non-dominated solutions, that trade off between different objectives. In this study, the priori approach was employed to convert the multiobjective problem into single objective using a weighting variable $\tau$ that includes a constant value generated between 0 and 1, to determine the importance of an objective, for example, the makespan, in the fitness function, and the complement of this variable ($1-\tau$) indicates the weight of the other objective. For instance, the objective function under this weighting variable is formulated as follows:

$$f=\left(1-\tau \right)\times \eta +\tau \times \beta$$

(4)

where $\beta$ represents the makespan objective, and $\eta$ stands for the total execution time. $\tau$ stands for the weighting variable, which is employed to convert this problem from multi-objective to single-objective, to become solvable using the met heuristic algorithms designed for single-objective problems, such as differential evolution. In the future, the posteriori approach will be applied to this problem, in an attempt to achieve better results for all objectives at the same time.

After describing the main components of the objective function, let us describe each one carefully. Starting with the makespan objective, at the beginning time, each $V{M}_{j }$ has a variable $E{t}_j$ assigned a value of 0, and then the tasks are distributed using a scheduler to those VMs. Each VM executes their assigned tasks and the execution time needed by each task to be executed under the $jth$ VM is added to the variable $E{t}_j$. Finally, after finishing the tasks assigned to all VMs, the values stored in the variable $Et$ for each VM are compared with each other, and the maximum value represents the makespan. Finally, the makespan, defined as the maximum of Et of all VMs, can be computed using the following expression:

$$\beta =\max (\overrightarrow{Et})$$

(5)

The second objective $\eta$ is the total execution time consumed to complete the tasks assigned to all the VMs and can be computed according to the following formula:

$$\eta ={\displaystyle \sum }_{j=1}^{m}E{t}_j$$

(6)

Finally, the proposed algorithm described in the next section is employed to minimize the objective function described in Equation (4), to find the near-optimal scheduling of tasks that minimizes both the makespan and total execution time, hence providing a better quality of service to the users.

5. The Proposed Algorithm

This section presents the main steps employed to adapt the differential evolution for tackling the task scheduling problem in cloud computing; these steps are listed as follows: initialization, evaluation, adaptive mutation factor, and additional exploitation operator.

5.1. Initialization

Before starting the optimization process with any metaheuristic algorithm, a number N of solutions with n dimensions (each dimension represents a task in the scheduling problem) for each solution are defined and randomly initialized between 0 and m, to assign each task to a virtual machine. For example, Figure 2 presents a simple example, to illustrate how to represent a solution for the task scheduling problem. In this figure, we create a solution with 10 tasks, where n is 10, and randomly assign a VM to each task in this solution, where the number of available VMs is up to 7. From this figure, it is obvious that the virtual machine with an index of 2 will execute tasks 2 and 9, and the VM with an index of 0 will be assigned to execute tasks 1 and 5, while the other tasks, in order, will be assigned to the VMs: 1, 4, 3, 5, 6, and 5, respectively. In brief, the mathematical formula of the initialization step is defined as follows:

$$\overrightarrow{X_i}=\overrightarrow{r}\ast m| i=0, 2, 3, 4, \dots , \left(N-1\right)$$

(7)

where $\overrightarrow{r}$ stands for a vector involving decimal numbers generated randomly between 0 and 1, and $\ast$ indicates the multiplication operator. Following that step, the evaluation stage commences, to evaluate the quality of each solution and determine the best so-far solution that can reach the lowest value for the objective function described in Equation (4).

Figure 2. A solution representation for task scheduling in cloud computing. This figure starts by numbering the cells with 0 and ends with an index of 9 for the last cell, such that the cell 0 indicates the first task, and the second cell indicates the second task, and so on.

5.2. Adaptive Scaling Factor (F)

The mutation stage in the differential evolution has a scaling factor, namely F, responsible for determining the step sizes. This factor in the classical DE algorithm includes a constant positive value, and this value is unchanged during the whole optimization process. Hence, if the population diversity is high and the value of this scaling factor is also high, the step size will take the solution a long distance from the current solution, this even occurs at the beginning of the optimization process, to encourage the algorithm to extensively explore the search space, to find the promising regions that might contain the best-so-far solution. Afterwards, the population diversity might be decreased when increasing the current iteration, while the scaling factor remains constant. However, what will happen if the population diversity remains high during the entire optimization process? Let us imagine together, if the population diversity remains high and the scaling factor is constant, then the generated step sizes are also high and, hence, the algorithm will always search for a better solution in regions far from the current solution, which might contain the near-optimal solution near to it. A similar problem occurs when the scaling factor is small and the population diversity is high. Therefore, in this study, we reformulated this factor to be dynamically updated according to the current iteration, to maximize the exploration operator of the classical DE algorithm at the beginning of the optimization process, and to search for the most promising region within the search space; and then, by increasing the current iteration, this exploration operator will be gradually converted into the exploitation operator, to focus more on this promising region, in order to achieve a better solution, in addition to accelerating the convergence. Based on this, the shortcomings of the classical DE with a constant scaling factor are largely avoided. Finally, the adaptive scaling factor is generated based on the current iteration, using the following formula:

$$F^{\prime }=\alpha \ast \left(\frac{T-t}{T}\right)$$

(8)

where T indicates the maximum iteration, and t stands for the current iteration. $\alpha$ is a predefined constant value.

5.3. Convergence Improvement Strategy

The mutation scheme described previously for generating the mutant vector in the classical DE is based on three solutions selected randomly from the current population. As a consequence of this, the exploration operator may be directed to explore the regions surrounding one of these solutions, despite the fact that the near-optimal solution may be in a region close to the best-so-far solution. Therefore, in this study, an additional strategy, namely a convergence improvement strategy (CIS), is proposed to exploit the regions around the best-so-far solution, to improve the convergence ability of the standard DE. This strategy in initially generates a vector, namely ${\overrightarrow{v}}_i^t,$ including numerical values generated around the best-so-far solution, using the following formula:

$${\overrightarrow{v}}_i^t=\overrightarrow{X^{*}}\left(t\right)+\overrightarrow{r}\ast \left(\overrightarrow{X_i}\left(t\right)-\overrightarrow{r_1}\ast \overrightarrow{X^{*}}\left(t\right)\right)$$

(9)

where $\overrightarrow{X^{*}}\left(t\right)$ indicates the best-so-far solution at the current iteration t, and $\overrightarrow{r}$ and $\overrightarrow{r_1}$ are two vectors including numerical values generated randomly between 0 and 1. Following this, another vector, namely a trial vector ${\overrightarrow{T}}_i^t$, will be generated based on conducting a crossover operation between $\overrightarrow{X^{*}}\left(t\right)$ and ${\overrightarrow{v}}_i^t$ under a crossover probability (P) predetermined according to experiments. Briefly, the trial vector will be generated according to the following formula:

$$T_{i, j}^t=\left\{\begin{array}{cc}{v}_{i, j}^t\hfill & if (r_2\le P)\hfill \\ X_j^{*}\left(t\right)\hfill & otherwise\hfill \end{array}\right.$$

(10)

where $r_2$ is a numerical value generated randomly between 0 and 1. Finally, the fitness value of the trial vector, ${\overrightarrow{T}}_i^t$, will be compared with that of the current solution $\overrightarrow{X_i}\left(t\right),$ and if the fitness of this trial vector is better, then it will be used in the next iteration; otherwise, the current solution is retained in the next generation, even when reaching a better one. However, applying this strategy to all individuals in the population might deteriorate the exploration operator of the classical DE, because it might reduce the population diversity. Therefore, this strategy has to be applied to a number of the solutions, to avoid this shortcoming; this number is estimated using the following formula:

$$N^{\prime }=N\ast \kappa$$

(11)

where $N$ is the number of individuals in the population, and $\kappa$ is the percentage of the individuals that will be extracted to be updated using the convergence improvement strategy. Finally, the steps of the CIS strategy are listed in Algorithm 1.

Algorithm 1. Convergence improvement strategy (CIS)

1. for $i=0$ to $N^{\prime }$ 2.  Generate the mutant vector ${\overrightarrow{v}}_i^t$ using Equation (9) 3.  for j = 0 to n 4.    ${\mathrm{r}}_2:$ a number generated randomly between 0 and 1 5.     $if (r_2<P$) 6.         $T_{i, j}^t=v_{i, j}^t$ 7.     else 8.         $T_{i, j}^t=X_j^{*}\left(t\right)$ 9.    End if 10.   end for 11.   $if$ $\left(f\left({\overrightarrow{T}}_i^t\right)<f\left({\overrightarrow{X}}_i^t\right)\right)$ 12.       ${\overrightarrow{X}}_i^t$=${\overrightarrow{T}}_i^t$ 13.   end $if$ 14.  Replace the best-so-far solution $\overrightarrow{X^{*}}\left(t\right)$ with ${\overrightarrow{T}}_i^t$ if ${\overrightarrow{T}}_i^t$ is better 15.  end for

5.4. Hybrid Differential Evolution

The classical DE is hybridized with the convergence improvement strategy and adaptive scaling factor, to produce a new variant dubbed hybrid differential evolution (HDE), having a better search ability, for a better solution when tackling the task scheduling in cloud computing. Another advantage of HDE is that it has the ability to accelerate the convergence speed in the direction of the near-optimal solution. The steps of HDE are described in Algorithm 2. This algorithm starts by initializing N solutions within the search space of the scheduling problem in cloud computing; the search space of this problem ranges between 0 and the number of virtual machines (m − 1). Then, the initialized solutions are evaluated, and the best-so-far solution $\overrightarrow{X^{*}}\left(t\right)$ that has the lowest fitness value is identified, to be employed for guiding some of the solutions within the optimization process towards a better solution. Line 3 within Algorithm 2 initializes the current iteration t with a value of 0. After this, the optimization process is triggered to update the initialized solutions to reach better solutions, whereby this process starts by defining the termination condition as shown in Line 4. Then, Lines 5–6 update the adaptive scaling factor, which is responsible for improving the exploration and exploitation capability of the proposed algorithm. Following this, updating of the solutions is implemented, to generate the trial vector based on both the current solution and the mutant vector. In the next step, this trial vector is compared with the current solution, to extract the one that will be preserved in the population for the next generation. This process is repeated until satisfying the termination condition. Finally, the flowchart of HDE is shown in Figure 3.

Algorithm 2. Hybrid differential evolution (HDE)

1. Initializes $N$ solutions, ${\overrightarrow{X}}_i, i=1, 2, \dots , N$, using Equation (7) 2. Evaluate the initialized solutions and identified $\overrightarrow{X^{*}}\left(t\right)$ 3. $t=0$ 4. while (t < $T$) 5.  Update $F^{\prime }$ using Equation (8) 6.   $F=F^{\prime }$ 7.  for $i=0$ to $N$ 8.    Generate the mutant vector ${\overrightarrow{v}}_i^t$ using Equation (1) 9.    ${\mathrm{j}}_{\mathrm{r}}=\mathrm{an} \mathrm{integer} \mathrm{generated} \mathrm{randomly} \mathrm{between} 1 \mathrm{and} \mathrm{n}$ 10.    for j = 0 to n 11.     ${\mathrm{r}}_2:$ a number generated randomly between 0 and 1 12.     $if (r_2<CR \Vert j=j_r$) 13.         $u_{i, j}^t=v_{i, j}^t$ 14.     else 15.         $u_{i, j}^t=X_{i,j}\left(t\right)$ 16.      End if 17.    end for 18.    $if$ $\left(f\left({\overrightarrow{u}}_i^t\right)<f\left({\overrightarrow{X}}_i^t\right)\right)$ 19.       ${\overrightarrow{X}}_i^t$=${\overrightarrow{u}}_i^t$ 20.    end $if$ 21.    Replace the best-so-far solution $\overrightarrow{X^{*}}\left(t\right)$ with ${\overrightarrow{T}}_i^t$ if ${\overrightarrow{T}}_i^t$ is better 22.  end for 23.  Updating $N^{\prime }$ solutions using the CIS algorithm (Algorithm 1) 24.   $t=t+1$ 25. end while Return $\overrightarrow{X^{*}}\left(t\right)$

Figure 3. The flowchart of the proposed algorithm: HDE (* is used to identify the best solution).

5.5. Time Complexity of HDE

In this part of the article, the time complexity is expressed using big-O notation, so that the superior speed of the suggested approach can be demostrated. To begin, the following are the primary factors that have the most significant impact on the acceleration of the proposed algorithm: the population size, N, the number of tasks, n, the maximum iteration, $T$, and the time complexity of Algorithm 1. Generally, the time complexity of HDE can be expressed as follows:

$$T\left(\mathrm{HDE}\right)=T\left(\mathrm{DE}\right)+T\left(\mathrm{CIS}\right)$$

(12)

The time complexity of the standard DE mostly depends solely on the first three factors: N, n, and T, as shown in Algorithm 2, which is formulated as follows:

$$T\left(\mathrm{DE}\right)=O\left(T\ast n\ast N\right)$$

(13)

The time complexity of the CIS also depends on the first three factors, with the exception of N, which is replaced by $N^{\prime }$. In general, the time complexity of CIS can be expressed as follows:

$$T\left(\mathrm{CIS}\right)=O\left(T\ast n\ast N^{\prime }\right)$$

(14)

By substitution, Equation (12) can be reformulated as follows:

$$T\left(\mathrm{HDE}\right)=O\left(T\ast n\ast N\right)+O\left(T\ast n\ast N^{\prime }\right)$$

(15)

From this equation, the term that has the highest growth rate is $O\left(T\ast n\ast N\right)$, because $N$ is always greater than $N^{\prime }$. Therefore, the time complexity of HDE in big-O is $O\left(T\ast n\ast N\right)$.

6. Results and Simulation

Several experiments were conducted in this study to show the efficiency of the proposed algorithm: HDE was compared to several heuristic and metaheuristic approaches; the metaheuristic algorithms were the sine cosine algorithm (SCA) [34], whale optimization algorithm (WOA) [35], slime mold algorithm (SMA) [36], equilibrium optimizer (EO) [37], grey wolf optimizer (GWO) [38], and classical DE [39]; the heuristic algorithms were first come first served (FCFS) [40], round robin (RR) algorithm [41], and shortest job first (SJF) scheduler [40]. These algorithms were executed in 30 independent runs on datasets generated randomly, with the number of tasks ranging between 100 and 3000; these tasks are labeled as T100 for the task size 100, T200 for the task size 200, and so on. Five VMs were selected for scheduling these task data sets, where the communication time and execution time for each task were randomly generated to determine the ability of each VM to implement each task, while taking into consideration that the workload of this task is different of the other tasks. The performance evaluation metrics used in this study to compare the algorithms were the best, average, worst, and standard deviation of the obtained outcomes within 30 independent repetitions, in addition to a Wilcoxon rank sum test, which was employed to identify whether there were any differences between the outcomes obtained by the proposed and those of the rival optimizers. All of the algorithms were built using the programming language Java on a personal computer, which had the following capabilities: Windows 10 operating system, Intel^® CoreTM i7-4700MQ processor running at 2.40 GHz, and 16 GB of memory installed.

The parameters of all the compared algorithms were set to the values found in the cited papers, to ensure a fair comparison. However, there were two main parameters that had to be the same for all the algorithms, and they were the population size (N), and the maximum number of iterations (T), which were set to 25 and 1500, respectively. Regarding the parameters of the classical DE and the proposed algorithm, HDE, several experiments were conducted to estimate the optimal value for each of their parameters. Broadly speaking, the classical DE has two main parameters: F and Cr, which were extracted according to several conducted experiments. From these experiments, it was observed that the best values for these parameters were 0.01 for Cr and 0.1 for the scaling factor (F). Regarding the parameter values of HDE, the Cr and $\alpha$ parameters were set to the same values as the Cr and F in the classical DE. However, HDE has two additional parameters: $P$ and $\kappa$, which were estimated by conducting experiments. These experiments showed that the best values for these parameters, $P$ and $\kappa ,$ were 0.01 and 0.2, respectively. Table 1 presents the parameter values of both HDE and DE.

Table 1. Parameter settings of HDE and DE.

	DE	HDE
T	1500	1500
N	25	25
F	0.1	0.1
Cr	0.01	0.01
$P$		0.01
$\kappa$		0.2

6.1. Comparison with Metaheuristic Algorithms

Due to the fact that meta-heuristic algorithms are stochastic optimization techniques, they require at least 10 separate runs to produce statistically significant results. In this study, each algorithm was run roughly thirty times independently, and the average results of each algorithm are reported. In Table A1 are shown the metrics of the best fitness values for each algorithm in the last iteration over all independent runs. These metrics include the mean, best, and worst values, as well as the standard deviation (SD). The top results in this table are highlighted in bold. This table demonstrates that HDE is comparable to DE and superior to all other algorithms for the 100-task size. With growing task sizes, HDE’s superiority becomes more apparent, and it may be the best option for any tasks with lengths more than 100. Additionally, to further show the efficiency of HDE, the average of the best, worst, and mean fitness values obtained for all the tasks sizes were computed and are presented in Figure 4, which affirms that HDE was the best for all shown metrics. Figure 5 shows the average (Avg) standard deviation (SD) obtained by each algorithm on all tasks sizes. Inspecting this figure shows that HDE was more stable than the other algorithms. After discussing the effectiveness of HDE in terms of the fitness value, we will move on to discuss its capacity to reduce the makespan in the next paragraph.

Figure 4. Comparison among algorithms by fitness value.

Figure 5. Comparison in terms of average SD of the fitness values.

The metrics that represent the best makespan values for each method in the last iteration across all independent runs are presented in Table A2. The best, worst, and average values, as well as the standard deviation, are the metrics that were included in this study. The best outcomes are displayed in bold within this table. This table illustrates that HDE was superior to all other algorithms for the 100-task size and was on par with DE in terms of its performance. The superiority of HDE became more evident with increasing task sizes, and it is possible that it is the best choice for all tasks with lengths greater than 100. In addition, in order to demonstrate the effectiveness of HDE in a more comprehensive manner, the mean, best, and worst makespan values that were obtained for each of the different task sizes were computed and are shown in Figure 6. This figure demonstrates that HDE was the optimal method for each of the metrics that are presented. Figure 7 displays the average of the standard deviation (SD) values that were obtained by each algorithm for all task sizes. Taking a closer look at this figure reveals that HDE was far more reliable than the other algorithms. Now we have finished talking about how effective HDE was in terms of the fitness value and makespan, in the following paragraph, we will move on to talking about how it had the ability to reduce the total execution time required by all VMs, until finishing the tasks that had been given to them.

Figure 6. Comparison among algorithms by makespan.

Figure 7. Comparison with metaheuristics in terms of the average SD of makespan.

The average, worst, best, and SD values obtained as a result of analyzing the total execution time values obtained by the various investigated metaheuristic algorithms within 30 independent runs are reported in Table A3. Based on the results in this table, it is clear that HDE performed just as well as DE and was superior to all the other algorithms when it comes to a size of 100 tasks. It is probable that HDE is the optimal option for all tasks with lengths that are larger than 100. The superiority of HDE became more readily apparent as the size of the tasks was increased. The average of the mean, best, and worst total execution values that were obtained for each of the various task sizes was computed and are given in Figure 8, in order to showcase the efficacy of HDE in a more thorough manner. This was done in order to prove that HDE was effective. This figure illustrates that HDE was the best strategy for each of the metrics that are presented. Figure 9 depicts the average of the standard deviation (SD) values that were obtained using each method for all of the various task sizes. When taking a closer look at this figure, it can be noticed that HDE was significantly more trustworthy than any of the other algorithms. Finally, from all the previous experiments and discussions, it is concluded that HDE is a strong alternative scheduler to find the near-optimal scheduling of tasks in cloud computing, with the aim of minimizing both the makespan and the total execution time.

Figure 8. Comparison among algorithms for the total execution time.

Figure 9. Comparison in terms of the average SD of total execution time.

Table A4 compares the proposed HDE algorithm to the other types using a Wilcoxon rank-sum test with 5% as the level of confidence [42]. The null hypothesis and the alternative hypothesis were both tested in this experiment. The null hypothesis suggests that there is no difference between the two methods being compared; this hypothesis is true when the p-value shown in Table A4 is greater than the confidence level. In contrast, the alternative hypothesis asserts that there is a difference between the results obtained using a pair of algorithms; this hypothesis is supported when p-value is less than the confidence level. Table A4 displays the results of comparing HDE to the other algorithms evaluated in this test. According to this table, the alternative hypothesis holds true in all instances, highlighting the difference between the outcomes of the proposed algorithm and those of other algorithms.

The boxplot represented in Figure 10 is discussed in this paragraph. The boxplot shows a five-number summary, including the lowest, maximum, median, and the first and third quartiles for the fitness values achieved by each algorithm during 30 independent runs. Examining this figure demonstrates that HDE was superior in terms of all five-number summaries for all of the investigated task lengths.

Figure 10. Comparison among algorithms in terms of the Boxplot: (a) Comparison for the task size of 200; (b) Comparison for the task size of 300; (c) Comparison for the task size of 400; (d) Comparison for the task size of 500; (e) Comparison for the task size of 600; (f) Comparison for the task size of 700.

Finally, HDE and the other algorithms were compared based on their respective convergence rates for the fitness function. On the basis of the convergence rates obtained by each algorithm, and presented in Figure 11, for task lengths 100, 200, 300, 400, 500, 600, 700, 800, and 900, HDE achieved superior convergence to the optimal solution for all depicted task lengths. Figure 12 shows a comparison among the algorithms in terms of CPU time. The figure provides the total CPU time in seconds for running each algorithm with different task sizes. HDE had a slightly higher computational cost than traditional DE, but it can provide a better QoS to users, because it can achieve a smaller makepan value for the majority of task sizes.

Figure 11. Comparison of algorithms in terms of convergence speed: (a) Comparison for the task size of 100; (b) Comparison for the task size of 200; (c) Comparison for the task size of 300; (d) Comparison for the task size of 400; (e) Comparison for the task size of 500; (f) Comparison for the task size of 600; (g) Comparison for the task size of 700; (h) Comparison for the task size of 800; (i) Comparison for the task size of 900.

Figure 12. Comparison of algorithms in terms of CPU time.

6.2. Comparison with Some Heuristic Algorithms

In this section, the proposed algorithm is compared with some well-known heuristic schedulers, such as FCFS, SJF, and round robin, to further verify the superiority of HDE in tackling the task scheduling problem in cloud computing. The results of each method were independently tested around thirty times. In Table A5, the average, worst, and best values are shown, as well as the standard deviations, that were achieved by the proposed approach and by each heuristic algorithm for each task size. The results of this table show that HDE performed significantly better than any of the heuristic algorithms. In addition, in order to demonstrate the effectiveness of HDE in a more comprehensive manner, the average of the best, worst, and mean makespan values obtained for all task sizes were computed and are shown in Figure 13. This figure confirms that HDE was the most effective method for all of the metrics presented. Figure 14 depicts the average (Avg) and standard deviation (SD) of the makespan values obtained by each algorithm across all task sizes. Taking a closer look at this figure reveals that HDE was significantly more reliable than the other algorithms. It is worth mentioning that the heuristic algorithms have a negligible computation cost compared to metaheuristic algorithms, but their solutions are poor when compared to the metaheuristics algorithms. As a result, to provide a better quality of service to the users, while excluding the computational cost, the proposed algorithm is the most effective. On the other hand, if the computational cost is more important than the quality of service, then the heuristic algorithms, specifically FCFS, are the best.

Figure 13. Comparison among algorithms for makespan.

Figure 14. Comparison with heuristic algorithms in terms of the average SD of makespan.

6.3. Simulation Results

The CloudSim platform was utilized in order to carry out simulations of the task scheduling process. Researchers from all over the world make use of the CloudSim platform because it is a full-fledged simulation toolset that enables modelling and simulation of real-world cloud infrastructure and application provisioning [12]. In this paper, CloudSim was provided with the parameters settings described in Table 2. In addition, the number of tasks ranged between 100 and 1000, with a step 100, to check the scalability of the proposed algorithm in comparison to the other metaheuristic algorithms. After conducting the simulation process, the makespan values obtained under various metaheuristic algorithms implemented within the Cloudsim platform are presented in Table 3 for each task size. Inspecting this table shows the effectiveness of HDE in comparison to the other algorithms, since it had the lowest makespan values for all the task sizes. This is confirmed by the last row in the same table which contains the average of each column within the table; this row reveals that HDE could achieve average makespan values up to 151,479.2179, which is the smallest in comparison to the others in the same row.

Table 2. Parameters of the CloudSim platform.

Parameters	Value	Parameters	Value	Parameters	Value
Cloudlets		Virtual Machines		Hosts
Length of task	10,000–50,000	Number of VMs	5	No of Hosts	2
Number of tasks	100–1000	MIPs	250	RAM	2048
Filesize	300	RAM	512	Bandwidth	10,000
Outputsize	300	Bandwidth	1000	Policy type	Time Shared
Data Center		Policy type	Time Shared	Storage	1,000,000
No of DataCenter	5	VMM	Xen
		Operating system	Linux
		No of CPUs	1

Table 3. Comparison among algorithms in terms of the makespan values for the Cloudsim-based simulation.

TS	EO	SCA	GWO	WOA	SMA	DE	HDE
T100	41,505.943	49,620.716	55,322.872	49,135.560	51,289.568	28,106.492	28,190.252
T200	104,498.731	102,703.632	98,004.431	96,811.803	100,997.74	54,684.484	53,803.068
T300	152,025.60	150,194.280	145,015.012	142,787.62	150,218.468	89,242.483	80,850.832
T400	200,391.084	202,607.707	191,254.443	192,639.200	195,546.292	124,179.684	108,165.464
T500	257,677.947	247,760.576	240,555.543	234,875.059	245,394.340	156,930.84	133,873.052
T600	295,715.628	310,647.336	294,597.264	286,597.052	296,876.432	199,452.735	164,761.723
T700	352,201.252	334,329.304	342,978.004	317,822.051	328,948.300	236,092.719	190,732.984
T800	389,077.392	376,469.660	398,101.811	384,081.343	378,277.532	277,318.875	219,123.340
T900	467,415.788	417,388.984	421,371.248	434,179.028	428,612.683	322,661.800	252,311.644
T1000	487,985.68	473,096.840	477,129.911	491,821.971	474,688.392	358,680.556	282,979.820
Avg:	274,849.5045	266,481.9035	266,433.0539	263,075.0687	265,084.9747	184,735.0668	151,479.2179

The bold values indicate the best values.

7. Conclusions and Future Work

This paper presents a new scheduler, namely hybrid differential evolution (HDE), for the task scheduling problem in the cloud computing environment. This scheduler is based on two proposed improvements to the classical differential evolution. The first improvement is based on improving the scaling factor, to involve numerical values generated dynamically based on the current iteration, to improve both the exploration and exploitation operators; meanwhile the second improvement is designed to further improve the exploitation operator of the classical DE, to achieve better outcomes in a smaller number of iterations. Several experiments were performed using randomly generated datasets and the CloudSim simulator, to verify the efficiency of HDE. In addition, HDE was compared with several heuristic and metaheuristic algorithms, such as the slime mold algorithm (SMA), equilibrium optimizer (EO), sine cosine algorithm (SCA), whale optimization algorithm (WOA), grey wolf optimizer (GWO), classical DE, first come first served (FCFS), round robin (RR) algorithm, and shortest job first (SJF) scheduler. Makespan and total execution time values were obtained for various task sizes, ranging between 100 and 3000, during the experiments. The findings of the experiments indicated that HDE produced effective results when compared to the other metaheuristic and heuristic algorithms that were investigated. As a result, HDE was the most effective metaheuristic scheduling algorithm among the many approaches that were investigated. In future work, HDE will be employed to tackle several other optimization problems, such as the DNA fragment assembly problem, image segmentation problem, 0-1 knapsack problem, and task scheduling problem in fog computing.