ParallelitÃ¤t und Pipelines

Technische Grundlagen 

der Informatik – Kapitel 9 

Prof. Dr. Sorin A. Huss 

Fachbereich Informatik 

TU Darmstadt

Kapitel 9: Themen 

• Parallelität 

• Pipelines 

• Mikroarchitektur 

Fortgeschrittene Verfahren 

WS 10/11 | Technische Grundlagen der Informatik - Repository - Prof. Sorin A. Huss | ‹Nr.›

Parallelität 

• Zwei Arten von Parallelität 

• Räumliche Parallelität 

• Vervielfachte Hardware bearbeitet mehrere Aufgaben gleichzeitig 

• Zeitliche Parallelität 

• Aufgabe wird in mehrere Unteraufgaben aufgeteilt 

• Unteraufgaben werden parallel ausgeführt 

• Beispiel: Fließbandprinzip bei Autofertigung 

• Nur eine Station für einen Arbeitsschritt 

• Aber alle unterschiedlichen Arbeitsschritte für mehrere Autos werden parallel ausgeführt 

• Auch genannt: Pipelining 


Parallelität: Grundlegende Begriffe 

• Einige Definitionen: 

• Datensatz: Vektor aus Eingabewerten, die zu einem Vektor aus 

Ausgabewerten bearbeitet werden 

• Latenz: Zeit von der Eingabe eines Datensatzes bis zur Ausgabe der 

zugehörigen Ergebnisse 

• Durchsatz: Die Anzahl von Datensätzen die pro Zeiteinheit bearbeitet werden 

können 

• Parallelität erhöht Durchsatz 


Beispiel: Plätzchen backen 

• Weihnachtszeit steht vor der Tür, also rechtzeitig anfangen! 

• Annahmen 

• Genug Teig ist fertig 

• 5 Minuten um ein Blech mit Teig zu bestücken 

• 15 Minuten Backzeit 

• Vorgehensweise 

• Ein Blech nach dem anderen vorbereiten und backen 

Latenz = 

Durchsatz = 


Beispiel: Plätzchen backen (seriell) 

• Weihnachtszeit steht vor der Tür, also rechtzeitig anfangen! 

• Annahmen 

• Genug Teig ist fertig 

• 5 Minuten um ein Blech mit Teig zu bestücken 

• 15 Minuten Backzeit 

• Vorgehensweise 

• Ein Blech nach dem anderen vorbereiten und backen 

Latenz 

= 5 + 15 = 20 Minuten = 1/3 h 

Durchsatz = 1 Blech alle 20 Minuten = 3 Bleche/h 


Beispiel: Plätzchen backen (parallel) 

• Gleiche Annahmen wie eben 

• 5 Minuten Blech bestücken, 15 Minuten Backen 

• Alternative Vorgehensweisen 

• Räumliche Parallelität: Zwei Bäcker (Ben & Alyssa), jeder mit einem eigenen Ofen 

• Zeitliche Parallelität: Aufteilen der Keksherstellung in Unteraufgaben 

• Blech bestücken 

• Backen 

• Nächstes Blech bestücken, während erstes noch im Ofen gebacken wird 

• Latenz und Durchsatz? 


Räumliche Parallelität 

Latenz: 

Zeit bis zum 

Fertigwerden des ersten Bleches 

0 5 10 15 20 25 30 35 40 45 50 

Räumliche 

Parallelität 

Blech 1 

Blech 2 

Blech 3 

Blech 4 

Ben 1 Ben 1 

Alyssa 1 Alyssa 1 

Ben 2 Ben 2 


Zeit 

Bestücken 

Backen 

Legende 

Latenz = 

Durchsatz = 


Räumliche Parallelität 

Latenz: 

Zeit bis zum 

Fertigwerden des ersten Bleches 

0 5 10 15 20 25 30 35 40 45 50 

Räumliche 

Parallelität 

Blech 1 

Blech 2 

Blech 3 

Blech 4 

Ben 1 Ben 1 


Ben 2 Ben 2 


Zeit 

Bestücken 

Backen 

Legende 

Latenz 

= 5 + 15 = 20 Minuten = 1/3 h 

Durchsatz = 2 Bleche alle 20 Minuten = 6 Bleche/h 


Zeitliche Parallelität 

Latenz: 

Zeit bis zum Fertigwerden 

des ersten Blechs 

0 5 10 15 20 25 30 35 40 45 50 

Zeitliche 

Parallelität 

Tray 1 

Tray 2 

Tray 3 

Ben 1 Ben 1 

Ben 2 Ben 2 

Ben 3 Ben 3 

Zeit 

Latenz = 

Durchsatz = 


Zeitliche Parallelität 

Latenz: 

Zeit bis zum Fertigwerden 

des ersten Blechs 

0 5 10 15 20 25 30 35 40 45 50 

Zeitliche 

Parallelität 

Tray 1 

Tray 2 

Tray 3 

Ben 1 Ben 1 

Ben 2 Ben 2 

Ben 3 Ben 3 

Zeit 

Latenz 

= 5 + 15 = 20 Minuten = 1/3 h 

Durchsatz = 1 Blech alle 15 Minuten = 4 Bleche/h 


Kombination 

• Zeitliche und räumliche Parallelität können miteinander kombiniert 

werden 

• Hier: 

• Zwei Bäcker und Öfen 

• Nächstes Blech bestücken während vorheriges Blech gebacken wird 

• Latenz = 20 Minuten 

• Durchsatz = 8 Bleche/h 

Nun zurück zur Digitaltechnik… 


Schaltung ohne Pipelining 

• Kritischer Pfad durch Elemente 2, 3, 4: 9 ns 

• t setup = 0,2 ns und t pcq =0,3 ns T c = 9+0,2+0,3 = 9,5 ns 

• Latenz = 9,5ns ; Durchsatz = 1 / 9,5ns = 105 MHz 


Schaltung mit zweistufiger Pipeline 

Stufe 1: Stufe 2: 

• Stufe 1: 3+2+0,2+0,3 = 5,5 ns 

• T c = 5,5 ns 

• Latenz = 2 Takte = 11 ns 

• Durchsatz = 1 / 5,5 ns = 182 MHz 

Stufe 2: 4+0,2+0,3 = 4,5 ns 


Schaltung mit dreistufiger Pipeline 

Stufe 1: Stufe 2: Stufe 3: 

• T c = 4,5ns 

• Latenz = 3 Takte = 13,5 ns 

• Durchsatz = 1 / 4,5 ns = 222 MHz 


Diskussion Pipelining 

• Mehr Pipelinestufen 

• Höherer Durchsatz (mehr Ergebnisse pro Zeiteinheit) 

• Aber auch höhere Latenz (d. h. länger warten auf das erste Ergebnis) 

• Lohnt sich nur, wenn viele Datensätze bearbeitet werden müssen 

• Klappt aber nicht immer 

• Problem: Abhängigkeiten 

• Beispiel Kekse: Erstmal schauen, wie ein Blech geworden ist, bevor das 

nächste bestückt wird 

• Wurde intensiv im 7. Kapitel behandelt (Prozessorarchitektur) 


Mikroarchitektur: Fortgeschrittene Verfahren 

• Tiefe Pipelines 

• Sprungvorhersage 

• Superskalare Prozessoren 

• Out-of-Order Prozessoren 

• Umbenennen von Registern 

• SIMD 

• Multithreading 

• Multiprozessoren 


Tiefe Pipelines 

• Üblicherweise 10-20 Stufen 

• Ausnahmen 

• Fehlkonstruktionen (Intel P4, >30 Stufen) 

• Anwendungsspezifische Spezialprozessoren (ggf. Hunderte von Stufen) 

• Grenzen für Pipeline-Tiefe 

• Pipeline Hazards 

• Zusätzlicher Zeitaufwand für sequentielle Schaltungen 

• Elektrische Leistungsaufnahme und Energiebedarf 

• Kosten 


Sprungvorhersage 

• Idealer Pipelined-Prozessor: CPI = 1 

• Fehler der Sprungvorhersage erhöht CPI 

• Statische Sprungvorhersage: 

• Prüfe Sprungrichtung (vorwärts oder rückwärts) 

• Falls rückwärts: Sage “Springen” vorher 

• Sonst: Sage “Nicht Springen” vorher 

• Dynamische Sprungvorhersage: 

• Führe Historie der letzten (einige Hundert) Verzweigungen in Branch Target 

Buffer, speichert: 

• Sprungziel 

• Wurde Sprung das letzte Mal / die letzten Male genommen? 


Beispiel: Sprungvorhersage 

add $s1, $0, $0 # sum = 0 

add $s0, $0, $0 # i = 0 

addi $t0, $0, 10 # $t0 = 10 

for: 

beq $s0, $t0, done # falls i == 10, springe 

add $s1, $s1, $s0 # sum = sum + i 

addi $s0, $s0, 1 # inkrementiere i 

j for 

done: 


1-Bit Sprungvorhersage 

• Speichert, ob die Verzweigung das letzte Mal genommen wurde 

• … und sagt genau dieses Verhalten für das aktuelle Mal vorher 

• Fehlvorhersagen 

• Einmal bei Austritt aus der Schleife bei Schleifenende 

• Dann wieder bei erneutem Eintritt in Schleife 

add $s1, $0, $0 # sum = 0 

add $s0, $0, $0 # i = 0 

addi $t0, $0, 10 # $t0 = 10 

for: 




j for 

done: 


2-Bit Sprungvorhersage 

• Falsche Vorhersage nur beim letzten Sprung aus Schleife heraus 

strongly 

taken 

taken 

predict 

taken 

weakly 

taken 

weakly 

not taken 

taken 

predict taken predict taken 

taken 

taken 

taken 

not taken 

taken 

predict 

not taken 

strongly 

not taken 

taken 

add $s1, $0, $0 # sum = 0 

add $s0, $0, $0 # i = 0 

addi $t0, $0, 10 # $t0 = 10 

for: 




j for 

done: 


Superskalare Mikroarchitektur 

• Mehrere Instanzen des Datenpfades führen mehrere Instruktionen gleichzeitig 

aus 

• Etwaige Abhängigkeiten zwischen Instruktionen erschweren jedoch eine 

parallele Ausführung 

CLK CLK CLK CLK 

CLK 

PC 

A 

RD 

Instruction 

Memory 

A1 

A2 

A3 

A4 

A5 

A6 

WD3 

WD6 

Register 

File 

RD1 

RD4 

RD2 

RD5 

ALUs 

A1 RD1 

A2 RD2 

Data 

Memory 

WD1 

WD2 


Beispiel: Superskalare Ausführung 

lw $t0, 40($s0) 

add $t1, $t0, $s1 

sub $t0, $s2, $s3 Idealer IPC-Wert: 2 

and $t2, $s4, $t0 Erreichter IPC-Wert: 2 

or $t3, $s5, $s6 

sw $s7, 80($t3) 

1 2 3 4 5 6 7 8 

Time (cycles) 

lw $t0, 40($s0) 

add $t1, $s1, $s2 

IM 

lw 

add 

RF 

$s0 

40 

$s1 

$s2 

+ 

+ 

DM 

$t0 

$t1 

RF 

sub $t2, $s1, $s3 

and $t3, $s3, $s4 

IM 

$s1 

sub 

$t2 

$s3 - 

RF 

DM 

$s3 

and $t3 

$s4 & 

RF 

or $t4, $s1, $s5 

sw $s5, 80($s0) 

IM 

or 

sw 

RF 

$s1 

$s5 

$s0 

80 

| 

+ 

DM 

$s5 

$t4 

RF 


Beispiel: Superskalare Ausführung mit Abhängigkeiten 

lw 

$t0, 40($s0) 

add $t1, $t0, $s1 

sub $t0, $s2, $s3 Idealer IPC-Wert: 2,00 

and $t2, $s4, $t0 Erreichter IPC-Wert: 6/5 = 1,20 

or $t3, $s5, $s6 

sw 

$s7, 80($t3) 

1 2 3 4 5 6 7 8 

9 

Time (cycles) 

lw $t0, 40($s0) 

IM 

lw 

RF 

$s0 

40 

+ 

DM 

$t0 

RF 

add $t1, $t0, $s1 

sub $t0, $s2, $s3 

IM 

add 

sub 

RF 

$t0 

$s1 

$s2 

$s3 

RF 

$t0 

$s1 

$s2 

$s3 

+ 

- 

DM 

$t1 

$t0 

RF 

and $t2, $s4, $t0 

or $t3, $s5, $s6 

Stall 

and 

IM 

or 

IM 

and 

or 

RF 

$s4 

$t0 

$s5 

$s6 

& 

| 

DM 

$t2 

$t3 

RF 

sw $s7, 80($t3) 

IM 

sw 

RF 

$t3 

80 

+ 

$s7 

DM 

RF 


Out-of-Order Mikroarchitektur 

• Kann Ausführungsreihenfolge von Instruktion umsortieren 

• Sucht im voraus nach parallel startbaren Instruktionen 

• Startet Instruktionen in beliebiger Reihenfolge 

• Solange keine Abhängigkeiten verletzt werden! 

• Abhängigkeiten 

• RAW (read after write) 

• Spätere Instruktion darf Register erst lesen, nachdem es vorher geschrieben wurde 

• WAR (write after read, anti-dependence) 

• Spätere Instruktion darf Register erst schreiben, nachdem es vorher gelesen wurde 

• WAW (write after write, output dependence) 

• Reihenfolge von in Register schreibenden Instruktionen muss eingehalten werden 


Out-of-Order Mikroarchitektur 

• Parallelismus auf Instruktionsebene (instruction level parallelism, ILP) 

• Anzahl von parallel startbaren Instruktionen (i.d.R. < 3) 

• Scoreboard 

• Tabelle im Prozessor 

• Verwaltet 

• Auf Start wartende Instruktionen 

• Verfügbare Recheneinheiten (z.B. ALUs) 

• Abhängigkeiten 


Beispiel: Out-of-Order Mikroarchitektur 

lw 

$t0, 40($s0) 

add $t1, $t0, $s1 



or $t3, $s5, $s6 

sw 

$s7, 80($t3) 

1 2 3 4 5 6 7 8 

Time (cycles) 

lw $t0, 40($s0) 

or $t3, $s5, $s6 

RAW 

sw $s7, 80($t3) 

Zwei Takte Latenz 

zwischen Laden und 

Verwendung von $t0 

RAW 

add $t1, $t0, $s1 

WAR 

sub $t0, $s2, $s3 

IM 

lw 

or 

RF 

$s0 

40 

$s5 

$s6 

+ 

| 

DM 

$t0 

RF 

$t3 

$t3 

sw $s7 

80 

+ 

RF 

DM 

IM 

IM 

add 

$t0 

$s1 

+ 

sub 

RF $s2 

$s3 

- 

RF 

DM 

$t1 

RF 

$t0 

RAW 

and $t2, $s4, $t0 

IM 

and 

RF 

$s4 

$t0 

& 

DM 

$t2 

RF 


Umbenennen von Registern 

lw $t0, 40($s0) 

add $t1, $t0, $s1 



or $t3, $s5, $s6 

sw $s7, 80($t3) 

1 2 3 4 5 6 7 

Time (cycles) 

lw $t0, 40($s0) 

sub $r0, $s2, $s3 

IM 

lw 

sub 

RF 

$s0 

40 

$s2 

$s3 

+ 

- 

DM 

$t0 

$r0 

RF 

2 Takte RAW RAW 

and $t2, $s4, $r0 

or $t3, $s5, $s6 

IM 

and 

or 

RF 

$s4 

$r0 

$s5 

$s6 

& 

| 

DM 

$t2 

RF 

$t3 

RAW 

add $t1, $t0, $s1 

sw $s7, 80($t3) 

IM 

add 

sw 

RF 

$t0 

$s1 

$t3 

80 

+ 

+ 

DM 

$s7 

$t1 

RF 


SIMD 

• Single Instruction Multiple Data (SIMD) 

• Eine Instruktion wird auf mehrere Datenelemente gleichzeitig angewandt 

• Häufige Anwendung: Graphik, Multimedia 

• Oft: Führe schmale arithmetische Operatione aus 

• Auch genannt „gepackte Arithmetik“ 

• Beispiel: Addiere gleichzeitig vier Bytes 

• ALU muss verändert werden 

• Kein Übertrag mehr zwischen einzelnen Bytes 

padd8 $s2, $s0, $s1 

32 24 23 16 15 8 7 0 Bit position 

a 2 

a 1 

a 0 

$s0 

a 3 

b 0 

$s1 

+ 

b 2 

b 1 

b 3 

a 0 

+ b 0 

$s2 

a 3 

+ b 3 

a 2 

+ b 2 

a 1 

+ b 1 


Weitere Mikroarchitekturtechniken 

• Multithreading 

• Beispiel: Textverarbeitung 

• Threads (parallel laufende, weitgehend unabhängige Instruktionsfolgen) 

• Texteingabe 

• Rechtschreibprüfung 

• Drucken 

• Multiprozessoren 

• Viele weitgehend unabhängige Prozessoren auf einem Chip 

• Am weitesten verbreitet heute in Grafikkarten (Hunderte von Prozessoren) 

• Aber auch in Spezialprozessoren, z.B. für UMTS Nachfolger LTE 


Genauer: Multithreading 

• Prozesse: Auf dem Computer gleichzeitig laufende Programme 

• z.B. Web-Browser, Musik im Hintergrund, Textverarbeitung 

• Thread: Parallele Ausführung als Teil eines Programmes 

• Ein Prozess kann mehrere Threads enthalten 

• In konventionellem Prozessor 

• Jeweils ein Thread wird ausgeführt 

• Wenn eine Thread-Ausführung einen Stall hat (z.B. Warten auf Speicher) 

• Sichere Architekturzustand des Threads 

• Lade Architekturzustand eines anderen, derzeit inaktiven aber lauffähigen Threads 

• Starte neuen Thread 

• Vorgang wird Kontextumschaltung (context switching) genannt 

• Alle Threads laufen scheinbar gleichzeitig 


Multithreading auf Mikroarchitekturebene 

• Mehrere Instanzen des Architekturzustandes im Prozessor 

• Mehrere Threads nun gleichzeitig aktiv 

• Sobald ein Thread stalled wird sofort ein anderer gestartet 

• Kein Sichern/Laden von Architekturzustand mehr 

• Falls ein Thread nicht alle Recheneinheiten ausnutzt, kann dies ein anderer Thread tun 

• Erhöht nicht den Grad an ILP innerhalb eines Threads 

• Erhöht aber Durchsatz des Gesamtsystems mit mehreren Threads 


Multiprozessoren 

• Mehrere unabhängige Prozessorkerne mit einem dazwischenliegenden 

Kommunikationsnetz 

• Arten von Multiprocessing: 

• Symmetric multiprocessing (SMT): mehrere gleiche Kerne mit einem gemeinsamen 

Speicher 

• Asymmetric multiprocessing: unterschiedliche Kerne für unterschiedliche Aufgaben 

• Beispiel: CPU in Handy für GUI, DSP für Funksignalverarbeitung 

• Auch „heterogene Multiprozessoren“ genannt 

• Clusters: Jeder Kern hat seinen eigenen Speicher 


Weiterführende Literatur 

• Patterson & Hennessy 

Computer Architecture: A Quantitative Approach

ParallelitÃ¤t und Pipelines

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?