Parallelisierung für Multiprozessor-Maschinen Teil 2

Abstract Inner-Loop Threading Loop Printing Multiprozessor Skalierung

Inner-Loop Threading public float[][] getValues() { for (int i = 0; i < 360; i++) lookupValues[j][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; } j : read-only Variable lookupValues : shared Variable sinValue, i : loop-private Variablen

Überlegungen: Wahl des Loop-Scheduler: abhängig vom verwendeten Algorithmus in der Schleife Wie oft werden Threads erzeugt und wieder zerstört? Schadet oder nützt die Anwendung von Threads in diesem Fall? static oder chunk Scheduler Für jeden Durchlauf der äußeren Schleife -> sehr oft Sie schadet, sofern wir nicht einen Mechanismus implementieren, der dem ständigen Erzeugen und Zerstören der Threads ausweicht.

Der bisherige Loop-Handler Für jede neue Schleife ist eine neue Instanz notwendig. Der Schleifen-Index kann nicht zurückgesetzt werden. Ebenso kann der maximale Schleifen-Index nicht verändert werden. Kann also nur einmal verwendet werden. Der Pool-Loop-Handler Verwendet die ThreadPool-Klasse. Implementiert zwei Methoden reset() und setRange() um eine Wiederverwendbarkeit sicherzustellen.

Die Methode loopProcess() public void loopProcess() { /* aus LoopHandler.java */ for (int i = 0; i < numThreads; i++) { lookupThreads[i] = new Thread(this); lookupThreads[i].start(); } for (int i = 0; i < numThreads; i++) { try { lookupThreads[i].join(); } catch(Exception e) {} } } public void loopProcess() { /* aus PoolLoopHandler.java */ reset(); for (int i = 0; i < numThreads; i++) { poolThreads.addRequest(this); } try { poolThreads.waitForAll(); } catch(Exception e) {} } für jeden Aufruf von loopProcess() werden neue threads erzeugt. für jeden Aufruf von loopProcess() werden nur neue „Aufträge“ auf schon bestehende Threads verteilt.

Wann verschlechtert die Parallelisierung von Inner Loops die Programmperformance? Anstatt des PoolLoopHandlers wird der LoopHandler verwendet. die Inner Loop besitzt relativ zur Outer Loop eine nur sehr kurze Laufzeit. Wann sollte man auf die Parallelisierung verzichten? Wenn der verwendete Algorithmus es zuläßt, eine der folgenden Techniken zu verwenden: Loop Distribution, Loop Isolation und Loop Interchange

Loop-Printing In einer parallelisierten Schleife, sollen Daten an die Java Konsole oder eine Datei ausgegeben werden. Probleme: Der Erhalt der Reihenfolge der ausgegebenen Daten. Flaschenhals der Konsole oder Datei: da nicht mehrere Daten gleichzeitig geschrieben werden können, muss jeder Thread warten, bis er an der Reihe ist, die Ausgabe zu tätigen. Dies führt dazu, dass wertvolle Rechenzeit durch Warten verloren geht.

Überlegung: Wenn in einem Schleifenschritt die Ausgabe nur einen sehr kurzen Teil der eigentlichen Berechnungszeit in Anspruch nimmt, spricht nichts gegen eine Parallelisierung. Einzig noch zu lösendes Problem: Die Erhaltung der richtigen Reihenfolge der Ausgabe. Problemlösung: Einführung einer eigenen Klasse, die die Ausgabe übernimmt.

Der LoopPrinter Implementiert einen 2-Schritt Ausgabe-Prozess: Der Thread schreibt nicht direkt auf die Konsole oder in die Datei, sondern in ein virtuelles im Speicher befindliches Ausgabewerk (LoopPrinter) Wenn die Schleife vollständig abgearbeitet ist, geschieht die eigentliche Ausgabe.

LoopPrinter lp = new LoopPrinter(1000); public void loopDoRange(int start, int end) { for (int i = start; i < end; i++) { lp.print(i, „Ausgabe“); } } lp.send2Stream(System.out); Verwendung der LoopPrinter-Klasse

public class LoopPrinter { private Vector pStorage[]; public LoopPrinter(int initSize) { pStorage = new Vector[initSize]; } public synchronized void print (int index, Object obj) { pStorage[index].addElement( obj.toString() ); } public synchronized void send2Stream(PrintStream ps) { for (int i = 0; i < pStorage.length; i++) { Enumeration e = pStorage[i].elements(); while (e.hasMoreElements()) { ps.print(e.nextElement()); } } } }

Multiprozessor Skalierung Begriffserklärung: Der Begriff der Skalierbarkeit einer parallelisierten Anwendung sagt aus, wieviel Prozessoren hinzugefügt werden können, um immer noch einen Geschwindigkeitszuwachs zu erzielen.

Faktoren, die die Skalierbarkeit beeinflussen: Setup-Zeit Die Zeit, die aufgewendet werden muss, um jene Programmzeilen abzuarbeiten, die nicht parallelisiert sind. Synchronisation Bei jeder Parallelisierung von Programmteilen, entsteht Code, der relativ zeitaufwendig synchronisiert werden muss. Serialisation Methoden, die synchronisiert sind, können nur sequentiell abgearbeitet werden. Implementierung der Java Virtual Machine

Amdahls Gesetz: Durch folgende Formel ist die maximale Skalierbarkeit einer Anwendung bestimmbar: S = (1 - F) + F / N S... Skalierbarkeit F... Prozent des Codes, der parallelisiert ist N... Anzahl der Prozessoren Beispiel: 95% des Codes ist parallelisiert, 8 Prozessoren stehen zur Verfügung. S = ( ) /8 S = 16.8% Das bedeutet: Der parallelisierte Code wird in 16.8% der Zeit eines nicht parallelisierten Programms ausgeführt.

Skalierbarkeit der Simple Loop Handler: 1. Wert: 500 Zeilen, 1000 Spalten 2. Wert: 1000 Zeilen, 500 Spalten

Skalierbarkeit der Inner Loop Handler: 1. Wert: 100 Zeilen, 5000 Spalten 2. Wert: 500 Zeilen, 1000 Spalten

Skalierbarkeit der Loop Printer Klasse: 1. Wert: 200 Iterationen mit 200 Zeilen, 1000 Spalten, wobei jede 100ste Zeile eine Ausgabe erfolgt. 2. Wert: eine Ausgabe erfolgt jede 20ste Zeile

Danke für Ihre Aufmerksamkeit. Für weitere Fragen stehe ich gerne zu Ihrer Verfügung: