OpenMP am Beispiel der Matrizenmultiplikation

Transkript

1 OpenMP am Beispiel der Matrizenmultiplikation David J. Meder, Dr. Victor Pankratius IPD Tichy Lehrstuhl für Programmiersysteme KIT die Kooperation von Forschungszentrum Karlsruhe GmbH und Universität Karlsruhe (TH)

2 Naiver Algorithmus Gegeben seien zwei Matrizen A l m und B m n Das Produkt C = A B l n der Matrizen A und B ist definiert als: m C ( ci, j ) ai, k bk, j k 1 Multipliziere jede Zeile von A mit jeder Spalte von B. m n n A B C l m l 2

3 Andere Algorithmen Varianten des naiven Algorithmus für Rechnerbündel: Systolischer Algorithmus Cannons Algorithmus Andere Algorithmen zur Multiplikation zweier n n-matrizen: Strassens Algorithmus Coppersmith-Winograd Algorithmus Laufzeiten Algorithmus Werden in einer späteren Vorlesung behandelt. Laufzeit Naiver Algorithmus O(n 3 ) Strassen s Algorithmus O(n 2,807 ) Coppersmith-Winograd Algorithmus O(n 2,376 ) 3

4 Naiver Algorithmus: Beispielimplementierungen Die folgenden Beispielimplementierungen wurden mit Microsoft Visual Studio 2008 Professional OpenMP 2.0 übersetzt und auf folgendem System ausgeführt: Intel Core 2 Quad Q GByte Arbeitsspeicher Windows 7 Pro. x64 Für die angegebenen Laufzeitmessungen wurden Matrizen mit float-elementen verwendet. Die parallelen Versionen wurden mit 2 bis 13 Fäden ausgeführt. 4

5 OpenMP Compilereinstellungen (1) Microsoft Visual C++ Über die Projekteigenschaften in Microsoft Visual Studio Über die Compileroption /openmp GNU C Compiler Über die Compileroption -fopenmp GCC 4.2+: OpenMP 2.5 GCC 4.4: OpenMP 3.0 5

6 OpenMP Compilereinstellungen (2) Apple XCode 3.1 Compiler auf LLVM GCC 4.2 ändern Compilerflag Enable OpenMP Support aktivieren 6

7 Naiver Algorithmus: Beispielimplementierung Sequentiell for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { c[i * n + j] += a[i * m + k] * b[k * n + j]; Laufzeit: 14,65 Sekunden i k i 7 k j j

8 Naiver Algorithmus: Beispielimplementierung Sequentiell for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) {? Wie kann dieser Algorithmus c[i * n + j] += a[i * m + k] * b[k * n + j]; mit OpenMP parallelisiert werden? Nur eine Schleife parallelisieren? Mehrere Schleife parallelisieren? Welche Schleifen sollen parallelisiert werden? Laufzeit: 0,87 Sekunden 8

9 Naiver Algorithmus: Beispielimplementierung Eine Schleife (1) for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { Matrix A zeilenweise aufteilen c[i * n + j] += a[i * m + k] * b[k * n + j]; #Fäden Laufzeit #Fäden Laufzeit #Fäden Laufzeit 2 6,29 6 3, ,30 3 4,25 7 3, ,45 4 3,44 8 3, ,31 5 3,74 9 3, ,32 9

10 Naiver Algorithmus: Beispielimplementierung Eine Schleife (2) for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { Matrix B spaltenweise aufteilen c[i * n + j] += a[i * m + k] * b[k * n + j]; #Fäden Laufzeit #Fäden Laufzeit #Fäden Laufzeit 2 6,51 6 4, ,02 3 4,30 7 3, ,64 4 3,56 8 3, ,50 5 5,10 9 4, ,07 10

11 Naiver Algorithmus: Beispielimplementierung Eine Schleife (3a) for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { Fehler? c[i * n + j] += a[i * m + k] * b[k * n + j]; Gleichzeitiger Zugriff auf c[i,j] von mehreren Fäden. 11

12 Naiver Algorithmus: Beispielimplementierung Eine Schleife (3b) for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { #pragma omp critical (LOCK_C) c[i * n + j] += a[i * m + k] * b[k * n + j]; Statt critical auch atomic möglich. Zugriff auf Feld mit kritischem Abschnitt schützen. ABER: Jeder Zugriff auf ein Element aus C wird geschützt. Laufzeit mit 2 Fäden: ca. 240s 12

13 Naiver Algorithmus: Beispielimplementierung Zwei Schleifen (1) for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { c[i * n + j] += a[i * m + k] * b[k * n + j]; #Fäden Laufzeit #Fäden Laufzeit #Fäden Laufzeit 2 6,87 6 4, ,48 3 4,55 7 3, ,72 4 4,01 8 3, ,47 5 4,46 9 3, ,72 13

14 Naiver Algorithmus: Beispielimplementierung Zwei Schleifen (1) for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++)?{ c[i * n + j] += a[i * m + k] * b[k * n + j]; Wird dieser Quelltext so übersetzt, wie wir es wollen? #Fäden Laufzeit #Fäden Laufzeit #Fäden Laufzeit 2 6,87 6 4, ,48 3 4,55 7 3, ,72 4 4,01 8 3, ,47 5 4,46 9 3, ,72 14

15 Naiver Algorithmus: Beispielimplementierung Zwei Schleifen (1) for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { Standardmäßig ist in OpenMP das Schachteln von parallelen Abschnitten deaktiviert (OMP_NESTED = FALSE). c[i * n + j] += a[i * m + k] * b[k * n + j]; In diesem Fall wird nur der äußerste Abschnitt parallelisiert. Innere parallele Abschnitte werden sequentiell ausgeführt. Geschachtelten Parallelismus z.b. mit omp_set_nested(true) aktivieren. #Fäden Laufzeit #Fäden Laufzeit #Fäden Laufzeit 2 6,87 6 4, ,48 3 4,55 7 3, ,72 4 4,01 8 3, ,47 5 4,46 9 3, ,72 15

16 Naiver Algorithmus: Beispielimplementierung Zwei Schleifen (2) omp_set_nested(1); for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { c[i * n + j] += a[i * m + k] * b[k * n + j]; #Fäden Laufzeit #Fäden Laufzeit #Fäden Laufzeit 2 3,99 6 3, ,23 3 3,77 7 4, ,77 4 3,75 8 3, ,78 5 4,27 9 3, ,64 16

17 Naiver Algorithmus: Beispielimplementierung Zwei Schleifen (2) omp_set_nested(1); for (int i = 0; i < l; i++) {? for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { c[i * n + j] += a[i * m + k] * b[k * n + j]; Wie sieht es mit anderen Kombinationsmöglichkeiten #Fäden Laufzeit #Fäden Laufzeit #Fäden Laufzeit aus? 2 3,99 6 3, ,23 3 3,77 7 4, ,77 4 3,75 8 3, ,78 5 4,27 9 3, ,64 17

18 Naiver Algorithmus: Beispielimplementierung Zwei Schleifen (3) omp_set_nested(1); for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { #pragma omp critical (LOCK_C) c[i * n + j] += a[i * m + k] * b[k * n + j]; Der Zugriff von Faden 1 auf Element C[1, 5] wird blockiert, wenn Faden 2 gerade auf Element C[5, 7] zugreift (Faden 2 hält die Sperre). 18

19 Naiver Algorithmus: Beispielimplementierung Zwei Schleifen (3) omp_set_nested(1); for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { #pragma omp critical (LOCK_C) c[i * n + j] += a[i * m + k] * b[k * n + j]; 19

20 Naiver Algorithmus: Beispielimplementierung Drei Schleifen omp_set_nested(1); for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { #pragma omp critical (LOCK_C) c[i * n + j] += a[i * m + k] * b[k * n + j]; 20

21 Was gibt es zu beachten? Auf was für einem Rechner soll die Anwendung laufen? Rechnerbündel, Multikernrechner, Einkernrechner? Wie ist der Rechner aufgebaut? Wie groß ist der verfügbare Hauptspeicher? Wie groß ist der verfügbare CPU-Cache (L1/L2/L3/ )? Wie viele Fäden sind pro Kern möglich (z.b. 8 Fäden pro Kern bei UltraSPARC T2 oder 2 Fäden bei Intel Core i7-870)? Davon abhängig Welchen Algorithmus nehme ich? Wie teile ich die Daten am besten auf? Wie viele Fäden soll ich verwenden? Mehr dazu in späteren Vorlesungen 21

22 Matrizenmultiplikation VERGLEICH VERSCHIEDENER ALGORITHMEN

23 Betrachtete Algorithmen Betrachtet werden drei verschiedene Algorithmen zur Matrizenmultiplikation: ijk-algorithmus ikj-algorithmus Cannons Algorithmus Jeder Algorithmus wird in einer sequentiellen sowie drei parallelen Varianten betrachtet. Parallelisiert werden die Algorithmen mit Hilfe von OpenMP. 23 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

24 Betrachtete Algorithmen ijk Einfacher Algorithmus. Kann durch Zwischenspeichern des Ergebnisses beschleunigt werden. for(int i = 0; i < l; i++) { for(int j = 0; j < n; j++) { sum = 0; for(int k = 0; k < m; k++) { c[i][j] sum += a[i][k] += a[i][k] * b[k][j]; * b[k][j]; c[i][j] = sum; 24 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

25 Betrachtete Algorithmen ikj Ähnlich wie ijk-algorithmus; ist jedoch Cache-freundlicher Kann durch Herausziehen der Schleifen-invarianten weiter beschleunigt werden. for(int i = 0; i < l; i++) { for(int k = 0; k < m; k++) { inv = a[i][k]; for(int j = 0; j < n; j++) { c[i][j] += a[i][k] inv * b[k][j]; * b[k][j]; 25 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

26 Betrachtete Algorithmen Cannons Algorithmus Basiert auf kij-algorithmus. Kann auch auf Rechnerbündeln verwendet werden. for (int k = 0; k < m; k++) { for (int i = 0; i < l; i++) { for (int j = 0; j < n; j++) { c[i][j] += a[i][(i+j+k) % m] * b[(i+j+k) % m][j]; 26 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

27 Vorgehen bei den Laufzeitmessungen (1) Jeder Algorithmus wird in einer sequentiellen und drei parallelen Varianten untersucht. #pragma omp parallel for(int i = 0; i < l; i++) { #pragma omp parallel for(int j = 0; j < n; j++) { #pragma omp parallel for(int k = 0; k < m; k++) { c[i][j] += a[i][k] * b[k][j]; Insgesamt 2 * * = 20 unterschiedliche Varianten. 27 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

28 Vorgehen bei den Laufzeitmessungen (2) Die Messungen werden auf einem System mit Intel QuadCore Q6600 Prozessor und 4 GByte Arbeitsspeicher durchgeführt. Compiler: Microsoft Visual C OpenMP 2.0, OMP_NESTED = FALSE Die parallelen Varianten werden mit 2, 4, 8, 16 und 32 Threads ausgeführt. Die verwendeten Matrizen haben Größen von 4x4 bis 2000x2000 Einträgen. Jede Kombination (#Threads + Größe der Matrix) wurde drei mal vermessen. 28 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

29 Ergebnisse auf Intel Q6600 Laufzeiten ijk (mit ijk (ohne ikj (mit ikj (ohne 2 Threads Cannon #pragma 2 #pragma 3 #pragma Sequentiell ijk (mit ijk (ohne ikj (mit ikj (ohne 4 Threads Cannon #pragma 2 #pragma 3 #pragma Sequentiell ijk (mit ijk (ohne ikj (mit ikj (ohne Cannon #pragma 2 #pragma 3 #pragma Sequentiell 8 Threads 29 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

30 Ergebnisse auf Intel Q6600 sequentielle Varianten Laufzeit: IKJ (mit < IKJ (ohne < IJK (mit < IJK (ohne < Cannon. Das Verwenden von temporären Variablen bring eine Beschleunigung von bis zu 22% ijk (mit ijk (ohne ikj (mit ikj (ohne Cannon 30 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

31 Ergebnisse auf Intel Q6600 parallele Varianten (1) Ergebnisse für Verwendung von 4 Threads. 3 #pragma-anweisungen nicht sinnvoll, da sie zu Laufzeitverlängerungen um bis zu 19% führen. Unterschiedliche Beschleunigungen bei den Algorithmen (sequentiell <-> 1 #pragma): ijk ikj Cannon Mit ZWS 3,94 4,41 - Ohne ZWS 3,89 4,01 3,58 31 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

32 Ergebnisse auf Intel Q6600 parallele Varianten (1) ijk (mit ijk (ohne ikj (mit ikj (ohne Cannon sequentiell 1 #pragma 2 #pragma 3 #pragma ijk (mit ijk (ohne ikj (mit ikj (ohne Cannon sequentiell 1 #pragma 2 #pragma 3 #pragma 1000x1000, 4 Threads 2000x2000, 4 Threads 32 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

33 Ergebnisse auf Intel Q6600 parallele Varianten (2) Ergebnisse für Verwendung von 2 Threads. 3 #pragma-anweisungen führen zu bis zu 33% längeren Laufzeiten (1 #pragma <-> 3 #pragma). Unterschiedliche Beschleunigungen bei den Algorithmen (sequentiell <-> 1 #pragma): ijk ikj Cannon Mit ZWS 2,04 2,01 - Ohne ZWS 1,99 2,27 1,91 33 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

34 Ergebnisse auf Intel Q6600 parallele Varianten (2) ijk (mit ijk (ohne ikj (mit ikj (ohne Cannon sequentiell 1 #pragma 2 #pragma 3 #pragma ijk (mit ijk (ohne ikj (mit ikj (ohne Cannon sequentiell 1 #pragma 2 #pragma 3 #pragma 1000x1000, 2 Threads 2000x2000, 2 Threads 34 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

35 Ergebnisse auf Intel Q6600 Zusammenfassung Zwischenspeichern von Werten bringt eine Laufzeitverkürzung um bis zu 30% (ikj mit TMP, 2 #pragma, 2000x2000 Matrix, 4 Threads). 4 Threads fast doppelt so schnell wie 2 Threads bei allen untersuchten Varianten. Mehr als 4 Threads bringen nichts. Mehr als 2 #pragma-anweisungen verlängern in vielen Fällen die Laufzeit (bspw. ikj mit TMP, 4 Threads, 1000x1000: 32% längere Laufzeit mit 3 #pragma als mit 2 #pragma). 35 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen

36 Ergebnisse auf Intel Q6600 Zusammenfassung ijk (mit ijk (ohne ikj (mit ikj (ohne Cannon 2000x2000, 1 #pragma sequentiell 2 Threads 4 Threads Anmerkung: 3 #pragma-anweisungen verlängern in diesem Fall die Laufzeit der Anwendung. Wird die Unterstützung für geschachtelte, parallele Ausdrücke in OpenMP aktiviert (OMP_NESTED = TRUE), so verlängert sich die Laufzeit bei 3 #pragma- Anweisungen nochmals. Im Fall von 512x512 Elementen großen Matrizen und 4 Fäden verlängert sich die Laufzeit von ca. 3 auf über 15 Sekunden! 36 Kapitel 2 Matrizenmultiplikation Vergleich verschiedener Algorithmen