Parallelisierung der Matrixmultiplikation

Transkript

1 Ein Beispiel für parallele Algorithmen Ivo Hedtke ehem. Hiwi am Lehrstuhl für Wissenschaftliches Rechnen (Prof. Dr. Zumbusch) Institut für Angewandte Mathematik Fakultät für Mathematik und Informatik Friedrich-Schiller-Universität Jena Gastvortrag im Seminar Wissenschaftliches Rechnen 9. Juli 2008

2 Worum geht es? Wir betrachten ein (numerisches) Problem und dessen Lösung auf einem Computer, einem Cluster und einer Grafikkarte. Es ist nicht das Ziel, neue bessere Algorithmen zu entwickeln!

3 1. Mathematische Grundlagen

4 Mathematische Grundlagen Die Matrixmultiplikation Gegeben: A M n (R), B M n (R). Gesucht: C = A B, C M n (R) Regel Vorzeile mal Nachspalte

5 Mathematische Grundlagen Laufzeit / Rechenaufwand / Speicherplatz Die Ergebnismatrix C hat n 2 Einträge. Für jeden Eintrag berechnen wir die Summe c kj = n i=1 a ki b ij. Das macht n 2 mal n Multiplikationen = n 3 Multiplikationen n 2 mal (n 1) Additionen = n 3 n 2 Additionen Insgesamt 2n 3 Operationen

6 Mathematische Grundlagen Laufzeit / Rechenaufwand / Speicherplatz Ein heutiger (guter) Rechner schafft ca. 10 GFLOPS. Das sind 10 Milliarden Gleitkommazahl-Rechenoperationen pro Sekunde. Theoretische Berechnungen: Schon für n = 1800 braucht ein Rechner mehr als eine Sekunde um das Produkt zweier Matrizen aus M n (R) zu berechnen. Das klingt zwar schnell, aber in der Praxis haben wir sehr oft n Bei einer Verdopplung von n benötigen wir die 8-fache Zeit. Praktisch sieht es ganz anders aus! DEMO

7 Mathematische Grundlagen Laufzeit / Rechenaufwand / Speicherplatz Eine Gleitkommazahl (FLOAT) belegt 4 Byte. Wir haben 3 Matrizen mit je n 2 Einträgen. Insgesamt also 12n 2 Byte an Speicherplatz. Beispiel (Speicherplatz für eine Matrix) n Speicherplatz 40kB 4MB 100MB 400 MB

8 2. Den Rechner rechnen lassen

9 Den Rechner rechnen lassen Quelltext # define N long i, j, n; float zwischenwert, ** result, ** matrix ;... for (i =0; i < N; i ++){ for (j =0; j < N; j ++){ zwischenwert =0; for (n =0; n< N; n ++){ zwischenwert += matrix [i][n]* matrix [n][j]; } result [i][j] = zwischenwert ; } }

10 Den Rechner rechnen lassen Laufzeiten N Zeit in s Zeit in min MFLOPS DEMO

11 Den Rechner rechnen lassen Laufzeiten Zeit in s N (Anzahl der Zeilen / Spalten)

12 3. Den Cluster rechnen lassen

13 Den Cluster rechnen lassen Der Cluster am IAM

14 Den Cluster rechnen lassen Der Cluster am IAM Daten zum Cluster: Anzahl der Rechner: 37 Anzahl der Prozessoren: 82 GH insgesamt: 202 Arbeitsspeicher: 90 GB Festplattenspeicher: 2 TB

15 Den Cluster rechnen lassen Den Cluster programmieren Frage: Wie arbeitet der Cluster? Was muss ich anders machen? MPI Message Passing Interface

16 Den Cluster rechnen lassen Die Verwendung von MPI #include "mpi.h" MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); Anzahl der Prozessoren MPI_Comm_rank(MPI_COMM_WORLD, &myrank); Nummer des eigenen Prozessors MPI_Finalize(); Compilieren mit mpicc...

17 Den Cluster rechnen lassen MPI Jeder Prozess (Knoten) erhält also eine eindeutige ID. Diese wird u. a. verwendet, um Aufgaben und Daten zu verteilen. Wir verwenden MPI für die Kommunikation zwischen Rechnen. Dabei unterschiedet man (je nach Betrachtungswinkel) unterschiedliche Arten.

18 Den Cluster rechnen lassen MPI Einteilung nach BLOCKIERUNG blockierende Kommunikation nichtblockierende Kommunikation Einteilung nach KOLLEKTIVITÄT kollektive Kommunikation einfache Kommunikation (senden, empfangen) Kommunikation mit Funktionen (summieren,... ) Kommunikation zwischen einzelnen Rechnern Einteilung nach STARRHEIT der Datenverteilung starres Schema variables Schema

19 Den Cluster rechnen lassen MPI Unter anderem stehen uns zur Verfügung: MPI_Send MPI_Recv MPI_Scatter MPI_Ssend MPI_Irecv MPI_Scatterv MPI_Rsend MPI_Reduce MPI_Bsend MPI_Probe MPI_Isend MPI_Gather MPI_Test MPI_Bcast MPI_Allgather MPI_Wait MPI_Alltoall MPI_Barrier

20 Den Cluster rechnen lassen MPI Einige Beispiele:

21 Den Cluster rechnen lassen MPI - kollektive Kommunikation Kollektive Kommunikation mit Funktion: MPI Reduce Die Teilergebnisse der einzelnen Rechner werden zum Chef übertragen, gleichzeitig wird eine Funktion darauf angewendet. Z. B. Summation der Teilergebnisse (bei numerischer Integration beispielsweise). Andere Beispiele sind Minimum und Maximum.

22 Den Cluster rechnen lassen MPI - kollektive Kommunikation Kollektive Kommunikation: MPI_Bcast R 0 : A R 0 : A R 1 : MPI_Bcast R 1 : A R 2 : R 2 : A R 3 : R 3 : A

23 Den Cluster rechnen lassen MPI - kollektive Kommunikation MPI_Scatter R 0 : A B C D R 0 : A R 1 : MPI_Scatter R 1 : B R 2 : R 2 : C R 3 : R 3 : D

24 Den Cluster rechnen lassen MPI - kollektive Kommunikation MPI_Gather R 0 : A R 0 : A B C D R 1 : B MPI_Gather R 1 : R 2 : C R 2 : R 3 : D R 3 :

25 Den Cluster rechnen lassen MPI - kollektive Kommunikation MPI_Allgather R 0 : A R 0 : A B C D R 1 : B MPI_Allgather R 1 : A B C D R 2 : C R 2 : A B C D R 3 : D R 3 : A B C D

26 Den Cluster rechnen lassen MPI - pfiffige Kommunikation Diese Kommunikationsstruktur ist denkbar: R 3 R 4 R 2 R 5 R 0 R 1 R 6 R 7 R 8

27 Den Cluster rechnen lassen MPI - pfiffige Kommunikation Diese Kommunikationsstruktur ist denkbar: R 3 R 4 R 2 R 5 R 0 R 1 R 6 R 7 R 8

28 Den Cluster rechnen lassen MPI - pfiffige Kommunikation Diese Kommunikationsstruktur ist denkbar: R 3 R 4 R 2 R 5 R 0 R 1 R 6 R 7 R 8

29 Den Cluster rechnen lassen MPI - pfiffige Kommunikation Denkbar schlecht. R 3 R 4 R 2 R 5 R 0 R 1 R 6 R 7 R 8

30 Den Cluster rechnen lassen MPI - pfiffige Kommunikation Besser ist: R 0

31 Den Cluster rechnen lassen MPI - pfiffige Kommunikation Besser ist: R 0 R 0 R 1

32 Den Cluster rechnen lassen MPI - pfiffige Kommunikation Besser ist: R 0 R 0 R 1 R 0 R 1 R 2 R 3

33 Den Cluster rechnen lassen MPI - pfiffige Kommunikation Besser ist: R 0 R 0 R 1 R 0 R 1 R 2 R 3 R 0 R 1 R 2 R 3 R 4 R 5 R 6 R 7

34 Den Cluster rechnen lassen MPI - pfiffige Kommunikation Und so arbeitet auch MPI_Bcast. R 0 R 0 R 1 R 0 R 1 R 2 R 3 R 0 R 1 R 2 R 3 R 4 R 5 R 6 R 7

35 Den Cluster rechnen lassen MPI - Senden und Empfangen blockiert MPI_Send (Ssend / Bsend) Je nach Datenmenge entscheidet MPI selbstständig ob MPI_Ssend oder MPI_Bsend verwendet wird. MPI_Ssend (synchrones Senden) Funktion kehrt erst zurück, nachdem mit dem Emfang der Daten begonnen wurde. MPI_Bsend (gepuffertes Senden) Sendedaten werden in einen Pufferspeicher umkopiert und von dort gesendet, die Funktion kehrt sofort nach dem Kopiervorgang zurück. MPI_Recv Prozess signalisiert seinen Empfangswunsch. Nach fehlerfreier Beendigung steht die Nachricht komplett im Empfangspuffer bereit.

36 Den Cluster rechnen lassen MPI - Senden und Empfangen Bevor wir mit nichtblockierender Kommunikation weitermachen: Tools: MPI_Wait Die Funktion kehrt erst zurück, wenn der der Sendepuffer schon komplett ausgelesen wurde. MPI_Test Überprüft, ob ein Transfer schon abgeschlossen wurde und kehrt sofort zurück. MPI_Barrier Synchronisiert alle Prozesse. Kehrt erst zurück, wenn es von allen Prozessen in einem Universum aufgerufen wurde.

37 Den Cluster rechnen lassen MPI - Senden und Empfangen nicht blockiert Nachrichtenverkehr besteht aus zwei Funktionsaufrufen. Der Erste stößt den Transfer nur an, der Zweite schließt ihn ab. MPI_Isend Stößt den Sendevorgang an. Mit MPI_Wait oder besser mit MPI_Test kann man feststellen, wann der Sendepuffer wieder überschrieben werden darf. MPI_Irecv Analog zu MPI_Isend. Vorteil: Rechnen statt Warten!

38 Den Cluster rechnen lassen Bevor wir wieder zur Matrixmultiplikation kommen, noch ein paar kleine Aspekte von MPI.

39 Den Cluster rechnen lassen Deadlocks Ein Beispiel: Es werden Funktionen für den blockierenden Nachrichtenverkehr verwendet. Und zwar wie folgt: Prozess 0 Prozess 1 MPI Send(...) MPI Send(...) MPI Recv(...) MPI Recv(...) Ein Deadlock!

40 Den Cluster rechnen lassen Fairness Wenn viele Prozesse Daten an einen Prozess senden, ist das unfair. Hier ein Beispiel: Verteilung Zeit pro Paket 2 Prozesse senden je 500 Pakete 4ms 4 Prozesse senden je 250 Pakete 7ms 10 Prozesse senden je 100 Pakete 45ms

41 Den Cluster rechnen lassen Profiling-Interface Gemäß dem MPI-Standard muss eine Funktion MPI_xyz auch unter dem Namen PMPI_xyz aufrufbar sein. Erlaubt, MPI_xyz selbst neu zu schreiben. Vorteile: Erlaubt die Anpassung von MPI an Eigenheiten des Clusters / des Programms. Möglichkeiten, Protokollierung einzubauen, ohne den Quelltext der Programme zu ändern....

42 Den Cluster rechnen lassen Datentypen Es gibt in MPI eigene Datentypen. Warum? Aus Gründen der Interpretationssicherheit! Beispiel: Auf 32-Bit CPUs besteht ein INTeger aus vier aufeinanderfolgenden Bytes = Ein Intel-Prozessor speichert dies als (7, 31, 87, 67) Ein Prozessor von Motorola speichert es als (67, 87, 31, 7). Probleme bei heterogenen Clustern!

43 Den Cluster rechnen lassen Matrixmultiplikation Natürlich gibt es noch sehr viele andere Funktionen und Möglichkeiten der Kommunikation. Wir wollen uns jetzt damit beschäftigen, wie eine einfache Matrixmultiplikation realisiert werden kann. Auch hier gibt es verschiedene Möglichkeiten.

44 Den Cluster rechnen lassen Matrixmultiplikation Es geht los,...

45 Den Cluster rechnen lassen Matrixmultiplikation... der Chef erhält (generiert) die Matrix,...

46 Den Cluster rechnen lassen Matrixmultiplikation... der Chef sendet die Matrix,...

47 Den Cluster rechnen lassen Matrixmultiplikation... alle Rechner haben die Matrix,...

48 Den Cluster rechnen lassen Matrixmultiplikation... der Chef verteilt die Aufgaben,...

49 Den Cluster rechnen lassen Matrixmultiplikation... alle Rechner wissen, was sie zu tun haben,...

50 Den Cluster rechnen lassen Matrixmultiplikation... alle Rechner rechnen,...

51 Den Cluster rechnen lassen Matrixmultiplikation... alle Rechner haben gerechnet,...

52 Den Cluster rechnen lassen Matrixmultiplikation... der Chef sammelt die Ergebnisse ein,...

53 Den Cluster rechnen lassen Matrixmultiplikation... der Chef bildet das Gesamtergebnis....

54 Den Cluster rechnen lassen Matrixmultiplikation... Habe fertig.

55 Den Cluster rechnen lassen Vor- und Nachteil(e) Vorteil: Verteilung der Arbeit auf viele Rechner Nachteile: Programmieren ist umständlicher Viel Datenverkehr über das Netzwerk (Zeit) Synchronisation notwendig (Wartezeit)

56 Den Cluster rechnen lassen Quelltext # include " mpi.h" # define N int myrank, nprocs ; float zwischenw, ** matrix, ** result, ** tmatrix ; MPI_Comm_size ( MPI_COMM_WORLD, & nprocs ); MPI_Comm_rank ( MPI_COMM_WORLD, & myrank ); for (i =0; i<n; i ++){ MPI_Bcast (& matrix [i],n, MPI_FLOAT,0, MPI_COMM_WORLD ); }

57 Den Cluster rechnen lassen Quelltext if( myrank == 0){ for ( i =0; i < zeile + rest ; i ++){ for (j =0; j < N; j ++){ zwischenw = 0; for (n =0; n< N; n ++){ zwischenwert += matrix [i][n]* matrix [n][j]; } result [i][j] = zwischenwert ; } } for (i =1; i < nprocs ; i ++){ for (j =0; j < zeile ; j ++){ MPI_Recv ( result [ zeile *i+ rest +j], N, MPI_FLOAT, i, 99, MPI_COMM_WORLD, & status ); } } } else {... }

58 Den Cluster rechnen lassen Quelltext if( myrank == 0){... } else { for ( k, j... ){ for (j =0; j < N; j ++){ zwischenw = 0; for (n =0; n<n; n ++){ zwischenw += matrix [i][n]* matrix [n][j]; } tmatrix [k][j]= zwischenw ; } } } for ( i =0; i< zeile ; i ++){ MPI_Send ( tmatrix [i], N, MPI_FLOAT, 0, 99, MPI_COMM_WORLD ); }

59 Den Cluster rechnen lassen Laufzeiten N Zeit in s Zeit in min GFLOPS DEMO

60 Den Cluster rechnen lassen Laufzeiten Gesamt Berechnung Senden Laufzeitmessung zur Matrixmultiplikation mit MPI 150 Zeit in s N (Anzahl der Zeilen / Spalten)

61 3. Die Grafikkarte rechnen lassen

62 Grafikkarte? Ja, Grafikkarte! NVIDIA GeForce 8800 GT

63 Grafikkarte? Ja, Grafikkarte! Wir verwenden die nvidia GeForce 8800 GT als extrem leistungsfähigen math. Co-Prozessor.

64 Grafikkarte? Ja, Grafikkarte! Und zur Programmierung verwenden wir CUDA Compute Unified Device Architecture

65 Die Grafikkarte rechnen lassen CUDA - Ein paar Grundlagen Der Unterschied zwischen CPU und GPU: 1. Introduction to CUDA Control Cache ALU ALU ALU ALU DRAM DRAM CPU GPU Figure 1-2. The GPU Devotes More Transistors to Data Processing

66 Die Grafikkarte rechnen lassen CUDA - Ein paar Grundlagen Im Fall der nvidia 8800 GT bedeutet das: Stream-Prozessoren: 112 Speicher: 512 MB Speicherbandbreite GB/s Gerade neu im Lehrstuhl: nvidia 9800 GX2 Stream-Prozessoren: 256 Speicher: 1 GB Speicherbandbreite. 128 GB/s

67 Die Grafikkarte rechnen lassen CUDA features a parallel data cache or on-chip shared memory with very fast CUDA - Ein paar general Grundlagen read and write access, that threads use to share data with each other (see Chapter 3). As illustrated in Figure 1-5, applications can take advantage of it by Warum die minimizing Speicherangabe? overfetch and round-trips Shared-Memory: to DRAM and therefore becoming less dependent on DRAM memory bandwidth. Control Cache ALU ALU ALU... Control Cache ALU ALU ALU... DRAM d0 d1 d2 d3 d4 d5 d6 d7 Without shared memory Control Cache ALU ALU ALU... Control Cache ALU ALU ALU... Shared memory Shared memory d0 d1 d2 d3 d4 d5 d6 d7 DRAM d0 d1 d2 d3 d4 d5 d6 d7 With shared memory Figure 1-5. Shared Memory Brings Data Closer to the ALUs

68 Die Grafikkarte rechnen lassen CUDA - Ein paar Grundlagen Wir müssen also die Daten auf die Grafikkarte bringen. CPU DRAM GPU Shared Memory Und das geht so:

69 Die Grafikkarte rechnen lassen CUDA - Ein paar Grundlagen unsigned int size_ A = wa * ha; unsigned int mem_ size_ A = sizeof ( float ) * size_ A ; float * h_a = ( float *) malloc ( mem_size_a );... float * d_a ; cudamalloc (( void **) &d_a, mem_size_a ); cudamemcpy (d_a, h_a, mem_size_a, cudamemcpyhosttodevice );... cudamemcpy (h_c, d_c, mem_size_c, cudamemcpydevicetohost );... free ( h_a ); cudafree ( d_a );

70 Die Grafikkarte rechnen lassen CUDA - Ein paar Grundlagen Das zentrale Element: Grid Block Thread Programming Model

71 Die Grafikkarte rechnen lassen CUDA - Programming Model Es gibt einen kernel. Dieser wird massiv parallel mit unterschiedlichen Daten ausgeführt. Thread Batching Organisiert wird dies in einem Grid aus thread blocks. Thread Block Ein thread block: Stapel von threads Effizienter Datenaustausch über den shared memory Möglichkeit der Synchronisation zur Koordinierung der Speicherzugriffe

72 Die Grafikkarte rechnen lassen CUDA - Programmierung mit Grids, Blocks und Threads Chapter 2. Programming Model Host Device Grid 1 Kernel 1 Block (0, 0) Block (1, 0) Block (2, 0) Block (0, 1) Block (1, 1) Block (2, 1) Grid 2 Kernel 2 Block (1, 1) Thread (0, 0) Thread (1, 0) Thread (2, 0) Thread (3, 0) Thread (4, 0) Thread (0, 1) Thread (1, 1) Thread (2, 1) Thread (3, 1) Thread (4, 1) Thread (0, 2) Thread (1, 2) Thread (2, 2) Thread (3, 2) Thread (4, 2) The host issues a succession of kernel invocations to the device. Each kernel is executed as a batch of threads organized as a grid of thread blocks

73 Die Grafikkarte rechnen lassen CUDA - Programmierung mit Grids, Blocks und Threads Ein thread wird durch seine thread ID identifiziert. thread ID = Nummer des threads im block thread ID Um komplexe Addressierung mittels thread ID zu ermöglichen, kann die ID ein-, zwei- und sogar dreidimensional sein.

74 Die Grafikkarte rechnen lassen CUDA - Programmierung mit Grids, Blocks und Threads Zugriff auf die ID: int tx = threadidx. x; int ty = threadidx. y;

75 Die Grafikkarte rechnen lassen CUDA - Programmierung mit Grids, Blocks und Threads Die Anzahl der threads in einem Block hat aber eine Höchstgrenze (abhängig von der Grafikkarte). Deshalb kann man blocks zu einem Grid zusammenfassen. Threads in unterschiedlichen Blocks können nicht miteinander kommunizieren (per shared memory) und man kann sie nicht synchronisieren! Die Ausführung der Blocks hängt von der Grafikkarte ab: Alle müssen beispielsweise nacheinander abgearbeitet werden, oder sie können alle gleichzeitig ausgeführt werden, oder eine Mischung aus beiden. Je nach den Eigenschaften der Grafikkarte.

76 Die Grafikkarte rechnen lassen CUDA - Programmierung mit Grids, Blocks und Threads Auch Blocks haben eine ID. Sie kann maximal zweidimensional sein. Zugriff auf die ID: int bx = blockidx. x; int by = blockidx. y;

77 Die Grafikkarte rechnen lassen CUDA - Das SDK Betriebssystem Windows XP in v1.1 und in v2.0beta2, Vista in v2.0beta2 Linux in v1.1 und in v2.0beta2 Mac OS X in v1.1 Grafikkarten nvidia GeForce: GTX 280, GTX 260, 9800 GX2, 9800 GTX, 9600 GT, 8800 Ultra, 8800 GTX, 8800 GTS, 8800 GT, 8800 GS, 8600 GTS, 8600 GT, 8500 GT, 8400 GS, 8800M GTX, 8800M GTS, 8700M GT, 8600M GT, 8600M GS, 8400M GT, 8400M GS Tesla: S1070, C1060, C870, D870, S870 Quadro: FX 5600, FX 4700 X2, FX 4600, FX 3700, FX 1700, FX 570, FX 370, NVS 290, FX 3600M, FX 1600M, FX 560M, FX 360M, Plex 1000 Model IV, Plex 1000 Model S4, NVS 320M, NVS 140M, NVS 135M, NVS 130M

78 Die Grafikkarte rechnen lassen CUDA - Das SDK Der Compiler NVCC Host-Code in C oder C++ Device-Code in C Device-Code: keine Rekursion! Möglichkeit die Grafikkarte nur zu emulieren.

79 Die Grafikkarte rechnen lassen CUDA - Das SDK matrixmul.cu (Host-Code) #include <matrixmul kernel.cu>... dim3 threads(16,16); dim3 grid(64,64); matrixmul<<< grid, threads >>>(... ); matrixmul kernel.cu (Device-Code)... global void matrixmul(... );... syncthreads();...

80 Die Grafikkarte rechnen lassen CUDA - Das SDK Die CUDA Utilities Im Host-Code: #include<cutil.h>. printf ist möglich, Timer sind möglich, durch cutcreatetimer, cutstarttimer, cutstoptimer und cutdestroytimer, Überprüfung auf geschehene Fehler möglich: CUT_CHECK_ERROR, CUT_DEVICE_INIT, CUT_EXIT (später in der Demo),...

81 Die Grafikkarte rechnen lassen CUDA Noch ein paar Features: CUBLAS: Single-precision Real & Complex Functions Level 1-3 CUFFT: 1-3 dim FFT: Complex-to-Complex, Real-to-Complex, Complex-to-Real Plug-ins: MATLAB Photoshop

82 Die Grafikkarte rechnen lassen Matrixmultiplikation Chapter 6. Example of Matrix Multiplication A B C C sub BLOCK_SIZE BLOCK_SIZE BLOCK_SIZE wa ha BLOCK_SIZE wa BLOCK_SIZE BLOCK_SIZE wb Each thread block computes one sub-matrix C sub of C. Each thread within the block computes one element of Csub. Ivo Hedtke Figure (hedtke@math.uni-jena.de) 6-1. Matrix Multiplication

83 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul.h # ifndef _ MATRIXMUL_ H_ # define _ MATRIXMUL_ H_ # define BLOCK_ SIZE 16 # define NN 4000 # define WA NN # define HA NN # define WB NN # define HB NN # define WC NN # define HC NN # endif // _MATRIXMUL_H_

84 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul.cu # include <stdlib.h> # include <stdio.h> # include <string.h> # include <math.h> # include <cutil.h> # include < matrixmul_kernel.cu > void InitMat ( float *, int ); void runtest (int, char **); void runtest ( int argc, char ** argv ) {

85 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul.cu void runtest ( int argc, char ** argv ) { unsigned int size_ A = WA * HA; unsigned int mem_ size_ A = sizeof ( float ) * size_ A ; float * h_a = ( float *) malloc ( mem_size_a ); InitMat (h_a, size_a ); float * d_a ; cudamalloc (( void **) &d_a, mem_size_a ); cudamemcpy (d_a,h_a, mem_size_a, cudamemcpyhosttodevice unsigned int size_ C = WC * HC; unsigned int mem_ size_ C = sizeof ( float ) * size_ C ; float * d_c ; cudamalloc (( void **) &d_c, mem_size_c ); float * h_c = ( float *) malloc ( mem_size_c );

86 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul.cu unsigned int timer = 0; cutcreatetimer (& timer ); cutstarttimer ( timer ); dim3 threads ( BLOCK_ SIZE, BLOCK_ SIZE ); dim3 grid (WC / threads.x, HC / threads.y); matrixmul <<< grid, threads >>>(d_c,d_a,d_a,wa,wb ); CUT_CHECK_ERROR (" Kernel execution failed "); cudamemcpy (h_c,d_c, mem_size_c, cudamemcpydevicetohost );

87 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul.cu } cutstoptimer ( timer ); printf (" Processing time for N=%i: %f (ms) \n", _ NN, cutgettimervalue ( timer )); cutdeletetimer ( timer ); printf (" %10.9 f",h_c [0]); free ( h_a ); free ( h_c ); CUDA_SAFE_CALL ( cudafree ( d_a )); CUDA_SAFE_CALL ( cudafree ( d_c ));

88 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul.cu int main ( int argc, char ** argv ){ CUT_ DEVICE_ INIT ( argc, argv ); // CUTIL runtest (argc, argv ); CUT_ EXIT ( argc, argv ); // CUTIL }

89 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul kernel.cu # include <stdio.h> # include " matrixmul.h" # define AS(i, j) As[i][j] # define BS(i, j) Bs[i][j] global void matrixmul ( float * C, float * A, _ float * B, int wa, int wb ){

90 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul kernel.cu int bx = blockidx. x; int by = blockidx. y; int tx = threadidx. x; int ty = threadidx. y; int abegin = wa * BLOCK_ SIZE * by; int aend = abegin + wa - 1; int astep = BLOCK_ SIZE ; int bbegin = BLOCK_ SIZE * bx; int bstep = BLOCK_ SIZE * wb; float Csub = 0;

91 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul kernel.cu for ( int a = abegin, b = bbegin ; a <= aend ; a += astep, b += bstep ) { shared float As[ BLOCK_SIZE ][ BLOCK_SIZE ]; shared float Bs[ BLOCK_SIZE ][ BLOCK_SIZE ]; AS(ty, tx) = A[a + wa * ty + tx ]; BS(ty, tx) = B[b + wb * ty + tx ]; syncthreads (); } for ( int k = 0; k < BLOCK_ SIZE ; ++ k){ Csub += AS(ty, k) * BS(k, tx ); syncthreads (); } syncthreads ();

92 Die Grafikkarte rechnen lassen Matrixmultiplikation: matrixmul kernel.cu } int c = wb * BLOCK_ SIZE * by + BLOCK_ SIZE * bx; C[c + wb * ty + tx] = Csub ;

93 Die Grafikkarte rechnen lassen Laufzeiten auf der GeForce 8600 GTS N dim3 grid(x) dim3 threads(y) Zeit in s GFLOPS 1024 X = (64, 64) Y = (16, 16) X = (124, 124) Y = (16, 16) X = (188, 188) Y = (16, 16) X = (250, 250) Y = (16, 16) X = (312, 312) Y = (16, 16) DEMO

94 Die Grafikkarte rechnen lassen Laufzeiten auf anderen Grafikkarten dim3 threads(16,16), dim3 threads(250,250), N=4000 GeForce 8600 GTS 10.6s, GFLOPS GeForce 8600 GT 10s, 12.8 GFLOPS GeForce 8800 GT 3s, GFLOPS

95 Die Grafikkarte rechnen lassen Laufzeiten auf anderen Grafikkarten dim3 threads(32,32), dim3 threads(125,125), N=4000 GeForce 8800 GT 95.1ms 1.34 TFLOPS

96 Die Grafikkarte rechnen lassen Laufzeiten auf der GeForce 8600 GTS Zeit in s N (Anzahl der Zeilen / Spalten)

97 Die Grafikkarte rechnen lassen Vor- und Nachteil(e) Vorteil massiv parallel Rechnen Nachteile aufwendige Programmierung Begrenzungen durch Eigenschaften der Grafikkarte Kommunikation zwischen Threads nur über Shared Memory (fast) keine Kommunikation zwischen Threads aus unterschiedlichen Blocks

98 Weitere Technologien

99 Open CL Open CL Mac OS X Server Snow Leopard

100 Open CL Open Computing Language soll erstmals von Apple 2009 mit OS X 10.6 (Snow Leopard) auf den Markt kommen wird als offener Standard bei der Khronos Group erarbeitet OpenCL Programme und Programmteile werden zur Laufzeit auf vorhandene Haupt- und Grafikprozessorkerne verteilt basiert auf der Syntax von C Die Technologie soll NVIDIAs CUDA weit voraus sein und dabei sehr einfach zu programmieren. 1 1 Quelle: NY Times

101 Midori Meldung vom 1. Juli: Angeblich auf Sinularity aufbauendes parallelisiertes Betriebssystem, welches nicht nur Forschungscharakter hat.

102 AMD Stream Computing Parallel processing architecture with 320 stream cores Up to 500 GFLOPs single precision performance 2GB GDDR3 on-board memory Windows XP, XP64, Linux 32 and Linux 64 Streams: A stream is a collection of data elements of the same type which can be operated on in parallel. Streams are denoted using angular brackets. Kernels: A kernel is a parallel function that operates on every element of input streams. Kernels are specified using the kernel keyword.

103 AMD Stream Computing Beispiel kernel void sum ( float a<>, float b<>, out float c < >) { c = a + b; } The code snippet shows a simple example of a kernel which adds two input streams and stores the results in an output stream. The kernel performs an implicit loop over each element in the output stream.

104 IBM Roadrunner

105 IBM Roadrunner Supercomputer im Los Alamos National Laboratory Leistung: 1,026 Peta-FLOPS = 1026 TFLOP 6480 AMD-Opteron-Prozessoren jedem Opteron-Kern ist ein Cell-Prozessoren unterstellt (=12960 Stück) OS: Red Hat Linux Einsatz: US-Energieministerium: Simulation der Alterung radioaktiver Substanzen

106 4. Zusammenfassung

107 Laufzeiten Zeit in s N CPU MPI GPU

108 Laufzeiten CPU MPI GPU Zeit in s N (Anzahl der Zeilen/Spalten)

109 Laufzeiten CPU MPI GPU Zeit in s N (Anzahl der Zeilen/Spalten)

110 Laufzeiten CPU MPI GPU Zeit in s N (Anzahl der Zeilen/Spalten)

111 Ein Ziel durchdachte Algorithmen + Message Passing Interface + Compute Unified Device Architecture = adäquater Ersatz für Supercomputer

112 Danke für die Aufmerksamkeit! Fragen???