vorlesung, wintersemester 2009/10m. schölzel 1 optimierungstechniken in modernen compilern...

1

Vorlesung, Wintersemester 2009/10 M. Schölzel

Optimierungstechniken in modernen Compilern

Einführung

2Optimierungstechniken in modernen Compilern Einführung

Klassifizierung von Computersystemen

Klassifizierung nach Flynn:

Single Instruction Single Data (SISD): Ein einzelner Prozessor führt einen Befehlsstrom auf Daten in einem

Datenspeicher aus.

Multiple Instruction Single Data (MISD): Eine Sequenz von Daten aus

demselben Speicher wird von mehreren Ausführungseinheiten bearbeitet, von denen jede einen

eigenen Steuerfluss besitzt.

Single Instruction Multiple Data (SIMD): Ein einzelner Befehl steuert mehrere Ausführungseinheiten, von denen jede Zugriff auf einen lokalen

Speicher hat.

Multiple Instruction Multiple Data (MIMD): Mehrere Steuerflüsse

steuern mehrere Ausführungseinheiten, von denen jede

Zugriff auf einen lokalen Speicher hat.

Es

exis

tier

t ei

n

Ste

uer

flu

ss i

m

Pro

gra

mm

.

Es

exis

tier

en

meh

rere

S

teu

erfl

üss

e im

P

rog

ram

m.

Alle Ausführungseinheiten greifen auf denselben

Datenspeicher zu.

Jede Ausführungseinheiten besitzt einen lokalen

Datenspeicher (z.B. einen Cache).


Einordnung von Prozessorarchitekturen

Prozessororganisation

SISD SIMD MISD MIMD

Shared Memory

Distributed Memory

ClusterSymmetric Multiprocessor

(SMP)

Non-UniformMemory Access

(NUMA)

Vector Processor

Array Processor

Uniprocessor

Scalar Superscalar

Dynamic Scheduled

Static Scheduled

Static AllocationDynamic Allocation

i386, i486

Pentium

VLIW: Transmeta Crusoe, Philips

TriMedia

GeclusterteVLIWs

Dual-Core Pentium

Itanium

TMS320C62x


Skalarer Prozessor ohne Pipeline

Typische Optimierungen des Compilers: Registerdruck minimieren Geeigneten Zielcode auswählen

Ste

ue

rwe

rk

Registerbank

ALU

Speicher

ldm (r8) r0

ldm (r9) r1

ldm (r10) r2

add r0,r1 r0

add r0,r2 r0

…

use r8,r9,r10

ldm (r8) r0

ldm (r9) r1

add r0,r1 r0

ldm (r10) r1

add r0,r1 r0

…

use r8,r9,r10

ldc #8 r0

add r0,r8 r0

ldm (r0) r1

ldm (r8+8) r1

Speicher

Speicher

Schematischer Aufbau:Hoher Registerdruck: Geringer Registerdruck:

Schlechte Codeauswahl: Bessere Codeauswahl:


Skalarer Prozessor mit Befehlspipeline

Typische Optimierungen des Compilers: Registerdruck minimieren Geeigneten Zielcode auswählen Pipeline-Hazards vermeiden

Registerbank

ALU

Speicher

FE/DE

Speicher

DE/EX

EX/MEM

Ste

ue

rwe

rk

MMU

MEM/WB

ldm (r8) r0

ldm (r9) r1

stall

stall

add r0,r1 r0

ldm (r10) r2

stall

stall

add r0,r2 r0

ldm (r8) r0

ldm (r9) r1

ldm (r10) r2

stall

add r0,r1 r0

stall

stall

add r0,r1 r0

Schematischer Aufbau:Schlechte Befehlsanordnung:

Bessere Befehlsanordnung:


Superskalarer Prozessor

Typische Optimierungen des Compilers: Registerdruck minimieren Geeigneten Zielcode auswählen Umordnung der Operationen, um Abhängigkeiten zwischen Operationen im Befehlspuffer

zu minimieren.

Registerbank

ALU Speicher

DE1/DE2

DE2/EX

EX/MEM

Ste

ue

rwe

rk

MMUALU

FE/DE1

Speicher

Befehlspuffer

add r0,r1 r2

add r0,r2 r2

add r0,r3 r4

add r0,r4 r4

add r0,r1 r2

add r0,r3 r4

add r0,r2 r2

add r0,r4 r4

Schlechte Befehls-anordnung für Puffer mit Kapazität 2:

Schematischer Aufbau:

Bessere Befehls-anordnung für Puffer mit Kapazität 2:


VLIW

Typische Optimierungen des Compilers: Registerdruck minimieren Geeigneten Zielcode auswählen Pipeline-Hazards vermeiden Feingranulare Parallelität erkennen und Operationen statisch

parallelisieren.

Registerbank

ALU Speicher

FE/DE

DE/EX

EX/MEM

Ste

ue

rwe

rk

MMUALU

Speicheradd r0,r1 r2

add r0,r2 r2

add r0,r3 r4

add r0,r4 r4

add r0,r1 r2 | add r0,r3 r4

add r0,r2 r2 | add r0,r4 r4

Schematischer Aufbau: Sequentieller Programmcode:

Parallelisierter Programmcode:


SMP

Typische Optimierungen: Grobgranulare Parallelität erkennen und das Programm in Threads aufteilen,

so dass wenig Synchronisation zwischen den Threads erforderlich ist. Registerdruck minimieren Geeigneten Zielcode auswählen Pipeline-Hazards vermeiden

call f

call gcall f

Registerbank

ALU

FE/DESpeicher

DE/EX

EX/MEM

Steu

erw

erk

MMU

MEM/WB

Registerbank

ALU

FE/DESpeicher

DE/EX

EX/MEM

Steu

erw

erk

MMU

MEM/WB

Bus

ldc #100 r0

loopHead:

…

dec r0

cmp r0,#0

jnz loopHead

ldc 100 r0

loopHead:

…

dec r0

cmp r0,#50

jg loopHead

ldc 50 r0

loopHead:

…

dec r0

cmp r0,#0

jnz r0 loopHead

Cache Cache

gemeinsamer Speicher

Schematischer Aufbau: Sequentieller Code: Code Proc1: Code Proc2:

call g

Sequentieller Code: Code Proc1: Code Proc2:


Warum soll der Compiler optimieren?

Optimierungen auf Quelltextebene (z.B. durch den Programmierer) sind möglich, machen es aber erforderlich, dass der Quelltext für jede Zielarchitektur optimiert wird.

Verschiedene Optimierungen, die auf Zielcodeebene erforderlich sind, lassen sich in einer Hochsprache nicht formulieren (z.B. Registerplanung):

Statisch geplante Architekturen:• Compiler führt Scheduling und Allokation durch – auf Quelltextebene in der

Regel nicht ausdrückbar Dynamisch geplante bzw. skalare Architekturen

• Compiler kann Hazards vermeiden helfen und Pipeline besser füllen• Nur ein kleines Fenster für die Optimierung in Hardware; Compiler kann

optimierbaren Code in dieses Fenster schieben SMP

• Compiler verteilt Programmcode und macht Parallelisierung möglich Programmiersprachen besitzen sequentielle Semantik; Geeignete

Form der Parallelität muss durch den Compiler erkannt werden: feingranular, grobgranular.


Demonstration dieser Problematik an einem Beispiel: Matrixmultiplikation

Optimal für eine skalare Architektur. Ergebnis der Multiplikation wird im Register für t akkumuliert.

for i = 1 to 100 step 1 do for j = 1 to 100 step 1 do t = 0.0; for k = 1 to 100 step 1 do t = t + a[j][k] * b[k][i] od c[j][i] = t; odod

i = 1iLoop: j = 1jLoop: t = 0.0; k = 1kLoop: t = t + a[j][k] * b[k][i] k = k + 1 if k <= 100 then goto kLoop c[j][i] = t; j = j + 1 if j <= 100 then goto jLoop i = i + 1; if i <= 100 then goto iLoop


Was kann parallel ausgeführt werden?


Basisblock enthält keine nennenswerte Parallelität

Iterationen der k-Schleife können nicht parallel ausgeführt werden: Iteration k+1 benötigt Wert von t aus Iteration k.

Iterationen der j-Schleife können nicht parallel ausgeführt werden: Benutzung derselben Variablen t.

Iterationen der i-Schleife können nicht parallel ausgeführt werden: Benutzung derselben Variablen t.

b

a cj

k

k

i

t


t

Scalar Expansion

Basisblock enthält keine nennenswerte Parallelität

Iterationen der k-Schleife können nicht parallel ausgeführt werden: Iteration k+1 benötigt Wert t[j] aus Iteration k.

Iterationen der j-Schleife können parallel ausgeführt werden, weil a und b nur gelesen werden und Akkumulation in unterschiedliche Elemente von t erfolgt.

Iterationen der i-Schleife können nicht parallel ausgeführt werden: Benutzung derselben Variablen t.

b

a cj

k

k

i

for i = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = 0.0; for k = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] od c[j][i] = t[j]; odod

t[j]



Loop-Distribution

for i = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = 0.0; od for j = 1 to 100 step 1 do for k = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] od od for j = 1 to 100 step 1 do c[j][i] = t[j]; odod

t

b

a cj

k

k

i

for i = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = 0.0; for k = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] od c[j][i] = t[j]; odod

Zuerst Vektor t initialisieren.

Werte in t berechnen.

Werte aus t nach c zurück schreiben.

Initialisieren, Berechnen und Zurückschreiben wurde separiert; kann aber nicht parallel ausgeführt werden.

Initialisieren, Berechnen und Zurückschreiben geschieht Elementweise in t.


Loop-Interchange

for i = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = 0.0; od for k = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] od od for j = 1 to 100 step 1 do c[j][i] = t[j]; odod

t

b

a cj

k

k

i

Iterationen der inneren Schleife können parallel ausgeführt werden.

for i = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = 0.0; od for j = 1 to 100 step 1 do for k = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] od od for j = 1 to 100 step 1 do c[j][i] = t[j]; odod

Keine nennenswerte Parallelität in der inneren Schleife, da jede Iteration den Wert t[j] aus der vorigen Iteration benötigt.


Möglichkeit der Vektorisierung (idealisiert)

for i = 1 to 100 step 1 do t[1..100] = 0.0; for k = 1 to 100 step 1 do t[1..100] = t[1..100]+a[1..100][k]*b[k][i] od c[1..100][i] = t[1..100];od

for i = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = 0.0; od for k = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] od od for j = 1 to 100 step 1 do c[j][i] = t[j]; odod

t

b

a cj

k

k

i

Vektoroperation erfordert die parallele Ausführbarkeit der Operationen auf den Elemente des Vektors. Damit sind diese Operationen parallel auf einem superskalaren nicht-Vektor Prozessor ausführbar.


Möglichkeit der Vektorisierung (praktisch)

for i = 1 to 100 step 1 do t[1..100] = 0.0; for k = 1 to 100 step 1 do t[1..100] = t[1..100]+a[1..100][k]*b[k][i] od c[1..100][i] = t[1..100];od

for i = 1 to 100 step 1 do for j = 1 to 100 step 32 do t[j..j+31] = 0.0; od for k = 1 to 100 step 1 do for j = 1 to 100 step 32 do t[j..j+31] = t[j..j+31]+a[j..j+31][k]*b[k][i] od od for j = 1 to 100 step 32 do c[j..j+31][i] = t[j..j+31]; odod

t

b

a cj

k

k

i


Ausführung auf VLIW-Prozessor mit N Ausführungseinheiten

for i = 1 to 100 step 1 do for j = 1 to 100 step N do t[j] = 0.0; ... ; t[j+N-1] = 0.0; od for k = 1 to 100 step 1 do for j = 1 to 100 step N do t[j] = t[j]+a[j][k]*b[k][i]; ... t[j+N-1] = t[j+N-1]+a[j+N-1][k]*b[k][i]; od od for j = 1 to 100 step N do c[j][i] = t[j]; ... c[j+N-1][i] = t[j+N-1]; odod

N Multiplikationen und Additionen können parallel ausgeführt werden.

for i = 1 to 100 step 1 do for j = 1 to 100 step 32 do t[j..j+31] = 0.0; od for k = 1 to 100 step 1 do for j = 1 to 100 step 32 do t[j..j+31] = t[j..j+31]+a[j..j+31][k]*b[k][i] od od for j = 1 to 100 step 32 do c[j..j+31][i] = t[j..j+31]; odod


t1

Matrixmultiplikation für SMP mit zwei Prozessoren


for i = 1 to 50 step 1 do for j = 1 to 100 step 1 do t0 = 0.0; for k = 1 to 100 step 1 do t0 = t0 + a[j][k] * b[k][i] od c[j][i] = t0; odod

for i = 51 to 100 step 1 do for j = 1 to 100 step 1 do t1 = 0.0; for k = 1 to 100 step 1 do t1 = t1 + a[j][k] * b[k][i] od c[j][i] = t1; odod

t0

b

aj

k

k

i


Grob- vs. feingranulare Parallelität

for i = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = 0.0; od for j = 1 to 100 step 1 do for k = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] od od for j = 1 to 100 step 1 do c[j][i] = t[j]; odod t

b

a cj

k

k

iMatrixmultiplikation vor Loop-Interchange (keine feingranulare Parallelität in der inneren Schleife):

for j = 1 to 50 step 1 do for k = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] odod

for j = 51 to 100 step 1 do for k = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] odod

Aber äußere Schleife kann auf zwei verschiedenen Prozessoren verteilt werden.

t[j]


Grob- vs. feingranulare Parallelität

for i = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = 0.0; od for k = 1 to 100 step 1 do for j = 1 to 100 step 1 do t[j] = t[j]+a[j][k]*b[k][i] od od for j = 1 to 100 step 1 do c[j][i] = t[j]; odod t

b

a cj

k

k

i

Aufteilen der äußeren Schleife auf verschiedene Prozessoren führt zu gleichzeitigem Schreiben derselben Elemente in t. Ist also nicht möglich.

Matrixmultiplikation nach Loop-Interchange (viel feingranulare Parallelität in der inneren Schleife):


Aufgeworfene Fragen

Unter welchen Umständen ist eine bestimmte Transformation zulässig?

Welche Transformationen erzeugen fein granulare Parallelität, grob granulare Parallelität?

Wie kann die erzeugte fein granulare Parallelität in superskalaren Prozessorarchitekturen genutzt werden?

Wie kann die erzeugte grob granulare Parallelität in SMP Architekturen genutzt werden?


Aufbau der Vorlesung

Einleitung Grundlagen

Aufbau eines Compilers Überblick über die Analysephase Vorgehen bei einfacher Synthesephase Zwischencodeformate Datenflussanalyseschema Modellierung von Datenabhängigkeiten Abhängigkeitsanalyse



Optimierungstechniken für DSPs und Mikrocontroller Globale Registerallokation Scheduling-Techniken Code-Selektion

Optimierunbgstechniken für superskalare Prozessoren Erzeugung fein granularer Parallelität Trade-Off Registerallokation/ILP Statische/Dynamische Parallelisierung HW-Support für bessere statische Parallelisierung Region-Based-Scheduling Global Code Motion Traces, Superblöcke, Hyperblöcke Modulo Scheduling IF-Conversion



Optimierungstechniken für SMPs Erzeugung grob granularer Parallelität Parallelisierung ohne Synchronisierung Parallelisierung mit Synchronisierung (OpenMP)

vorlesung, wintersemester 2009/10m. schölzel 1 optimierungstechniken in modernen compilern...

Documents

r0 cmp r0

r1 r0 stall

r8 r0 ldm r0 r1 ldm

r1 r0 ldm r10 r1

r1 r0 use r8

r1 r0 schematischer

r2 r0 use r8

r1 r0 ldm r10 r2 stall