See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/226382382

Workflow Scheduling Algorithms for Grid Computing

Chapter · September 2008

DOI: 10.1007/978-3-540-69277-5_7

CITATIONS READS
282 180

3 authors:

Jia Yu Rajkumar Buyya

16 PUBLICATIONS   2,490 CITATIONS   
University of Melbourne
825 PUBLICATIONS   52,039 CITATIONS   
SEE PROFILE
SEE PROFILE

Kotagiri Ramamohanarao
University of Melbourne
478 PUBLICATIONS   8,044 CITATIONS   

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Data-intensive application resource provisionig in clouds View project

Virtual Physiological Kidney View project

All content following this page was uploaded by Kotagiri Ramamohanarao on 25 September 2018.

The user has requested enhancement of the downloaded file.

7
Workflow Scheduling Algorithms for Grid
Computing

Jia Yu, Rajkumar Buyya, and Kotagiri Ramamohanarao

Grid Computing and Distributed Systems (GRIDS) Laboratory

Department of Computer Science and Software Engineering
The University of Melbourne, VIC 3010 Austraila
{jiayu,raj,rao}@csse.unimelb.edu.au

Summary. Workflow scheduling is one of the key issues in the management of work-
flow execution. Scheduling is a process that maps and manages execution of inter-
dependent tasks on distributed resources. It introduces allocating suitable resources to
workflow tasks so that the execution can be completed to satisfy objective functions
specified by users. Proper scheduling can have significant impact on the performance
of the system. In this chapter, we investigate existing workflow scheduling algorithms
developed and deployed by various Grid projects.

Keywords: Workflow scheduling, Inter-dependent tasks, Distributed resources,

Heuristics.

7.1 Introduction
Grids [22] have emerged as a global cyber-infrastructure for the next-generation
of e-Science and e-business applications, by integrating large-scale, distributed
and heterogeneous resources. A number of Grid middleware and management
tools such as Globus [21], UNICORE [1], Legion [27] and Gridbus [13] have been
developed, in order to provide infrastructure that enables users to access remote
resources transparently over a secure, shared scalable world-wide network. More
recently, Grid computing has progressed towards a service-oriented paradigm
[7,24] which defines a new way of service provisioning based on utility computing
models. Within utility Grids, each resource is represented as a service to which
consumers can negotiate their usage and Quality of Service.
Scientific communities in areas such as high-energy physics, gravitational-
wave physics, geophysics, astronomy and bioinformatics, are utilizing Grids to
share, manage and process large data sets. In order to support complex sci-
entific experiments, distributed resources such as computational devices, data,
applications, and scientific instruments need to be orchestrated while managing
the application workflow operations within Grid environments [36]. Workflow
is concerned with the automation of procedures, whereby files and other data
are passed between participants according to a defined set of rules in order to
achieve an overall goal [30]. A workflow management system defines, manages
and executes workflows on computing resources.

F. Xhafa, A. Abraham (Eds.): Meta. for Sched. in Distri. Comp. Envi., SCI 146, pp. 173–214, 2008.
springerlink.com 
c Springer-Verlag Berlin Heidelberg 2008
174 J. Yu, R. Buyya, and K. Ramamohanarao

Grid Users
……
Workflow Grid Workflow Modeling
Workflow Design Monitor & Definition Tools
& Definition
Grid Information Services
Build Time Grid Workflow
feedback Specification Resource Info Service
Run Time (e.g. MDS)

Grid Workflow Enactment Engine

Application Info
Workflow Scheduling Service (e.g. VDS)
Interaction with
Data Fault Information services
Movement Management
Workflow Execution
& Control

Grid Middleware

Interaction with Grid Grid Resources

resources

Fig. 7.1. Grid Workflow Management System

Fig. 7.1 shows an architecture of workflow management systems for Grid com-
puting. In general, a workflow specification is created by a user using workflow
modeling tools, or generated automatically with the aid of Grid information ser-
vices such as MDS(Monitoring and Discovery Services) [20] and VDS (Virtual
Data System) [23] prior to the run time. A workflow specification defines work-
flow activities (tasks) and their control and data dependencies. At run time, a
workflow enactment engine manages the execution of the workflow by utilizing
Grid middleware. There are three major components in a workflow enactment
engine: the workflow scheduling, data movement and fault management. Work-
flow scheduling discovers resources and allocates tasks on suitable resources to
meet users’ requirements, while data movement manages data transfer between
selected resources and fault management provides mechanisms for failure han-
dling during execution. In addition, the enactment engine provides feedback to
a monitor so that users can view the workflow process status through a Grid
workflow monitor. Workflow scheduling is one of the key issues in the workflow
management [59].
A scheduling is a process that maps and manages the execution of inter-
dependent tasks on the distributed resources. It allocates suitable resources to
workflow tasks so that the execution can be completed to satisfy objective func-
tions imposed by users. Proper scheduling can have significant impact on the per-
formance of the system. In general, the problem of mapping tasks on distributed
services belongs to a class of problems known as NP-hard problems [53]. For such
problems, no known algorithms are able to generate the optimal solution within
polynomial time. Solutions based on exhaustive search are impractical as the
overhead of generating schedules is very high. In Grid environments, scheduling
decisions must be made in the shortest time possible, because there are many
 7 Workflow Scheduling Algorithms for Grid Computing 175

users competing for resources, and time slots desired by one user could be taken
up by another user at any moment.
Many heuristics and meta-heuristics based algorithms have been proposed
to schedule workflow applications in heterogeneous distributed system environ-
ments. In this chapter, we discuss several existing workflow scheduling algorithms
developed and deployed in various Grid environments.

7.2 Workflow Scheduling Algorithms for Grid Computing

Many heuristics [33] have been developed to schedule inter-dependent tasks in
homogenous and dedicated cluster environments. However, there are new chal-
lenges for scheduling workflow applications in a Grid environment, such as:
• Resources are shared on Grids and many users compete for resources.
• Resources are not under the control of the scheduler.
• Resources are heterogeneous and may not all perform identically for any
given task.
• Many workflow applications are data-intensive and large data sets are re-
quired to be transferred between multiple sites.
Therefore, Grid workflow scheduling is required to consider non-dedicated and
heterogeneous execution environments. It also needs to address the issue of large
data transmission across various data communication links.
The input of workflow scheduling algorithms is normally an abstract workflow
model which defines workflow tasks without specifying the physical location
of resources on which the tasks are executed. There are two types of abstract
workflow model, deterministic and non-deterministic. In a deterministic model,
the dependencies of tasks and I/O data are known in advance, whereas in a
non-deterministic model, they are only known at run time.
The workflow scheduling algorithms presented in the following sections are
based on the deterministic type of the abstract workflow model and are rep-
resented as a Directed Acyclic Graph (DAG). Let Γ be the finite set of tasks
Ti (1 ≤ i ≤ n). Let Λ be the set of directed edges. Each edge is denoted by (Ti , Tj ),
corresponding to the data communication between task Ti and Tj , where Ti is
called an immediate parent task of Tj , and Tj the immediate child task of Ti .
We assume that a child task cannot be executed until all of its parent tasks are
completed. Then, the workflow application can be described as a tuple Ω(Γ, Λ).
In a workflow graph, a task which does not have any parent task is called an
entry task, denoted as Tentry and a task which does not have any child task is
called an exit task, denoted as Texit . If a workflow scheduling algorithm requires
a single entry task or a single exit task, and a given workflow contains more than
one entry task or exit task in the workflow graph, we can produce a new workflow
by connecting entry points to a zero-cost pseudo entry and exiting nodes to an
exit task, without without affecting the schedule [45].
To date, there are two major types of workflow scheduling (see Fig. 7.2), best-
effort based and QoS constraint based scheduling. The best-effort based schedul-
ing attempts to minimize the execution time ignoring other factors such as the
176 J. Yu, R. Buyya, and K. Ramamohanarao

Immediate mode
Batch mode
List scheduling Dependency mode
Heuristics
based Dependency-batch
mode
Cluster based scheduling
Best-effort based
scheduling Duplication based scheduling

Greedy randomized adaptive

search procedure
Metaheuristics Simulated annealing
Grid Workflow
based
Scheduling
Genetic algorithms

Heuristics based
Deadline-
constrained Metaheuristics based
QoS-constraint
based scheduling Heuristics based
Budget-
constrained Metaheuristics based

Others

Fig. 7.2. A taxonomy of Grid workflow scheduling algorithms

monetary cost of accessing resources and various users’ QoS satisfaction levels.
On the other hand, QoS constraint based scheduling attempts to minimize per-
formance under most important QoS constraints, for example time minimization
under budget constraints or cost minimization under deadline constraints.

7.3 Best-Effort Based Workflow Scheduling

Best-effort based workflow scheduling algorithms are targeted towards Grids
in which resources are shared by different organizations, based on a community
model (known as community Grid). In the community model based resource allo-
cation, monetary cost is not considered during resource access. Best-effort based
workflow scheduling algorithms attempt to complete execution at the earliest
time, or to minimize the makespan of the workflow application. The makespan
of an application is the time taken from the start of the application, up until all
outputs are available to the user [14].
In general, best-effort based scheduling algorithms are derived from either
heuristics based or meta-heuristics based approach. The heuristic based approach
is to develop a scheduling algorithm which fit only a particular type of problem,
while the meta-heuristic based approach is to develop an algorithm based on a
meta-heuristic method which provides a general solution method for developing
a specific heuristic to fit a particular kind of problem [29].Table 7.1 7.2 show the
overview of best-effort based scheduling algorithms.
 7 Workflow Scheduling Algorithms for Grid Computing 177

Table 7.1. Overview of Best-effort Workflow Scheduling Algorithms (Heuristics)

Scheduling Method Algorithm Project Organization Application

Individual task scheduling Myopic CondorUniversity of N/A

DAG Man
Wisconsin-
Madison, USA.
Batch mode vGrADS Rice Univer- EMAN bio-
Min-Min sity, USA. imaging
Pegasus University Montage as-
of Southern tronomy
California,
List scheduling

USA.
Max-min vGrADS Rice Univer- EMAN bio-
sity, USA. imaging
Sufferage vGrADS Rice Univer- EMAN bio-
sity, USA. imaging
Dependency mode HEFT ASKALON University of WIEN2K
Innsbruck, quantum
Austria. chemistry
& Invmod
hydrological
Dependency-batch mode Hybrid Sakellarious University of Randomly
& Zhao Manchester, generated
UK. task graphs
University of Randomly
Cluster based scheduling Ranaweera &
THAN Cincinnati, generated
Duplication based scheduling Agrawal
USA task graphs

Table 7.2. Overview of Best-effort Workflow Scheduling Algorithms (Meta-heuristics)

Scheduling Method Project Organization Application

Greedy randomized adaptive Pegasus University of Montage astron-

search procedure (GRASP) Southern Califor- omy
nia, USA.
Genetic algorithms (GA) ASKALON University of Inns- WIEN2K quantum
bruck, Austria. chemistry
Simulated annealing (SA) ICENI London e-Science Randomly gener-
Centre, UK. ated task graphs

7.3.1 Heuristics
In general, there are four classes of scheduling heuristics for workflow applica-
tions, namely individual task scheduling, list scheduling, and cluster and dupli-
cation based scheduling.
178 J. Yu, R. Buyya, and K. Ramamohanarao

Individual task scheduling

The individual task scheduling is the simplest scheduling method for scheduling
workflow applications and it makes schedule decision based only on one individual
task. The Myopic algorithm [55] has been implemented in some Grid systems such
as Condor DAGMan [49]. The detail of the algorithm is shown in Algorithm 7.1.
The algorithm schedules an unmapped ready task to the resource that is expected
to complete the task earliest, until all tasks have been scheduled.

Algorithm 7.1. Myopic scheduling algorithm

1: while ∃t ∈ Γ is not completed do
2: task ← get a ready task whose parent tasks have been completed
3: r ← for t ∈ task, get a resource which can complete t at the earliest time
4: schedule t on r
5: end while

List scheduling
A list scheduling heuristic prioritizes workflow tasks and scheldules the tasks
based on their priorities. There are two major phases in a list scheduling heuris-
tic, the task prioritizing phase and the resource selection phase [33]. The task
prioritizing phase sets the priority of each task with a rank value and generates a
scheduling list by sorting the tasks according to their rank values. The resource
selection phase selects tasks in the order of their priorities and map each selected
task on its optimal resource.
Different list scheduling heuristics use different attributes and strategies to
decide the task priorities and the optimal resource for each task. We catego-
rize workflow-based list scheduling algorithms as either batch, dependency or
dependency-batch mode.
The batch mode scheduling group workflow tasks into several independent
tasks and consider tasks only in the current group. The dependency mode ranks
workflow tasks based on its weight value and the rank value of its inter-dependent
tasks, while the dependency-batch mode further use a batch mode algorithm to
re-ranks the independent tasks with similar rank values.

Batch mode
Batch mode scheduling algorithms are initially designed for scheduling parallel
independent tasks, such as bag of tasks and parameter tasks, on a pool of re-
sources. Since the number of resources is much less than the number of tasks,
the tasks need to be scheduled on the resources in a certain order. A batch mode
algorithm intends to provide a strategy to order and map these parallel tasks on
the resources, in order to complete the execution of these parallel tasks at earli-
est time. Even though batch mode scheduling algorithms aim at the scheduling
problem of independent tasks; they can also be applied to optimize the execu-
tion time of a workflow application which consists of a lot of independent parallel
tasks with a limited number of resources.
 7 Workflow Scheduling Algorithms for Grid Computing 179

Batch Mode Algorithms. Min-Min, Max-Min, Sufferage proposed by Mah-

eswaran et al. [39] are three major heuristics which have been employed for schedul-
ing workflow tasks in vGrADS [4] vGrADS [4] and pegasus [11]. The heuristics is
based on the performance estimation for task execution and I/O data transmis-
sion. The definition of each performance metric is given in Table 7.3.

Table 7.3. Performance Matrices

Symbol Definition

EET (t, r) Estimated Execution Time: the amount of time the resource r will
take to execute the task t, from the time the task starts to execute
on the resource.
EAT (t, r) Estimated Availability Time: the time at which the resource r is
available to execute task t.
F AT (t, r) File Available Time: the earliest time by which all the files required
by the task t will be available at the resource r.
ECT (t, r) Estimated Completion Time: the estimated time by which task
t will complete execution at resource r: ECT (t, r) = EET (t, r) +
max(EAT (t, r), F AT (t, r))
M CT (t) Minimum Estimated Completion Time: minimum ECT for task
t over all available resources.

Algorithm 7.2. Min-Min and Max-Min task scheduling algorithms

1: while ∃t ∈ Γ is not scheduled do
2: availT asks ← get a set of unscheduled ready tasks whose parent tasks have
been completed
3: schedule(availT asks)
4: end while
5: PROCEDURE: schedule(availT asks)
6: while ∃t ∈ availT asks is not scheduled do
7: for all t ∈ availT asks do
8: availResources ← get available resources for t
9: for all r ∈ availResources do
10: compute ECT (t, r)
11: end for
12: // get M CT (t, r) for each resource
Rt ← min ECT (t, r)
r∈availResources
13: end for
14: // Min-Min: get a task with minimum ECT (t, r) over tasks
T ← arg min ECT (t, Rt )
t∈availT asks
// Max-Min: get a task with maximum ECT (t, r) over tasks
T ← arg max ECT (t, Rt )
t∈availT asks
15: schedule T on RT
16: remove T from availT asks
17: update EAT (RT )
18: end while
180 J. Yu, R. Buyya, and K. Ramamohanarao

Algorithm 7.3. Sufferage task scheduling algorithm.

1: while ∃t ∈ Γ is not completed do
2: availT asks ← get a set of unscheduled ready tasks whose parent tasks have
been completed
3: schedule(availT asks)
4: end while
5: PROCEDURE: schedule(availT asks)
6: while ∃t ∈ availT asks is not scheduled do
7: for all t ∈ availT asks do
8: availResources ← get available resources for t
9: for all r ∈ availResources do
10: compute ECT (t, r)
11: end for
12: // compute earliest ECT
Rt1 ← arg min ECT (t, r)
r∈availResources
13: // compute second earliest ECT
Rt2 ← arg min ECT (t, r)
r∈availResources&r=R1
t
14: // compute sufferage value for task t
suft ← ECT (t, Rt2 ) − ECT (t, Rt1 )
15: end for
16: T ← arg max suft
t∈availT asks
17: schedule T on RT1
18: remove T from availT asks
19: update EAT (RT )
20: end while

The Min-Min heuristic schedules sets of independent tasks iteratively

(Algorithm 7.2: 1-4). For each iterative step, it computes ECTs(Early Com-
pletion Time) of each task on its every available resource and obtains the
MCT(Minimum Estimated Completion Time) for each task (Algorithm 7.2: 7-
12). A task having minimum MCT value over all tasks is chosen to be scheduled
first at this iteration. It assigns the task on the resource which is expected to
complete it at earliest time.
The Max-Min heuristic is similar to the Min-Min heuristic. The only differ-
ence is the Max-Min heuristic sets the priority to the task that requires longest
execution time rather than shortest execution time. After obtaining MCT values
for each task (Algorithm 7.2: 7-13), a task having maximum MCT is chosen to
be scheduled on the resource which is expected to complete the task at earli-
est time. Instead of using minimum MCT and maximum MCT, the Sufferage
heuristic sets priority to tasks based on their sufferage value. The sufferage value
of a task is the difference between its earliest completion time and its second
earliest completion time (Algorithm 7.3: 12-14).
Comparison of batch mode algorithms. The overview of three batch mode
algorithms is shown in Table 7.4. The Min-Min heuristic schedules tasks hav-
ing shortest execution time first so that it results in the higher percentage of
 7 Workflow Scheduling Algorithms for Grid Computing 181

Table 7.4. Overview of batch mode algorithms

Algorithm Features
M in − M in It sets high scheduling priority to tasks which have the shortest exe-
cution time.
M ax − M in It sets high scheduling priority to tasks which have long execution
time.
Suf f erage It sets high scheduling priority to tasks whose completion time by the
second best resource is far from that of the best resource which can
complete the task at earliest time.

tasks assigned to their best choice (which can complete the tasks at earlist time)
than Max-Min heuristics [12]. Experimental results conducted by Maheswaran
et al. [39] and Casanova et al. [14] have proved that Min-Min heuristic outper-
form Max-Min heuristic. However, since Max-min schedule tasks with longest
execution time first, a long execution execution task may have more chance of
being executed in parallel with shorter tasks. Therefore, it might be expected
that the Max-Min heuristic perform better than the Min-Min heuristic in the
cases where there are many more short tasks than long tasks [12, 39].
On the other hand, since the Sufferage heuristic considers the adverse effect
in the completion time of a task if it is not scheduled on the resource having
with minimum completion time [39], it is expected to perform better in the cases
where large performance difference between resources. The experimental results
conducted by Maheswaran et al. shows that the Sufferage heuristic produced the
shortest makespan in the high heterogeneity environment among three heuristics
discussion in this this section. However, Casanova et al. [14] argue that the
Sufferage heuristic could perform worst in the case of data-intensive applications
in multiple cluster environments.

Extended batch mode algorithms. XSufferage is an extension of the Suf-

fereage heuristic. It computes the sufferage value on a cluster level with the
hope that the files presented in a cluster can be maximally reused. A modified
Min-Min heuristic, QoS guided Min-Min, is also proposed in [28]. In addition
to comparing the minimum completion time over tasks, it takes into account
different levels of quality of service (QoS) required by the tasks and provided by
Grid resources such as desirable bandwidth, memory and CPU speed. In general,
a task requiring low levels of QoS can be executed either on resources with low
QoS or resources with high QoS, whereas the task requiring high levels of QoS
can be processed only on resources with high QoS. Scheduling tasks without
considering QoS requirements of tasks may lead to poor performance, since low
QoS tasks may have higher priority on high QoS resources than high QoS tasks,
while resources with low QoS remain idle [28]. The QoS guided Min-Min heuris-
tic starts to map low QoS tasks until all high QoS tasks have been mapped.
The priorities of tasks with the same QoS level are set in the same way of the
Min-Min heuristic.
182 J. Yu, R. Buyya, and K. Ramamohanarao

t0
w0
W0,1 W0,3
W0,2

t1 t2 t3
w1 w2 w3

W1,4
W2,5 W3,5
t4
w4

W4,5
t5

w5

Fig. 7.3. A weighted task graph example

Dependency Mode

Dependency mode scheduling algorithms are derived from the algorithms for
scheduling a task graph with interdependent tasks on distributed computing
environments. It intends to provide a strategy to map workflow tasks on hetero-
geneous resources based on analyzing the dependencies of the entire task graph,
in order to complete these interdependent tasks at earliest time. Unlike batch
mode algorithms, it ranks the priorities of all tasks in a workflow application at
one time.
Many dependency mode heuristics rank tasks based on the weights of task
nodes and edges in a task graph. As illustrated in Fig. 7.3, a weight wi is as-
signed to a task Ti and a weight wi,j is assigned to an edge (Ti , Tj ). Many list
scheduling schemes [33] developed for scheduling task graphs on homogenous
systems set the weight of each task and edge to be equal to its estimation exe-
cution time and communication time, since in a homogenous environment, the
execution times of a task and data transmission time on all available resources
are identical. However, in a Grid environment, resources are heterogeneous. The
computation time varies from resource to resource and the communication time
varies from data link to data link between resources. Therefore, it needs to con-
sider processing speeds of different resources and different transmission speeds
of different data links and an approximation approach to weight tasks and edges
for computing the rank value.
Zhao and Sakellariou [62] proposed six possible approximation options, mean
value, median value, worst value, best value, simple worst value, and simple best
value. These approximation approaches assign a weight to each task node and
edge as either the average, median, maximum, or minimum computation time
and communication time of processing the task over all possible resources. In-
stead of using approximation values of execution time and transmission time,
Shi and Dongarra [46] assign a higher weight task with less capable resources.
Their motivation is quite similar to the QoS guided min-min scheduling, i.e., it
 7 Workflow Scheduling Algorithms for Grid Computing 183

may cause longer delay if tasks with scarce capable resources are not scheduled
first, because there are less choices of resources to process these tasks.

Dependency Mode Algorithm. The Heterogeneous-Earliest-Finish-Time

(HEFT) algorithm proposed by Topcuoglu et al. [51] has been applied by the
ASKALON project [18,55] to provide scheduling for a quantum chemistry appli-
cation, WIEN2K [10], and a a quantum chemistry application, and a hydrological
application, Invmod [43], on the Austrian Grid [2].
As shown in Algorithm 7.4, the algorithm first calculates average execution
time for each task and average communication time between resources of two
successive tasks. Let time(Ti , r) be the execution time of task Ti on resource r
and let Ri be the set of all available resources for processing Ti . The average
execution time of a task Ti is defined as

time(Ti , r)
r∈Ri
i = (7.1)
|Ri |

Let time(eij , ri , rj ) be the data transfer time between resources ri and rj

which process the task Ti and task Tj respectively. Let Ri and Rj be the set of
all available resources for processing Ti and Tj respectively. The average trans-
mission time from Ti to Tj is defined by:

time(eij , ri , rj )
ri Ri rj Rj
cij = (7.2)
|Ri ||Rj |

Then tasks in the workflow are ordered in HEFT based on a rank fuction. For
a exit task Ti , the rank value is:

rank(Ti ) = i (7.3)

The rank values of other tasks are computed recursively based on Eqs. 7.1,
7.2, 7.3 as shown in 7.4.

Algorithm 7.4. Heterogeneous-Earliest-Finish-Time (HEFT) algorithm

1: compute the average execution time for each task t ∈ Γ according to equation 7.1
2: compute the average data transfer time between tasks and their successors accord-
ing to equation 7.2
3: compute rank value for each task according to equations 7.3 and 7.4
4: sort the tasks in a scheduling list Q by decreasing order of task rank value
5: while Q is not empty do
6: t ← remove the first task from Q
7: r ← find a resource which can complete t at earliest time
8: schedule t to r
9: end while
184 J. Yu, R. Buyya, and K. Ramamohanarao

rank(Ti ) = i + max (cij + rank(Tj )) (7.4)

Tj succ(Ti )

where succ(Ti ) is the set of immediate successors of task Ti . The algorithm then
sorts the tasks by decreasing order of their rank values. The task with higher rank
value is given higher priority. In the resource selection phase, tasks are scheduled
in the order of their priorities and each task is assigned to the resource that can
complete the task at the earliest time.
Even though original HEFT proposed by Topcuoglu et al. [51] computes the
rank value for each task using the mean value of the task execution time and
communication time over all resources, Zhao and Sakellariou [62] investigated
and compared the performances of the HEFT algorithm produced by other dif-
ferent approximation methods on different cases. The results of the expeirments
showed that the mean value method is not the most effiecient choice, and the
performance could differ significantly from one application to another [62].

Dependency-Batch Mode

Sakellariou and Zhao [45] proposed a hybrid heuristic for scheduling DAG on het-
erogeneous systems. The heuristic combines dependency mode and batch mode.
As described in Algorithm 7.5, the heuristic first compute rank values of each task
and ranks all tasks in the decreasing order of their rank values (Algorithm 7.5: line
1-3). And then it creates groups of independent tasks (Algorithm 7.5:line 4-11).
In the grouping phase, it processes tasks in the order of their rank values and add
tasks into the current group. Once it finds a task which has a dependency with
any task within the group, it creates another new group. As a result, a number
of groups of independent tasks are generated. And the group number is assigned

Algorithm 7.5. Hybrid heuristic

1: compute the weight of each task node and edge according to equations 7.1 and 7.2

2: compute the rank value of each task according to equations 7.3 and 7.4
3: sort the tasks in a scheduling list Q by decreasing order of task rank value
4: create a new group Gi and i = 0
5: while Q is not empty do
6: t ← remove the first task from Q
7: if t has a dependence with a task in Gi then
8: i + +; create a new group Gi
9: end if
10: add t to Gi
11: end while
12: j=0
13: while j <= i do
14: scheduling tasks in Gi by using a batch mode algorithm
15: j++
16: end while
 7 Workflow Scheduling Algorithms for Grid Computing 185

based on the order of rank values of their tasks, i.e., if m > n, the ranking value
of tasks in group m is higher than that of the tasks in group n. Then it schedules
tasks group by group and uses a batch mode algorithm to reprioritize the tasks in
the group.

Cluster based and Duplication based scheduling

Both cluster based scheduling and duplication based scheduling are designed to
avoid the transmission time of results between data interdependent tasks, such
that it is able to reduce the overall execution time. The cluster based scheduling
clusters tasks and assign tasks in the same cluster into the same resource, while
the duplication based scheduling use the idling time of a resource to duplicate
some parent tasks, which are also being scheduled on other resources.
Bajai and Agrawal [3] proposed a task duplication based scheduling algorithm
for network of heterogeneous systems(TANH) . The algorithm combines cluster
based scheduling and duplication based scheduling and the overview of the al-
gorithm is shown in Algorithm 7.6. It first traverses the task graph to compute
parameters of each node including earliest start and completion time, latest start
and completion time, critical immediate parent task, best resource and the level
of the task. After that it clusters tasks based on these parameters. The tasks in
a same cluster are supposed to be scheduled on a same resource. If the number
of the cluster is greater than the number of resources, it scales down the number
of clusters to the number of resources by merging some clusters. Otherwise, it
utilizes the idle times of resources to duplicate tasks and rearrange tasks in order
to decrease the overall execution time.

Algorithm 7.6. TANH algorithm

1: compute parameters for each task node
2: cluster workflow tasks
3: if the number of clusters greater than the number of available resources then
4: reducing the number of clusters to the number of available resources
5: else
6: perform duplication of tasks
7: end if

7.3.2 Meta-heuristics
Meta-heuristics provide both a general structure and strategy guidelines for
devoping a heuristic for solving computational problems. They are generally
applied to a large and complicated problem. They provide an efficient way of
moving quickly toward a very good solution. Many metahuristics have been ap-
plied for solving workflow scheduling problmes, including GRASP, Genetic Algo-
rithms and Simulated Annealing. The details of these algorithms are presented
in the sub-sections that follow.
186 J. Yu, R. Buyya, and K. Ramamohanarao

Greedy Randomized Adaptive Search Procedure (GRASP)

A Greedy Randomized Adaptive Search Procedure (GRASP) is an iterative ran-
domized search technique. Feo and Resende [19] proposed guidelines for develop-
ing heuristics to solve combinatorial optimization problems based on the GRASP
concept. Binato et al. [8] have shown that the GRASP can solve job-shop schedul-
ing problems effectively. Recently, the GRASP has been investigated by Blythe
et al. [11] for workflow scheduling on Grids by comparing with the Min-Min
heuristic on both computational- and data-intensive applicaitons.

Algorithm 7.7. GRASP algorithm

1: while stopping criterion not satisfied do
2: schedule ← createSchedule(workf low)
3: if schedule is better than bestSchedule then
4: bestSchedule ← schedule
5: end if
6: end while
7: PROCEDURE: createSchedule(workf low)
8: solution ← constructSolution(workf low)
9: nSolution ← localSearch(solution)
10: if nSolution is better than solution then
11: return nSolution
12: end if
13: return solution
14: END createSchedule
15: PROCEDURE: constructSolution(workf low)
16: while schedule is not completed do
17: T ← get all unmapped ready tasks
18: make a RCL for each t ∈ T
19: subSolution ← selecta resource randomly for each t ∈ T from its RCL
20: solution ← solution subSolution
21: update information for further RCL making
22: end while
23: return solution
24: END constructSolution
25: PROCEDURE: localSearch(solution)
26: nSolution ← find a optimal local solution
27: return nSolution
28: END localSearch

Algorithm 7.7 describes a GRASP. In a GRASP, a number of iterations are

conducted to search a possible optimal solution for scheduling tasks on resources.
A solution is generated at each iterative step and the best solution is kept as
the final schedule (Algorithm 7.7:line 1-6). A GRASP is terminated when the
specified termination criterion is satisfied, for example, after completing a cer-
tain number of interations. In general, there are two phases in each interation:
construction phase and local search phase.
 7 Workflow Scheduling Algorithms for Grid Computing 187

The construction phase (Algorithm 7.7:line 8 and line 15-24) generates a fea-
sible solution. A feasible solution for the workflow scheduling problem is required
to meet the following conditions: a task must be started after all its predecessors
have been completed; every task appears once and only once in the schedule. In
the construction phase, a restricted candidate list (RCL) is used to record the
best candidates, but not necessarily the top candidate of the resources for pro-
cessing each task. There are two major mechanisms that can be used to generate
the RCL, cardinality-based RCL and value-based RCL.

Algorithm 7.8. Construction phase procedure for workflow scheduling

1: PROCEDURE: constructSolution(Ω)
2: while schedule is not completed do
3: availT asks ← get unmapped ready tasks
4: subSolution ← schedule(availT
 asks)
5: solution ← solution subSolution
6: end while
7: return solution
8: END constructSolution
9: PROCEDURE: schedule(tasks)
10: availT asks ← tasks
11: pairs ←
12: while ∃t ∈ tasks not scheduled do
13: for all t ∈ availT asks do
14: availResources ← get available resources for t
15: for all r ∈ availResources do
16: compute increaseM
 akespan(t, r)
17: pairs ← pairs (t, r)
18: end for
19: end for
20: minI ← minimum makespan increase over availP airs
21: maxI ← maximum makespan increase over availP airs
22: availP airs ← select pairs whose makespan increase is less than minI+α(maxI−
minI)
23: (t , r  ) ← select a pair at random from availP airs
24: remove t from availT asks
25: solution ← solution (t , r  )
26: end while
27: return solution
28: END schedule

The cardinality-based RCL records the k best rated solution components,

while the value-based RCL records all solution components whose performance
evaluated values are better than a better than a given threshold [31]. In the
GRASP, resource allocated to each task is randomly selected from its RCL
(Algorithm 7.7: line 19). After allocating a resource to a task, the resource in-
formation is updated and the scheduler continues to process other unmapped
tasks.
188 J. Yu, R. Buyya, and K. Ramamohanarao

Algorithm 7.8 shows the detailed implementation of the construction phase

for workflow scheduling presented by Blythe et al. [11] which uses a value-based
RCL method. The scheduler estimates the makespan increase for each unmapped
ready task (Algorithm 7.8: line 3-4 and line 13-19) on each resource that is able to
process the task. A makespan increase of a task t on a resource r is the increase of
the execution length to the current completion length (makespan) if r is allocated
to t. Let minI and maxI be the lowest and highest makespan increase found
respectively. The scheduler selects a task assignment randomly from the task
and resource pair whose makespan increase is less than minI + α(maxI − minI),
where is a parameter to determine how much variation is allowed for creating
RCL for each task and 0 ≤ α ≤ 1.
Once a feasible solution is constructed, a local search is applied into the solu-
tion to improve it. The local search process searches local optima in the neigh-
borhood of the current solution and generates a new solution. The new solution
will replace the current constructed solution if its overall performance is better
(i.e. its makespan is shorter than that of the solution generated) in the construc-
tion phase. Binato et al. [8] implementation of the local search phase for job-shop
scheduling. It identifies the critical path in the disjunctive graph of the solution
generated in the construction phase and swaps two consecutive operations in the
critical path on the same machine. If the exchange improves the performance, it
is accepted.

Genetic Algorithms (GAs)

Genetic Algorithms (GAs) [25] provide robust search techniques that allow a
high-quality solution to be derived from a large search space in polynomial time
by applying the principle of evolution. Using genetic algorithms to schedule
task graphs in homogeneous and dedicated multiprocessor systems have been
proposed in [31, 56, 64]. Wang et al. [54] have developed a genetic-algorithm-
based scheduling to map and schedule task graphs on heterogeneous envoriments.
Prodan and Fahringer [42] have employed GAs to schedule WIEN2k workflow
[10] on Grids. Spooner et al. [47] have employed GAs to schedule sub-workflows
in a local Grid site.
A genetic algorithm combines exploitation of best solutions from past searches
with the exploration of new regions of the solution space. Any solution in the
search space of the problem is represented by an individual (chromosome). A
genetic algorithm maintains a population of individuals that evolves over gener-
ations. The quality of an individual in the population is determined by a fitness
function . The fitness value indicates how good the individual is compared to
others in the population.
A typical genetic algorithm is illustrated in Fig. 7.4. It first creates an initial
population consisting of randomly generated solutions. After applying genetic
operators, namely selection, crossover and mutation, one after the other, new
offspring are generated. Then the evaluation of the fitness of each individual in
the population is conducted. The fittest individuals are selected to be carried over
next generation. The above steps are repeated until the termination condition
 7 Workflow Scheduling Algorithms for Grid Computing 189

Fig. 7.4. Genetic Algorithms

Table 7.5. Fitness Values and Slots for Roulette Wheel Selection

Individual Fitness value Slot Size Slot

1 0.45 0.25 0.25
2 0.30 0.17 0.42
3 0.25 0.14 0.56
4 0.78 0.44 1
Total 1.78 1

is satisfied. Typically, a GA is terminated after a certain number of iterations,

or if a certain level of fitness value has been reached [64].
The construction of a genetic algorithm for the scheduling problem can be
divided into four parts [32]: the choice of representation of individual in the
population; the determination of the fitness function; the design of genetic op-
erators; the determination of probabilities controlling the genetic operators.
As genetic algorithms manipulate the code of the parameter set rather than
the parameters themselves, an encoding mechanism is required to represent in-
dividuals in the population. Wang et al. [54] encoded each chromosome with two
separated parts: the matching string and the scheduling string. Matching string
190 J. Yu, R. Buyya, and K. Ramamohanarao

R1
T0 T1 T2 T0 T2 T7
R2
T1
T3 T4 R3 T3 T5

T5 R4 T4 T6
T6
time
T7
(a)

Machine string Scheduling string

T0:R0 T0
T1:R2 T2
T2:R1
T3:R3 T1
T4:R4
T5:R3 T3
T6:R4
T7:R1 T4

T5

T6

T7

(b)

Fig. 7.5. (a) Workflow application and schedule. (b) seperated machine string and
scheduling string. (c) two-dimensional string.

Table 7.6. Fitness Values and Slots for Rank Selection

Individual Fitness value Rank Slot Size Slot

1 0.45 3 0.3 0.3
2 0.30 2 0.2 0.5
3 0.25 1 0.1 0.6
4 0.78 4 0.4 1

represents the assignment of tasks on machines while scheduling string represents

the execution order of the tasks (Fig. 7.5a.). However, a more intuitive scheme,
two-dimensional coding scheme is employed by many [32, 56, 64] for scheduling
tasks in distributed systems. As illustrated in Fig. 7.5c, each schedule is simpli-
fied by representing it as a 2D string. One dimension represents the numbers of
resources while the other dimension shows the order of tasks on each resource.
A fitness function is used to measure the quality of the individuals in the
population. The fitness function should encourage the formation of the solution
 7 Workflow Scheduling Algorithms for Grid Computing 191

to achieve the objective function. For example, the fitness function developed
in [32] is Cmax − F T (I), where Cmax is the maximum completion time observed
so far and F T (I) is the completion time of the individual I. As the objective
function is to minimize the execution time, an individual with a large value of
fitness is fitter than the one with a small value of fitness.
After the fitness evaluation process, the new individuals are compared with the
previous generation. The selection process is then conducted to retain the fittest
individuals in the population, as successive generations evolve. Many methods
for selecting the fittest individuals have been used for solving task scheduling
problems such as roulette wheel selection, rank selection and elitism.
The roulette wheel selection assigns each individual to a slot of a roulette
wheel and the slot size occupied by each individual is determined by its fitness
value. For example, there are four individuals (see Table 7.5) and their fitness
values are 0.45, 0.30, 0.25 and 0.78, respectively. The slot size of an individual is
calculated by dividing its fitness value by the sum of all individual fitness in the
population. As illustrated in Fig. 7.6, individual 1 is placed in the slot ranging
from 0 − 0.25 while individual 2 is in the slot ranging from 0.26 − 0.42. After
that, a random number is generated between 0 and 1, which is used to determine
which individuals will be preserved to the next generation. The individuals with
a higher fitness value are more likely to be selected since they occupy a larger
slot range.
The roulette wheel selection will have problems when there are large dif-
ferences between the fitness values of individuals in the population [41]. For
example, if the best fitness value is 95% of all slots of the roulette wheel, other
individuals will have very few chances to be selected. Unlike the roulette wheel
selection in which the slot size of an individual is proportional to its fitness value,
a rank selection process firstly sorts all individuals from best to worst according
to their fitness values and then assigns slots based on their rank. For example,
the size of slots for each individual implemented by DOǦAN and Özgüner [16]
is proportional to their rank value. As shown in Table 7.6, the size of the slot
for individual I is defined as P I =  nR(I)R(i) , where R(I) is the rank value of I
i=1
and n is the number of all individuals. Both the roulette wheel selection and the
rank selection select individuals according to their fitness value. The higher the
fitness value, the higher the chance it will be selected into the next generation.
However, this does not guarantee that the individual with the highest value goes
to the next generation for reproduction. Elitism can be incorporated into these
two selection methods, by first copying the fittest individual into the next gener-
ation and then using the rank selection or roulette wheel selection to construct
the rest of the population. Hou et al. [32] showed that the elitism method can
improve the performance of the genetic algorithm.
In addition to selection, crossover and mutation are two other major genetic
operators. Crossovers are used to create new individuals in the current popula-
tion by combining and rearranging parts of the existing individuals. The idea
behind the crossover is that it may result in an even better individual by combin-
ing two fittest individuals [32]. Mutations occasionally occur in order to allow a
192 J. Yu, R. Buyya, and K. Ramamohanarao

Fig. 7.6. Roulette Wheel Selection Example

certain child to obtain features that are not possessed by either parent. It helps
a genetic algorithm to explore new and potentially better genetic material than
was previously considered. The frequency of mutation operation occurrence is
controlled by the mutation rate whose value is determined experimentally [32].

Simulated Annealing (SA)

Simulated Annealing (SA) [38] derives from the Monte Carlo method for statis-
tically searching the global optimum that distinguishes between different local
optima. The concept is originally from the way in which crystalline structures
can be formed into a more ordered state by use of the annealing process, which
repeats the heating and slowly cooling a structure. SA has been used by YarKhan
and Dongarra [57] to select a suitable size of a set of machines for scheduling a
ScaLAPACK applicaton [9] in a Grid environment. Young et al. [58] have inves-
tigated performances of SA algorithms for scheduling workflow applications in a
Grid envrionment.
A typical SA algorithm is illustrated in Fig. 7.7. The input of the algorithm
is an initial solution which is constructed by assigning a resource to each task at
random. There are several steps that the simulated annealing algorithm needs to
go through while the temperature is decreased by a specified rate. The annealing
process runs through a number of iterations at each temperature to sample the
search space. At each cycle, it generates a new solution by applying random
change on the current solution. Young et al. [58] implemented this randomization
by moving one task onto a different resource. Whether or not the new solution
is accepted as a current solution is determined by the Metropolis algorithm
[38, 58] shown in Algorithm 7.9. In the Metropolis algorithm, the new solution
and the current solution are compared and the new solution is unconditionally
accepted if it is better than the current one. In the case of the minimization
problem of workflow scheduling, the better solution is one which has a lower
execution time and the improved value is denoted as dβ. In other cases, the new
−dβ
solution is accepted with the Boltzmann probability e T [38] where T is the
current temperature. Once a specified number of cycles have been completed,
the temperature is decreased. The process is repeated until the lowest allowed
temperature has been reached. During this process, the algorithm keeps the
best solution so far, and returns this solution at termination as the final optimal
solution.
 7 Workflow Scheduling Algorithms for Grid Computing 193

Fig. 7.7. Simulated Annealing

Algorithm 7.9. Metropolis algorithm

1: if dβ then
2: return true −dβ
3: else if a random number less than e T then
4: return true
5: else
6: return f alse
7: end if
194 J. Yu, R. Buyya, and K. Ramamohanarao

7.3.3 Comparison of Best-Effort Scheduling Algorithms

The overview of the best effort scheduling is presented in Table 7.7 and 7.8. In
general, the heuristic based algorithms can produce a reasonable good solution
in a polynomial time. Among the heuristic algorithms, individual task scheduling
is simplest and only suitable for simple workflow structures such as a pipeline in
which several tasks are required to be executed in sequential. Unlike individual
task scheduling, list scheduling algorithms set the priorities of tasks in order to
make an efficient schedule in the situation of many tasks compete for limited
number of resources. The priority of the tasks determines their execution order.
The batch mode approach orders the tasks required to be executed in parallel
based on their execution time whereas the dependency mode approach orders the
tasks based on the length of their critical path. The advantage of the dependency
mode approach is that it intent to complete tasks earlier whose interdependent
tasks required longer time in order to reduce the overall execution time. However,
its complexity is higher since it is required to compute the critical path of all
tasks. Another drawback of the dependency mode approach is that it cannot
efficiently solve resource competition problem for a workflow consisting of many
parallel tasks having the same length of their critical path. The dependency-
batch mode approach can take advantage of both approaches, and Sakellariou
and Zhao [45] shows that it outperforms the dependency mode approach in
most cases. However, computing task priorities based on both batch mode and
dependency mode approach results in higher scheduling time.
Even though data transmission time has been considered in the list scheduling
approach, it still may not provide an efficient schedule for data intensive workflow
applications, in which the majority of computing time is used for transferring
data of results between the inter-dependent tasks. The main focus of the list
scheduling is to find an efficient execution order of a set of parallel tasks and
the determination of the best execution resource for each task is based only
on the information of current task. Therefore, it may not assign data inter-
dependent tasks on resources among which an optimized data transmission path
is provided. Both cluster based and duplication based scheduling approach focus
on reducing communication delay among interdependent tasks. The clustering
based approach minimizes the data transmission time by grouping heavily com-
municating tasks to a same task cluster and assigns all tasks in the cluster to
one resource, in order to minimize the data transmission time, while duplication
based approach duplicates data-interdependent tasks to avoid data transmission.
However, the restriction of the algorithms based on these two approaches up to
date may not be suitable for all Grid workflow applications, since it assumes
that heavily communicating tasks can be executed on a same resource. Tasks
in Grid workflow applications can be highly heterogeneous and require different
type of resources.
The meta-heuristics based workflow scheduling use guided random search
techniques and exploit the feasible solution space iteratively. The GRASP gen-
erates a randomized schedule at each iteration and keeps the best solution as the
final solution. The SA and GAs share the same fundamental assumption that
 7 Workflow Scheduling Algorithms for Grid Computing 195

Table 7.7. Comparison of Best-effort Workflow Scheduling Algorithms (Heuristics)

Scheduling Method Algorithm Complexity* Features

Individual task scheduling Myopic O(vm)Decision is based on one

task.
Batch mode Min-min O(vgm) Decision based on a set
of parallel independent
tasks.
List scheduling

Dependency mode HEFT O(v 2 m) Decision based on the

critical path of the task.
Dependency-batch mode Hybrid O(v 2 m + vgm) Ranking tasks based on
their critical path and re-
ranking adjacent indepen-
dent tasks by using a
batch mode algorithm.
Replicating tasks to
Cluster based scheduling 2 more than one resources
THAN O(v )
Duplication based scheduling in order to reduce
transmission time.
*where v is the number of tasks in the workflow, m is the number of resources and g
is the number of tasks in a group of tasks for the batch mode scheduling.

Table 7.8. Comparison of Best-effort Workflow Scheduling Algorithms (Meta-

heuristics)

Scheduling Method Features

Greedy randomized adaptive Global solution obtained by comparing differences be-

search procedure (GRASP) tween randomized schedules over a number of iteration.
Genetic algorithms (GA) Global solution obtained by combining current best solu-
tions and exploiting new search region over generations.
Simulated annealing (SA) Global solution obtained by comparing differences be-
tween schedules which are generated based on current
accepted solutions over a number of iterations, while the
acceptance rate is decreased.

an even better solution is more probably derived from good solutions. Instead of
creating a new solution by randomized search, SA and GAs generate new solu-
tions by randomly modifying current already know good solutions. The SA uses
a point-to-point method, where only one solution is modified in each iteration,
whereas GAs manipulate a population of solutions in parallel which reduce the
probability of trapping into a local optimum [65]. Another benefit of producing
a collection of solutions at each iteration is the search time can be significantly
decreased by using some parallelism techniques.
Compared with the heuristics based scheduling approaches, the advantage of
the meta-heuristics based approaches is that it produces an optimized scheduling
196 J. Yu, R. Buyya, and K. Ramamohanarao

solution based on the performance of entire workflow, rather than the partial of
the workflow as considered by heuristics based approach. Thus, unlike heuris-
tics based approach designed for a specified type of workflow application, it
can produce good quality solutions for different types of workflow applications
(e.g. different workflow structure, data- and computational-intensive workflows,
etc). However, the scheduling time used for producing a good quality solution
required by meta-heuristics based algorithms is significantly higher. Therefore,
the heuristics based scheduling algorithms are well suited for a workflow with a
simple structure, while the meta-heuristics based approaches have a lot of po-
tential for solving large and complex structure workflows. It is also common to
incorporate these two types of scheduling approaches by using a solution gener-
ated by a heuristic based algorithm as a start search point for the meta-heuristics
based algorithms to generate a satisfactory solution in shorter time.

7.3.4 Dynamic Scheduling Techniques

The heuristics presented in last sections assume that the estimation of the per-
formance of task execution and data communication is accurate. However, it is
difficult to predict accurately execution performance in community Grid envi-
ronments due to its dynamic nature. In a community Grid, the utilization and
availability of resources varies over time and a better resource can join at any
time. Constructing a schedule for entire workflow before the execution may re-
sult in a poor schedule. If a resource is allocated to each task at the beginning of
workflow execution, the execution environment may be very different at the time
of task execution. A ‘best’ resource may become a ‘worst’ resource. Therefore,
the workflow scheduler must be able to adapt the resource dynamics and update
the schedule using up-to-date system information. Several approaches have been
proposed to address these problems. In this section, we focus on the approaches
which can apply the algorithms into dynamic environments.
For individual task and batch mode based scheduling, it is easy for the sched-
uler to use the most up-to-date information, since it takes into account only the
current task or a group of independent tasks. The scheduler could map tasks
only after their parent tasks become to be executed.
For dependency mode and metahueristics based scheduling, the scheduling de-
cision is based on the entire workflow. In other words, scheduling current tasks
require information about its successive tasks. However, it is very difficult to es-
timate execution performance accurately, since the execution environment may
change a lot for the tasks which are late executed. The problems appear more
significant for a long lasting workflow. In general, two approaches, task parti-
tioning and iterative re-computing, have been proposed to allow these scheduling
approaches to allocate resources more efficiently in a dynamic environment.
Task partitioning is proposed by Deelman et al. [17]. It partitions a work-
flow into multiple sub-workflows which are executed sequentially. Rather than
mapping the entire workflow on Grids, allocates resources to tasks in one sub-
workflow at a time. A new sub-workflow mapping is started only after the last
mapped sub-workflow has begun to be executed. For each sub-workflow, the
 7 Workflow Scheduling Algorithms for Grid Computing 197

scheduler applies a workflow scheduling algorithm to generate an optimized

schedule based on more up-to-date information.
Iterative re-computing keeps applying the scheduling algorithm on the remain-
ing unexecuted partial workflow during the workflow execution. It does not use
the initial assignment to schedule all workflow tasks but reschedule unexecuted
tasks when the environment changes. A low-cost rescheduling policy has been
developed by developed by Sakellariou and Zhao [44]. It reduces the overhead
produced by rescheduling by conducting rescheduling only when the delay of a
task execution impacts on the entire workflow execution.
In addition to mapping tasks before execution using up-to-date information,
task migration [4, 42] has been widely employed to reschedule a task to another
resource after it has been executed. The task will be migrated when the task
execution is timed out or a better resource is found to improve the performance.

7.4 QoS-Constraint Based Workflow Scheduling

Many workflow applications require some assurances of quality of services (QoS)
. For example, a workflow application for maxillo-facial surgery planning [16]
needs results to be delivered before a certain time. For thus applications, work-
flow scheduling is required to be able to analyze users’ QoS requirements and
map workflows on suitable resources such that the workflow execution can be
completed to satisfy users’ QoS constraints.
However, whether the execution can be completed within a required QoS not
only depend on the global scheduling decision of the workflow scheduler but
also depend on the local resource allocation model of each execution site. If the
execution of every single task in the workflow cannot be completed as what the
scheduler expects, it is impossible to guarantee the entire workflow execution. In-
stead of scheduling tasks on community Grids, QoS-constraint based schedulers
should be able to interact with service-oriented Grid services to ensure resource
availability and QoS levels. It is required that the scheduler can negotiate with
service providers to establish a service level agreement (SLA) which is a contract
specifying the minimum expectations and obligations between service providers
and consumers. Users normally would like to specify a QoS constraint for entire
workflow. The scheduler needs to determine a QoS constraint for each task in
the workflow, such that the QoS of entire workflow is satisfied.
In general, service-oriented Grid services are based on utility computing mod-
els. Users need to pay for resource access and service pricing is based on the QoS
level and current market supply and demand. Therefore, unlike the scheduling
strategy deployed in community Grids, QoS constraint based scheduling may
not always need to complete the execution at earliest time. They sometimes
may prefer to use cheaper services with a lower QoS that is sufficient to meet
their requirements.
To date, supporting QoS in scheduling of workflow applications is at a very
preliminary stage. Most QoS constraint based workflow scheduling heuristics are
based on either time or cost constraints. Time is the total execution time of the
198 J. Yu, R. Buyya, and K. Ramamohanarao

Table 7.9. Overview of deadline constrained workflow scheduling algorithms

Algorithm Project Organization Application

Back-tracking Menascé& Casalicchio George Mason N/A

University, USA
Univ. Roma “Tor
Vergata”, Italy
Deadline distribution Gridbus University of Randomly gener-
Melbourne, ated task graphs
Australia
Genetic algorithms Gridbus University of Randomly gener-
Melbourne, ated task graphs
Australia

Table 7.10. Overview of budget constrained workflow scheduling algorithms

Algorithm Project Organization Application

LOSS and GAIN CoreGrid University of Randomly gener-

Cyprus, Cyprus ated task graphs
University of
Manchester, UK
Genetic algorithms Gridbus University of Randomly gener-
Melbourne, ated task graphs
Australia
Genetic algorithms Gridbus University of Randomly gener-
Melbourne, ated task graphs
Australia

workflow (known as deadline). Cost is the total expense for executing workflow
execution including the usage charges by accessing remote resources and data
transfer cost (known as budget ). In this section, we present scheduling algo-
rithms based on these two constraints, called Deadline constrained scheduling
and Budget constrained scheduling. Table 7.9 and 7.10 presents the overview of
QoS constrained workflow scheduling algorithms.

7.4.1 Deadline Constrained Scheduling

Some workflow applications are time critical and require the execution can be
completed within a certain timeframe. Deadline constrained scheduling is de-
signed for these applications to deliver results before the deadline. The distinc-
tion between the deadline constrained scheduling and the best-effort scheduling
is that the deadline constrained scheduling also need to consider monetary cost
when it schedules tasks. In general, users need to pay for service assess. The price
is based on their usages and QoS levels. For example, services which can process
 7 Workflow Scheduling Algorithms for Grid Computing 199

faster may charges higher price. Scheduling the tasks based on the best-effort
based scheduling algorithms presented in the previous sections, attempting to
minimize the execution time will results in high and unnecessary cost. Therefore,
a deadline constrained scheduling algorithm intends to minimize the execution
cost while meeting the specified deadline constraint.
Two heuristics have been developed to minimize the cost while meeting a
specified time constraint. One is proposed by Menasc and Casalicchio [37] de-
noted as Back-tracking, and the other is proposed by Yu et al. [60] denoted as
Deadline Distribution.

Back-tracking

The heuristic developed by Menascè and Casalicchio assigns available tasks to

least expensive computing resources. An available task is an unmapped task
whose parent tasks have been scheduled. If there is more than one available
task, the algorithm assigns the task with the largest computational demand
to the fastest resources in its available resource list. The heuristic repeats the
procedure until all tasks have been mapped. After each iterative step, the execu-
tion time of current assignment is computed. If the execution time exceeds the
time constraint, the heuristic back-tracks the previous step and remove the least
expensive resource from its resource list and reassigns tasks with the reduced
resource set. If the resource list is empty the heuristic keep back-tracking to the
previous step, reduces corresponding resource list and reassign the tasks.

Deadline/Time Distribution (TD)

Instead of back-tracking and repairing the initial schedule, the TD heuristic

partitions a workflow and distributes overall deadline into each task based on
their workload and dependencies. After deadline distribution, the entire workflow
scheduling problem has been divided into several sub-task scheduling problems.
As shown in Fig. 7.8, in workflow task partitioning, workflow tasks are cate-
gorized as either synchronization tasks or simple tasks. A synchronization task
is defined as a task which has more than one parent or child task. For exam-
ple, T1 , T10 and T14 are synchronization tasks. Other tasks which have only one
parent task and child task are simple tasks. For example, T2 − T9 and T11 − T13
are simple tasks. Simple tasks are then clustered into a branch. A branch is a
set of interdependent simple tasks that are executed sequentially between two
synchronization tasks. For example, the branches in the example are {T2 , T3 , T4 }
and {T5 , T6 }, {T7 }, {T8 , T9 }, {T11 } and {T12 , T13 }.
After task partitioning, workflow tasks Γ are then clustered into partitions and
the overall deadline is distributed over each partition. The deadline assignment
strategy considers the following facts:
• The cumulative expected execution time of a simple path between two syn-
chronization tasks is same.
• The cumulative expected execution time of any path from an entry task to
an exit task is equal to the overall deadline.
200 J. Yu, R. Buyya, and K. Ramamohanarao

Simple task Branch

Synchronization task

V1
T2 T3 T4 T2 T3 T4
V2
T5 T6 V0 T5 T6 V8
T0 T14 T0 T14
V6
T7 T7 V3 V4
T11 T11
T10 T10
T8 T9 T12 T13 T8 T9 T12 T13

V5 V7
a) Before partitioning b) After partitioning

Fig. 7.8. Workflow Task Partition

• The overall deadline is divided over task partitions in proportion to their

minimum processing time.
After distributing overall deadline into task partitions, each task partition is
assigned a deadline. There are three attributes associated with a task partition
Vi : deadline(dl[Vi ]), ready time (rt[Vi ]), and expected execution time(eet[Vi ] ).
The ready time of Vi is the earliest time when its first task can be executed. It
can be computed according to its parent partitions and defined by:

0 , Tentry ∈ Vi
rt[Vi ] = max dl[Vj ] , otherwise (7.5)
Vj ∈P Vi

where P Vi is the set of parent task partitions of Vi . The relation between three
attributes of a task partition Vi follows that:

eet[Vi ] = dl[Vi ] − rt[Vi ] (7.6)

A sub-deadline can be also assigned to each task based on the deadline of its
task partition. If the task is a synchronization task, its sub-deadline is equal
to the deadline of its task partition. However, if a task is a simple task of a
branch, its sub-deadline is assigned by dividing the deadline of its partition
based on its processing time. Let Pi be the set of parent tasks of Ti and Si is
the set of resources that are capable to execute Ti . tji is the sum of input data
transmission time and execution time of executing Ti on Si . The sub-deadline
of task in partition is defined by:

dl[Ti ] = eet[Ti ] + rt[V ] (7.7)

 7 Workflow Scheduling Algorithms for Grid Computing 201

where
min tji
1≤j≤|Si |
eet[Ti ] =  eet[V ]
min tlk
1≤l≤|Sk |
Tk ∈V

0, Ti = Tentry
rt[Ti ] = max dl[Tj ], otherwise
Tj ∈Pi

Once each task has its own sub-deadline, a local optimal schedule can be gen-
erated for each task. If each local schedule guarantees that their task execution
can be completed within their sub-deadline, the whole workflow execution will
be completed within the overall deadline. Similarly, the result of the cost mini-
mization solution for each task leads to an optimized cost solution for the entire
workflow. Therefore, an optimized workflow schedule can be constructed from all
local optimal schedules. The schedule allocates every workflow task to a selected
service such that they can meet its assigned sub-deadline at low execution cost.

7.4.2 Budget Constrained Scheduling

As the QoS guaranteed resources charges access cost, users would like to execute
workflows based on the budget they available. Budget constrained scheduling
intends to minimize workflow execution time while meeting users’ specified bud-
gets. Tsiakkouri et al. [52] present budget constrained scheduling called LOSS
and GAIN.

LOSS and GAIN

LOSS and GAIN scheduling approach adjusts a schedule which is generated by

a time optimized heuristic and a cost optimized heuristic to meet users’ bud-
get constraints, respectively. A time optimized heuristic attempts to minimize
execution time while a cost optimization attempts to minimize execution cost.
If the total execution cost generated by time optimized schedule is not greater
than the budget, the schedule can be used as the final assignment; otherwise, the
LOSS approach is applied. The idea behinds LOSS is to gain a minimum loss in
execution time for the maximum money savings, while amending the schedule
to satisfy the budget. The algorithm repeats to re-assign the tasks with smallest
values of the LossWeight until the budget constraint is satisfied. The LossWeight
value for each task to each available resource is computed and it is defined by:
Tnew − Told
LossW eight(i, r) = (7.8)
Cold − Cnew
where Told and Cold are the execution time and corresponding cost of task Ti on
the original resource assigned by the time optimized scheduling, Tnew and Cnew
are the execution time of task Ti on resource r respectively. If Cold is not greater
than Cnew , the value of LossWeight is set to zero.
202 J. Yu, R. Buyya, and K. Ramamohanarao

If the total execution cost generated by a cost optimized scheduler is less

than the budget, the GAIN approach is applied to use surplus to decrease the
execution time. The idea behinds GAIN is to gain the maximum benefit in
execution time for the minimum monetary cost, while amending the schedule.
The algorithm repeats to re-assign the tasks with biggest value of the GainWeight
until the cost exceeds the budget. The GainWeight value for each task to each
available resource is computed and it is defined by:
Told − Tnew
GainW eight(i, r) = (7.9)
Cnew − Cold
where Tnew , Told , Cnew and Cold have the same meaning as in the LOSS ap-
proach. If Tnew is greater than Told or Cnew is equal to Cold , the value of Gain-
Weight is set to zero.

7.4.3 Meta-heuristic Based Constrained Workflow Scheduling

A genetic algorithm [61] is also developed to solve the deadline and budget
constrained scheduling problem. It defines a fitness function which consists of two
components, cost-fitness and time-fitness. For the budget constrained scheduling,
the cost-fitness component encourages the formation of the solutions that satisfy
the budget constraint. For the deadline constrained scheduling, it encourages the
genetic algorithm to choose individuals with less cost. The cost fitness function
of an individual I is defined by:
c(I)
Fcost (I) = , α = {0, 1} (7.10)
B α (maxCost(1−α) )

where c(I) is the sum of the task execution cost and data transmission cost of I,
maxCost is the most expensive solution of the current population and B is the
budget constraint. α is a binary variable and α = 1 if users specify the budget
constraint, otherwise α = 0.
For the budget constrained scheduling, the time-fitness component is designed
to encourage the genetic algorithm to choose individuals with earliest completion
time from the current population. For the deadline constrained scheduling, it
encourages the formation of individuals that satisfy the deadline constraint. The
time fitness function of an individual I is defined by:
t(I)
Ftime (I) = Dβ (maxT ime(1−β) )
, β = {0, 1} (7.11)

where t(I) is the completion time of I, maxTime is the largest completion time
of the current population and D is the deadline constraint. β is a binary variable
and β = 1 if users specify the deadline constraint, otherwise β = 0.
For the deadline constrained scheduling problem, the final fitness function
combines two parts and it is expressed as:

Ftime (I), if Ftime (I) > 1
F (I) = (7.12)
Fcost (I), otherwise
 7 Workflow Scheduling Algorithms for Grid Computing 203

For the budget constrained scheduling problem, the final fitness function com-
bines two parts and it is expressed as:

Fcost (I), if Fcost (I) > 1
F (I) = (7.13)
Ftime (I), otherwise
In order to applying mutation operators in Grid environment, it developed
two types of mutation operations, swapping mutation and replacing mutation.
Swapping mutation aims to change the execution order of tasks in an individual
that compete for a same time slot. It randomly selects a resource and swaps the
positions of two randomly selected tasks on the resource. Replacing mutation re-
allocates an alternative resource to a task in an individual. It randomly selects
a task and replaces its current resource assignment with a resource randomly
selected in the resources which are able to execute the task.

7.4.4 Comparison of QoS Constrained Scheduling Algorithms

The overview of QoS constrained scheduling is presented in Table 7.11 7.12. Com-
paring two heuristics for the deadline constrained problem, the back-tracking
approach is more nave. It is like a constrained based myopic algorithm since it
makes a greedy decision for each ready task without planning in the view of
entire workflow. It is required to track back to the assigned tasks once it finds
the deadline constraint cannot be satisfied by the current assignments. It is re-
stricted to many situations such as data flow and the distribution of execution
time and cost of workflow tasks. It may be required to go through many itera-
tions to modify the assigned schedule in order to satisfy the deadline constraint.
In contrast, the deadline distribution makes a scheduling decision for each task
based on a planned sub-deadline according to the workflow dependencies and
overall deadline. Therefore, it has a better plan while scheduling current tasks
and does not require tracing back the assigned schedule. However, different dead-
line distribution strategies may affect the performance of the schedule produced
from one workflow structure to another.
To date, the LOSS and GAIN approach is the only heuristic that addresses the
budget constrained scheduling problem for Grid workflow applications. It takes
advantage of heuristics designed for a single criteria optimization problem such
as time optimization and cost optimization scheduling problem to solve a multi-
criteria optimization problem. It amends the schedule optimized for one factor to
satisfy the other factor in the way that it can gain maximum benefit or minimum
loss. Even though the original heuristics are targeted at the budget-constrained
scheduling problem, such concept is easy to apply to other constrained schedul-
ing. However, there exist some limitations. It relies on the results generated by
an optimization heuristics for a single objective. Even though time optimization
based heuristics have been developed over two decades, there is a lack of workflow
optimization heuristics for other factors such as monitory cost based on different
workflow application scenarios. In addition, large scheduling computation time
could occur for data-intensive applications due to the weight re-computation for
each pair of task and resource after amending a task assignment.
204 J. Yu, R. Buyya, and K. Ramamohanarao

Table 7.11. Comparison of deadline constrained workflow scheduling algorithms

Algorithm Features

Back-tracking It assigns ready tasks whose parent tasks have been

mapped to the least expensive computing resources
and back-tracks to previous assignment if the cur-
rent aggregative execution time exceeds the dead-
line.
Deadline distribution It distributes the deadline over task partitions in
workflows and optimizes execution cost for each task
partition while meeting their sub-deadlines.
Genetic algorithms It uses genetic algorithms to search a solution which
has minimum execution cost within the deadline.

Table 7.12. Comparison of budget constrained workflow scheduling algorithms

Algorithm Features

LOSS and GAIN It iteratively adjusts a schedule which is generated by

a time optimized heuristic or a cost optimized heuristic
based on its corresponding LOSS or GAIN weight rate
of each task-resource pair, until the total execution cost
meets users’ budget constraint.
Genetic algorithms It uses genetic algorithms to search a solution which has
minimum execution time within the budget.

Unlike best-effort scheduling in which only one single objective (either op-
timizing time or system utilization) is considered, QoS constrained scheduling
needs to consider more factors such as monetary cost and reliability. It needs
to optimize multiple objectives among which some objectives are conflicting.
However, with the increase of the number of factors and objectives required to
be considered, it becomes infeasible to develop a heuristic to solve QoS con-
strained scheduling optimization problems. For this reason, we can believe that
metahueristics based scheduling approach such as genetic algorithms will play
more important role for the multi-objective and multi-constraint based workflow
scheduling.

7.5 Simulation Results

In this section, we show an example of experimental comparisons for workflow
scheduling algorithms. Basically, we compares deadline constrained scheduling
heuristics which are presented in previous section.
 7 Workflow Scheduling Algorithms for Grid Computing 205

7.5.1 Workflow Applications

Given that different workflow applications may have a different impact on the
performance of the scheduling algorithms, a task graph generator is developed to
automatically generate a workflow based on the specified workflow structure, and
the range of task workload and the I/O data. Since the execution requirements
for tasks in scientific workflows are heterogeneous, the service type attribute is
used to represent different types of services. The range of service types in the
workflow can be specified. The width and depth of the workflow can also be
adjusted in order to generate workflow graphs of different sizes.

task

a) balanced-structure application b) unbalanced-structure application

Fig. 7.9. Small portion of workflow applications

According to many Grid workflow projects [11, 35, 55], workflow application
structures can be categorized as either balanced structure or unbalanced structure.
Examples of balanced structure include Neuro-Science application workflows [63]
and EMAN refinement workflows [35], while the examples of unbalanced struc-
ture include protein annotation workflows [40] and Montage workflows [11].
Fig. 7.9 shows two workflow structures, a balanced-structure application and an
unbalanced-structure application, used in our experiments. As shown in Fig. 7.9a,
the balanced-structure application consists of several parallel pipelines, which re-
quire the same types of services but process different data sets. In Fig. 7.9b, the
structure of the unbalanced-structure application is more complex. Unlike the
balanced-structure application, many parallel tasks in the unbalanced structure
require different types of services, and their workload and I/O data varies sig-
nificantly.

7.5.2 Experiment Setting

GridSim [48] is used to simulate a Grid environment for experiments. Fig. 7.10
shows the simulation environment, in which simulated services are discovered by
206 J. Yu, R. Buyya, and K. Ramamohanarao

1. reg
ister
GIS (serv
ice ty
pe)
2.query(type A) Grid
1. r Service
egi
ste
3. service list r (s
erv
ice
Workflow typ
5.slots e)
System
Grid
4. availableSlotQuery(duration) Service

6. makeReservation(task)

Fig. 7.10. Simulation environment

Table 7.13. Service speed and corresponding price for executing a task

Service ID Processing Time(sec) Cost($/sec)

1 1200 300
2 600 600
3 400 900
4 300 1200

Table 7.14. Transmission bandwidth and corresponding price

Bandwidth(Mbps) Cost ($/sec)

100 1
200 2
512 5.12
1024 10.24

querying the GridSim Index Service (GIS). Every service is able to provide free
slot query, and handle reservation request and reservation commitment.
There are 15 types of services with various price rates in the simulated Grid
testbed, each of which was supported by 10 service providers with various pro-
cessing capability. The topology of the system is such that all services are con-
nected to one another, and the available network bandwidths between services
are 100Mbps, 200Mbps, 512Mbps and 1024Mbps.
For the experiments, the cost that a user needs to pay for a workflow execution
comprises of two parts: processing cost and data transmission cost. Table 7.13
shows an example of processing cost, while Table 7.14 shows an example of
data transmission cost. It can be seen that the processing cost and transmission
cost are inversely proportional to the processing time and transmission time
respectively.
In order to evaluate algorithms on a reasonable deadline constraint we also
implemented a time optimization algorithm, HEFT, and a cost optimization
 7 Workflow Scheduling Algorithms for Grid Computing 207

algorithm, Greedy Cost (GC). The HEFT algorithm is a list scheduling algo-
rithm which attempts to schedule DAG tasks at minimum execution time on a
heterogeneous environment. The GC approach is to minimize workflow execu-
tion cost by assigning tasks to services of lowest cost. The deadline used for the
experiments are based on the results of these two algorithms. Let Tmax and Tmin
be the total execution time produced by GC and HEFT respectively. Deadline
D is defined by:

D = Tmin + k(Tmax − Tmin ) (7.14)

The value of k varies between 0 and 10 to evaluate the algorithm performance

from tight constraint to relaxed constraint. As k increases, the constraint is more
relaxed.

7.5.3 Backtracing(BT) vs. Deadline/Time Distribution (TD)

In this section, TD is compared with BackTracking denoted as BT on the two
workflow applications, balanced and unbalanced. In order to show the results
more clearly, we normalize the execution time and cost. Let Cvalue and Tvalue
be the execution time and the monetary cost generated by the algorithms in the
experiments respectively. The execution time is normalized by using Tvalue /D,
and the execution cost by using Cvalue /Cmin , where Cmin is the minimum cost
achieved Greedy Cost. The normalized values of the execution time should be
no greater than one, if the algorithms meet their deadline constraints.
A comparison of the execution time and cost results of the two dead-
line constrained scheduling methods for the balanced-structure application and

Balanced Structure (Execution Time) Unbalanced Structure (Execution Time)

1.05 1.1
TD TD
BT BT
Execution Time/Deadline

Execution Time/Deadline

1 1

0.95 0.9

0.9 0.8

0.85 0.7

0.8 0.6
0 2 4 6 8 10 0 2 4 6 8 10
User Deadline (k) User Deadline (k)

(a) balanced structure (b) unbalanced structure

Fig. 7.11. Execution time for scheduling balanced- and unbalanced-structure

applications
208 J. Yu, R. Buyya, and K. Ramamohanarao

Balanced Structure (Execution Cost) Unbalanced Structure (Execution Cost)

8 7
TD TD

Execution Cost/Cheapest Cost

7 BT 6 BT
Execution Time/Deadline

6 5
5
4
4
3
3

2 2

1 1
0 2 4 6 8 10 0 2 4 6 8 10
User Deadline (k) User Deadline (k)

(a) balanced structure (b) unbalanced structure

Fig. 7.12. Execution cost for scheduling balanced- and unbalanced-structure applica-
tions

Balanced-structure application (Scheduling Overhead) Unbalanced-structure application (Scheduling Overhead)

40 60
TD TD
Normalized Scheduling Time

Normalized Scheduling Time

35 BT BT
50
30
40
25
20 30
15
20
10
10
5
0 0
0 2 4 6 8 10 0 2 4 6 8 10
User Deadline (k) User Deadline (k)

(a) balanced structure (b) unbalanced structure

Fig. 7.13. Scheduling overhead for deadline constrained scheduling

unbalanced-structure application is shown in Fig. 7.11 and Fig. 7.12 respec-

tively. From Fig. 7.11, we can see that TD slightly exceeds deadline at k = 0,
while BT can satisfy deadlines each time. For execution cost required by the
two approaches shown in Fig. 7.12, TD significantly outperforms BT. TD saves
almost 50% execution cost when deadlines are relatively low. However, the two
approaches produce similar results when deadline is greatly relaxed.
Fig. 7.13 shows the comparison of scheduling running time for two approaches.
The scheduling time required by TD is much lower than BT. As the deadline
varies, BT requires more running time when deadlines are relatively tight. For
example, scheduling times at k = 0, 2, 4 are much longer than at k = 6, 8, 10 .
This is because it needs to back-track for more iterations to adjust previous task
assignments in order to meet tight deadlines.
 7 Workflow Scheduling Algorithms for Grid Computing 209

7.5.4 TD vs. Genetic Algorithms

In this section, the deadline constrained genetic algorithm is compared with
the non-GA heuristics (i.e. TD) on the two workflow structures, balanced and
unbalanced workflows.
The genetic algorithm is investigated by starting with two different initial pop-
ulations. One initial population consists of randomly generated solutions, while
the other initial population consists of a solution produced by TD together with
other randomly generated solutions. In the result presentation, the results gener-
ated by GA with a completely random initial population is denoted by GA, while
the results generated by GA which include an initial individual produced by the
TD heuristic are denoted as GA+TD. The parameter settings used as the default
configuration for the proposed genetic algorithm are listed in Table 7.15.
Fig. 7.14 and Fig. 7.15 compare the execution time and cost of using three
scheduling approaches for scheduling the balanced-structure application and
unbalanced-structure application with various deadlines respectively.
We can see that it is hard for both GA and TD to successfully meet the low
deadline individually. As shown in Fig. 7.14a and 7.15a, the normalized execu-
tion times produced by TD and GA exceed 1 at tight deadline (k = 0), and

Table 7.15. Default settings

Parameter Value/Type
Population size 10
Maximum generation 100
Crossover probability 0.9
Reordering mutation probability 0.5
Replacing mutation probability 0.5
Selection scheme elitism-rank selection
Initial individuals randomly generated

Balanced-structure application (Execution Time) Balanced-structure application (Execution Cost)

TD 7 TD
Execution Cost/Cheapest Cost

Deadline GA GA
Execution Time/Deadline

GA+TD GA+TD
4

1
0 2 4 6 8 10 0 2 4 6 8 10
Deadline (k) Deadline (k)

(a) execution time (b) execution cost

Fig. 7.14. Normalized Execution Time and Cost for Scheduling Balanced-structure
Application
210 J. Yu, R. Buyya, and K. Ramamohanarao

Unbalanced-structure application (Execution Time) Unbalanced-structure application (Execution Cost)

1.05
Deadline 8 TD

Execution Cost/Cheapest Cost

1 GA
Execution Time/Deadline

GA+TD
0.95
4
0.9

0.85
2
0.8 TD
GA
0.75 GA+TD
1
0.7
0 2 4 6 8 10 0 2 4 6 8 10
Deadline (k) Deadline (k)

(a) execution time (b) execution cost

Fig. 7.15. Normalized Execution Time and Cost for Scheduling Unbalanced-structure
Application

GA performs worse than TD since its values is higher than TD, especially for
balanced-structure application. However, the results are improved when incor-
porating GA and TD together by putting the solution produced by TD into the
initial population of GA. As shown in Fig. 7.15a, the value of GA+TD is much
lower than that of GA and TD at the tight deadline.
As the deadline increases, both GA and TD can meet the deadline (see
Fig. 7.14a and 7.15a) and GA can outperform TD. For example, execution time
(see Fig. 7.14a) and cost (see Fig. 7.14b) generated by GA at k = 2 are lower
than that of TD. However, as shown in Fig. 7.14b) the performance of GA is re-
duced and TD can perform better, when the deadline becomes very large (k = 8
and 10). In general, GA+TD performs best. This shows that the genetic algo-
rithm can improve the results returned by other simple heuristics by employing
these heuristic results as individuals in its initial population.

7.6 Conclusions
In this chapter, we have presented a survey of workflow scheduling algorithms for
Grid computing. We have categorized current existing Grid workflow schedul-
ing algorithms as either best-effort based scheduling or QoS constraint based
scheduling.
Best-effort scheduling algorithms target on community Grids in which re-
source providers provide free access. Several heuristics and metahueristics based
algorithms which intend to optimize workflow execution times on community
Grids have been presented. The comparison of these algorithms in terms of com-
puting time, applications and resources scenarios has also been examined in
detail. Since service provisioning model of the community Grids is based on best
effort, the quality of service and service availability cannot be guaranteed. There-
fore, we have also discussed several techniques on how to employ the scheduling
algorithms in dynamic Grid environments.
 7 Workflow Scheduling Algorithms for Grid Computing 211

QoS constraint based scheduling algorithms target on utility Grids in which

service level agreements are established between service providers and con-
sumers. In general, users are charged for service access based on the usage and
QoS levels. The objective functions of QoS constraint based scheduling algo-
rithms are determined by QoS requirements of workflow applications. In this
chapter, we have focused on examining scheduling algorithms which intend to
solve performance optimization problems based on two typical QoS constraints,
deadline and budget.

Acknowledgment
We would like to thank Hussein Gibbins and Chee Shin Yeo for their comments
on this paper. This work is partially supported through Australian Research
Council (ARC) Discovery Project grant.

References
1. Almond, J., Snelling, D.: UNICORE: Uniform Access to Supercomputing as an
Element of Electronic Commerce. Future Generation Computer Systems 15, 539–
548 (1999)
2. The Austrian Grid Consortium, http://www.austrangrid.at
3. Bajaj, R., Agrawal, D.P.: Improving Scheduling of Tasks in a Heterogeneous En-
vironment. IEEE Transactions on Parallel and Distributed Systems 15, 107–118
(2004)
4. Berman, F., et al.: New Grid Scheduling and Rescheduling Methods in the GrADS
Project. International Journal of Parallel Programming (IJPP) 33(2-3), 209–229
(2005)
5. Berriman, G.B., et al.: Montage: a Grid Enabled Image Mosaic Service for the
National Virtual Observatory. In: ADASS XIII, ASP Conference Series (2003)
6. Berti, G., et al.: Medical Simulation Services via the Grid. In: HealthGRID 2003
conference, Lyon, France, January 16-17 (2003)
7. Benkner, S., et al.: VGE - A Service-Oriented Grid Environment for On-Demand
Supercomputing. In: The 5th IEEE/ACM International Workshop on Grid Com-
puting (Grid 2004), Pittsburgh, PA, USA (November 2004)
8. Binato, S., et al.: A GRASP for job shop scheduling. In: Essays and surveys on
meta-heuristics, pp. 59–79. Kluwer Academic Publishers, Dordrecht (2001)
9. Blackford, L.S., et al.: ScaLAPACK: a linear algebra library for message-passing
computers. In: The Eighth SLAM Conference on Parallel Processing for Scientific
Computing (Minneapolis, MN, 1997), Philadelphia, PA, USA, p. 15 (1997)
10. Blaha, P., et al.: WIEN2k: An Augmented Plane Wave plus Local Orbitals Program
for Calculating Crystal Properties. Institute of Physical and Theoretical Chemistry,
Vienna University of Technology (2001)
11. Blythe, J., et al.: Task Scheduling Strategies for Workflow-based Applications in
Grids. In: IEEE International Symposium on Cluster Computing and the Grid
(CCGrid 2005) (2005)
12. Braun, T.D., Siegel, H.J., Beck, N.: A Comparison of Eleven static Heuristics for
Mapping a Class of Independent Tasks onto Heterogeneous Distributed Computing
Systems. Journal of Parallel and Distributed Computing 61, 801–837 (2001)
212 J. Yu, R. Buyya, and K. Ramamohanarao

13. Buyya, R., Venugopal, S.: The Gridbus Toolkit for Service Oriented Grid and
Utility Computing: An overview and Status Report. In: The 1st IEEE International
Workshop on Grid Economics and Business Models, GECON 2004, Seoul, Korea,
April 23 (2004)
14. Casanova, H., et al.: Heuristics for Scheduling Parameter Sweep Applications in
Grid Environments. In: The 9th Heterogeneous Computing Workshop (HCW 2000)
(April 2000)
15. Cooper, K., et al.: New Grid Scheduling and Rescheduling Methods in the GrADS
Project. In: NSF Next Generation Software Workshop, International Parallel and
Distributed Processing Symposium, Santa Fe (April 2004)
16. Doǧan, A., Özgüner, F.: Genetic Algorithm Based Scheduling of Meta-Tasks with
Stochastic Execution Times in Heterogeneous Computing Systems. Cluster Com-
puting 7, 177–190 (2004)
17. Deelman, E., et al.: Pegasus: Mapping scientific workflows onto the grid. In: Euro-
pean Across Grids Conference, pp. 11–20 (2004)
18. Fahringer, T., et al.: ASKALON: a tool set for cluster and Grid computing. Con-
currency and Computation: Practice and Experience 17, 143–169 (2005)
19. Feo, T.A., Resende, M.G.C.: Greedy Randomized Adaptive Search Procedures.
Journal of Global Optimization 6, 109–133 (1995)
20. Fitzgerald, S., et al.: A Directory Service for Configuring High-Performance Dis-
tributed Computations. In: The 6th IEEE Symposium on High-Performance Dis-
tributed Computing, Portland State University, Portland, Oregon, August 5-8
(1997)
21. Foster, I., Kesselman, C.: Globus: A Metacomputing Infrastructure Toolkit. Inter-
national Journal of Supercomputer Applications 11(2), 115–128 (1997)
22. Foster, I., Kesselman, C. (eds.): The Grid: Blueprint for a Future Computing In-
frastructure. Morgan Kaufmann Publishers, USA (1999)
23. Foster, I., et al.: Chimera: A Virtual Data System for Representing, Querying and
Automating Data Derivation. In: The 14th Conference on Scientific and Statistical
Database Management, Edinburgh, Scotland (July 2002)
24. Foster, I., et al.: The Physiology of the Grid, Open Grid Service Infrastructure
WG. In: Global Grid Forum (2002)
25. Goldberg, D.E.: Genetic Algorithms in Search, Optimization, and Machine Learn-
ing. Addison-Wesley, Reading (1989)
26. Goldberg, D.E., Deb, K.: A comparative analysis of selection schemes used in
genetic algorithms. Foundations of Genetic Algorithms, 69–93 (1991)
27. Grimshaw, A., Wulf, W.: The Legion vision of a worldwide virtual computer. Com-
munications of the ACM 40(1), 39–45 (1997)
28. He, X., Sun, X., von Laszewski, G.: QoS Guided Min-Min Heuristic for Grid Task
Scheduling. Journal of Computer Science and Technology 18(4), 442–451 (2003)
29. Hillier, F.S., Lieberman, G.J.: Introduction to Operations Research. McGraw-Hill
Science, New York (2005)
30. Hollinsworth, D.: The Workflow Reference Model, Workflow Management Coali-
tion, TC00-1003 (1994)
31. Hoos, H.H., Stützle, T.: Stochastic Local Search: Foundation and Applications.
Elsevier Science and Technology (2004)
32. Hou, E.S.H., Ansari, N., Ren, H.: A Genetic Algorithm for Multiprocessor Schedul-
ing. IEEE Transactions on Parallel and Distributed Systems 5(2), 113–120 (1994)
33. Kwok, Y.K., Ahmad, I.: Static Scheduling Algorithms for Allocating Directed Task
Graphs to Multiprocessors. ACM Computing Surveys 31(4), 406–471 (1999)
 7 Workflow Scheduling Algorithms for Grid Computing 213

34. Ludtke, S., Baldwin, P., Chiu, W.: EMAN: Semiautomated software for high-
resolution single-particle reconstructions. Journal of Structural Biology 128, 82–97
(1999)
35. Mandal, A., et al.: Scheduling Strategies for Mapping Application Workflows onto
the Grid. In: IEEE International Symposium on High Performance Distributed
Computing (HPDC 2005) (2005)
36. Mayer, A., et al.: Workflow Expression: Comparison of Spatial and Temporal Ap-
proaches. In: Workflow in Grid Systems Workshop, GGF-10, Berlin, March 9 (2004)
37. Menascè, D.A., Casalicchio, E.: A Framework for Resource Allocation in Grid
Computing. In: The 12th Annual International Symposium on Modeling, Analysis,
and Simulation of Computer and Telecommunications Systems (MASCOTS 2004),
Volendam, The Netherlands, October 5-7 (2004)
38. Metropolis, N., et al.: Equations of state calculations by fast computing machines.
Joural of Chemistry and Physics 21, 1087–1091 (1953)
39. Maheswaran, M., et al.: Dynamic Matching and Scheduling of a Class of Indepen-
dent Tasks onto Heterogeneous Computing Systems. In: The 8th Heterogeneous
Computing Workshop (HCW 1999), San Juan, Puerto Rico, April 12 (1999)
40. O’Brien, A., Newhouse, S., Darlington, J.: Mapping of Scientific Workflow within
the e-Protein project to Distributed Resources, UK e-Science All Hands Meeting,
Nottingham, UK (2004)
41. Obitko, M.: Introduction to Genetic Algorithms (March 2006),
http://cs.felk.cvut.cz/∼ xobitko/ga/
42. Prodan, R., Fahringer, T.: Dynamic Scheduling of Scientific Workflow Applications
on the Grid using a Modular Optimisation Tool: A Case Study. In: The 20th Sym-
posium of Applied Computing (SAC 2005), Santa Fe, New Mexico, USA, March
2005. ACM Press, New York (2005)
43. Rutschmann, P., Theiner, D.: An inverse modelling approach for the estimation of
hydrological model parameters. Journal of Hydroinformatics (2005)
44. Sakellariou, R., Zhao, H.: A Low-Cost Rescheduling Policy for Efficient Mapping
of Workflows on Grid Systems. Scientific Programming 12(4), 253–262 (2004)
45. Sakellariou, R., Zhao, H.: A Hybrid Heuristic for DAG Scheduling on Heteroge-
neous Systems. In: The 13th Heterogeneous Computing Workshop (HCW 2004),
Santa Fe, New, Mexico, USA, April 26 (2004)
46. Shi, Z., Dongarra, J.J.: Scheduling workflow applications on processors with dif-
ferent capabilities. Future Generation Computer Systems 22, 665–675 (2006)
47. Spooner, D.P., et al.: Performance-aware Workflow Management for Grid Com-
puting. The Computer Journal (2004)
48. Sulistio, A., Buyya, R.: A Grid Simulation Infrastructure Supporting Advance
Reservation. In: The 16th International Conference on Parallel and Distributed
Computing and Systems (PDCS 2004), November 9-11. MIT, Cambridge (2004)
49. Tannenbaum, T., et al.: Condor - A Distributed Job Scheduler. In: Computing
with Linux. MIT Press, Cambridge (2002)
50. Thickins, G.: Utility Computing: The Next New IT Model. Darwin Magazine (April
2003)
51. Topcuoglu, H., Hariri, S., Wu, M.Y.: Performance-Effective and Low-Complexity
Task Scheduling for Heterogeneous Computing. IEEE Transactions on Parallel and
Distributed Systems 13(3), 260–274 (2002)
52. Tsiakkouri, E., et al.: Scheduling Workflows with Budget Constraints. In: Gor-
latch, S., Danelutto, M. (eds.) The CoreGRID Workshop on Integrated research
in Grid Computing, Technical Report TR-05-22, University of Pisa, Dipartimento
Di Informatica, Pisa, Italy, November 28-30, pp. 347–357 (2005)
214 J. Yu, R. Buyya, and K. Ramamohanarao

53. Ullman, J.D.: NP-complete Scheduling Problems. Journal of Computer and System
Sciences 10, 384–393 (1975)
54. Wang, L., et al.: Task Mapping and Scheduling in Heterogeneous Computing En-
vironments Using a Genetic-Algorithm-Based Approach. Journal of Parallel and
Distributed Computing 47, 8–22 (1997)
55. Wieczorek, M., Prodan, R., Fahringer, T.: Scheduling of Scientific Workflows in
the ASKALON Grid Enviornment. ACM SIGMOD Record 34(3), 56–62 (2005)
56. Wu, A.S., et al.: An Incremental Genetic Algorithm Approach to Multiprocessor
Scheduling. IEEE Transactions on Parallel and Distributed Systems 15(9), 824–834
(2004)
57. YarKhan, A., Dongarra, J.J.: Experiments with Scheduling Using Simulated An-
nealing in a Grid Environment. In: Parashar, M. (ed.) GRID 2002. LNCS, vol. 2536.
Springer, Heidelberg (2002)
58. Young, L., et al.: Scheduling Architecture and Algorithms within the ICENI Grid
Middleware. In: UK e-Science All Hands Meeting, pp. 5–12. IOP Publishing Ltd.,
Bristol, UK, Nottingham, UK (2003)
59. Yu, J., Buyya, R.: A Taxonomy of Workflow Management Systems for Grid Com-
puting. Journal of Grid Computing 3(3-4), 171–200 (2005)
60. Yu, J., Buyya, R., Tham, C.K.: A Cost-based Scheduling of Scientific Workflow
Applications on Utility Grids. In: The first IEEE International Conference on e-
Science and Grid Computing, Melbourne, Australia, December 5-8 (2005)
61. Yu, J., Buyya, R.: Scheduling Scientific Workflow Applications with Deadline and
Budget Constraints using Genetic Algorithms. Scientific Programming 14(3-4),
217–230 (2006)
62. Zhao, H., Sakellariou, R.: An experimental investigation into the rank function
of the heterogeneous earliest finish time shceulding algorithm. In: Kosch, H.,
Böszörményi, L., Hellwagner, H. (eds.) Euro-Par 2003. LNCS, vol. 2790, pp. 189–
194. Springer, Heidelberg (2003)
63. Zhao, Y., et al.: Grid Middleware Services for Virtual Data Discovery, Composition,
and Integration. In: The Second Workshop on Middleware for Grid Computing,
Toronto, Ontario, Canada (2004)
64. Zomaya, A.Y., Ward, C., Macey, B.: Genetic Scheduling for Parallel Processor Sys-
tems: Comparative Studies and Performance Issues. IEEE Transactions on Parallel
and Distributed Systems 10(8), 795–812 (1999)
65. Zomaya, A.Y., Teh, Y.H.: Observations on Using Genetic Algorithms for Dynamic
Load-Balancing. IEEE Transactions on Parallel and Distributed Systems 12(9),
899–911 (2001)

View publication stats