{'fraction_non_alphanumeric': 0.03692878020959578, 'fraction_numerical': 0.010123333570970271, 'mean_word_length': 4.796694214876033, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
An Efficient Algorithm for Workflow Scheduling in the Clouds Based on Differential Evolution Method

The Cloud is a computing platform that provides on-demand access to a shared pool of configurable resources such as networks, servers, storage that can be rapidly provisioned and released with minimal management effort from clients. At its core, Cloud computing focuses on manimizing the effectiveness of the shared resources. Therefore, workflow scheduling is one of the challenges that the Cloud must tackle especially if a large number of tasks are executed on geographically distributed servers. The Cloud is comprised of computational and storage servers that aim to provision efficient access to remote and geographically distributed resources. To that end, many challenges, specifically workflow scheduling, are yet to be solved such. Despite it has been the focus of many researchers, a handful efficient solutions have been proposed for Cloud computing. In this work, we propose a novel algorithm for workflow scheduling that is derived from the Opposition-based Differential Evolution method, MODE. This algorithm not only ensures fast convergence but also averts getting trapped in local extrema. Our simulation experiments Cloud Sim show that MODE is superior to its predecessors. Moreover, the deviation of its solution from the optimal one is negligible.


Introduction
The Cloud is a computing platform that provides convenient, on-demand access to a shared pool of configurable computing resources such as networks, servers, storage that can be rapidly provisioned and released with minimal management effort on clients. At its core, Cloud computing focuses on maximizing the effectiveness of the shared resources. Therefore, workflow scheduling is one of the challenges that the Cloud must tackle especially if a large number of tasks are executed on geographically distributed servers. This requires a reasonable scheduling algorithm in order to minimize a task completion time (makespan).
Our work described in this paper is a new attempt to introduce a more efficient scheduling algorithm. Specifically, we introduce a Modified version of the Opposition-based Differential Evolution (ODE) method [19], which we call MODE. Via experiments, we demonstrate its effectiveness and performance in comparison with other algorithms.
The rest of the paper is organized as follows. Section II reviews some of the related works germane to workflow scheduling algorithms. Section III describes the Oppositionbased Differential Evolution (ODE) method. Section IV describes the computation and communication model on which Cloud tasks operate. Based on this model, Section V presents our proposed scheduling algorithm MODE (Modified ODE). Section VI describes the experiments we conducted using the simulation tool CloudSim [1] in order to evaluate the proposed algorithm. Section VII concludes our paper and sketches future work.

Related Work
A workflow is a sequence of connected tasks. Workflow scheduling in Clouds is a challenge because each task needs to be mapped to an appropriate server while allowing that task to satisfy some performance constraints. In general, the scheduling problem, i.e. the mapping of tasks to the computation resources such as servers, is an NP-complete problem [4]. Hence, past works mainly banked on heuristic-based or metaheuristic-based solutions for scheduling workflows.
Some researchers [13] proposed an algorithm for task scheduling based on two-level load balancing in the cloud environment. This algorithm not only meets user's requirements but also provides high resource utilization. The authors also introduced the implementation of an efficient Quality of Service (QoS) based Meta-heuristic method.
Others [15] presented an optimized algorithm for task scheduling based on Hybrid Genetic Algorithms. They considered the QoS requirements like completion time, bandwidth, cost, distance, reliability of different type tasks. They used annealing in their implementation after the selection, crossover and mutation, to improve local search ability of genetic algorithm.
In [16], the authors presented a model for task scheduling in cloud computing to minimize the overall time of execution and transmission. They proposed a particle swarm optimization algorithm to solve task scheduling that is based on small position value rule (SPVPSO). The researchers compared the SPVPSO algorithm with the CR-PSO and L-PSO and found that the SPVPSO algorithm had attained the optimal solution and converged faster in large tasks than the other two algorithms.
Another work [17] proposed a hierarchical scheduling algorithm which satisfied the Service Level Agreement with quick response from the service provider. The authors used the response time as a Quality of Service (QoS) metric to prioritize the execution of jobs by estimating their completion times.
Another paper [18] presented an optimized algorithm for task scheduling in cloud computing based on Activity-Based Costing (ABC). This algorithm assigns a priority level for each task and uses cost drivers. The priority is estimated based on four major factors: time, space, resources and profit.
Pandey [9] presented a scheduling algorithm (PSO_H) to minimize the cost of the execution. However, instead of finding the schedule which has a minimum cost, PSO_H looked for the schedule that minimizes the execution cost at the nearest server. The author compared the PSO_H algorithm with the Random and Round Robin algorithm and showed that the optimal solution of PSO_H algorithm is better than two matching algorithms.

Opposition-Based Differential Evolution (ODE)
Opposition-based Differential Evolution (ODE) [19] is an evolutionary optimization technique that consists of two main steps: population initialization and producing new generations by genetic operations such as selection, crossover and mutation. ODE enhances these two steps by considering the opposite point of individuals in the population.

Opposition-Based Learning
The concept of Opposition-Based Learning (OBL) was original introduced by Tizhoosh [20]. The main idea behind OBL is the simultaneous consideration of an estimate and its corresponding opposite estimate in order to achieve a better approximation for the current candidate solution.
Definition 1 (Opposite Number): Let x ∈ [a, b] be a real number, then the opposite number ̅ is defined as Definition 2 (Opposite Point in n-Dimensional Space): Similarly, the above definition can be extended for higher dimensions as follows: The opposition-based optimization can be defined as follows: Let P=(x 1 , x 2 ,..,x D ) be a point in D-dimensional space, and f(.) is the fitness function which is used to measure the candidate's fitness. According to the definition of opposite point, = ( ̅ , ̅ , … , ̅ ) is the opposite of P=(x 1 , x 2 ,..,x D ). Now if ( ) ≤ ( ), then point P can be replaced by , otherwise we continue with P.

Opposition-Based Population Initialization
Using the definition of opposite points, the oppositionbased initialization for the ODE can be described as follows: Procedure: Opposition-Based Population Initialization 1. Random initialization of population P(x 1 , x 2 ,…,x PopSize ) 2. Calculate opposite population by equal (2) 3. OP ← Opposite (P) 4. Selecting the PopSize fittest individuals from {P ∪ OP} as initial population.

Opposition-Based Differential Evolution Algorithm
By combining the Opposition-Based Learning method and the Differential Evolution algorithm, the ODE algorithm can be described as follows:

Problem Formulation
We denote the workflow as a Directed Acyclic Graph (DAG) represented by G=(V, E), where: 1. V is set of vertex, each vertex represents a task 2. T={T 1 , T 2 ,…,T M } is the set of tasks, M is the number of tasks 3. E represents the data dependencies between these tasks.
The edge (T i , T j ) ∈ E means the task T i is the father of the task T j , the data produced by T i will be consumed by the task T j . Formally, we need to minimize the execution time, called makespan, of the workflow: makespan → min where makespan is the time difference between the start and finish of a sequence of workflow's tasks.

Particle Representation
In the proposed scheduling algorithm, the solution is represented as a vector of length equal to the number of tasks. The value corresponding to each position i in the vector represents the server to which task i was executed.
Example 1 Consider a workflow with a set of tasks T={T 1 , T 2 , T 3 , T 4 , T 5 }, a set of servers S = {S 1 , S 2 , S 3 }. So the particle x i k = [1; 2; 1; 3; 2] gives us the following scheduling plan: In that scheduling plan, tasks T1 and T3 will be executed by the server S1, tasks T2 and T5 are assigned to the server S2 and task T4 is handled by server S3.

Rank-Based Roulette Wheel Selection
Rank-based roulette wheel selection is the selection strategy where the probability of a particle being selected is based on its fitness rank relative to the entire population. Rank-based selection schemes first sort individuals in the population according to their fitness and then computes the selection probabilities according to their ranks rather than the fitness values. Rank-based selection uses a function to map the indices of individuals in the sorted list to their selection probabilities. The rank for an individual may be scaled linearly using the following formula: The algorithm to selected individuals from population by Rank-based Roulette Wheel Selection can be described as follows:  (7) 9. rand ← Random(0,SP) 10. s← PopSize 11. while(rank[s] < rand && s>0)s= s-1 12. return x s End.

The MODE Algorithm
The MODE algorithm can be described as follows:  In the Initialization step, we randomly generate a population of PopSize individuals, and calculate the opposite of individuals in the population using equation (5) and (6), then select the Popsize fittest individuals from current population and their counterpart opposites.
In each iteration, MODE selects two individuals from population according to the Rank-based Roulette Wheel Selection method. According to the mutation operator, a mutant vector is generated by adding the weighted difference between two selected vector of the target population individuals to a third one as follows : where p1, p2 are two individuals selected by rank-based roulette wheel selection method, and pbest is the best individual in the population.
After the mutation phase, the crossover operator is applied to obtain the trail vector u i using the following equation : Where rand i,j is the j th independent random number uniformly distributed in the range of [0, 1]. Also I rand is a random number in the range of [1, M]. CR is a user defined crossover factor in the range [0, 1]. Now, we need to decide whether the trail vector u i should be a member of the population of the next generation, it is compared with the target individual x i . Finally, the selection is based on the survival of the fitness as follows : After the crossover phase, we calculate the opposite of individuals in the population by equation (5) and (6). The fitness of individuals is evaluated, then the PopSize fittest individuals are selected for the next generation.

Evaluation
We conducted some experiments in order to compare the performance of the MODE against the PSO_H [9] and Random [12]. Our experimental setup consists of a computer with Intel Core i5 2.2 GHz, RAM 4GB, and Windows 7 Ultimate. The experiments were carried out using the simulation tool CloudSim [14] and the packet library Jswarm [1] and Java.

Data
We use both random and real world instances in our experiments using the following data sets: The computation power of the servers and the bandwidth of connections between servers are collected from a Cloud provider such as Amazon [2] and its Web site (exp. http://aws.amazon.com/ec2/pricing) The sets of working data are collected from Montage project [3]. The instances are divided into 6 groups based on the number of servers N and the number of tasks M: Group 1: M=10, N=3; Group 2: M=10, N=5; Group 3: M=20, N=5; Group 4: M=20, N=8; Group 5: M=25, N=8; Group 6: M=50, N=8; We denote the ratio of the number of edges and the number of vertexes of graph G by:

Results
Each problem instance was executed 30 times continuously. The results summarized in Table 1 show that the mean value (column Mean) and standard deviation value (column STD) of MODE are better than those of PSO_H [9] and Random [12] in most of the cases. When the number of servers (N) and the number of tasks (M) are relatively large (i.e. larger scale cloud), for example M=20 and N=8; M=25, N=8; M=50, N=8, MODE is better than PSO_H and Random with respect to all metrics: mean, standard deviation and best value (column Best). Figures 1-6 depict the performance of the three algorithms: proposed algorithm MODE, PSO_H [9], and Random [12] where the vertical axis represents the makespan (seconds) of the schedule. For each instance, we compare the best position vector (column BEST), the mean value (column MEAN) and standard deviation value (column STD). At the first instance, MODE even found the optimal solution.

Conclusion
The ultimate goal of any scheduling algorithm is to minimize the execution time. Far from that goal, our proposed algorithm also avoid being trapped on local extrema. The contributions of our paper are: 1. Building a novel approach, represented by the formula to calculate the opposite of individuals in the population. 2. Proposing a new scheduling algorithm named MODE by incorporating the ODE (Opposition-Based Differential Evolution) strategy and Rank-based Roulette Wheel Selection method. The experimental results show that MODE is superior to its predecessor especially when MODE works in a larger scale Cloud, i.e. the number of servers and tasks are fairly large. In the future, we are planning to improve the MODE algorithm in order to solve bigger instances in a reasonable makespan.