Efficient application scheduling is critical for achieving high performance in

heterogeneous computing environments. There are different scheduling

algorithms some of them we will study are as follows

Task Scheduling problem: A scheduling system model consist of an

application, a target computing environment, and a performance criteria for
scheduling. An application is represented by a directed acyclic graph G =(V,E)
where V is the set of v tasks. E is the set of e edges between the tasks. Each
edge (i, j) E, represents the precedence constraint that the task n i should
complete before the execution of nj. Data is a v*v matrix of computation data
where data i, k is the amount of data required to be transmitted from task i to taskk
In a given task graph, a node(task) without any parent is called entry task and
similarly a node without any child is called exit task. We assume that target
computing environment consist of a set Q of q heterogeneous processors
connected in a fully connected topology in which each processor can
communicate with each other. It is also assumed that computation can be
overlapped with communication. Tasks are assumed to be non-preemptive. W is
a v x q computation cost matrix in which each w i, j gives the estimated
execution time to complete task ni on processor pj. Before scheduling the tasks
are labled with the average execution costs. The average execution cost of a task
ni is defined as

The data transfer rates between processors are stored in a matrix B of size q x q.
The communication starts up costs of processors are given in a q-dimensional
vector L. The communication cost of the edge (i, k) which is for transferring
data from task ni(scheduled on processor pm) to taskk (scheduled on processor pn)
is defined by

When both ni and nk scheduled on same processor ci,k becomes 0. Since we

assume that intraprocessor communication cost is negligible, when it is
compared with the interprocessor communication cost. Before scheduling,
average communication costs are used to label the edges. The average
communication cost of an edge (i,k) is defined by
Where is the average transfer rate among the processors and is the average
communication startup time.
EST (ni, pj) and EFT (ni, pj) are the earliest execution start time and earliest
execution finish time of task ni on processor pj. For the entry task nentry

For the other tasks in the graph, the EST and EFT values are computed
recursively , starting from the entry task as shown in following equations. In
order to compute the EFT of a task ni, all immediate predecessor tasks of ni
must have been scheduled.

Many scheduling algorithms have been designed for grid environments, to solve
the problem of mapping a set of tasks to a set of machines (scheduling). Many
heuristics have been proposed to obtain semi-optimal match. Existing
scheduling heuristics can be divided into two categories: on-line mode and
batch-mode.
In the on-line mode, a task is mapped to a machine as soon as it arrives at the
scheduler. Some instances of this category are as follows:
In all following heuristics, m denotes number of machines.
MET (Minimum Execution Time): MET assigns each task to the resource that
performs it in the least amount of execution time, no matter whether this
resource is available or not at that time. This heuristic can cause a severe load
imbalance across the resources. However, this is one of the heuristics that is
implemented in SmartNet.
MCT (Minimum Completion Time): MCT assigns each task to the resource
which obtains earliest completion time for that task. This causes some tasks to
be assigned to resources that do not have minimum execution time for them.
This heuristic is also implemented in SmartNet. It takes O(m) time to map a
given task to expected resource, too.
In the batch-mode heuristics, tasks are collected into a set called meta-task
(MT). These sets are mapped at prescheduled times called mapping events.
Some instances of this category are as follows:
Min-Min: Min-Min begins with the set MT of all unassigned tasks. It has two
phases. In the first phase, the set of minimum expected completion time (such
that task has the earliest expected completion time on the corresponding
machine) for each task in MT is found. In the second phase, the task with the
overall minimum expected completion time from MT is chosen and assigned
to the corresponding resource. Then this task is removed from MT and the
process is repeated until all tasks in the MT are mapped. This heuristic takes O
(s2m) time.
Max-Min: Max-Min is very similar to Min-Min, except in phase 2. Max-Min
assigns task with maximum expected completion time to the corresponding
resource, in phase 2. So, it takes O(s2m) time, too.
Reviewing Min-Min and Max-Min heuristics, it can be seen that depending on
the length of unassigned tasks in MT (metatask), one of these heuristics has
better results than the other one. For example, if there is only one long task and
too many short tasks, Max-Min will execute long task first and allows short
tasks to be executed concurrently with the long task, resulting better make-span
and even better resource utilization rate and load balancing level, compared to
Min-Min that executes all short tasks first and then executes the long task.
Table 1 gives a sample in which Max-Min outperforms Min-Min. It shows
expected execution time of four tasks (t1, t2, t3, t4) on two machines (m1, m2). The
machines are assumed to be idle at the start.
As you see in Figure 1, Min-Min gives a makespan of 39, but in Figure 2, Max-
Min gives a makespan of 30. Also, in Max-Min, two machines had been
working throughout this assignment, but in the Min-Min, the machine 0 m that
obtains better completion time is busy all the time but 1 m is free. So here, Max-
Min has better makespan and load balancing level than Min-Min.