Kapitel 5.4 - CES

Path-Based Scheduling 5.4-1
Formalisierung des Path-Scheduling-Algorithmus’ 5.4-2
Kontrollflußgraph
G = ( V, E, v 0 )
1. Kontrollflußgraph extrahieren
2. Kontrollflußgraph in einen azyklischen Kontrollflußgraphen
umwandeln
V – Menge der Operationen
E ⊂ V × V– Menge der gerichteten Kanten
– Anfangsknoten
v 0
e v i v j
3. Pfade berechnen
4. für jeden Pfad 'constraints' berechnen
5. für jeden Pfad 'cut-Intervalle' berechnen
Für jede Kante = ( , ) ∈ Eexistiert eine Bedingung cond ( v i , v j ),
die die Durchführung der Operation v j steuert.
N.B.: G ist im allgemeinen Fall ein zyklischer Graph.– (1)
6. für alle Pfade 'cut-Intervalle' berechnen
7. 'cut-Punkte' für den gesamten Graph bestimmen
8. 'cut-Punkte' für jeden Pfad berechnen
9. Pfade zerlegen
10. Zustände berechnen
11. Zustandsübergänge berechnen
12. Zustandsübergangs-Bedingungen berechnen
Azyklischer Kontrollflußgraph 5.4-3
Ausgehend von G kann man durch Schleifen-Entfernung einen azyklischen
Graph generieren.
G'
= ( V, E' , L' , V 0 )
V – Operationen
L' – entfernte Kanten
E' – Rest-Kanten
E' ∩ L' = ∅ und E' ∪ L' = E
13. Bedingungen für jede Operation berechnen
V 0 – Anfangsknoten, wobei
V 0 = { V 0 } ∪ { V}
falls ∃v
∈ V ⋅ ( v' , v) ∈ L'
- (2)
d.h. alle Endknoten der entfernten Kante

Beispiel - Spezifikation und Kontrollflußgrap 5.4-4
Beispiel - Azyklischer Kontrollflußgraph 5.4-5
entity prefetch is
port (branchpc, ibus : in bit 32;
branch, ire : in bit;
ppc, popc, obus : out bit 32);
1
2
1
architecture behaviour of prefetch is
begin
process
begin
ppc

Pfade des Kontrollflußgraphen 5.4-6
Pfade und Constraints 5.4-8
Ein Pfad ist eine Sequenz von aufeinanderfolgenden Knoten. Die
Menge aller Pfade von G’ ist :
1
∪
IP G’ = P v ∈ v0 G’ ( v)
- (3)
2
wobei P G’ ( v)
die Menge aller Pfade ist, die in v beginnen
3
P G’ ( v)
⎧{ v :: rp | rp ∈ P G’ ( v' ), falls ∃v'
⋅ ( vv' , ) ∈E'}
= ⎨
⎩{ [ v]
}, sonst
'::' entspricht der 'cons'-Operation.
– (4)
branch
5
4
6
branch
V0 = {1,7}
Pfade im Beispiel sind:
p 1 (1) = [1,2,3,4,5,6,7,8,9,10]
p 2 (1) = [1,2,3,4,6,7,8,9,10]
p 1 (7) = [7,8,9,10]
7
ire
8
Teilpfade eines Pfades 5.4-7
9
k
Sei T i ( p)
der Teilpfad
k
T i ([ v1 , v 2 , …, v n ]) = [ v i , v i + 1 ,…
, v ] k
Die Menge aller Teilpfade eines Pfades p ist
⎧ k ⎫
TP( p) = ⎨T i( p)
1 ≤ i ≤ k ≤ len( p)
⎬
⎩
⎭
wobei len(p) die Länge des Pfades p ist.
– (5)
– (6)
10
Ziel des Algorithmus:
Jeder Pfad in minimalen Anzahl von
Zustände zu realisieren unter Beruecksichtigung
der Constraints
mögliche Constraints in jedem Zustand:
• Variablen dürfen nur einmal zugewiesen werden
• E/A Schnittstellen durfen nur einmal gelesen bzw. geschrieben werden
• Jeder funktionale Einheit darf nur einmal benutzt werden
• Maximale Zeitdauer des Zustands kann vorgegeben werden

Integration der Constraints 5.4-9
Beispiel - Constraints für einen Pfad 5.4-10
Wenn zwischen Operationen v i und v j auf einem Pfad p ein ’constraint’
entsteht, dann wird er als ein Teilpfad [ v i + 1 , v i + 2 , … , v ] j aufgefaßt,
wobei ( v i , v i + 1 ) ∈ E'
1
2
v i
a = b + c
1 Addierer
3
v i+1
branch
4
v j
d = e + f constraint [v i+1 , ..., v j ]
Der 'constraint' besagt, daß der Pfad vor einem Knoten in diesem
Intervall geschnitten werden muß.
Die Menge aller 'constraints' auf einem Pfad p ist
5
ire
6
7
8
cp ( ) ⊂TP( p)
und
9
die Menge aller 'constraints' in G' ist
C G’ =
{ cp ( ) p ∈ P G’ }
– (7)
10
Constraint 1 Constraint 2
für den Pfad p 1 (1) :
Constraint 1 entsteht weil pc in Knoten 5 und 9 zugewiesen wird
c 1 (p 1 (1)) = [6,7,8,9]
Constraint 2 entsteht zwischen den Knoten 3 und 9 unter der
Annahme das nur ein Addierer existiert
c 2 (p 1 (1)) = [4,5,6,7,8,9]

Intervallgraph eines Pfades 5.4-11
Beispiel - Interval Graph für einen Pfad 5.4-12
IG G’ ( p) = ( V IGG’ ( p) , R)
V IGG’
( p) = c( p) ∪ { v ∈ V|
∃v'
· ,( v' , v)
∈ L}
das sind alle ’constraints’ auf dem Pfad p und die Endknoten der
Schleifenabbruchs-Kante
branch
1
2
3
4
( c i , c j ) ∈ R ⇔ overlap( c i , c j ) ∧ ( c i , c j ∈ V IGG’ ( p)
)
–(8)
5
6
Constraint 1
overlap ist ein Prädikat über zwei Pfade und ist definiert wie folgt :
ire
7
8
Constraint 2
overlap ([
],
p) = false
overlap( v::g,
p) = mem( v,
p) ∨ overlap( g,
p)
– (9)
9
10
Constraint 1 Constraint 2
mem ist ein Prädikat, welches das Enthaltensein eines Knotens in
einem Pfad überprüft
1
2
2
mem( v , [ ]) = false
mem( v,
v'::p) = ( v = v' ) ∨ mem( v,
p)
–(10)
5
3
4
1
2
3
3
1
6
7
8
4
5
4 5
9
10
Constraints und Intervallgraph fur ein anderes Beispiel

Cliquen-Partitionierung im Intervallgraph 5.4-13
Cliquen im Intervallgraph IG G’ ( p)
entsprechen der minimalen Anzahl
von Schnittintervallen in einem Pfad p , wobei alle ’constraints’ eingehalten
wurden.
Cut-Intervallgraph von G’ 5.4-14
CT G’
= ( V CTG’
, E CTG’
)
V CTG’
= ∪p ∈ P G’
CUT G’ ( p)
cl 2
1 2 3 4 5 6 7 7
8
9
3 2
6 5
cl 1
4 3
5 4
10
11
( tp i , tp j ) ∈ E CTG’
⇔
overlap( tp i , tp j ) ∧
( tp i ∈V CTG’
)∧
( tp j ∈ V CTG’
) ∧
( tp i ≠ tp j )
- (15)
Die Menge der Cliquen
CL G’ ( p) = { cl 1 , …, cl r } ⊂ 2 cp ( )
und cl i ∩ cl j = ∅ fuer i ≠ j
– (11)
Die 'cut-Menge' eines Pfades p ist
∪
CUT G’ ( p) =
cut( cl i )
– (12)
cl i ∈ CL G’ ( p)
wobei cut( cl i ) = cut– points tp
– (13)
∀t ∈ cl p i
und cut_points ist definiert wie folgt :
cut_points ([ ],g)= [ ]
cut_points (v::f,g)= if mem(v, g) then v::cut_points(f,g)
else cut_points(f,g) – (14)
Die Minimierung von 'cuts' über den gesamten Graphen G' wird
durch Cliquen-Partitionierung von CTG' erreicht.
Die Menge der Cliquen :
Analog zu (12) kann man die 'cut-Mengen' bestimmen:
wobei
KL G’
KUT G’
= { kl 1 , …, kl s }
= { kut 1 , …, kut s }
kut i = cut – points t p
t ∈ kl p i
– (16)
– (17)

Beispiel - Interval Graph für G' 5.4-15
’cut-Punkte’ des Graphen 5.4-16
1
2
1
2
Mit einer heuristischen Auswahl kann man aus der Menge der Kut-
Intervalle KUT G’ bestimmte Knoten auswählen, die 'cut-Punkte' heißen:
3
3
CP G’
= { cp 1 , …, cp s }
branch
5
4
4
branch
cp i ∈ v,
1 ≤ i ≤ s
– (11)
Für jeden Pfad p ∈ P G’ kann eine Menge von cut-Punkten KP( p)
folgendermaßen
definiert werden :
6
6
kp ∈ KP( p)
⇔ ∃cp i ∈ CP G’ , ( kp = cp i )
– (20)
ire
7
8
ire
7
8
7
8
kp ist der Knoten, an dem die Eingangskante geschnitten werden
muß, so daß der Pfad geteilt wird.
9
9
9
10
10
10
CUT G’ ( p 1 ( 1)
) = {[ 1] ,[ 6, 7, 8, 9]
}
CUT G’
( p 2
( 1)
) = {[ 1] ,[ 4, 6, 7, 8, 9]
}
CUT G’
( p 1
( 7)
) = {[ 7]
}
KUT G’ = {[ 1] ,[ 7]
}

Zerlegung des Pfades 5.4-17
Zustandsbildung 5.4-18
Bevor ein Pfad p zerlegt wird, wird eine Hilfsfunktion Htp ( , rp)
definiert.
Diese Funktion liefert einen Teilpfad des Pfades p bis zu einem
’cut-Punkt’ sowie den Rest des Pfades
Htp ( , [ ]) = ( tp ,[ ])
Htp ( , v::rp) = if v ∈ KP( p)
then (tp, v::rp)
else H(tp::v, rp) – (21)
Jetzt wird die Funktion Z zur Zerlegung des Pfades
Z([ ]) = [ ]
p ∈ P G’
definiert
Zv::rp ( ) = { tp} ∪ Z{ rp' } falls H( [ v] , rp) = ( tp, rp' ) – (22)
Jetzt können alle zerlegte Teilpfade in Zuständen zusammengefaßt
werden. Dafür werden Äquivalenzklassen gebildet. Die Teilpfade, die
zu einer Äquivalenzklasse gehören, sind Teilpfade mit den gleichen
Anfangsknoten (d.h. gleiche Anfangsoperation).
wobei
v i ::rp i ≅ v j ::rp j ⇔ v i = v j
v i ::rp i ∈ Zp ( i ) ∧ v j ::rp j ∈ Zp ( j ), p i , p j ∈ P G’
– (24)
S G ist die Zustandsmenge, d.h. die Menge aller Äquivalenzklassen, die
mit ≅ über dem gesamten Kontrollflußgraph G definiert sind.
Für den Zustandsgraphen
Die Menge aller Teilpfade des Graphen :
ZG G
= ( S G , E ZG )
– (25)
Z G’
=
{ Zp ( ) | p ∈ P G’ }
– (23)
gibt es für jedes s ∈ S G einen eindeutigen Anfangsknoten, der
genannt wird.
fst( s)

Zustandsübergäng 5.4-19
Bedingungen für Zustandsübergänge 5.4-20
Um einen Zustandsübergang zu ermöglichen, müssen zwischen s i
und s j die Bedingungen über allen Teilpfaden, die von s i nach fst( s j )
gehen, erfüllt werden, d.h. es müssen eine UND-Operation über allen
Bedingungen eines Pfades und eine ODER-Operation über allen Pfaden,
die von s i nach fst( s j ) führen, gebildet werden.
s j
s i
E ZG sind die Kanten des Zustandsgraphen.
Eine Kante zwischen s i , s j ∈ S G existiert, wenn die Knoten s i unds j
durch mindestens eine Kante verbunden sind.
∧
∨
trans( s i , s j ) =
cond( v,
v' ) ∧ cond( last( tp) , fst( s ))
j
∀tp
∈ s i
mem( v,
tp)∧
( last( tp) , fst( s
mem( v’ , tp)∧
j
)) ∈ E
( vv’ , ) ∈ E’
– (27)
Eine Hilfsfunktion, die die letzten Knoten des Teilpfads tp ∈ Z( p)
liefert,
wird folgendermaßen definiert :
last ([ ]) = ⊥
last(v::rp) = if rp = [ ] then v else last(rp) – (26)
alle ausgehenden
Kanten zwischen
s i und s j
die Bedingungen
über jede solche
Kante
Jetzt können die Zustandsübergänge definiert werden
( s i , s j ) ∈ E ZG ⇔ ∃tp
∈ s i . ( last( tp) , fst( s j )) ∈ E,
s i , s j ∈ S G
N.B.: Dadurch, daß E und nicht E' genommen wird und keine si¦sj
Restriktion gemacht wird, sind Schleifen auch mitenthalten.

Bedingungen für Operationen - 1 5.4-21
Bedingungen für Operationen - 2 5.4-22
Eine weitere Hilfsfunktion, die den Teil eines Teilpfades bis zu einem
Knoten v berechnet, ist die folgende :
until(v’::tp, v) = if v’ = v then [v’] else v’::until(tp, v)– (30)
v
v
s
s j
i
Für jeden Knoten müssen die Bedingungen erfüllt sein.
Eine Funktion, die Wahr wird, wenn der Automat im Zustand s i ist,
wird wie folgt definiert ( s ∈ S G ):
Die Funktion en(v) definiert die Bedingungen für die Operation v :
⎛
⎛
⎞ ⎜
⎜
⎟ ⎜
en( v) = ⎜ on( s i ) ⎟ ∧ ⎜
⎜ ∨ ⎟ ⎜
⎝∀
s i
∈ S
⎠ ⎜
G ⎝
in( v,
s i
)
∨
∧
∀s i
∈S G
mem( u,
until( tp,
v)
) ∧
∀tp
∈ s
mem( u’ , until( tp,
v)
) ∧
i
( uu’ , ) ∈ E’
in( v,
s ) i
⎞
⎟
⎟
cond( u, u' ) ⎟
⎟
⎟
⎠
– (31)
on( s)
⎧ true
= ⎨
⎩ false
- (28)
Eine Hilfsfunktion, die Wahr wird, wenn eine Operation v in einem
Zustand s ∈ S G durchgeführt wird, wird wie folgt definiert :
in( v,
s)
⎧ true
= ⎨
⎩false
wenn der Automat im Zustand s ist
sonst
falls ∃tp ∈ s,
mem( v,
tp)
sonst
- (29)
in allen Zuständen,
in denen v liegt
alle Teilpfade in allen
Zuständen, in denen v liegt
Knoten des Teilpfades,
der in v endet