Agenda

Parallelität auf Instruktionsebene
Übersetzung von künstlichen Sprachen
Präsentation: Christoph Heitmann
03.06.2009
Motivation
Moderne Rechnerarchitekturen nutzen die parallele Befehlsausführung für eine beschleunigte/effiziente Programmausführung
VLIW
• Very Long Instruction Word
• Mehrere Befehle zu einem
VLIW-Befehl
zusammengefasst
• Statische Planung
Superskalar
• Mehrere parallelarbeitende
Funktionseinheiten
• Dynamische Planung
Parallelität auf
Instruktionsebene
2
Agenda
Grundlagen
Lokale
Codeplanung
Globale
Codeplanung
Softwarepipelining
3
Agenda
Grundlagen
Lokale
Codeplanung
Globale
Codeplanung
Softwarepipelining
4
Grundlagen
Phasenstruktur eines Compilers
Die Optimierung für Befehlsparallelität erfolgt auf Basis eines Zwischencodes und für eine spezifische Architektur
Frontend
Optimierung
Backend
Optimierung für
Parallelität auf
Instruktionsebene
Zielcode-Generierung
Lexikalische Analyse
Syntaktische Analyse
Semantische Analyse
u.a.
ZwischencodeGenerierung
5
Grundlagen
Darstellungsformen (1)
Das Programmbeispiel berechnet den größten gemeinsamen Teiler zweier Zahlen nach Euklid
Ursprungsprogramm (C#):
Code für abstrakte Maschine:
// Gegeben: Zwei Ganzzahlen a > 0, b > 0,
// Variable z für Zwischenberechnungen
1
while (b > 0)
| Block A
2
{
3
if (a < b)
| Block B
4
{
5
z = a;
| Block C
6
a = b;
| Block C
7
b = z;
| Block C
8
}
9
z = a - b;
| Block D
10
a = b;
| Block D
11
b = z;
| Block D
12
}
// Gegeben: Zwei Ganzzahlen a > 0, b > 0
// r0 = Speicherdresse von a,
// r1 = Speicherdresse von b, r2 = 0
I1
S:
LD r3, r0
I2
LD r4, r1
I3
CJMP r3 < r4, T
|--- Ende Grundblock A ---|
I4
SUB r5, r3 – r4
I6
ST r0, r4
I7
ST r1, r5
I8
CJMP r4 > r2, S
|--- Ende Grundblock B ---|
|--- Ende von Programmteil S ---|
I9
T:
LD r5, r0
I10
ST r0, r4
I11
ST r1, r5
I12
CJMP S
|--- Ende Grundblock C ---|
|--- Ende von Programmteil T ---|
Generiere
Zwischencode
Abstrakte Maschine
 RISC-ähnliche Architektur
 Lade- und Speicherbefehl (LD bzw. ST)
 Addition und Subtraktion (ADD bzw. SUB)
 Bedingter Sprungbefehl (CJMP)
 1x Rechenwerk (ALU)
 1x Speicherkommunikationseinheit (MEM)
6
Grundlagen
Darstellungsformen (2)
Im Programm befindliche Steuerungs- und Datenabhängigkeiten lassen sich mit Hilfe von Graphen veranschaulichen
Kontrollflussgraph (und Verfeinerung)
Datenabhängigkeitsgraph
B
F
ALU MEM
A
T
T
B
SUB r5, r3–r4
SUB r5, r3 – r4
T
F
C
B
F
ST r0, r4
ST r0, r4
ST r1, r5
CJMP r4 > r2, S
F
1
1
ST r1, r5
1
1
1
CJMP
S
1
 Steuerungsabhängigkeiten
 echte Datenabängigkeiten
 Beschreibt Programmfluss mit Bedingungsprüfungen
 Ressourcenreservierungstabelle
 Programmverzweigungen mit wahr (T) und unwahr (F)
 Kantenbeschriftung mit Verzögerungszeiten
7
Agenda
Grundlagen
Lokale
Codeplanung
Globale
Codeplanung
Softwarepipelining
8
Agenda
Grundlagen
Lokale
Codeplanung
Globale
Codeplanung
Softwarepipelining
9
Planung eines Grundblockes (1)
Die lokale Codeplanung ergibt einen Ablaufplan für einen Grundblock, und stellt somit den ersten Schritt einer Optimierung dar
Datenabhängigkeitsgraph:
Optimiertes Maschinenprogramm:
B
ALU MEM
SUB r5, r3–r4
ST r0, r4
1
1
ST r1, r5
1
Listenplanung
1
Takt
1
2
3
Maschinencode
SUB r5, r3 – r4
ST r0, r4
ST r1, r5
CJMP r4 > r2, S
-
ALU
MEM
1
CJMP
S
1
Grundsatz der Listenplanung
„… berechnet der Algorithmus den frühesten Zeitpunkt,
zu dem ein Knoten ausgeführt werden kann, gemäß
seinen Datenabhängigkeiten zu den vorher verplanten
Knoten.“
Alfred V. Aho, Monica S. Lam, Ravi Sethi, Jeffrey D. Ullman
10
Planung eines Grundblockes (2)
Nicht alle Grundblöcke bieten die Möglichkeit einer parallelen Befehlsausführung
Ablaufpläne optimierter Grundblöcke
Takt
1
2
3
4
Maschinencode
LD r3, r0
LD r4, r1
CJMP r3 < r4, T
-
ALU
Takt
1
2
3
Maschinencode
SUB r5, r3 – r4
ST r0, r4
ST r1, r5
CJMP r4 > r2, S
-
ALU
Takt
1
2
3
4
5
Maschinencode
LD r5, r0
ST r0, r4
ST r1, r5
CJMP r3 < r4, T
-
ALU
Auswertung
MEM
 Grundblock A: Keine parallele Ausführung
 Grundblock B: Benötigt 3 statt 4 Takte
 Grundblock C: Keine parallele Ausführung
MEM
Fazit
Die Listenplanung im Rahmen
der lokalen Ablaufplanung
erfasst nur ein geringes
Parallelitätspotential.
MEM
-
11
Agenda
Grundlagen
Lokale
Codeplanung
Globale
Codeplanung
Softwarepipelining
12
Agenda
Grundlagen
Lokale
Codeplanung
Globale
Codeplanung
Softwarepipelining
13
Planung mehrerer Grundblöcke / Bereiche (1)
Im Rahmen der Bereichsplanung erfolgt eine Herausarbeitung von Parallelität über Grundblockgrenzen hinaus
Dominanzbeziehungen und
Parallelitätskonzepte
Bereichsplanung
 Dominanzbeziehungen zwischen Grundblöcken
 berücksichtigt Dominanzbeziehungen
• Dominanz
• Postdominanz
• Kontrolläquivalenz
 einfache Codeverschiebung (aufwärts)
 spekulative Ausführung
 erfolgt an Hand eines azyklischen Graphen
 Konzepte
• einfache Codeverschiebung
•
aufwärts
•
abwärts
Ein Bereich ist eine Menge von Grundblöcken und
im Programmablauf nur durch einen Eingangspunkt
erreichbar.
(Definition in Anlehnung an David Bernstein, Michael Rodeh)
• Spekulative Ausführung
• Duplikation
14
Planung mehrerer Grundblöcke / Bereiche (2)
Die Bereichsplanung erfolgt von innen nach außen und ermöglicht die parallele Ausführung von Befehlen verschiedener Grundblöcke
Global geplanter Ablaufplan
Zeile
1
2
3
4
5
6
7
8
9
Block
A
A
A
A
A
B
B
C
C
S:
T:
Maschinencode
LD
LD
CJMP r3 < r4, T
LD
SUB r5, r3 – r4
ST
CJMP r4 > r2, S
ST
ST
CJMP r3 < r4, T
ST
Auswertung
ALU
r3,
r4,
r5,
r0,
r1,
r0,
r1,
r0
r1
MEM
 ursprünglich: 11 Zeilen / max. 17 Takte
 jetzt: 9 Zeilen / max. 9 Takte
r0
r4
r5
r4
r5
Der Grad der parallelen Ausführung
lässt sich mit Hilfe der Bereichsplanung
steigern. Jedoch ist das Parallelitätspotential auf Grund der azyklischen
Optimierung von Schleifen begrenzt.
15
Agenda
Grundlagen
Lokale
Codeplanung
Globale
Codeplanung
Softwarepipelining
16
Agenda
Grundlagen
Lokale
Codeplanung
Globale
Codeplanung
Softwarepipelining
17
Schleifentypen
Zu beachtende Abhängigkeiten zwischen einzelnen Iterationen einer Schleife existieren in sogenannten Do-Across-Schleifen
Do-Schleife
Do-Across-Schleife
// Gegeben: Array a mit Ganzzahlen,
// Indexvariable i mit 0 initialisiert
// Anzahl Elemente n des Arrays a, Konstante c
1
while (i < n)
1
{
3
a[i] = a[i] + c;
4
i++;
5
}
//
//
//
//
1
2
3
4
5
 z.B. Operationen auf Vektoren
 z.B. Berechnungen mit Zwischenprodukten
 einzelne Schleifendurchläufe unabhängig
 Abhängigkeiten zwischen den Iterationen
 einfacher Fall
 komplex
Gegeben: Array a mit Ganzzahlen,
Indexvariable i mit 0 initialisiert
Anzahl Elemente n des Arrays a,
Variable prod mit 1 initialisiert
while (i < n)
{
prod = prod * a[i];
i++;
}
18
Abwickeln von Schleifen
Bestehen keine Datenabhängigkeiten zwischen den Durchläufen, kann die Schleife theoretisch vollständig abgewickelt werden
Viermal abgewickelte Do-Schleife
I1
LD++
// Iteration 1
I2
ADD , LD++ // Iterationen 1 + 2
I3
ST++ , ADD // Iterationen 1 + 2
I4
ST++
// Iteration 2
I5
LD++
// Iteration 3
I6
ADD , LD++ // Iterationen 3 + 4
I7
ST++ , ADD // Iterationen 3 + 4
I8
ST++
// Iteration 4
|----------- Ende der Abwicklung ------------|
I9
S:
LD++
// Iterationen 5 bis n
I10
ADD
I11
ST++ , CJMP-- S
Softwarepipeling:
Lösung
Ermöglicht die geforderte Ausführungsbeschleunigung mit einem geringen
Zuwachs bzgl. des Codeumfangs.
 sehr hohes Parallelitätspotential
 drastischer Codezuwachs
 Kompromiss notwendig
19
Umsetzung der Do-Schleife in einer Softwarepipeline
Eine Pipeline bietet i.d.R. schon für wenige Iterationen einen hohen, mit der Durchlaufzahl wachsenden Geschwindigkeitsvorteil.
Bestandteile
Softwarepipeline
 Prolog
• „Füllen“ der Pipeline
• einmalig ausgeführt
 Stationärer Zustand („Kernel“)
• Mini-Schleife
• maximale Parallelität
• n-fach ausgeführt
 Epilog
• „Leeren“ der Pipeline
• einmalig ausgeführt
1
2
3
4
5
6
Best.
(P)
(SZ)
(E)
Maschinencode
S:
LD++
ADD
ST++
LD++
ADD
ST++
LD++
ADD
ST++
ALU
MEM
JMP
CJMP-- S
 SZ bearbeitet n – 2 Iterationen
 SZ benötigt 2 (statt 3) Takte je Iteration
 Schleife muss mindestens 3x durchlaufen werden
 Konfliktprüfung: Modulare Ressourcenreservierungstabelle
20
Umsetzung der Do-Across-Schleife (1)
Die Umsetzung einer Do-Across-Schleife findet auf Basis eines zyklischen Abhängigkeitsgraphen statt.
Planungsverfahren
Graphenerweiterung
 Planung eines zyklischen Graphen
ALU MEM JMP
LD++
 Minimierung des Einleitungsintervalls ist nur NP-lösbar
0,1
LD
0,1
0,1
MULT
1,1
 Vereinfachung durch Anwendung einer Heuristik
0,1
0,1
• Ober- und Untergrenze des Einleitungsintervalls
• liefert Ergebnisse nahe am Optimum
0,1
ST , CJMP
1
-- S
 Sukzessive Planung von SCCs (Strong Connected Components)
 Berechnung der längsten einfachen Pfade
SCC1
A
• Zyklen haben keine Auswirkung
• garantiert Einhaltung aller Abhängigkeiten
 Rückverfolgung (engl. „Backtracking“)
0,1
SCC2
B
1,1
0,1
0,1
C
0,1
D
21
Umsetzung der Do-Across-Schleife (2)
Im Beispiel ergibt sich ein Einleitungsintervall s von 3 Takten
Softwarepipeline
Verfahrensanwendung
s
N
Intervall
Startzeitpunkt
3
3
3
3
A
0, ∞
1, ∞
2,2
3,3
0
1
2
3
B
C
D
Modulare
Ressourcenreservierung
ALU
MEM
‼
JMP
Rückverfolgung
s
N
Intervall
Startzeitpunkt
3
3
3
3
A
0, ∞
1, ∞
3,3
4,4
0
2
3
4
B
C
D
Zeile
1
2
3
4
5
6
7
8
Pipeline
Prolog
SZ
Epilog
S:
Maschinencode
LD++
LD
MULT
LD++
ST
LD
MULT
ST
ALU
MEM
JMP
CJMP-- S
Modulare
Ressourcenreservierung
ALU
MEM
JMP
22
Umsetzung der Do-Across-Schleife (3)
Eine geringe Codeverlängerung ist in Betracht des Geschwindigkeitszuwachses zu vernachlässigen
Auswertung
 Codeverlängerung
• 8 Zeilen / Takte
• ursprünglich 5 Takte
Softwarepipeling:
 Gesamtausführungszeit
• Pipeline: 5 + 3n Takte
• ursprüngliche Schleife: 4 Takte
Fazit
Ermöglicht die geforderte Ausführungsbeschleunigung mit einem geringen
Zuwachs bzgl. des Codeumfangs.
• Vorteil schon ab 6 Durchläufen
 Planung schon im 2. Versuch erfolgreich
23
Hierarchische Reduktion
Durch die hierarchische Reduktion wird das Konzept des Softwarepipelinings universeller anwendbar
Bisher
Konzept der hierarchischen Reduktion
 Schleifen mit nur einem Grundblock
 ähnlich der Bereichsplanung (globale Codeplanung)
 keine Verzweigungen innerhalb der Schleife
 Behandlung von Kontrollstrukturen
 umgebender Code nicht betrachtet
 „if-then-else“-Konstrukte
 Zurückführen auf elementares Objekt
 Objekt wird wie Grundblock behandelt
 reduzierte Objekte können überlappt werden
 Glassbox statt Blackbox (Bereichsplanung)
 Abhängigkeiten als Maximum beider Äste
 keine Ressourcenüberbeanspruchung
 Überlappung: Prolog/Epilog und andere Instruktionen
 Objekte erhalten Ressourcenverbrauch des SZ
 SZ darf nicht überlappt werden
24
Zusammenfassung
Lokale
Codeplanung
 für ein (Grundblock-)Element
 geringes Parallelitätspotential
 einfach zu planen
 Grundlage für globale Planung
25
Zusammenfassung
Lokale
Codeplanung
Globale
Codeplanung
 für ein (Grundblock-)Element
 Bereichsplanung
 geringes Parallelitätspotential
 mittleres Parallelitätspotential
 einfach zu planen
 Dominanzbeziehungen
 Grundlage für globale Planung
26
Zusammenfassung
Lokale
Codeplanung
Globale
Codeplanung
Softwarepipelining
 für ein (Grundblock-)Element
 Bereichsplanung
 Schleifen
 geringes Parallelitätspotential
 mittleres Parallelitätspotential
 Kompromiss
 einfach zu planen
 Dominanzbeziehungen
 Grundlage für globale Planung
• Codelänge
• Geschwindigkeit
 hohes Parallelitätspotential
27
Vielen Dank für die Aufmerksamkeit!