2011 International Joint Conference of IEEE TrustCom-11/IEEE ICESS-11/FCST-11
A Global Scheduling Algorithm Based on Dynamic Critical Path
Xing Gu, Qun Yang, De-chang Pi, He-yang Ke
College of Computer Science and Technology, Nanjing University of Aeronautics and Astronautics
Nanjing, China
E-mail: guxing94@yahoo.cn
Abstract—Task scheduling algorithm, with which the tasks
with precedence constraints are assigned to the proper
processor, is vital for obtaining high performance in
multiprocessors system. In this paper, we firstly analyzed three
typical table-based algorithms, i.e. MCP algorithm, ETF
algorithm and BDCP algorithm. It is showed these algorithms
cannot guarantee that the critical tasks have the priority to
schedule firstly. To solve this problem, we proposed a new
global scheduling algorithm that based on dynamic critical
path (GDCP). In GDCP algorithm, tasks on the critical path
have the priority to be scheduled firstly in each scheduling
step, and a global search strategy will be applied to select a
suitable processor to execute each task, thus reduces the
schedule length. The result of experiments shows that the
proposed algorithm is better than other algorithms.
Keywords- scheduling algorithm; dynamic critical path;
global select strategy; schedule length
I. INTRODUCTION
The objective of task scheduling is to reasonably assign
related tasks to a multiprocessor system in order to obtain
the minimum schedule length, which is an important issue
of parallel computing. An efficient task scheduling method
can achieve a high performance in a system. It is well
known, however, that multiprocessor scheduling for most
precedence-constrained task graphs is an NP-complete
problem in its general form [5]. Therefore, task scheduling
has been extensively studied, and various heuristics have
been proposed in the literature [1][6][7][8][9]. In compile-
time scheduling, these heuristics are classified into a variety
of categories, such as list scheduling, task duplication and
clustering.
A scheduling algorithm needs to address a number of
issues. It should take task into account granularity, arbitrary
computation and communication costs. What’s more, in
order to be practical use, it should have low complexity and
be economical. List scheduling [2][3][4] is generally
accepted as an attractive approach since it combines low
complexity with good results. In this paper, we propose a
new static scheduling algorithm, which is called GDCP
(global scheduling algorithm based on dynamic critical
path). It schedules arbitrary precedence-constrained task
graphs to a multiprocessor system with unlimited number of
fully-connected identical processors. The GDCP algorithm
overcomes the drawbacks of past approaches and obtains a
better performance.
The remainder of this paper is organized as follows. In
the next section, we define the task scheduling problem, and
describe three typical scheduling algorithms. Our GDCP
978-0-7695-4600-1/11 $26.00 © 2011 IEEE
DOI 10.1109/TrustCom.2011.183
algorithm is proposed in Section 3. In Section 4, we use an
example to illustrate these algorithms and give experimental
results. Section 5 provides the concluding remarks.
II. BACKGROUND
A. Task Scheduling Problem
A scheduling problem consists of an application, a target
computing environment, and performance criteria for
scheduling.
A parallel program is represented as a directed acyclic
graph G=(V,E), where V is the set of nodes and E is the set
of edges. A node in the graph represents a task which is a
set of instructions that can be executed on any of the
available processors. The weight of node vi denoted by wi is
its computation cost. The edges between the nodes represent
the dependency between the tasks. Between two nodes
vi,vjęV, edge eijęE denotes the precedence constraint such
that task vj should not start its execution until task vi
completes its execution. The weight of edge eij denoted by
cij represents the communication cost. The source node and
the destination node of an edge are called the parent node
and the child node respectively. In a task graph, a node with
no parent node is called an entry node, and a node with no
child node is called an exit task. A node which obtains all of
the messages from its parent nodes and waits for scheduling
to a processor is called a ready node.
A critical path (CP) of a task graph is a path formed by a
set of nodes and edges, from an entry node to an exit node,
of which the sum of computation costs and communication
costs is maximum quantity.
The target system is a multiprocessor system with
unlimited number of fully connected identical processors.
The different processors transmit data by the messaging
way, and all of the processors can execute tasks and
communicate with others at a time. Usually we assume that
all inter-processor communications are performed without
contention and the communication overhead between two
tasks scheduled onto the same processor is taken as zero.
B. Related Work
It is well known, most of the reported scheduling
algorithms are based on the approach of list scheduling. The
basic idea of list scheduling is to assign priorities to tasks of
the graph and place the tasks in an ordered list by the
priorities, and then schedule a node of the list to a processor.
The following steps are repeatedly carried out until all of
nodes have been scheduled to the multiprocessor system.
1) Select the node with the highest priority from the
scheduling list;
1335
 2) According to a certain method, select a suitable
processor and distribute the designate node to it.
In the following, we present some of the well-known
list-base scheduling algorithms and analyze advantages and
shortcomings of them.
Modified Critical Path (MCP) [3]: the algorithm
determines node priorities by assigning an attribute called
as-late-as-possible (ALAP) to all nodes. The algorithm first
computes all the latest possible start times for all nodes.
Then, it constructs a schedule list arranged in ascending
order of the latest possible start time. As for the nodes
which have the same latest possible start times, the
algorithm orders them by the value of their child node. At
each step, the MCP algorithm removes the first node from
the list and schedules it to a processor that allows for the
earliest start time. The complexity of the MCP algorithm is
shown to be O(v2logv). The main problem with MCP
algorithm is that static priority may not always order the
nodes for scheduling according to their relative importance.
What is more, the nodes which have smaller latest possible
start times may not on the CP. In other words, the MCP
algorithm does not assign node priorities accurately and thus
may result in a bad effect of schedule performance.
Earliest Time First (ETF) [2]: As opposed to the MCP
algorithm, ETF determines priorities of nodes dynamically.
It selects a node for scheduling based on an attribute called
the earliest start time. At each step, the algorithm computes
the earliest start time of all ready nodes, and schedules the
one with the minimum value to the processor where it can
start in the earliest time. When there are two nodes with the
same value of the earliest start time, the ETF algorithm
selects the node with a higher static level attribute. The
complexity of the ETF algorithm is shown to be O(pv2). The
major drawback of ETF algorithm is that it may not be able
to reduce the partial schedule length at each step. This is
because the node with the earliest start time may not
necessarily on the critical path. Schedule such nodes in
advance may influence the start time of the CP node so that
the schedule length of the tasks graph cannot shorten
effectively.
Balanced Dynamic Critical Path (BDCP) [4]: it
assigns nodes of a task graph to priorities with the value of
their earliest possible start times (EPST). At each step, the
algorithm dynamically chooses a node which has the
smallest value of EPST as the scheduling node, and
schedules the node to a processor which enables the current
schedule length of the graph to be smallest. The complexity
of BDCP algorithm is O(v2). Although the algorithm
overcomes the disadvantages of past static scheduling
algorithms, the value of EPST cannot reflect the importance
of nodes correctly, and the nodes on the CP still cannot be
scheduled in advance so that it would affect the final
schedule length of the task graph.
III. THE PROPOSED ALGORITHM
This section presents the proposed algorithm called a
global scheduling algorithm based on dynamic critical path,
which aims at achieving high performance and low
complexity. The proposed algorithm assigns dynamic
1336
proper priorities to the nodes at each step based on the
dynamic critical path, and distributes the node with the
highest priority to a processor which is selected by a global
search strategy. The method guarantees relatively important
nodes could be preferentially scheduled to an adequate
processor, thereby the schedule length is shorten effectively.
A. Some Scheduling Attributes
Before presenting the objective function, it is necessary
to define some attributes which are derived from a given
partial schedule.
epst(vi): the epst(vi) is the earliest possible start time of
node vi, which is recursively defined as follows:
­°0, if it is a entry node
epst (vi ) = ® (1)
°̄vj∈max {epst (vj ) + wj + cji}, otherwise
pred ( vi )
where pred(vi) corresponds the set of immediate
predecessors of node vi, wj is the weight of node vj, and cji is
the communication cost of edge eji transferring data from
node vj to task vi. When both vj and vi are scheduled on the
same processor, cji becomes zero, since we assume that the
intra-processor communication cost is negligible when it is
compared with the inter-processor communication cost.
After the earliest possible start times of all tasks in a
graph are obtained, the schedule length of partially
scheduled graph will be the max finish time of all tasks, thus
the current schedule length (csl) which is also called
makespan is calculated by:
csl = max {epst (vi ) + wi} (2)
vi∈exit ( G )
where exit(G) represents the set of tasks in the scheduled
graph. The value of csl is useful because the objective of
scheduling algorithm is to reduce the schedule length step
by step and have a shortest schedule length ultimately.
In addition, the latest start time of a node vi, when the
node have to start its execution without increasing the
schedule length of the task graph, denoted by lpst(vi), is
recursively defined as follows:
­°csl − wi, if it is a eixt node
lpst(vi) = ® (3)
°̄vj∈min {lpst (vj ) − cij − wi}, otherwise
succ ( vi )
where succ(vi) is the set of immediate successors of
node vi, wi and cij represent the weight of node vi and edge
eij respectively.
B. Task Priority
The CP of a task graph is the path with the maximum
cost, and potentially determines the schedule length of the
scheduled task graph. Thus, the nodes on the CP have the
priority to be scheduled than other nodes. However, the CP
can change dynamically as the scheduling proceeds. The CP
at an intermediate scheduling step is called the dynamic
critical path. Thereby, the issue how to assign proper
priorities to all nodes of the schedule graph especially the
nodes on the dynamic critical path plays an important role in
scheduling algorithm.
 According to the critical path algorithm in graph theory D. The Proposed GDCP Algorithm
[10], it is known that if epst(vi) is equal to lpst(vi), node vi The pseudo-code of the proposed algorithm is shown in
must be a critical node, namely, node vi is on the CP. Thus, Algorithm 1. The GDCP algorithm has a time complexity of
in our algorithm we first assign a node whose epst and lpst O(n2) where n is the number of tasks.
are equal higher priorities than other nodes. And then, for
the nodes which have the same priority, the smaller epst is,
the higher priorities it has. Tasks are ordered by the
decreasing order of their priorities ultimately. Therefore, the
most important nodes which are on the CP can be taken into
account preferentially at each scheduling step with the result
that reduces the final schedule length effectively.
C. Processor Selection
After choosing a scheduling node, we need a method to
select a suitable processor for scheduling that node. As can
be noticed, the classic scheduling algorithm selects the
processor allowing the minimum start time for a node. This
method probably gives a locally optimized result. However,
it usually gives bad results in the case of great
communication cost. For example, figure 1(a) shows a task
graph; figure 1(b) gives the schedule result with the above-
mentioned processor selection method which selects a
processor provided the earliest start time of each node, and
then the schedule length is 4. But figure 1(c) shows that
when schedule all nodes to the same processor, the schedule
length is 3 at last.
Algorithm 1. The pseudo-code for the proposed algorithm

E. An Example

Figure 1. Example of a task graph and two different schedule case

We adopt a global search strategy that is to say use csl

which is defined in (2) as criterion to select a processor. By
using this method, it could ensure that all nodes in a graph
are fully taken into account and the scheduling length can be
reduced gradually at each step. First try to assign a
processor PE to place a node v and compute the start time of
node v when it starts execution, then replace the epst of
Figure 2. (a)A parallel Gaussian elimination task graph;(b)The schedule
node v with the start time briefly. After that, calculate the of the task graph generated by the GDCP algorithm
value of csl according to formula (2). Try to distribute node
v to all the available processors and then select the As an illustration, consider the task graph which is a
processor where the csl of the scheduling graph is shortest. macro data-flow graph and represents the parallel Gaussian
If there is more than one such processor, we choose the elimination algorithm written in an SPWD style [4] shown
processor that provides the minimum start execution time in Figure 2(a). The values of numbers inside nodes and
for the child node of node v that has smallest difference edges represent computation cost of nodes and
between the epst and lpst. communication cost between two nodes respectively in the
task graph, and the edges in the CP in this graph are shown
with thick arrow.

1337
 The schedule generated by the GDCP algorithm is
shown in Figure 2(b). The GDCP algorithm schedules the
task graph in the order: v1, v3, v7, v4, v9, v12, v5, v10, v14,
v16, v6, v11, v15, v17, v18, v2, v8, v13, and the schedule
length is 450 time units. At first step, only node v1 has
equal values of epst and lpst in all ready nodes and so it is
selected for scheduling to the processor PE0 which enable
the current schedule length of task graph shorten. After
scheduling several nodes: v1, v3, v7, v4, v9, v12, the ready
node on the CP is the only one v5 and then schedule it to the
processor PE1 where the current schedule length could be
reduced. Finally, there are remaining nodes: v2, v8, v13
which have lower priorities. Sort them by the value of epst
and schedule them to a processor in sequence. Eventually,
the schedule of the task graph is generated by the proposed
algorithm.
IV. PERFORMANCE EVALUATION
Random graphs are generally used to compare
scheduling algorithms. We implement a graph generator
based on the method according to the paper [5]. A random
DAG is described as follows: the computation cost of each
node in the graph is randomly selected from a uniform
distribution with the mean equal to 40. Beginning with first
node, a random number indicating the number of children is
chosen from a uniform distribution with the mean equal to
v/10. The communication cost of each edge is also
randomly selected from a uniform distribution with mean
equal to 40 times the specified value of CCR
(communication-to-computation-ratio). We generate a batch
of random task graphs consisting of subsets of graphs in
which the number of nodes vary from 20 to 160 with
increments of 20, and each subset consists of graphs with
different CCRs (0.1, 0.2 1.0, 5.0 and 10.0). At last, we use
normalized schedule length (NSL) [5] to compare these
scheduling algorithms.
Figure 3 shows the results of different scheduling
algorithms in above-mentioned test environment. In figure
3(a), it is known that the larger the value of CCR is, the
better result the proposed algorithm obtains. And as can be
observed from figure 3(b), the NSLs of all algorithms have a
slightly increasing trend along with the increase of the
number of nodes. But the GDCP algorithm has a better
performance than others in each condition.
Figure 3. (a)The average NSLs of algorithms with different CCR;(b) The
average NSLs of algorithms with different number of nodes
1338
V. CONCLUSIONS
After analyzing several typical list scheduling
algorithms, the paper presents a global scheduling algorithm
based on dynamic critical path. The algorithm generally
schedules the nodes on the CP preferentially, and reduces
schedule length of task graph as far as possible at each
scheduling step so that obtains the shortest final schedule
length. The results of experiments shows the proposed
algorithm works well on various random graphs and gets
better performance than others.
ACKNOWLEDGMENT
I really appreciate my tutor Professor Yang, whose help
and patience made this paper get off the ground and come to
a close smoothly.
Last but not least, thanks are given to my roomies, who
have shared with me my worries, frustrations, and hopefully
my ultimate happiness in eventually finishing this paper.
REFERENCES
[1] T Hagras, and J Janecek, “Static vs. Dynamic List-Scheduling
Performance Comparision,” in Acta Polytechnica, vol. 43, January
2003.
[2] JJ Hwang, YC Chow, F, and FD Anger, “Scheduling Precedence
Graphs in Systems with Interprocessor Communication Times,”
SIAM Journal on Computing, vol. 18, pp. 244-257, June 1989
[3] Wang M Y, and Gajski D D, “Hypertool: A Programming Aid for
Message-passing Systems,” IEEE Transactions on Parallel and
Distributed Systems, vol. 1, pp. 330-343, July 1990.
[4] SHI Wei, and ZHENG Wei-Min, “The Balanced Dynamic Critical
Path Scheduling Algorithm of Dependent Task Graphs,” Chinese
Journal of Computers, vol. 24, pp. 991-997, September 2001.
[5] YK Kwok, and Ishfaq Ahmad, “Benchmarking and Comparison of
the Task Graph Scheduling Algorithms,” Parallel and Distributed
Computing, vol. 59, pp. 381-422, December 1999.
[6] Jorge Barbosa, and AP Monteiro, “A List Scheduling Algorithm for
Scheduling Multi-user Jobs on Clusters,” Computer Science, vol.
5336, pp. 123-136, December 2008.
[7] Ishfaq Ahmad, and Yu-Kwong Kwok, “On Exploiting Task
Duplication in Parallel Program Scheduling,” IEEE Transactions on
Parallel and Distributed Systems, vol. 9(9), pp. 872-892, September
1998.
[8] H Topcuoglu, S. Hariri, and M Y Wu, “Performance-Effective and
Low-Complexity Task Scheduling for Heterogeneous Computing,”
IEEE Transactions on Parallel and Distributed Systems, vol. 13(3), pp.
260-274, March 2002.
[9] YK Kwong Kwok, and Ishfaq Ahmad, “Efficient Scheduling of
Arbitrary Task Graphs to Multiprocessors Using a Parallel Genetic
Algorithm,” Parallel and Distributed Computing, vol. 47(1), pp. 58-77,
November 1997.
[10] Mark Allen Weiss, “Data Structures and Algorithm Analysis in C,” in
Post &Telecom Press, 2005.