Abstract

In

this

paper

we

propose

a

parallel

randomized

algorithm

called

Parallel

Fast

Assignment

using

Search

Technique

-LRB-

PFAST

-RRB-

for

scheduling

parallel

programs

represented

by

directed

acyclic

graphs

-LRB-

DAGs

-RRB-

during

compile-time

The

PFAST

algorithm

has

time

complexity

where

e

is

the

number

of

edges

in

the

DAG

This

linear-time

algorithm

works

by

first

generating

an

initial

solution

and

then

refining

it

using

a

parallel

random

search

Using

a

prototype

computer-aided

parallelization

and

scheduling

tool

called

CASCH

the

algorithm

is

found

to

outperform

numerous

previous

algorithms

while

taking

dramatically

smaller

execution

times

The

distinctive

feature

of

this

research

is

that

instead

of

simulations

our

proposed

algorithm

is

evaluated

and

compared

with

other

algorithms

using

the

CASCH

tool

with

real

applications

running

on

the

Intel

Paragon

The

PFAST

algorithm

is

also

evaluated

with

randomly

generated

DAGs

for

which

optimal

schedules

are

known

The

algorithm

generated

optimal

solutions

for

a

majority

of

the

test

cases

and

closeto-optimal

solutions

for

the

others

The

proposed

algorithm

is

the

fastest

scheduling

algorithm

known

to

us

and

is

an

attractive

choice

for

scheduling

under

running

time

constraints

Introduction

To

efficiently

exploit

the

tremendous

potential

of

parallel

architectures

the

tasks

of

a

parallel

program

must

be

carefully

decomposed

and

scheduled

to

the

processors

so

that

the

program

completion

time

is

minimized

When

the

characteristics

of

the

parallel

program

such

as

execution

times

of

the

tasks

amount

of

communication

data

and

task

dependencies

are

known

a

priori

the

parallel

program

can

be

modeled

as

a

node

and

edgeweighted

directed

acyclic

graph

-LRB-

DAG

-RRB-

in

which

V

is

the

set

of

nodes

and

E

the

set

of

edges

representing

tasks

and

messages

respectively

The

weight

associated

with

a

node

represents

the

amount

of

execution

time

of

the

corresponding

task

and

the

weight

associated

with

an

edge

represents

the

amount

of

communication

time

An

example

DAG

is

shown

in

Figure

-LRB-

s

are

the

indices

of

nodes

-RRB-

With

such

a

static

model

the

scheduler

is

invoked

off-line

during

compile-time

and

thus

can

afford

moderate

time

complexity

in

order

to

generate

a

better

schedule

This

form

of

multiprocessor

scheduling

problem

is

called

static

scheduling

or

DAG

scheduling

-LSB-

-RSB-

-LSB-

-RSB-

-LSB-

-RSB-

-LSB-

-RSB-

-LSB-

-RSB-

Static

scheduling

even

with

a

very

simple

model

is

an

NP-complete

problem

-LSB-

-RSB-

-LSB-

-RSB-

For

instance

the

problem

is

NP-complete

even

in

two

models

-LRB-

-RRB-

scheduling

unit-weighted

tasks

to

an

arbitrary

number

of

processors

-LSB-

-RSB-

-LRB-

-RRB-

scheduling

one

or

two

unit-weighted

tasks

to

two

processors

-LSB-

-RSB-

Optimal

solutions

exist

only

in

three

simple

cases

-LRB-

i

-RRB-

scheduling

a

tree-structured

DAG

with

identical

node

weights

to

an

arbitrary

number

of

processors

-LSB-

-RSB-

-LRB-

ii

-RRB-

scheduling

an

arbitrary

DAG

with

identical

node

weights

to

two

processors

-LSB-

-RSB-

and

-LRB-

iii

-RRB-

scheduling

an

interval-ordered

DAG

to

an

arbitrary

number

of

processors

-LSB-

-RSB-

However

even

inthese

cases

no

communication

is

assumed

among

the

tasks

of

the

parallel

program

Thus

heuristic

approaches

are

sought

to

tackle

the

problem

under

more

realistic

cases

in

a

reasonable

amount

of

time

-LSB-

-RSB-

-LSB-

-RSB-

-LSB-

-RSB-

-LSB-

-RSB-

While

it

is

understood

that

static

scheduling

is

done

offline

and

therefore

some

extra

time

can

be

afforded

in

generating

a

better

solution

the

time-complexity

of

a

scheduling

algorithm

is

an

important

issue

from

a

practical

point

of

view

Although

there

are

a

large

number

of

scheduling

heuristics

suggested

in

the

literature

and

many

of

them

can

generate

good

solutions

few

have

a

low

timecomplexity

-LSB-

-RSB-

-LSB-

-RSB-

-LSB-

-RSB-

-LSB-

-RSB-

-LSB-

-RSB-

As

such

most

of

the

algorithms

may

be

inapplicable

for

practical

purposes

In

a

recent

study

-LSB-

-RSB-

we

compared

recently

reported

algorithms

and

made

a

number

of

observations

For

example

we

found

that

an

algorithm

may

take

more

than

an

hour

to

produce

a

schedule

for

a

DAG

with

This

research

was

supported

by

the

Hong

Kong

Research

Grants

Council

under

contract

number

O

e

-LRB-

-RRB-

G

V

E

-LRB-

-RRB-

Throughout

the

paper

we

denote

and

byv

and

e

respectively

V

E

ni

O

-LRB-

-RRB-

A

Parallel

Algorithm

for

Compile-Time

Scheduling

of

Parallel

Programs

on

Multiprocessors

Yu-Kwong

Kwok

and

Ishfaq

Ahmad

Email

-LCB-

csricky

iahmad

-RCB-

@cs

ust.hk

Department

of

Computer

Science

The

Hong

Kong

University

of

Science

and

Technology

Clear

Water

Bay

Hong

Kong

nodes

a

typical

size

for

many

applications

-LSB-

-RSB-

-LSB-

-RSB-

Taking

such

a

large

amount

of

time

to

generate

a

solution

for

an

application

is

a

major

hurdle

in

incorporating

these

algorithms

in

parallelizing

compilers

On

the

other

hand

some

algorithms

have

low

time-complexity

but

their

solution

quality

is

not

satisfactory

-LSB-

-RSB-

Thus

an

algorithm

which

meets

the

conflicting

goals

of

high

performance

and

low

time-complexity

is

highly

desired

In

this

regard

Yang

and

Gerasoulis

-LSB-

-RSB-

proposed

some

novel

techniques

for

reducing

the

time-complexity

of

scheduling

algorithms

Our

objective

is

to

design

an

algorithm

that

has

a

comparable

or

lower

complexity

while

producing

better

solutions

In

this

paper

we

propose

a

low

complexity

scheduling

algorithm

called

Parallel

Fast

Assignment

using

Search

Technique

-LRB-

PFAST

-RRB-

which

has

time-complexity

and

is

a

parallel

algorithm

The

PFAST

algorithm

is

based

on

an

effective

search

technique

The

linear-time

algorithm

first

generates

an

initial

solution

and

thenrefines

it

using

a

random

neighborhood

search

technique

In

addition

to

simulation

studies

the

algorithm

is

evaluated

using

a

prototype

computer-aided

parallelization

and

scheduling

tool

called

CASCH

-LRB-

Computer-Aided

SCHeduling

-RRB-

-LSB-

-RSB-

with

real

applications

running

on

the

Intel

Paragon

The

PFAST

algorithm

outperforms

numerous

previous

algorithms

while

its

execution

times

are

dramatically

smaller

Indeed

based

on

our

experimental

results

the

PFAST

is

the

fastest

scheduling

algorithm

known

to

us

The

algorithm

is

also

evaluated

using

random

task

graphs

for

which

optimal

solutions

are

known

The

PFAST

algorithm

generated

optimal

solutions

for

a

significant

portion

of

the

test

cases

and

close-tooptimal

solutions

for

the

other

cases

Furthermore

the

algorithm

is

scalable

in

that

it

exhibits

an

almost

linear

speedup

The

PFAST

algorithm

is

therefore

an

attractive

choice

for

generating

high

quality

schedules

in

a

parallel

processing

environment

under

running

time

constraints

This

paper

is

organized

as

follows

In

Section

we

first

discuss

the

trade-off

between

more

complexity

and

better

performance

In

the

same

section

we

introduce

the

idea

of

using

neighborhood

search

to

improve

the

scheduling

performance

In

Section

we

describe

the

proposed

PFAST

algorithm

and

its

design

principles

In

Section

we

present

a

detailed

example

to

illustrate

the

functionality

of

the

algorithms

Section

contains

the

performance

results

of

the

PFAST

algorithms

as

well

as

a

comparison

with

other

algorithms

The

final

section

concludes

this

paper

Related

Work

and

Motivation

of

a

New

Approach

Traditional

DAG

scheduling

algorithms

attempt

to

minimize

the

schedule

length

through

local

optimizations

of

the

scheduling

of

individual

nodes

However

most

of

the

local

optimization

strategies

are

not

effective

in

general

in

that

most

algorithms

minimize

the

start-time

of

a

node

at

each

scheduling

step

These

algorithms

differ

only

in

the

way

of

selecting

a

node

for

scheduling

Some

of

them

construct

a

list

of

nodes

before

scheduling

starts

-LRB-

as

in

the

list

scheduling

algorithms

like

the

MCP

algorithm

-LSB-

-RSB-

-RRB-

while

some

of

them

dynamically

select

nodes

for

scheduling

-LRB-

e.g.

the

DLS

algorithm

-LSB-

-RSB-

-RRB-

However

in

an

optimal

schedule

some

nodes

may

have

to

start

later

than

the

earliest

possible

time

Thus

like

most

algorithms

of

a

greedy

nature

these

scheduling

algorithms

can

not

avoid

making

a

local

decision

which

may

lead

to

a

sub-optimal

schedule

As

backtracking

is

not

employed

in

order

not

to

incur

high

complexity

a

mistake

made

in

an

earlier

step

may

not

be

remedied

in

later

steps

To

obtain

an

optimal

schedule

we

have

to

tackle

the

scheduling

problem

from

a

global

perspective

However

global

information

is

usually

obtained

at

the

expense

of

high

time-complexity

To

obtain

such

global

information

we

can

use

the

characteristics

of

the

task

graph

such

as

the

graph

structure

and

the

relative

magnitudes

ofthe

node

and

edge

weights

Using

such

attributes

we

can

decide

from

a

global

point

of

view

which

nodes

in

the

task

graph

deserve

special

attention

so

that

eventually

an

optimal

schedule

can

be

constructed

For

instance

some

previously

reported

scheduling

algorithms

is

based

on

a

global

characteristic

structure

of

the

task

graph

namely

the

critical

path

-LRB-

CP

-RRB-

A

CP

is

a

path

with

the

maximum

sum

of

node

and

edge

O

e

v

-LRB-

-RRB-

Figure

A

simple

DAG

weights

or

simply

the

maximum

length

Thus

if

an

unlimited

number

of

processors

are

available

the

length

of

the

CP

provides

an

upper

bound

on

the

schedule

length

In

light

of

this

attractive

property

most

scheduling

algorithms

assign

higher

priorities

to

nodes

of

the

CP

for

scheduling

For

example

in

most

list

scheduling

algorithms

a

node

on

the

CP

occupies

an

earlier

position

in

the

scheduling

list

However

while

the

CP

length

provides

an

upper

bound

on

the

schedule

length

making

all

the

nodes

on

the

CP

start

at

the

earliest

possible

time

does

not

guarantee

an

optimal

schedule

In

fact

if

the

edge

weights

are

much

larger

than

the

node

weights

in

general

such

a

strategy

can

even

lead

to

a

bad

schedule

-LSB-

-RSB-

To

meet

the

conflicting

goals

of

high

performance

and

high

efficiency

we

employ

an

effective

optimization

technique?neighborhood

search

-LSB-

-RSB-

In

simple

terms

in

a

neighborhood

search

algorithm

an

initial

solution

with

moderate

quality

is

quickly

generated

Then

according

to

some

pre-defined

neighborhood

the

algorithm

probabilistically

selects

and

tests

whether

a

near-by

solution

in

the

search

space

is

better

or

not

If

it

is

better

adopt

it

and

start

searching

in

the

new

neighborhood

otherwise

select

another

solution

point

Usually

the

algorithm

stops

after

a

specified

number

of

search

steps

has

elapsed

or

the

solution

does

not

improve

after

a

fixed

number

of

steps

The

success

of

such

neighborhood

search

techniques

chiefly

relies

on

the

construction

of

thesolution

neighborhood

A

judiciously

constructed

neighborhood

can

potentially

lead

the

search

to

attain

the

global

optimal

solution

The

Proposed

Algorithm

In

this

section

we

present

the

proposed

PFAST

algorithm

and

its

design

principles

To

facilitate

understanding

of

the

neighborhood

search

technique

we

first

restrict

the

discussion

to

the

sequential

version

of

the

PFAST

algorithm

which

is

referred

to

as

simply

the

FAST

algorithm

We

then

describe

the

parallelization

technique

leading

to

the

PFAST

algorithm

A

detailed

scheduling

example

will

be

presented

in

Section

A

Solution

Neighborhood

Formulation

Neighborhood

search

is

an

old

but

effective

optimization

technique

The

principle

of

neighborhood

search

is

to

refine

a

given

initial

solution

point

in

the

solution

space

by

searching

through

the

neighborhood

of

the

initial

solution

point

To

apply

the

neighborhood

search

technique

to

the

DAG

scheduling

problem

we

have

to

define

a

neighborhood

of

the

initial

solution

point

-LRB-

i.e.

the

initial

schedule

-RRB-

We

can

arrive

at

such

a

neighborhood

definition

by

using

the

observation

discussed

below

A

simple

neighborhood

point

of

a

schedule

in

the

solution

space

can

be

defined

as

another

schedule

which

is

obtained

by

transferring

anode

from

aprocessor

to

another

processor

In

the

DAG

scheduling

problem

one

method

of

improving

the

schedule

length

is

to

transfer

a

blockingnode

from

one

processor

to

another

The

notion

of

blocking

is

simple?a

node

is

called

blocking

if

removing

it

from

its

original

processor

can

make

the

succeeding

nodes

start

earlier

In

particular

we

are

interested

in

transferring

the

nodes

that

block

the

CPNs

-LRB-

CP

nodes

-RRB-

because

the

CPNs

are

the

more

important

nodes

However

high

complexity

will

result

if

we

attempt

to

locate

the

actual

blocking-nodes

on

all

the

processors

Thus

in

our

approach

we

only

generate

a

list

of

potential

blockingnodes

which

are

the

nodes

that

may

block

the

CPNs

Again

to

maintain

a

low

complexity

the

blocking-nodes

list

is

static

and

is

constructed

before

the

search

process

starts

A

natural

choice

of

blocking-nodes

list

is

the

set

of

IBNs

and

OBNs

-LRB-

with

respect

to

an

initial

CP

-RRB-

because

these

nodes

have

the

potential

to

block

the

CPNs

in

the

processors

In

the

schedule

refinement

phase

the

blocking-nodes

list

defines

the

neighborhood

that

the

random

search

process

will

explore

The

size

of

such

a

neighborhood

is

because

there

are

blockingnodes

and

p

processors

Scheduling

Serially

To

generate

an

initial

schedule

we

employ

the

traditional

list

scheduling

approach?construct

a

list

and

schedule

the

nodes

on

the

list

one

by

one

to

the

processors

The

list

is

constructed

by

ordering

the

nodes

according

to

the

node

priorities

The

list

is

static

so

that

the

order

of

nodes

on

the

list

will

not

change

during

the

scheduling

process

The

reason

is

that

as

the

objective

of

our

algorithm

is

to

produce

a

good

schedule

in

time

we

do

not

re-compute

the

node

priorities

after

each

scheduling

step

while

generating

the

initial

schedule

Certainly

if

the

schedule

length

of

the

initial

schedule

is

optimized

the

subsequent

random

search

process

can

start

at

a

better

solution

point

and

thereby

generate

a

better

final

schedule

In

the

FAST

algorithm

we

use

the

CPN-Dominant

List

as

the

scheduling

list

The

CPN-Dominant

List

can

be

constructed

in

time

since

each

edge

is

visited

only

once

Construction

of

the

CPN-Dominant

list

-LRB-

-RRB-

Initially

the

list

is

empty

Make

the

entry

CPN

be

the

first

node

in

the

list

Set

Position

to

An

IBN

-LRB-

In-Branch

Node

-RRB-

is

an

ancestor

of

a

CPN

but

is

not

a

CPN

in

itself

An

OBN

-LRB-

Out-Branch

Node

-RRB-

is

a

node

which

is

neither

a

CPN

nor

an

IBN

O

vp

-LRB-

-RRB-

O

v

-LRB-

-RRB-

O

e

v

-LRB-

-RRB-

O

e

v

-LRB-

-RRB-

Let

be

the

next

CPN

Repeat

-LRB-

-RRB-

If

has

all

its

parent

nodes

in

the

list

then

-LRB-

-RRB-

Put

at

Position

in

the

list

and

increment

Position

-LRB-

-RRB-

else

-LRB-

-RRB-

Let

be

the

parent

node

of

which

is

not

in

the

sequence

and

has

the

largest

blevel

Ties

are

broken

by

choosing

the

parent

with

a

smaller

t-level

If

has

all

its

parent

nodes

in

the

sequence

put

at

Position

in

the

sequence

and

increment

Position

Otherwise

recursively

include

all

the

ancestor

nodes

of

in

the

sequence

so

that

the

nodes

with

a

larger

value

of

b-level

are

considered

first

-LRB-

-RRB-

Repeat

the

above

step

until

all

the

parent

nodes

of

are

in

the

list

Then

put

at

Position

in

the

list

-LRB-

-RRB-

endif

-LRB-

-RRB-

Make

to

be

the

next

CPN

Until

all

the

CPNs

are

in

the

list

-LRB-

-RRB-

Append

all

the

OBNs

to

the

sequence

in

a

decreasing

order

of

b-level

Using

the

CPN-Dominant

List

we

can

schedule

the

nodes

on

the

list

one

after

another

to

the

processors

Again

in

order

not

to

incur

high

complexity

we

do

not

search

for

the

earliest

slot

on

a

processor

but

simply

schedule

a

node

to

theready-time

of

a

processor

Initially

the

ready-time

of

all

available

processors

is

zero

After

a

node

is

scheduled

to

a

processor

the

ready-time

of

that

processor

is

updated

to

the

finish-time

of

the

last

node

By

doing

so

a

node

is

scheduled

to

a

processor

that

allows

the

earliest

start-time

which

is

determined

by

checking

the

processor?s

readytime

with

the

node?s

data

arrival

time

-LRB-

DAT

-RRB-

The

DAT

of

a

node

can

be

computed

by

taking

the

maximum

value

among

the

message

arrival

times

across

the

parent

nodes

If

the

parent

is

scheduled

to

the

same

processor

as

the

node

the

message

arrival

time

is

simply

the

parent?s

finish-time

otherwise

it

is

equal

to

the

parent?s

finish-time

-LRB-

on

a

remote

processor

-RRB-

plus

the

communication

cost

ofthe

edge

Not

all

processors

need

to

be

checked

in

this

process

Instead

we

can

examine

the

processors

accommodating

the

parent

nodes

together

with

an

empty

processor

-LRB-

if

any

-RRB-

The

procedure

for

generating

the

initial

schedule

can

be

formalized

below

InitialSchedule

-LRB-

-RRB-

Construct

the

CPN-Dominant

List

Repeat

-LRB-

-RRB-

Remove

the

first

node

from

the

list

-LRB-

-RRB-

Schedule

to

the

processor

among

the

processors

accommodating

the

parent

nodes

of

together

with

a

new

processor

-LRB-

if

any

-RRB-

that

allows

the

earliest

start-time

by

checking

s

DAT

with

the

ready-times

of

the

processors

Until

the

list

is

empty

The

time-complexity

of

InitialSchedule

is

derived

as

follows

The

first

step

takes

time

In

the

repeat

loop

the

dominant

step

is

the

procedure

to

determine

the

data

arrival

time

of

a

node

The

cumulative

timecomplexity

of

this

step

throughout

the

execution

of

the

repeat

loop

is

also

because

each

edge

is

visited

once

Thus

the

overall

time-complexity

of

InitialSchedule

is

also

Given

the

procedure

InitialSchedule

we

present

the

sequential

version

of

our

neighborhood

search

algorithm

In

order

to

avoid

the

algorithm

being

trapped

in

a

local

optimal

solution

we

incorporate

a

probabilistic

jump

procedure

in

the

algorithm

The

FAST

algorithm

is

outlined

below

The

FAST

Algorithm

-LRB-

-RRB-

NewSchedule

InitialSchedule

-LRB-

-RRB-

Construct

the

blocking-nodes

list

which

contains

all

the

IBNs

and

OBNs

-LRB-

-RRB-

BestSL

infinity

searchcount

-LRB-

-RRB-

repeat

-LRB-

-RRB-

searchstep

counter

-LRB-

-RRB-

do

-LCB-

neighborhood

search

-LRB-

-RRB-

Pick

a

node

randomly

from

the

blocking-nodes

list

-LRB-

-RRB-

Pick

a

processor

P

randomly

-LRB-

-RRB-

Transfer

to

P

-LRB-

-RRB-

If

schedule

length

does

not

improve

transfer

back

to

its

original

processor

and

increment

counter

otherwise

set

counter

to

-LRB-

-RRB-

-RCB-

while

-LRB-

searchstep

MAXSTEP

and

counter

MARGIN

-RRB-

-LRB-

-RRB-

if

BestSL

SL

-LRB-

NewSchedule

-RRB-

then

-LRB-

-RRB-

BestSchedule

NewSchedule

-LRB-

-RRB-

BestSL

SL

-LRB-

NewSchedule

-RRB-

-LRB-

-RRB-

endif

-LRB-

-RRB-

NewSchedule

Randomly

pick

a

node

from

the

CP

and

transfer

it

to

another

processor

probabilistic

jump

-LRB-

-RRB-

until

-LRB-

searchcount

MAXCOUNT

-RRB-

The

total

number

of

search-steps

is

While

the

number

of

search

steps

in

each

iteration

is

bounded

by

MAXSTEP

the

algorithm

will

also

terminate

searching

and

proceed

to

the

step

of

probabilistic

jump

if

the

solution

does

not

improve

The

b-level

of

a

node

is

the

length

-LRB-

sum

of

the

computation

and

communication

costs

-RRB-

of

the

longest

path

from

this

node

to

an

exit

node

The

t-level

of

a

node

is

the

length

of

the

longest

path

from

an

entry

node

to

this

node

-LRB-

excluding

the

cost

of

this

node

-RRB-

n

x

n

x

n

x

ny

nx

ny

n

y

n

y

n

x

nx

n

x

n

i

ni

ni

ni

O

e

v

-LRB-

-RRB-

O

e

v

-LRB-

-RRB-

O

e

v

-LRB-

-RRB-

ni

ni

ni

MAXSTEP

MAXCOUNT

within

a

specified

number

of

steps

denoted

as

MARGIN

This

is

done

in

order

to

further

enhance

the

expected

efficiency

of

the

algorithm

The

reason

of

making

MAXSTEP

MARGIN

and

MAXCOUNT

as

constants

is

two-fold

First

the

prime

objective

in

the

design

of

the

algorithm

is

to

keep

the

timecomplexity

low

even

when

the

size

of

the

input

graph

is

huge

Second

the

major

strength

of

the

FAST

algorithm

lies

in

its

ability

to

generate

a

good

initial

solution

by

using

the

CPN-Dominant

List

As

such

the

likelihood

of

improving

the

initial

solution

dramatically

by

using

large

number

of

search

steps

is

not

high

Thus

we

fix

MARGIN

to

be

MAXSTEP

to

be

and

MAXCOUNT

to

be

Thetime-complexity

of

the

sequential

FAST

algorithm

is

determined

as

follow

As

discussed

earlier

the

procedure

InitialSchedule

-LRB-

-RRB-

takes

time

The

blocking-nodes

list

can

be

constructed

in

time

as

the

IBNs

and

OBNs

are

already

identified

in

the

procedure

InitialSchedule

-LRB-

-RRB-

In

the

main

loop

the

node

transferring

step

takes

time

since

we

have

to

re-visit

all

the

edges

once

after

transferring

the

node

to

a

processor

in

the

worst

case

Thus

the

overall

time-complexity

of

the

sequential

algorithm

is

Parallel

Probabilistic

Search

The

parallelization

of

the

neighborhood

search

is

based

on

a

partitioning

of

the

blocking-nodes

set

into

q

subsets

where

q

is

the

number

of

available

physical

processing

elements

-LRB-

PPEs

-RRB-

on

which

the

PFAST

algorithm

is

executed

Each

PPE

then

performs

a

neighborhood

search

using

its

own

blocking-nodes

subset

The

PPEs

communicate

periodically

to

exchange

the

best

solution

found

thus

far

and

start

new

search

steps

based

on

the

best

solution

The

period

of

communication

for

the

PPEs

is

set

to

be

T

number

of

search-steps

which

follows

an

exponentially

decreasing

sequence

initially

then

and

so

on

where

The

rationale

is

that

at

early

stages

of

the

search

exploration

is

more

important

than

exploitation

The

PPEs

should

therefore

work

independently

for

longer

period

of

time

However

at

final

stages

of

the

search

exploitation

is

more

important

so

that

the

PPEs

should

communicate

more

frequently

The

PFAST

algorithm

is

outlined

below

The

PFAST

Algorithm

-LRB-

-RRB-

if

myPPE

-LRB-

-RRB-

master

then

-LRB-

-RRB-

Determine

the

initial

schedule

-LRB-

-RRB-

Construct

the

blocking-nodes

set

-LRB-

-RRB-

Partition

the

blocking-nodes

set

into

q

subsets

which

are

ordered

topologically

-LRB-

-RRB-

endif

-LRB-

-RRB-

Every

PPE

receives

a

blocking-nodes

subset

and

the

initial

schedule

-LRB-

-RRB-

repeat

-LRB-

-RRB-

-LRB-

-RRB-

repeat

search

-LRB-

-RRB-

Run

FAST

to

search

for

a

better

schedule

-LRB-

-RRB-

until

searchcount

-LRB-

-RRB-

Exchange

the

best

solution

-LRB-

-RRB-

until

total

searchcount

MAXCOUNT

In

the

PFAST

algorithm

one

PPE

is

designated

as

the

master

which

is

responsible

for

preprocessing

work

including

construction

of

an

initial

schedule

the

blockingnodes

set

and

the

subsets

Since

the

total

number

of

search-steps

is

evenly

distributed

to

the

PPEs

the

PFAST

algorithm

should

have

linear

speedup

over

the

sequential

FAST

algorithm

if

communication

takes

negligible

time

However

inter-PPE

communication

inevitably

takes

significant

amount

of

time

and

the

ideal

case

of

linear

speedup

is

not

achievable

But

the

solution

quality

of

PFAST

can

be

better

than

that

of

the

sequential

FAST

algorithm

This

is

because

the

PPEs

explore

different

parts

of

the

search

space

simultaneously

through

different

neighborhoods

induced

by

the

partitions

of

the

blocking-nodes

set

The

sequential

FAST

algorithm

on

the

other

hand

has

to

handle

a

much

larger

neighborhood

for

the

same

problem

size

A

Scheduling

Example

To

see

how

the

procedure

InitialSchedule

works

consider

the

DAG

shown

earlier

in

Figure

The

attributes

used

by

the

other

four

algorithms

are

also

shown

in

Figure

The

CPN-Dominant

List

of

the

DAG

is

Note

that

is

considered

after

because

has

a

smaller

value

of

t-level

Using

the

CPN-Dominant

List

the

initial

schedule

produced

by

InitialSchedule

is

shown

in

Figure

-LRB-

a

-RRB-

The

schedule

length

generated

by

InitialSchedule

is

already

short

despite

its

simple

scheduling

strategy

To

illustrate

the

effectiveness

of

the

neighborhood

search

process

consider

the

initial

schedule

shown

in

Figure

-LRB-

a

-RRB-

The

blocking-nodes

list

of

the

DAG

is

We

can

notice

that

the

node

blocks

the

CPN

In

the

random

search

process

it

is

highly

probable

that

is

selected

for

transferring

Suppose

it

is

transferred

from

PE

to

PE

The

resulting

schedule

is

shown

in

Figure

-LRB-

b

-RRB-

from

which

we

can

see

that

despite

the

increased

start

times

of

and

the

final

schedule

length

is

nonetheless

shortened

O

e

v

-LRB-

-RRB-

O

v

-LRB-

-RRB-

O

e

v

-LRB-

-RRB-

O

e

v

-LRB-

-RRB-

t

t

t

t

MAXCOUNT

q

i

MAXCOUNT

i

q

n

n

n

n

-LCB-

-RCB-

n

n

n

n

-LCB-

-RCB-

n

Performance

Results

In

our

study

by

using

a

prototype

computer-aided

scheduling

tool

called

CASCH

we

compared

our

proposed

algorithm

with

four

related

scheduling

algorithms

the

Mobility

Directed

-LRB-

MD

-RRB-

algorithm

-LSB-

-RSB-

the

Earliest

Task

First

-LRB-

ETF

-RRB-

algorithm

-LSB-

-RSB-

the

Dynamic

Level

Scheduling

-LRB-

DLS

-RRB-

algorithm

-LSB-

-RSB-

and

the

Dominant

Sequence

Clustering

-LRB-

DSC

-RRB-

algorithm

-LSB-

-RSB-

We

chose

the

DSC

MD

ETF

and

DLS

algorithms

out

of

algorithms

which

we

compared

in

a

previous

study

-LSB-

-RSB-

The

comparison

of

FAST

with

these

algorithms

provides

an

indirect

comparison

with

the

remaining

algorithms

In

this

section

we

first

present

the

performance

results

of

the

sequential

FAST

algorithm

and

compare

it

with

those

of

DSC

MD

ETF

and

DLS

algorithms

using

a

prototype

parallelization

tool

In

Section

we

present

the

performance

results

of

the

PFAST

algorithm

by

using

two

suites

of

random

task

graphs

for

which

optimal

solutions

are

known

In

Section

we

present

the

results

of

applying

the

algorithm

to

large

DAGs

For

comparison

the

results

of

the

DLS

DSC

and

ETF

algorithms

are

also

shown

CASCH

We

performed

experiments

using

the

CASCH

tool

which

generates

a

task

graph

from

a

sequential

program

uses

a

scheduling

algorithm

to

perform

scheduling

and

then

generates

the

parallel

code

in

a

scheduled

form

for

the

Intel

Paragon

The

timings

for

the

nodes

and

edges

on

the

DAG

are

assigned

through

a

timing

database

which

was

obtained

through

profiling

CASCH

also

provides

a

graphical

interface

to

interactively

run

and

test

various

algorithms

including

the

ones

discussed

in

this

paper

Instead

of

only

measuring

the

schedule

length

through

a

Gantt

chart

we

measure

the

running

time

of

the

scheduled

code

on

the

Paragon

Various

scheduling

algorithms

therefore

can

be

more

accurately

tested

and

compared

through

CASCH

using

real

applications

on

an

actual

machine

The

reader

is

referred

to

-LSB-

-RSB-

for

details

about

the

tool

In

addition

in

order

to

examine

the

performance

of

the

algorithm

given

very

large

graphs

which

can

arise

in

practice

we

performed

experiments

with

randomly

generated

large

DAGs

consisting

of

thousands

of

nodes

Parallel

Applications

In

our

first

experiment

we

tested

the

FAST

algorithm

with

the

DAGs

generated

from

three

real

applications

Gaussian

elimination

Laplace

equation

solver

and

Fast

Fourier

Transform

-LRB-

FFT

-RRB-

-LSB-

-RSB-

The

Gaussian

elimination

and

Laplace

equation

solver

applications

operate

on

matrices

Thus

the

number

of

nodes

in

the

DAGs

generated

from

these

applications

are

related

to

the

matrix

dimension

N

and

is

about

On

the

other

hand

the

FFT

application

accepts

the

number

of

points

as

input

We

examined

the

performance

in

three

aspects

application

execution

time

number

of

processors

used

and

the

scheduling

algorithm

running

time

The

results

for

the

Gaussian

elimination

are

shown

in

Figure

In

Figure

-LRB-

a

-RRB-

we

normalized

the

application

execution

times

obtained

through

all

the

algorithms

with

respect

to

those

obtained

through

the

FAST

algorithm

It

was

shown

that

the

programs

scheduled

by

the

FAST

algorithm

are

to

faster

than

the

other

algorithms

node

SL

t-level

b-level

ALAP

n

n

n

Figure

The

static

levels

-LRB-

SLs

-RRB-

t-levels

b-levels

and

ALAP

times

of

the

nodes

-LRB-

CPNs

are

marked

by

an

asterisk

-RRB-

PE

PE

PE

PE

Figure

-LRB-

a

-RRB-

Schedules

generated

by

the

InitialSchedule

-LRB-

-RRB-

-LRB-

schedule

length

-RRB-

-LRB-

b

-RRB-

The

final

schedule

after

the

local

search

process

with

node

is

transferred

to

PE

-LRB-

schedule

length

-RRB-

PE

PE

PE

PE

-LRB-

a

-RRB-

-LRB-

b

-RRB-

O

N

-LRB-

-RRB-

Note

that

the

results

of

the

DSC

algorithm

for

matrix

dimensions

and

were

not

available

because

the

DSC

used

more

than

the

available

Paragon

processors

in

scheduling

the

parallel

program

This

can

be

explicated

by

the

fact

that

the

DSC

algorithm

uses

processors

Concerning

the

number

of

processors

used

the

FAST

ETF

and

DLS

algorithms

used

about

the

same

amount

of

processors

The

number

of

processors

used

by

all

the

algorithms

is

shown

in

Figure

-LRB-

b

-RRB-

The

scheduling

times

of

all

the

algorithms

are

shown

in

Figure

-LRB-

c

-RRB-

indicating

that

the

DSC

algorithm

was

the

fastest

algorithm

with

the

proposed

FAST

algorithm

very

close

to

it

On

the

other

hand

the

ETF

and

DLS

algorithms

running

times

are

relatively

large

but

they

were

much

faster

than

the

MD

algorithm

This

is

because

the

MD

algorithm

is

about

times

slower

than

the

other

algorithms

The

results

for

the

Laplace

equation

solver

are

shown

in

Figure

from

which

we

can

see

that

the

percentage

improvements

of

the

FAST

algorithm

over

the

other

algorithms

is

up

to

As

to

the

number

of

processors

used

the

FAST

MD

ETF

and

DLS

algorithms

demonstrated

similar

performance

with

the

DSCalgorithm

again

uses

more

processors

than

the

other

algorithms

For

the

scheduling

times

the

FAST

algorithm

is

the

fastest

among

all

thealgorithms

The

MD

algorithm

is

again

times

slower

than

the

other

algorithms

The

results

for

the

FFT

are

shown

in

Figure

The

FAST

algorithm

is

again

better

than

all

the

other

four

algorithms

in

terms

of

the

application

execution

times

and

scheduling

times

Comparison

against

Optimal

Solutions

In

this

section

we

present

the

performance

results

of

the

PFAST

algorithm

We

implemented

the

PFAST

algorithm

on

the

Intel

Paragon

using

the

C

language

and

FAST

DSC

MD

ETF

DLS

N.A.

N.A.

FAST

DSC

MD

ETF

DLS

-LRB-

a

-RRB-

Normalized

execution

times

of

Gaussian

elimination

on

the

Intel

Paragon

-LRB-

b

-RRB-

Number

of

Processors

used

for

the

Gaussian

elimination

FAST

DSC

MD

ETF

DLS

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

Algorithm

Matrix

Dimension

-LRB-

Number

of

Tasks

-RRB-

-LRB-

c

-RRB-

Scheduling

times

-LRB-

sec

-RRB-

on

a

SPARC

Station

for

the

Gaussian

elimination

Figure

Normalized

execution

times

number

of

processors

used

and

scheduling

algorithm

running

times

for

the

Gaussian

elimination

for

all

the

scheduling

algorithms

Matrix

Dimension

Matrix

Dimension

O

v

-LRB-

-RRB-

O

v

-LRB-

-RRB-

O

v

-LRB-

-RRB-

FAST

DSC

MD

ETF

DLS

FAST

DSC

MD

ETF

DLS

-LRB-

b

-RRB-

Number

of

Processors

used

for

the

Laplace

equation

solver

FAST

DSC

MD

ETF

DLS

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

Algorithm

Matrix

Dimension

-LRB-

Number

of

Tasks

-RRB-

-LRB-

c

-RRB-

Scheduling

times

-LRB-

sec

-RRB-

on

a

SPARC

Station

for

the

Laplace

equation

solver

Matrix

Dimension

Matrix

Dimension

-LRB-

a

-RRB-

Normalized

execution

times

of

Laplace

equation

solver

on

the

Intel

Paragon

Figure

Normalized

execution

times

number

of

processors

used

and

scheduling

algorithm

running

times

for

the

Laplace

equation

solver

for

all

the

scheduling

algorithms

tested

it

using

different

suites

of

synthetic

task

graphs

Our

aim

is

to

investigate

the

absolute

solution

quality

of

the

algorithm

by

applying

it

to

two

different

sets

of

random

task

graphs

for

which

optimal

solutions

are

known

As

no

widely

accepted

benchmark

graphs

exist

for

the

DAG

scheduling

problem

we

believe

using

random

graphs

with

diverse

parameters

is

appropriate

for

testing

the

performance

of

the

algorithm

The

first

suite

of

random

task

graphs

consists

of

three

sets

of

graphs

with

different

CCRs

and

Each

set

consists

of

graphs

in

which

the

number

of

nodes

vary

from

to

with

increments

of

thus

totalling

graphs

per

set

The

graphs

within

the

same

set

have

the

same

value

of

CCR

The

graphs

were

randomly

generated

as

follows

First

the

computation

cost

of

each

node

in

the

graph

was

randomly

selected

from

a

uniform

distribution

with

mean

equal

to

-LRB-

minimum

and

maximum

-RRB-

Beginning

with

the

first

node

a

random

number

indicating

the

number

of

children

was

chosen

from

a

uniform

distribution

with

mean

equal

to

thus

the

connectivity

of

the

graph

increases

with

the

size

of

the

graph

The

communication

cost

of

each

edge

was

also

randomly

selected

from

a

uniform

distribution

with

mean

equal

to

times

the

specified

value

of

CCR

Hereafter

this

suite

of

graphs

is

designated

random

task

graphs

To

obtain

optimal

solutions

for

the

task

graphs

we

applied

a

parallel

A

algorithm

-LSB-

-RSB-

to

the

graphs

Since

generating

optimal

solutions

for

arbitrarily

structured

task

graphs

takes

exponential

time

it

is

not

feasible

to

obtain

optimal

solutions

for

large

graphs

On

the

other

hand

to

investigate

the

scalability

of

the

PGS

algorithm

it

is

desirable

to

test

it

with

larger

task

graphs

for

which

optimal

solutions

are

known

To

resolve

this

problem

we

employed

a

different

strategy

to

generate

the

second

suite

of

random

task

graphs

Rather

than

trying

to

find

out

the

optimal

solutions

after

the

graphs

are

randomly

generated

we

set

out

to

generate

task

graphs

with

given

optimal

schedule

lengths

and

number

of

processors

used

in

the

optimal

schedules

The

method

of

generating

task

graphs

with

known

optimal

schedules

is

as

follows

Suppose

that

the

optimal

schedule

length

of

a

graph

and

the

number

of

processors

used

are

specified

as

and

p

respectively

For

each

PE

i

we

randomly

generate

a

number

from

a

uniform

distribution

with

mean

The

time

interval

between

and

of

PE

i

is

then

randomly

partitioned

into

sections

Each

section

represents

the

execution

span

of

one

task

thus

tasksare

scheduled

to

PE

i

with

no

idle

time

slot

In

this

manner

v

tasks

are

generated

so

that

every

processor

has

the

same

schedule

length

To

generate

an

edge

two

tasks

and

are

randomly

chosen

such

that

The

edge

is

made

to

emerge

from

to

As

to

the

edge

weight

there

are

two

cases

to

consider

-LRB-

i

-RRB-

the

two

tasks

are

scheduled

to

different

processors

and

-LRB-

ii

-RRB-

the

two

tasks

are

scheduled

to

the

same

processor

In

the

first

case

the

edge

weight

is

randomly

chosen

from

a

uniform

distribution

with

maximum

equal

to

-LRB-

the

mean

is

adjusted

according

to

the

given

CCR

value

-RRB-

In

the

second

case

the

edge

weight

can

be

an

arbitrary

positive

integer

because

the

edge

does

not

affect

the

start

and

finish

times

of

the

tasks

which

are

scheduled

to

the

same

processor

We

randomly

chose

the

edge

weight

for

this

case

according

to

the

given

CCR

value

Using

this

method

we

generated

three

sets

of

task

graphs

with

three

CCRs

and

Each

set

consists

of

graphs

in

which

the

number

of

nodes

vary

from

to

in

increments

of

thus

each

set

contains

graphs

The

graphs

within

the

same

set

have

the

same

value

of

CCR

Hereafter

we

call

this

suite

of

graphs

the

random

task

graphs

FAST

DSC

MD

ETF

DLS

16 64 128 512

Algorithm

FAST

DSC

MD

ETF

DLS

16 64 128 512

Algorithm

-LRB-

b

-RRB-

Number

of

Processors

used

for

the

FFT

FAST

DSC

MD

ETF

DLS

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

Algorithm

Number

of

Points

-LRB-

Number

of

Tasks

-RRB-

-LRB-

c

-RRB-

Scheduling

times

-LRB-

sec

-RRB-

on

a

SPARC

Station

for

FFT

Number

of

Points

Number

of

Points

Figure

Normalized

execution

times

number

of

processors

used

and

scheduling

algorithm

running

times

for

FFT

for

all

the

scheduling

algorithms

-LRB-

a

-RRB-

Normalized

execution

times

of

FFTon

the

Intel

Paragon

v

SLo

pt

xi

v

p

SL

op

t

x

i

xi

n

b

FT

-LRB-

-RRB-

ST

n

b

-LRB-

-RRB-

n

a

nb

ST

n

b

-LRB-

-RRB-

FT

-LRB-

-RRB-

-LRB-

-RRB-

Table

shows

the

results

of

the

PFAST

algorithm

using

and

PPEs

on

the

Intel

Paragon

Using

PPE

means

that

the

algorithm

is

the

sequential

FAST

algorithm

It

should

be

noted

that

for

graphs

of

smaller

size

the

blocking-nodes

subsets

of

the

PPEs

are

not

disjoint

so

as

to

make

each

subset

contain

at

least

nodes

In

the

table

the

total

number

of

optimal

solutions

generated

and

the

average

percentage

deviations

-LRB-

from

the

optimal

solutions

-RRB-

for

each

CCR

are

also

shown

Note

that

the

average

percentage

deviations

are

calculated

by

dividing

the

total

deviations

by

the

number

of

non-optimal

cases

only

These

average

deviations

thus

indicate

more

accurately

the

performance

of

the

PFAST

algorithm

when

it

is

not

able

to

generate

optimal

solutions

We

notice

that

the

PFAST

algorithm

generated

optimal

solutions

for

a

significant

portion

of

all

the

test

cases

While

the

number

of

optimal

solutions

is

about

the

same

for

the

three

values

of

CCR

the

average

deviations

increase

with

the

larger

values

of

CCR

The

most

important

observation

is

that

the

deviations

do

not

vary

much

with

increasing

numbers

of

PPEs

used

For

some

of

the

graphs

the

deviations

do

not

change

for

any

number

of

PPEs

used

An

explanation

for

this

phenomenon

is

that

the

final

solutions

of

such

cases

can

be

reached

within

a

few

transferal

of

blocking-nodes

Another

observation

is

that

when

PPEs

were

used

the

deviations

of

some

cases

increased

This

is

presumably

due

to

the

small

sizes

of

blocking-nodes

subsets

which

restrict

the

diversity

of

the

random

search

Finally

we

note

that

the

worst

percentage

deviation

-LRB-

for

the

case

of

CCR

graph

size

-RRB-

is

within

from

the

optimal

Thus

the

PFAST

algorithm

has

shown

reasonably

high

capability

in

generating

near-to-optimal

solutions

The

average

execution

times

and

speedups

of

the

PFAST

algorithm

are

shown

in

Figure

These

averages

were

computed

across

the

three

values

of

CCR

We

notice

that

the

execution

times

of

the

PFAST

algorithm

using

PPE

is

already

very

short

Furthermore

the

speedup

curves

are

quite

flat

indicating

that

the

speedup

of

the

algorithm

is

not

affected

by

increasing

graph

sizes

Another

observation

is

that

the

speedups

are

smaller

than

the

ideal

linear

speedups

by

a

considerable

margin

An

explanation

for

these

two

observations

is

that

the

sizes

of

the

random

graphs

are

small

so

that

the

amount

of

scheduling

effort

does

not

dominate

the

amount

of

interPPE

communication

time

In

other

words

the

inter-PPE

communication

is

a

significant

overhead

that

limits

the

achievable

speedups

However

even

for

such

small

graphs

the

PFAST

algorithm

exhibited

reasonable

scalability

Table

shows

the

results

of

the

PFAST

algorithm

for

the

random

task

graphs

using

and

PPEs

on

the

Intel

Paragon

For

these

much

larger

graphs

the

PFAST

algorithm

generated

only

one

optimal

solution

-LRB-

the

case

of

CCR

size

-RRB-

However

an

encouraging

observation

is

that

the

percentage

deviations

are

small

Indeed

the

best

deviation

is

only

and

the

worst

only

which

can

be

considered

as

close-to-optimal

The

Graph

Size

No

of

Opt

Avg

Dev

Table

Results

of

the

PFAST

algorithm

compared

against

optimal

solutions

-LRB-

deviations

-RRB-

for

the

random

task

graphs

with

three

CCRs

using

and

PPEs

on

the

Intel

Paragon

CCR

No

of

PPEs

average

deviations

which

increase

with

increasing

CCR

are

smaller

than

A

very

interesting

observation

is

that

for

some

cases

of

larger

task

graphs

-LRB-

e.g.

sizes

larger

than

-RRB-

using

more

PPEs

improve

the

schedule

lengths

For

example

in

the

case

of

CCR

and

size

using

PPEs

resulted

in

a

deviation

of

while

using

PPEs

gave

a

deviation

of

Using

PPEs

further

decreased

the

deviation

to

This

observation

implies

that

parallelization

of

a

search

algorithm

can

potentially

improve

the

solution

quality

This

is

due

to

the

partitioning

of

the

search

neighborhood

which

lets

the

search

to

explore

different

regions

of

the

search

space

simultaneously

thereby

increasing

the

likelihood

of

getting

better

solutions

There

are

a

few

cases

in

which

using

more

PPEs

resulted

in

an

increased

deviations

however

For

example

for

the

case

of

CCR

and

size

using

PPEs

gave

a

deviation

of

while

using

PPEs

improved

the

deviation

to

However

when

PPEs

were

used

the

deviation

was

only

which

is

worse

than

that

of

using

PPEs

but

better

than

that

of

using

PPEs

The

average

execution

times

and

speedups

of

the

PFAST

algorithm

for

the

random

task

graphs

are

shown

in

Figure

Compared

with

the

speedup

plots

shown

earlier

in

Figure

the

speedups

for

task

graphs

are

considerably

higher

This

is

due

to

the

fact

that

inter-PPE

communication

for

larger

task

graphs

is

not

a

significant

overhead

Again

the

PFAST

demonstrated

reasonably

good

scalability

even

for

task

graphs

with

nodes

Based

on

the

above

results

we

can

conclude

that

the

PFAST

algorithm

is

suitable

for

finding

high

quality

Graph

Size

No

of

Opt

Avg

Dev

Table

Results

of

the

PFAST

algorithm

compared

against

optimal

solutions

-LRB-

deviations

-RRB-

for

the

random

task

graphs

with

three

CCRs

using

and

PPEs

on

the

Intel

Paragon

CCR

No

of

PPEs

50 100 150 200

250 300 350 400

PPEs

PPEs

PPEs

PPEs

Figure

-LRB-

a

-RRB-

The

average

running

times

of

the

PFAST

algorithm

for

the

random

task

graphs

with

three

CCRs

using

PPE

on

the

Intel

Paragon

-LRB-

b

-RRB-

the

average

speedups

of

the

PFAST

algorithm

for

and

PPEs

-LRB-

a

-RRB-

Average

runningtimesusing

-LRB-

b

-RRB-

Average

speedups

Graph

Size

Running

Times

-LRB-

secs

-RRB-

schedules

for

large

task

graphs

under

strict

running

times

requirements

Large

DAGs

To

test

the

scalability

and

robustness

of

the

FAST

algorithm

we

performed

experiments

with

very

large

DAGs

These

DAGs

include

a

Gaussian

elimination

graph

a

Laplace

equation

solver

graph

a

FFT

graph

and

a

random

graph

For

these

graphs

we

simply

measured

the

schedule

length

produced

by

an

algorithm

We

applied

the

DLS

DSC

ETF

and

PFAST

algorithms

to

these

graphs

on

the

Intel

Paragon

We

ran

the

PFAST

algorithm

using

PPEs

and

other

algorithms

PPE

The

schedule

lengths

for

the

large

DAGs

normalized

with

respect

to

that

of

the

PFAST

algorithm

are

shown

in

Figure

-LRB-

a

-RRB-

Note

that

the

MD

algorithm

was

excluded

from

the

comparison

because

it

took

more

than

hours

to

produce

a

schedule

for

a

DAG

An

encouraging

observation

is

that

the

PFAST

algorithm

outperformed

all

the

algorithms

in

all

the

test

cases

The

percentage

improvement

ranges

from

to

Concerning

the

scheduling

times

we

can

immediately

note

from

Figure

-LRB-

b

-RRB-

that

the

ETF

and

DLS

algorithms

were

considerably

slower

than

the

PFAST

and

DSC

algorithms

By

using

effective

parallelization

the

PFAST

algorithm

outperforms

the

DSC

algorithm

both

in

terms

of

solution

quality

and

complexity

These

results

of

large

DAGs

indeed

provide

further

evidence

to

the

claim

that

the

PFAST

algorithm

is

suitable

for

finding

high

quality

schedules

for

huge

DAGs

Concluding

Remarks

In

this

paper

we

have

presented

a

low

complexity

parallel

algorithm

called

the

PFAST

algorithm

to

meet

the

conflicting

goals

of

high

performance

and

low

timecomplexity

Instead

of

using

sophisticated

methods

to

optimize

the

scheduling

of

individual

nodes

the

PFAST

algorithm

first

generates

an

initial

schedule

and

then

refines

it

in

parallel

using

an

effective

probabilistic

search

techniques

We

have

compared

the

algorithm

with

a

number

of

well-known

efficient

scheduling

algorithms

using

real

applications

and

randomly

generated

task

graphs

The

results

obtained

demonstrate

that

the

proposed

algorithm

is

superior

to

existing

algorithms

in

terms

of

both

solution

quality

and

complexity

Based

on

the

comparison

study

in

this

paper

and

the

comparison

of

algorithms

in

-LSB-

-RSB-

we

find

the

PFAST

algorithm

to

be

the

fastest

algorithm

known

to

us

50 100 150 200

250 300 350 400

PPEs

PPEs

PPEs

PPEs

Figure

-LRB-

a

-RRB-

The

average

running

times

of

the

PGS

algorithm

for

the

random

task

graphs

with

three

CCRs

using

PPE

on

the

Intel

Paragon

-LRB-

b

-RRB-

the

average

speedups

of

the

PGS

algorithm

for

and

PPEs

-LRB-

a

-RRB-

Average

running

times

PPE

-LRB-

b

-RRB-

Average

speedups

Graph

Size

Running

Times

-LRB-

secs

-RRB-

-LRB-

a

-RRB-

Normalized

schedule

lengths

for

large

DAGs

the

PFAST

algorithm

used

PPEs

on

the

Intel

Paragon

-LRB-

b

-RRB-

Scheduling

times

-LRB-

sec

-RRB-

on

the

Intel

Paragon

the

PFAST

algorithm

used

PPEs

while

other

algorithms

used

PPE

Figure

Normalized

schedule

lengths

and

scheduling

times

for

the

large

DAGs

for

all

the

scheduling

algorithms

PFAST

DSC

ETF

DLS

Gauss

Laplace

FFT

Random

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

Algorithm

Graph

types

-LRB-

Number

of

Nodes

-RRB-

PFAST

DSC

ETF

DLS

Gauss

Laplace

FFT

Random

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

-LRB-

-RRB-

Algorithm

Graph

types

-LRB-

Number

of

Nodes

-RRB-

An

interesting

observation

of

the

PFAST

algorithm

is

that

parallelization

can

sometimes

improve

solution

quality

in

that

for

some

cases

the

PFAST

algorithm

generated

better

solutions

when

using

more

PPEs

This

is

due

to

the

partitioning

of

the

blocking-nodes

set

which

implies

a

partitioning

of

the

search

neighborhood

The

partitioning

causes

the

algorithm

to

explore

the

search

space

simultaneously

thereby

enhancing

the

likelihood

of

getting

better

solutions

References

-LSB-

-RSB-

T.L.

Adam

K.M.

Chandy

and

J.

Dickson

A

Comparison

of

List

Scheduling

for

Parallel

Processing

Systems

Communications

of

the

ACM

vol

Dec.

pp.

-LSB-

-RSB-

I.

Ahmad

Y.-K

Kwok

and

M.-Y

Wu

Analysis

Evaluation

and

Comparison

of

Algorithms

for

Scheduling

Task

Graphs

on

Parallel

Processors

International

Symposium

on

Parallel

Architectures

Algorithms

and

Networks

Beijing

China

Jun.

pp.

-LSB-

-RSB-

I.

Ahmad

Y.-K

Kwok

M.-Y

Wu

and

W.

Shu

Automatic

Parallelization

and

Scheduling

of

Programs

on

Multiprocessors

using

CASCH

Proc

Int?l

Conference

on

Parallel

Processing

Aug.

to

appear

-LSB-

-RSB-

M.

Beck

K.K.

Pingali

and

A.

Nicolau

Static

scheduling

for

dynamic

dataflow

machines

Journal

of

Parallel

and

Distributed

Computing

pp.

-LSB-

-RSB-

E.G.

Coffman

Computer

and

Job-Shop

Scheduling

Theory

Wiley

New

York

-LSB-

-RSB-

H.

El-Rewini

H.H.

Ali

and

T.G.

Lewis

Task

Scheduling

in

Multiprocessing

Systems

IEEE

Computer

Dec.

pp.

-LSB-

-RSB-

M.R.

Garey

and

D.S.

Johnson

Computers

and

Intractability

A

Guide

to

the

Theory

of

NP-Completeness

W.H.

Freeman

and

Company

-LSB-

-RSB-

A.

Gerasoulis

and

T.

Yang

A

Comparison

of

Clustering

Heuristics

for

Scheduling

DAG?s

on

Multiprocessors

Journal

of

Parallel

and

Distributed

Computing

vol

no.

Dec.

pp.

-LSB-

-RSB-

J.J.

Hwang

Y.C.

Chow

F.D.

Anger

and

C.Y.

Lee

Scheduling

Precedence

Graphs

in

Systems

with

Interprocessor

Communication

Times

SIAM

Journal

on

Computing

vol

no.

Apr.

pp.

-LSB-

-RSB-

H.

Kasahara

and

S.

Narita

Practical

Multiprocessor

Scheduling

Algorithms

for

Efficient

Parallel

Processing

IEEE

Trans

on

Computers

vol

Nov.

pp.

-LSB-

-RSB-

Y.-K

Kwok

and

I.

Ahmad

Dynamic

Critical-Path

Scheduling

An

Effective

Technique

for

Allocating

Task

Graphs

onto

Multiprocessors

IEEE

Transactions

on

Parallel

and

Distributed

Systems

vol

no.

May

pp.

-LSB-

-RSB-

Y.-K

Kwok

I.

Ahmad

M.

Kafil

and

Imtiaz

Ahmad

Parallel

Algorithms

for

Optimal

Scheduling

of

Arbitrary

Task

Graphs

to

Multiprocessors

submitted

for

publication

-LSB-

-RSB-

B.

Lee

A.R.

Hurson

and

T.Y.

Feng

A

Vertically

Layered

Allocation

Scheme

for

Data

Flow

Systems

Journal

of

Parallel

and

Distributed

Computing

vol

pp.

-LSB-

-RSB-

J.-C

Liou

and

M.A.

Palis

A

Comparison

of

General

Approaches

to

Multiprocessor

Scheduling

Proc

of

Int?l

Parallel

Processing

Symposium

Apr.

pp.

-LSB-

-RSB-

C.

McCreary

A.A.

Khan

J.J.

Thompson

and

M.E.

McArdle

A

Comparison

of

Heuristics

for

Scheduling

DAG?s

on

Multiprocessors

Proceedings

of

International

Parallel

Processing

Symposium

pp

-LSB-

-RSB-

M.A.

Palis

J.-C

Liou

and

D.S.L.

Wei

Task

Clustering

and

Scheduling

for

Distributed

Memory

Parallel

Architectures

IEEE

Transactions

on

Parallel

and

Distributed

Systems

vol

no.

Jan.

pp.

-LSB-

-RSB-

C.H.

Papadimitriou

and

K.

Steiglitz

Combinatorial

Optimization

Algorithms

and

Complexity

Prentice-Hall

Englewood

Cliffs

NJ

-LSB-

-RSB-

B.

Shirazi

M.

Wang

and

G.

Pathak

Analysis

and

Evaluation

of

Heuristic

Methods

for

Static

Scheduling

Journal

of

Parallel

and

Distributed

Computing

no.

pp.

-LSB-

-RSB-

G.C.

Sih

and

E.A.

Lee

A

Compile-Time

Scheduling

Heuristic

for

Interconnection-Constrained

Heterogeneous

Processor

Architectures

IEEE

Transactions

on

Parallel

and

Distributed

Systems

vol

no.

Feb.

pp.

-LSB-

-RSB-

M.Y.

Wu

and

D.D.

Gajski

Hypertool

A

Programming

Aid

for

Message-Passing

Systems

IEEE

Trans

on

Parallel

and

Distributed

Sys.

vol

no.

Jul.

pp.

-LSB-

-RSB-

T.

Yang

and

A.

Gerasoulis

DSC

Scheduling

Parallel

Tasks

on

an

Unbounded

Number

of

Processors

IEEE

Transactions

on

Parallel

and

Distributed

Systems

vol

no.

Sep.

pp.

-LSB-

-RSB-

J.

Yang

L.

Bic

and

A.

Nicolau

A

Mapping

strategy

for

MIMD

Computers

International

Journal

of

High

Speed

Computing

vol

no

pp.

multiprocessors
parallel algorithm
parallel processing
random search
task graphs

compile-time scheduling
parallel programming tool