Parallelisierung für Multiprozessor-Maschinen

Präsentation zum Thema: "Parallelisierung für Multiprozessor-Maschinen"—  Präsentation transkript:

1 Parallelisierung für Multiprozessor-Maschinen
Teil 1

2 Konzeptionelle Voraussetzungen
Wir müssen davon ausgehen, dass... Der aktuelle Thread nicht die höchste Priorität haben muss Ein Thread mit niedriger Priorität gleichzeitig laufen kann Threads mit unterschiedlichen Prioritäten gleichzeitig laufen können Sich die Gefahr von „Race Conditons“ erhöht

3 Parallelisierung eines Single-Thread Programms
public class SinTable { private float lookupValues[] = null; public synchronized float[] getValues() { if (lookupValues == null) { lookupValues = new float [360 * 100]; for (int i = 0; i < (360 * 100); i++) { float sinValue = (float)Math.sin(i % 360) * Math.PI/180.0); lookupValues[i] = sinValue * (float)i / 180.0f; } } return lookupValues; } }

4 SinTable mit mehreren Threads

5 Die Methode getValues()
public float[] getValues() { for (int i = 0; i < numThreads; i++) { lookupThreads[i] = new Thread(this); lookupThreads[i].start(); } try { lookupThreads[i].join(); } catch (InterruptedExpception iex) {} return lookupValues;

6 Loop Scheduling und Load Balancing
Loop Scheduling ist der Verteilungsprozess von Iterationen auf die einzelnen Threads. Es gibt viele verschiedene Arten des loop-schedulings. Unter Load Balancing (Lastverteilung) versteht man die möglichst gleichmäßige Verteilung der Berechnungen auf die einzelnen Threads. Dabei sollte der Rechenaufwand für die Verteilung (Overhead) so gering wie möglich gehalten werden.

7 Statisches, bzw. Chunk Scheduling
Jeder Thread erhält die gleiche Anzahl von Iterationen. Vorteil: Der Rechenaufwand für die Verteilung der Iterationen (Overhead) ist gering. Nachteil: Funktioniert nur mit Algorithmen, bei denen jede Iteration ungefähr die gleiche Rechenzeit beansprucht - sonst befinden sich evtl. mehrere Prozessoren gegen Ende der Berechnung im Leerlauf.

8 Self-Scheduling Beim Self-Scheduling werden dem Thread nur wenige Iterationen zugewiesen. Nachdem diese berechnet wurden, werden dem Thread wieder nur wenige Iterationen übergeben. Vorteil: Auch wenn alle Threads nicht gleichzeitig fertig sind, wird die Leerlaufzeit einzelner Threads durch die geringe Anzahl an Iterationen minimiert. Nachteil: Führt bei sehr kleinen Iterationsmengen zu einem erhöhten Overhead.

9 Guided Self-Scheduling
Das Guided Self-Scheduling ist eine Mischung aus dem Static Scheduling und dem Self-Scheduling. Zu Beginn wird an die Threads eine große Anzahl von Iterationen vergeben, die dann aber progressiv immer geringer wird. Vorteil: Die Leerlaufzeit einzelner Prozessoren wird stark verringert und es ergibt sich erst am Ende der Laufzeit ein erhöhter Aufwand für die Verteilung der Iterationen (Overhead).

10 Variablenklassifizierung
Es gibt mehrere Möglichkeiten die von der Schleife benötigten Variablen vor Race Conditions zu schützen. Loop-private Variable: Eine Variable, die ihren Wert von einer Iteration der Schleife nicht an eine andere weitergibt oder erst in der Schleife selbst deklariert wird. Beispiel: for (int i = start; i < end; i++) { float sinValue = (float)Math.sin((i % 360) * Math.PI/180.0); }

11 Variablenklassifizierung (2)
Read-only Variable: Variablen, die ihren Wert während der Ausführung der Schleife nicht ändern (z.B. Konstanten). Storeback Variable: eine loop-private Variable, deren Wert nach der Ausführung der Schleife noch einmal benötigt und nach dem Schleifendurchlauf gespeichert wird.

12 Variablenklassifizierung (3)
Reduction Variable: Falls es bei der Berechnung auf die Reihenfolge nicht ankommt (z.B. bei einer Summe) kann der Wert am Ende der Teilberechnung eines Threads (Storeback) an eine globale Variable übergeben werden. Diese Berechnung muss allerdings synchronisiert werden, um eine Race Condition zu vermeiden. Shared Variable: Anfangs sind alle Variablen im Loop shared variables. Manchmal lassen sich die shared variables leider nicht nach den oben genannten Mustern klassifizieren, da evtl. jede Iteration auf den Wert der vorigen Iteration zugreifen muss.

13 Analyse und Transformation des Loops
Loop distribution: Es ist oftmals möglich die Berechnung der eigentlichen Schleife (des Loops) in mehrere kleine Schleifen aufzuteilen, die dann parallel laufen können. Loop isolation: Manche Schleifen lassen sich nicht parallelisieren, allerdings enthalten manche Programme mehrere voneinander unabhängige (isolierte) Schleifen, die dann parallel ausgeführt werden können.

14 Analyse und Transformation des Loops (2)
Loop interchange: In vielen Programme trifft man auf ineinander verschachtelte Schleifen. In diesem Fall ist es meist am besten die äußerste Schleife auf mehrere Threads zu verteilen. Dies ist nicht immer sofort möglich.

15 Analyse und Transformation des Loops (3)
Public float[] [] getValues() { for (int i = 0; i < 360; i++) { lookupValues[0] [i] = 0; } for (int j = 1; j < 1000; j++) { for (int i = 0; i < 360; i++) { float sinValue = (float)Math.sin(i % 360) * Math.PI/180.0); lookupValues[j] [i] = sinValue * (float)i / 180.0f; lookupValues[j] [i] += lookupValues[j-1] [i] * (float)j/180.0f; } } return lookupValues; }

16 Analyse und Transformation des Loops (4)
Public float[] [] getValues() { for (int i = 0; i < 360; i++) { lookupValues[0] [i] = 0; } for (int i = 0; i < 360; i++) { for (int j = 1; j < 1000; j++) { float sinValue = (float)Math.sin(i % 360) * Math.PI/180.0); lookupValues[j] [i] = sinValue * (float)i / 180.0f; lookupValues[j] [i] += lookupValues[j-1] [i] * (float)j/180.0f; } } return lookupValues; }

17 Analyse und Transformation des Loops (5)
Loop reimplementation: Leider ist es sehr schwierig einen Algorithmus zu implementieren, der unsere Schleifen automatisch auf mehrere Threads verteilt. Oftmals müssen Teile des Programms umgeschrieben werden (z.B. while-, bzw. do-Schleifen müssen in for-Schleifen umgeschrieben werden) oder die Berechnungen müssen auf mehrere Schleifen verteilt werden. Leider ist dies nicht immer ganz leicht möglich... (to be continued)

18 Exkurs: Multi-Threading Compiler
Es gibt mehrere Compiler, die Java-Bytecode automatisch in Maschinencode kompilieren können. Einige dieser Compiler könne auch Single-Thread Programme automatisch auf mehrere Prozessoren (und damit Threads) verteilen. Beispiel: JET 1.01 (