SCHEDULING

SOURCES-
Mark Manwaring
Kia Bazargan
Giovanni De Micheli
Gupta
Youn-Long Lin
M. Balakrishnan
Camposano,
J. Hofstede,
Knapp,
MacMillen
Lin
Overview of Hardware Synthesis
assign times to
operations under
given constraints
reduce the amount of hardware, optimize the design in
general.
May be done with the consideration of additional constraints.
assign operations to
physical resources
under given
constraints
Outline of scheduling
The scheduling problem.

1. Scheduling without constraints.

2. Scheduling under timing constraints.
Relative scheduling.

3. Scheduling under resource constraints.
The ILP model (Integer Linear Programming).
Heuristic methods (graph coloring, etc).
Timing constraints versus resource constraints
What is Scheduling
Example of scheduling:
ASAP
This is As Soon as
Possible Scheduling
(ASAP).
It can be used as a
bound in other
methods like ILP or
when latency only is
important, not area.

Example of Scheduling
Adder number
1
Adder number
3
Multiplier
number 2
More complex example of
Scheduling
What is necessary to solve the
scheduling problem?
Circuit model:
Sequencing graph.
Cycle-time is given.
Operation delays expressed in cycles.

Scheduling:
Determine the start times for the operations.
Satisfying all the sequencing (timing and resource) constraints.
Goal:
Determine area/latency trade-off.
Do you remember what is
latency?


Scheduling affects

Area: maximum number of concurrent
operations of same type is a lower
bound on required hardware resources.

Performance: concurrency of resulting
implementation.
Taxonomy of scheduling
problems to solve
1. Unconstrained scheduling.

2. Scheduling with timing constraints:
Latency.
Detailed timing constraints.

3. Scheduling with resource constraints.

Related problems:
Chaining. What is chaining?
Synchronization. What is synchronization?
Pipeline scheduling.
Simplest scheduling model

All operations have bounded delays.

All delays are in cycles.

Cycle-time is given.

No constraints - no bounds on area.

Goal
Minimize latency.

Scheduling 2
Scheduling problems are NP-hard, so all kind of heuristics are used

ASAP As soon as possible
ALAP
List scheduling Resource Constrained algorithms
Force directed algorithms time constrained
Path based
Percolation algorithms
Simulated annealing
Tabu search and other heuristics
Simulated evolution
Linear Programming
Integer Linear Programming - time constrained
What are types of Scheduling
Algorithms?
Types of Scheduling Processes
Assignment of operations to time (control steps)
within given constraints and minimizing a cost
function

Time-constrained
Resource-constrained

With or without control (conditions)
With or without iterations (infinite loops)

Constructive
Iterative
Classification of Scheduling
Algorithms
Scheduling
Algorithms
Simplest model of
scheduling
All operations have bounded delays.

All delays are expressed in numbers of cycles
of a single one-phase clock.
Cycle-time is given.

No constraints - no bounds on area.

Goal:
Minimize latency.
Minimum Latency
Unconstrained Scheduling
Unconstrained scheduling used when

Dedicated resources are used.

Operations differ in type.

Operations cost is marginal when compared to that of
steering logic, registers, wiring, and control logic.

Binding is done before scheduling: resource conflicts
solved by serializing operations sharing same
resource.

Deriving bounds on latency for constrained problems.
Minimum Latency Unconstrained
Scheduling Problem
Minimum-latency
unconstrained
scheduling problem
Given a set of operations V with set of
corresponding integer delays D and a partial order
on the operations E:
Find an integer labeling of the operations
: V --> Z
+
, such that:
t
i
= (v
i
),
t
i
> t
j
+ d
j
i, j such that (v
j
, v
i
) e E
and t
n
is minimum.
d
i
d
j

(v
j
, v
i
)
t
i
> t
j
+ d
j

t
j
t
i
Input to
d
i
must
be stable
Example of using
mobility
Operations with zero mobility:
{v
1
, v
2
, v
3
, v
4
, v
5
}.
They are on the critical path.
Operations with mobility one:
{v
6
, v
7
}.
Operations with mobility two:
{v
8
, v
9
, v
10
, v
11
}.
mobility two:
1. Start from
ALAP
2.Use mobility to
improve

Classes of scheduling algorithms
Operation Scheduling Formalisation

Time
Constrained
Scheduling
ALAP solves a latency-constrained problem.

Latency bound can be set to latency computed by ASAP
algorithm.

Mobility
Defined for each operation.
Difference between ALAP and ASAP schedule.
Zero mobility implies that an operation can be started only at one
given time step.
Mobility greater than 0 measures span of time interval in which
an operation may start.

Slack on the start time.

Latency Constrained
Scheduling
Time Constrained
Scheduling
Motivation
Interface design.
Control over operation start time.

Constraints
Upper/lower bounds on start-time difference of any operation pair.

Minimum timing constraints between two operations
An operation follows another by at least a number of prescribed time
steps
l
ij
> 0 requires t
j
> t
i
+ l
ij

Maximum timing constraints between two operations
An operation follows another by at most a number of prescribed time
steps
u
ij
> 0 requires t
j
s t
i
+ u
ij

Scheduling under Detailed
Timing Constraints
Example
Circuit reads data from a bus, performs computation, writes
result back on the bus.

Bus interface constraint: data written three cycles after read.

Minimum and maximum constraint of 3 cycles between read and
write operations.

Example
Two circuits required to communicate simultaneously to external
circuits.

Cycle in which data available is irrelevant.

Minimum and maximum timing constraint of zero cycles between
two write operations.
Scheduling under Detailed
Timing Constraints
Mul delay = 2
ADD delay =1
Scheduling under detailed
timing constraints
Motivation:
Interface design.
Control over
operation start time.

Constraints:
Upper/lower bounds on start-time
difference of any operation pair.
Feasibility of a solution.
Constraint graph model
Start from a sequencing graph.

Model delays as weights on edges.

Add forward edges for minimum constraints.
Edge (v
i
, v
j
) with weight l
ij
=> t
j
> t
i
+l
ij
.

Add backward edges for maximum constraints.
Edge (v
i
, v
j
) with weight:
- u
ij
=>

t
j
s t
i
+ u
ij

because t
j
s t
i
+ u
ij
=> t
i
> t
j
- u
ij

Add this edge for
max constraint
Add this edge for
min constraint
Unbounded delays
Synchronization.
Unbounded-delay operations (e.g.
loops).
Anchors.
Unbounded-delay operations.
Relative scheduling
Schedule ops w.r. to the anchors.
Combine schedules.

Method for Scheduling with
Unbounded-Delay Operations
Presence of maximum timing constraints may
prevent existence of a consistent schedule.

Required upper bound on time distance between
operations may be inconsistent with first
operation execution time.

Minimum timing constraints may conflict with
maximum timing constraints.

A criterion to determine existence of a schedule:
For each maximum timing constraint u
ij
Longest weighted path between v
i
and v
j
must
be s u
ij

Method for Scheduling Under
Detailed Timing Constraints
Example of using
constraint graph with
minimum and maximum
constraints
Sequencing graph
Constraint graph
explain
So now we can calculate
this table from
sequencing graph
Weight of longest path from source to a vertex is the
minimum start time of a vertex.

Bellman-Ford or Lia-Wong algorithm provides the
schedule.

A necessary condition for existence of a schedule is
constraint graph has no positive cycles.

Method for Scheduling Under
Detailed Timing Constraints

Methods for Scheduling
Under Detailed Timing
Constraints
Shown
in last
slide
Will
follow
Methods for scheduling
under detailed timing constraints
Start from the Sequencing Graph. Assumption:
All delays are fixed and known.

Set of linear inequalities.

Longest path problem.

Algorithms for the longest path problem were
discussed in Chapter 2 of De Micheli:
Bellman-Ford,
Liao-Wong.
Bellman-Fords
algorithm
BELLMAN_FORD(G(V, E, W))
{
s
1

0
= 0;
for (i = 1 to N)
s
1

i
=w
0, i
;
for (j =1 to N){
for (i =1 to N){
s
j+1
i
= min { s
j

i
, (s
j

k
+w
q, i
)},
}
if (s
j+1

i
== s
j

i
i ) return (TRUE) ;
}
return (FALSE)
}
k=i
Longest path problem
Use shortest path algorithms:
by reversing signs on weights.

Modify algorithms:
by changing min with max.

Remarks:
Dijkstras algorithm is not relevant.
Inconsistent problem:
Positive-weighted cycles.
Example Bellman-Ford
Iteration 1: l
0
=0, l
1
=3, l
2
= 1, l
3
=.
Iteration 2: l
0
=0, l
1
=3, l
2
=2, l
3
=5.
Iteration 3: l
0
=0, l
1
=3, l
2
=2, l
3
=6.
Use shortest path algorithms:
by reversing signs on
weights.

source
3 -1=2
1+4=5
2+4=6
Liao-Wongs
algorithm
LIAO WONG(G( V, E F, W))
{
for ( i = 1 to N)
l
1
i
= 0;
for ( j = 1 to |F|+ 1) {
foreach vertex v
i

l
j+1
i
= longest path in G( V, E,W
E
) ;
flag = TRUE;
foreach edge ( v
p
, v
q
) eF {
if ( l
j+1
q
< l
j+ 1
p
+ w
p,q
){
flag = FALSE;
E = E ( v
0
, v
q
) with weight ( l
j+ 1

p
+ w
p,q
)
}
}
if ( flag ) return (TRUE) ;
}
return (FALSE)
}
adjust
Example Liao-Wong
Iteration 1: l
0
= 0, l
1
= 3, l
2
= 1, l
3
= 5.
Adjust: add edge (v
0
, v
2
) with weight 2.
Iteration 2: l
0
= 0, l
1
= 3, l
2
= 2, l
3
= 6.
Only positive
edges from (a)
(b) adjusted by
adding longest
path from node
0 to node 2
Looking for longest path
from node 0 to node 3
Method for scheduling
with unbounded-delay operations
Unbounded delays:
Synchronization.
Unbounded-delay operations (e.g. loops).

Anchors.
Unbounded-delay operations.

Relative scheduling:
Schedule operations with respect to the anchors.
Combine schedules.
Relative
scheduling
method
Relative scheduling
method
For each vertex:
Determine relevant anchor set R(.).
Anchors affecting start time.
Determine time offset from anchors.

Start-time:
Expressed by:




Computed only at run-time because delays of anchors are unknown.
Relative scheduling under timing
constraints
Problem definition:
Detailed timing constraints.
Unbounded delay operations.

Solution:
May or may not exist.
Problem may be ill-specified.
Relative scheduling under timing
constraints
Feasible problem:
A solution exists when unknown delays are zero.

Well-posed problem:
A solution exists for any value of the unknown delays.

Theorem:
A constraint graph can be made well-posed iff there
are no cycles with unbounded weights.
(a) & (b) Ill-posed constraint (c) well-posed constraint
Example of Relative scheduling under timing constraints
Relative scheduling approach
1. Analyze graph:
1. Detect anchors.
2. Well-posedness test.
3. Determine dependencies from anchors.

2. Schedule operations with respect to relevant anchors:
Bellman-Ford, Liao-Wong, Ku algorithms.

3. Combine schedules to determine start times:

Example of Relative
scheduling
Example of control-unit synthesized for
Relative scheduling



Operations must be serialized

Scheduling and Binding

schedule
binding
Scheduling
Problem
Scheduling Problem
formalization
Various Operator
types in Scheduling
ASAP
Scheduling

ASAP Scheduling
ASAP scheduling algorithm
ASAP ( G
s
(V, E)){
Schedule v
0
by setting t
S

0
= 1;
repeat {
Select a vertex v
i
whose predecessors are all scheduled;
Schedule v
i
by setting t
S
i
= max t
S

j
+ d
j
;
}
until (v
n
is scheduled) ;
return (t
S
);
}
j:(v
j
,v
i
)eE
Similar to breadth-first search
Example - ASAP
Solution
Multipliers = 4
ALUs = 2
Latency Time=4
ALAP
Scheduling

ALAP Scheduling
successor
ALAP scheduling algorithm
As Late as Possible - ALAP
Similar to depth-first search
Example ALAP
Solution
multipliers =
2
ALUs = 3
Latency Time=4
Remarks on ALAP and mobility
ALAP solves a latency-constrained problem.

Latency bound can be set to latency computed by
ASAP algorithm. <-- using bounds, also in other approaches

Mobility:
Mobility is defined for each operation.
Difference between ALAP and ASAP schedule.

What is mobility?number of cycles that I can move
upwards or downwards the operation

Slack on the start time.
Resource
Constrained
Scheduling under
resource constraints
Classical scheduling problem.
Fix area bound - minimize latency.

The amount of available resources affects the
achievable latency.

Dual problem:
Fix latency bound - minimize resources.

Assumption:
All delays bounded and known.
Minimum latency resource-constrained
scheduling problem
Given a set of operations V with integer delays D a partial
order on the operations E, and upper bounds {a
k
; k = 1,
2,,n
res
}:
Find an integer labeling of the operations : V --> Z
+
such that :
t i = '(v i ),
t i t j +d j 8 i; j s:t: (v j ; v i ) 2 E,
jfv i jT (v i ) = k and t i l < t i +d i gj a k
and tn is minimum.
Number of operations of any given type in
any schedule step does not exceed bound.
:V {1,2, n
res
}
Scheduling under resource
constraints
Intractable problem.

Algorithms:
Exact:
Integer linear program.
Hu (restrictive assumptions).

Approximate:
List scheduling.
Force-directed scheduling.
Resource Constraint Scheduling
ML-RCS:
minimize latency,
bound on resources
MR-LCS:
minimize resources,
bound on latency
Algorithm of Hu for
Resource Constraint Scheduling
ML-RCS:
minimize latency,
bound on resources
Example of using
Hus algorithm
Assumptions:
One resource type only.
All operations have unit delay.
Distance
from sink
Additional assumptions:
Graph is a forest.

Algorithm:
Label vertices with distance
from sink.
Greedy strategy.
Exact solution.
Hu's algorithm
Algorithm
Hu's schedule with a resources
Set step, l = 1.
Repeat until all operations are
scheduled:
Select s s a resources with:
All predecessors scheduled.
Maximal labels.
Schedule the s operations at step l.
Increment step l = l +1.
All
operations
have unit
delay.

All
operations
have the
same type.
Minimum latency with a = 3
resources.
Step 1:
Select {v
1
, v
2
, v
6
}.
Step 2:
Select {v
3
, v
7
, v
8
}.
Step 3:
Select {v
4
, v
9
, v
10
}.
Step 4:
Select {v
5
, v
11
}.
Algorithm
Hu's schedule with a resources
We always select 3
resources
Minimum latency with a = 3
resources.
Step 1:
Select {v
1
, v
2
, v
6
}.
Step 2:
Select {v
3
, v
7
, v
8
}.
Step 3:
Select {v
4
, v
9
, v
10
}.
Step 4:
Select {v
5
, v
11
}.
Algorithm
Hu's schedule with a resources
We always select 3
resources
Example of Hus Algorithm
Distance
from sink
Example
of Hus
Algorithm

Exactness of Hu's algorithm
Theorem1:
Given a DAG with operations of the same type.
a is a lower bound on the number of resources to complete a
schedule with latency .
is a positive integer.
Theorem2:
Hu's algorithm applied to a tree with unit-cycle resources
achieves latency with a resources.
Corollary:
Since a is a lower bound on the number of resources for
achieving , then is minimum.
LIST
scheduling
List scheduling idea

Example

DFG
List Schedule
Assumptions
a
1
= 2 multipliers with delay 1.
a
2
= 2 ALUs with delay 1.
First Step
U
1,1
= {v
1
, v
2
, v
6
, v
8
}
Select {v
1
, v
2
}

U
1,2
= {v
10
}; selected
Second step
U
2,1
= {v
3
, v
6
, v
8
}
select {v
3
, v
6
}
U
2,2
= {v
11
}; selected
Third step
U
3,1
= {v
7
, v
8
}
Select {v
7
, v
8
}
U
3,2
= {v
4
}; selected
Fourth step
U
4,2
= {v
5
, v
9
}; selected
Priority list heuristics.
Assign a weight to each vertex indicating
its scheduling priority
Longest path to sink.
Longest path to timing constraint.

List Scheduling
Algorithms
List scheduling
algorithms
Heuristic method for:
1. Minimum latency subject to resource bound.
2. Minimum resource subject to latency bound.

Greedy strategy (like Hu's).

General graphs (unlike Hu's).


LIST scheduling
List scheduling algorithm
for minimum resource Usage
Candidate Operations U
l,k

Operations of type k whose predecessors are scheduled and completed at
time step before l


Unfinished operations T
l,k
are operations of type k that started at earlier cycles
and whose execution is not finished at time l


Note that when execution delays are 1, T
l,k
is empty.
} ) , ( : ) ( : {
,
E v v j l d t k v ype V v U
i j j j i i k l
e s + = e = and
} ) , ( : ) ( : {
,
E v v j l d t k v ype V v T
i j j j i i k l
e > + = e = and
List scheduling algorithm
for minimum latency for resource bound
List scheduling algorithm
for minimum latency for resource bound
LIST_L ( G(V, E), a ) {
l = 1;
repeat {
for each resource type k = 1, 2,,n
res
{
Determine candidate operations U
l,k
;
Determine unfinished operations T
l,k
;
Select S
k
_ U
l,k
vertices, such that |S
k
| + |T
l,k
| s a
k
;
Schedule the S
k
operations at step l;
}
l = l +1;
}
until (v
n
is scheduled) ;
return (t );
}
Assumptions:
a
1
= 3 multipliers with
delay 2.
a
2
= 1 ALUs with delay 1.
List scheduling algorithm
for minimum latency
1. List scheduling algorithm
for minimum latency for resource bound
Now we need
two time units for multiplier
Assumptions
a
1
= 3 multipliers with delay 2.
a
2
= 1 ALU with delay 1.

Example
Assume =4
Let a = [1, 1]
T
First Step
U
1,1
= {v
1
, v
2
, v
6
, v
8
}
Operations with zero slack {v
1
, v
2
}
a = [2, 1]
T
U
1,2
= {v
10
}
Second step
U
2,1
= {v
3
, v
6
, v
8
}
Operations with zero slack {v
3
, v
6
}
U
2,2
= {v
11
}
Third step
U
3,1
= {v
7
, v
8
}
Operations with zero slack {v
7
, v
8
}
U
3,2
= {v
4
}
Fourth step
U
4,2
= {v
5
, v
9
}
Both have zero slack; a = [2, 2]
T

Assumptions:
a
1
= 3 multipliers with delay 2.
a
2
= 1 ALUs with delay 1.
1. List scheduling algorithm
for minimum latency for resource bound
Solution
3 multipliers as assumed
1 ALU as assumed
LATENCY 7

Compute the latest possible start times
tL by ALAP ( G(V,E), );
2. List scheduling algorithm
for minimum resource usage
overlap
2. Example: List scheduling algorithm for
minimum resource usage
From ALAP
We can move
them
Solution
2 multipliers
1 ALU
LATENCY 4
Now we assume
the same time of
each operation
List Scheduling Algorithm example
ML-RCS
* * * *
*
*
-
-
+
+
<
Assume 3
multipliers
Assume 1
ALU
t=0mul 3m 1 ALU
t=1 1 ALU
t=2 3mul
t=3 1 ALU
t=4 1 ALU
t=5 1 ALU
Now we assume the same time of
each operation
Other way of explanation
of the same as in last
slide
List
Scheduling
Algorithm
example
ML-RCS
Generic List
Scheduling
List Scheduling Example
The scheduled DFG
DFG with mobility labeling (inside <>)







ready operation list/resource constraint
Static-List Scheduling
DFG





Partial schedule of five nodes






Priority list






The final
schedule

Classification of
Scheduling Approaches

Classification of
Scheduling Approaches
Classification of Scheduling
Approaches


Scheduling with chaining
Consider propagation delays of resources not in terms of cycles.

Use scheduling to chain multiple operations in the same control step.

Useful technique to explore effect of cycle-time on area/latency trade-off.

Algorithms:
ILP,
ALAP/ASAP,
List scheduling.
Example of Scheduling with chaining
Cycle-time: 60.
Summary

Scheduling determines area/latency trade-off.
Intractable problem in general:
Heuristic algorithms.
ILP formulation (small-case problems).
Chaining:
Incorporate cycle-time considerations.

Other scheduling
approaches

Scheduling
Finite Impulse
Response Filter
D
* *
+
*
D
+
*
D
+
*
D
+
*
D
+
*
D
+
*
D
+
*
D
+
*
D
+
*
D
+
IN[i]
OUT
c0 c3 c2 c1 c7 c6 c5 c4 c10 c9 c8
A0
A0
A3 A2 A1 A6 A5 A4 A8 A7 A9
B0
B1
B1
B4 B3 B2 B5 B7 B6 B8 B9
IN[i-1] IN[i-2] IN[i-6] IN[i-5] IN[i-4] IN[i-3] IN[i-8] IN[i-7]
IN[i-10]
IN[i-9]
This can be directly used for synthesis with 11 multipliers, 10 adders and 10
registers. But the latency would be 1 multiplier + 10 adders
Example 1
FIR
Scheduling
+
+
+
+
+
+
+
*
*
*
*
*
*
*
*
*
*
+
+
+
*
1
10
9
8
7
6
5
4
3
2
11
c0
c1
c2
c3
c4
c5
c6
c7
c8
c9
c10
A0
A4
A3
A2
A1
A5
A6
A7
A8
A9
B0
B3
B2
B1
B4
B6
B5
B9
B8
B7
IN[i] IN[i-1]
IN[i-6]
IN[i-5]
IN[i-4]
IN[i-3]
IN[i-2]
IN[i-8]
IN[i-7]
IN[i-9]
IN[i-10]
OU
T
1 adder, 1 multiplier
2 multipliers
This is also bad
as we use both
multipliers only
in stage 1
There are many ways
to solve this problem,
transform the tree,
schedule, allocate,
pipeline, retime
Example: Cascade Filter
optimization
IN[i] OUT
+ +
+ +
*
* *
D
D
+ +
+ +
*
* *
D
D
A0[i]
A0[i-1]
A0[i-2]
A1 A2
A5
A4
A3
c0
c1
c2
B
C0[i]
C0[i-1]
C0[i-2]
c5
c4 c3
C1
C5
C4
C2
C3
Look to ci coefficients and compare with two
previous slides.
Example 2
This is not FIR,
six coefficients
Cascade
Filter
Scheduling,
cont example
2
* *
+
********
*
+
+
+
+
+
*
+
* *
+
1
2
3
4
5
6
OUT
c1
c4
c5
c0
c2
c3
A0[i-1] A0[i-2]
A0[i-2]
C0[i-1]
C0[i-1] C0[i-2]
A2
A4
A5
A0[i] A3
B
C5
c0[i] C3
C1
C2
C4
C0[i-2]
IN
IN[i] OUT
+ +
+ +
*
* *
D
D
+ +
+ +
*
* *
D
D
A0[i]
A0[i-1]
A0[i-2]
A1 A2
A5
A4
A3
c0
c1
c2
B
C0[i]
C0[i-1]
C0[i-2]
c5
c4 c3
C1
C5
C4
C2
C3
2 mul, 2 add
Infinite Impulse
Response Filter
* *
IN
+ +
D
D
+ +
* *
OUT
* *
+ +
D
D
+ +
* *
D
+
*
+
*
A0[i]
A0[i-1]
A0[i-
2]
C0[i] D0[i]
D0[i-1]
C0[i-1]
c0
c8
c9
c6 c7
c4
c5
c3 c2
c1 A1
A4 A3
A2 C1
C3
B
C0[i-2]
C4
C2
D
D1 D2
C5 C6 A5 A6
Example 3
IIR Filter, 10 coefficients
IIR Filter Scheduling continued
*
+
*
+
+
+
+
+
+ +
+
+
*
* *
* *
*
*
*
1
7
3
4
6
5
2
8
c3
c4
c6
c5 c7
c0 c2
c1
c8
c9
A0[i-2] A0[i-1]
A0[i-2] A0[i-1]
C0[i-2]
C0[i-1]
C0[i-1] C0[i-2]
D0[i-1]
D0[i-1]
A2
D1
D2
C3
D0[i]
D
C0[i]
B
A3 A0[i]
A4
A6
C6
C2
A5 A1
C1
C5
C4
OUT
IN
IIR Filter, 10 coefficients
Two adders two
multipliers

Minimize Resources Subject to
bound on Latency = MR-LCS