2 Dieter an Mey, SunHPC 2002, Einleitung 10000, , ,000 10,000 1,000 0,100 0,010. 0,001 Cyber 175 Cyber 205

Transkript

1 Inhalt Das Sun Fire SMP-Cluster: Dieter an Mey Rechen- und Kommunikationszentrum der RWTH Aachen 12. März 2002 rz.rwth-aachen.de [/hpc hpc[/ [/sun]] -Optimierung Shared Parallelisierung 1 2 Inhalt Entwicklung der HPC-Ressourcen an der RWTH -Optimierung Shared Parallelisierung 10000, , ,000 10,000 1,000 0,100 0,010 0,001 Max. Geschwindigkeit [GFlop/s] 0,2 0,04 0,004 0,001 Cyber 175 Cyber (Bochum) Hauptspeicher [GByte] 5 0,8 1 0,3 IBM 3090 VF SNI S-600/ , SNI VPP300/8 SunFire Cluster SunFire Cluster SunFire Cluster Juni 2001 Ende 2001 Ende Nutzungsstatistik des Rechner-Clusters Juli Januar 2002 Top 500 Liste der 500 schnellsten Rechner Std FB 1 = Fakultät für Mathematik, Informatik und Naturwissenschaft FB 2 = Fakultät für Architektur FB 3 = Fakultät für Bauingenieur- und Vermessungswesen FB 4 = Fakultät für Maschinenwesen FB 5 = Fakultät für Bergbau, Hüttenwesen und Geowissenschaften FB 6 = Fakultät für Elektrotechnik und Informationstechnik FB 7 = Philosophische Fakultät FB 8 = Fakultät für Wirtschaftswissenschaften FB 10 = Medizinische Fakultät RV-NRW = Rechnerverbund NRW #1 #50 #200 #500 PC-Technologie Moore's Law SunFire Stufe 4: 2003 Stufe 3: März 2002 Stufe 2: Dez Stufe 1: Juni vor Installation des Sun-Rechners - nach Installation des Sun-Rechners (und Abschaltung des Vektorrechners) FB1 FB2 FB3 FB4 FB5 FB6 FB7 FB8 FB10 RV-NRW 1 Jun Dez Jun Dez Jun Dez Jun Dez Jun Dez Jun Dez Jun Dez Jun Dez Jun Dez Jun Dez Jun

2 Aktuelle Konfiguration 8 8 x Sun Fire 6800, seit Juni 2001 Je 24 x UltraSPARC-III, 750 MHz Je Je 24 Gbyte Hauptspeicher 8 8 x Sun Fire 6800, seit Dezember 2001 Je Je 24 x UltraSPARC-III/Cu, 900 MHz Je Je 24 Gbyte Hauptspeicher 4 4 x Sun Fire 15K, März 2002 Je Je 72 x UltraSPARC-III/Cu, 900 MHz Je 144 Gbyte Hauptspeicher 192 Prozessoren 288 GFlop/s 192 Prozessoren 346 GFlop/s 288 Prozessoren 520 GFlop/s 576 Gbyte Weiterer Ausbau 2Q x Sun Fire Prozessoren Je Je 24 x UltraSPARC-III, 900 MHz 346 GFlop/s Je 24 Gbyte Hauptspeicher 8 8 x Sun Fire Prozessoren Je 24 x UltraSPARC-III/Cu, 900 MHz 346 GFlop/s Je Je 24 Gbyte Hauptspeicher Sun 4 4 x Sun Fire 15K Je Je 72 x UltraSPARC-III/Cu, 900 MHz 288 Prozessoren Je 144 Gbyte Hauptspeicher 520 GFlop/s 576 Gbyte 7 8 Weiterer Ausbau 2003 Aktuelle Vernetzung 8 8 x Sun Fire Prozessoren Je 24 x UltraSPARC-IV, 1500 MHz 1152 GFlop/s Je 24 Gbyte Hauptspeicher 8 8 x Sun Fire Prozessoren Je 24 x UltraSPARC-IV, 1500 MHz 1152 GFlop/s Je 24 Gbyte Hauptspeicher 192 Gbyte 4 4 x Sun Fire 15K Je 72 x UltraSPARC-IV, 1500 MHz 576 Prozessoren Je Je 144 Gbyte Hauptspeicher 1728 GFlop/s 576 Gbyte 8 x Sun Fire 6800 Je 2 Gigabit-Ethernet Je 2 Myrinet 2000-Karten 8 x Sun Fire 6800 Je 1 Gigabit-Ethernet 4 x Sun Fire 15K Je 1 Gigabit-Ethernet 2 x Sun Enterprise 450 NFS-Server Server Je 2 Gigabit-Ethernet Myrinet-Switch Gigabit-Switch 9 10 Zukünftige Vernetzung Aktuelle Dateihaltung 8 x Sun Fire 6800 Je 2 Gigabit-Ethernet Je 1 Myrinet 2000-Karten Je 2x2 Fire Link-Adapter 8 x Sun Fire 6800 Je 1 Gigabit-Ethernet Je 1 Myrinet 2000-Karten Je 2x2 Fire Link-Adapter 4 x Sun Fire 15K Je 1 Gigabit-Ethernet Je 2x2 Fire Link-Adapter 2 x Sun Enterprise 450 NFS-Server Server Je 2 Gigabit-Ethernet Sun Fire Link -Switch Myrinet-Switch Sun Fire Link -Switch Gigabit-Switch Sun Fire Link -Switch 8 x Sun Fire 6800 Lokale Lokale Systemplatten Lokale Lokale Scratchplatten (180 GB, $TMP) 8 x Sun Fire 6800 Lokale Lokale Systemplatten LokaleLokale Scratchplatten (180 GB, $TMP) 4 x Sun Fire 15K Lokale Lokale Systemplatten LokaleLokale Scratchplatten (180 GB, $TMP) 2 x Sun Enterprise 450 NFS-Server Server Softwareplatten Permanente Dateien ($HOME) Mittelfristige große Arbeitsdateien ($WORK) Gigabit-Ethernet indirekter Zugriff auf globale Daten über NFS-Fileservice Fileservice 1 TB 11 12

3 Zukünftige Dateihaltung 8 x Sun Fire 6800 Lokale Systemplatten Lokale Scratchplatten (180 GB, $TMP) 8 x Sun Fire 6800 Lokale Systemplatten Lokale Scratchplatten (180 GB, $TMP) 4 x Sun Fire 15K Lokale Systemplatten Lokale Scratchplatten (180 GB, $TMP) 2 x Sun Enterprise 450 NFSNFS-Server Das Sun Fire SMP-Cluster: Fiber Chanel Aktuelle Konfiguration Architektur Programmierung -Optimierung Message Passing Shared Parallelisierung Ausblick auf die folgenden Veranstaltungen Direkter Zugriff auf globale Daten über ein FiberFiber-ChannelChannel-basiertes System Area Network mit dem QFS Dateisystem Softwareplatten Permanente Dateien ($HOME) Mittelfristige große Arbeitsdateien ($WORK) 13 Inhalt 6 TB 14 Architektur des RWTHRWTH-Hochleistungsrechners Architektur des RWTHRWTH-Hochleistungsrechners 4 x Sun Fire Sun Fire UltraSparc III 8 x Sun Fire x Sun Fire Gbyte (on board) Bandbreite zu den s: 2,4 Gbyte/s Bandbreite zum : 4,8 Gbyte/s Systemdaten Snooping-Bandbreite: 9,6 Gbyte/s Storage Area Network (SAN) processor control 900 MHz 1,8 Gflops L2-: 8 MByte datapath registers 8 Gbyte (on board) Bandbreite zu den s: 2,4 Gbyte/s Bandbreite zum : 4,8 Gbyte/s Systemdaten Speicher: 144 Gbyte (SMP) Summe L2-s: 576 Mbyte aggregierte Bandbreite: 43,2 Gbyte/s 17 akkumulierte Speicherbandbreite 172,8 Gbyte/s theoret. Rechenleistung: 130 Gflops Bandbreite zum SAN: 400 Mbyte/s lokale Platten: ca. 400 Gbyte WildCat Vernetzung (MPI): 2,4 Gbyte/s Netzanschlüsse: 2 x Gbit-Ethernet (oder: wie weit weg sind die Daten) 4 UltraSparc III Speicher: 24 Gbyte (SMP) Summe L2-s: 192 Mbyte akkumulierte Speicherbandbreite 9,6 Gbyte/s theoret. Rechenleistung: 36/43,2 Gflops Bandbreite zum SAN: 200 Mbyte/s lokale Platten: ca. 200 Gbyte WildCat Vernetzung (MPI): 2,4 Gbyte/s Netzanschlüsse: 1/2 x Gbit-Ethernet Speicherhierarchien Architektur des RWTHRWTH-Hochleistungsrechners Sun Fire 15k 750/900 MHz 1,5/1,8 Gflops L2-: 8 MByte on-chip cache Second level cache (SRAM) Geschwindigkeit: ~nsec ~10 nsec Größe: 64 KByte 8 MByte Main memory (DRAM) ~100 nsec GByte Secondary storage (Disk) Tertiary storage (Disk/Tape) ~10 msec ~10 sec Terabytes Viele Algorithmen können so umstrukturiert werden, daß sie einen großen Anteil von Lokalität in ihren Datenzugriffen zeigen. Örtliche Lokalität: Daten, die nahe beieinander liegen (lines (lines)) Zeitliche Lokalität: Wiederbenutzung eines vor kurzem benutzten Datums. 18

4 Inhalt -Optimierung Shared Parallelisierung Einzelprozessorsystem - stark vereinfachtes Modell Matrizenmultiplikation Matrizenmultiplikation - Standardalgorithmus Multiplikation von vollbesetzten Matrizen subroutine mmul (n,m,l,a,lda,b,ldb,c,ldc) integer*4 n,m,l,i,j,k,lda,ldb,ldc real*8 a(lda,*), b(ldb,*),c(ldc,*) C ik = a ij * b jk c ik = Σ a ij * b jk j 21 do k = 1, l do i = 1, n c(i,k) = 0.0d0 do j = 1, m c(i,k)=c(i,k)+a(i,j)*b(j,k) return end 22 Matrizenmultiplikation - serielle Rechengeschwindigkeit (1) MFlop/s UltraSPARC-III/Cu 900 MHz Forte Developer 6U2 f90 f90 O n=m=l=100 in L2-cache n=m=l=1000 out of L2-cache Matrizenmultiplikation Die Multiplikation von großen Matrizen (die nicht in den passen) kann auf die Multiplikation und Addition von kleineren Matrizen (die in den passen ) zurückgeführt werden C11 C21 C12 C22 A11 A12 = * A21 A22 B11 B21 B12 B22 Mit C11 = A11 * B11 + A12 * B21 C21 = A21 * B11 + A22 * B21 C12 = A11 * B12 + A12 * B22 C22 = A21 * B12 + A22 * B22 Blockalgorithmen (Linpack -> Lapack) 23 24

5 Matrizenmultiplikation - Blockalgorithmus subroutine mmul ( n1,n2,n3,a,lda,b,ldb,c,ldc ) subroutine mm ( n,m,l,a,lda,b,ldb,c,ldc ) implicit none IMPLICIT REAL*8 ( a-h,o-z ) integer*4 n,m,l,i,j,k,lda,ldb,ldc PARAMETER ( nb1opt=500, nb2opt=100, nb3opt=100 ) real*8 a(lda,*), b(ldb,*), c(ldc,*) REAL*8 a(lda,*), b(ldb,*), c(ldc,*) real*8 b00, b01, b02, b03 real*8 b10, b11, b12, b13 nb1 = int( (n1+nb1opt-1)/nb1opt ) real*8 b20, b21, b22, b23 nb2 = int( (n2+nb2opt-1)/nb2opt ) real*8 b30, b31, b32, b33 nb3 = int( (n3+nb3opt-1)/nb3opt ) nb1 = int( n1 / nb1 ) do j = 1, l-3, 4 nb2 = int( n2 / nb2 ) do k = 1, m-3, 4 nb3 = int( n3 / nb3 ) b00 = b(k,j) nb1 = int( nb1 / 4 ) * 4 b10 = b(k+1,j) nb2 = int( nb2 / 4 ) * 4 b20 = b(k+2,j) nb3 = int( nb3 / 4 ) * 4 b30 = b(k+3,j) nb1=max(nb1,4) b01 = b(k,j+1) nb2=max(nb2,4) b11 = b(k+1,j+1) Registeroptimierung nb3=max(nb3,4) b21 = b(k+2,j+1) b31 = b(k+3,j+1) DO kk = 1, n3, nb3 b02 = b(k,j+2) DO k = kk, MIN(n3,kk+nb3-1) b12 = b(k+1,j+2) DO i = 1, n3 b22 = b(k+2,j+2) c(i,k) = 0.0d0 b32 = b(k+3,j+2) b03 = b(k,j+3) b13 = b(k+1,j+3) DO ii = 1, n1, nb1 b23 = b(k+2,j+3) DO jj = 1, n2, nb2 b33 = b(k+3,j+3) IF ( ii+nb1-1 <= n1.and. jj+nb2-1 <= n2.and. kk+nb3-1 <= n3 ) THEN do i = 1, n CALL mm (nb1, nb2, nb3, a(ii,jj), lda, b(jj,kk), ldb, c(ii,kk), ldc ) c(i,j) = c(i,j) + a(i,k) * b00 + a(i,k+1) * b10 ELSE & + a(i,k+2) * b20 + a(i,k+3) * b30 DO k = kk, MIN(n3,kk+nb3-1) c(i,j+1) = c(i,j+1) + a(i,k) * b01 + a(i,k+1) * b11 DO i = ii, MIN(n1,ii+nb1-1) & + a(i,k+2) * b21 + a(i,k+3) * b31 DO j = jj, MIN(n2,jj+nb2-1) c(i,j+2) = c(i,j+2) + a(i,k) * b02 + a(i,k+1) * b12 c(i,k) = c(i,k) + a(i,j) * b(j,k) & + a(i,k+2) * b22 + a(i,k+3) * b32 c(i,j+3) = c(i,j+3) + a(i,k) * b03 + a(i,k+1) * b13 & + a(i,k+2) * b23 + a(i,k+3) * b33 END IF return end RETURN END 25 Matrizenmultiplikation - serielle Rechengeschwindigkeit (2) MFlop/s UltraSPARC-III/Cu 900 MHz Forte Developer 6U2 f90 f90 O mmulblock.f (blocksize( blocksize=32) mmulblock.f (blocksize( blocksize=512) mmulblock2.f (blksz( blksz=32+512) n=m=l=100 in L2-cache n=m=l=1000 out of L2-cache Matrizenmultiplikation - serielle Rechengeschwindigkeit (3) -Optimierung MFlop/s UltraSPARC-III/Cu 900 MHz Forte Developer 6U2 / 7U0 EA2 f90 f90 O mmulblock.f (blocksize( blocksize=32) mmulblock.f (blocksize( blocksize=512) mmulblock2.f (blksz( blksz=32+512). Forte70.init init; ; mmulblock2.f. Forte70.init init; ; blas.f lsunperf n=m=l=100 in L2-cache n=m=l=1000 out of L2-cache MFlop/s 1530 MFlop/s Wähle den richtigen Compiler! Wähle die richtigen Compileroptionen! Gibt es eine passende optimierte Bibliotheksroutine? Wähle den richtigen (Block-)Algorithmus! Besuche Ruud s Seminare! Inhalt Mehrprozessorsystem mit verteiltem Speicher (Distributed ) External network -Optimierung Shared Parallelisierung 29 30

6 Mehrprozessorsystem mit gemeinsamem Speicher (Shared ) - Uniform Access (UMA) Cluster von Mehrprozessorsystemen mit gemeinsamem Speicher (SMP-Cluster Cluster) External network / Bus / Bus / Bus MPI - Geschichte 1994: 1994: MPI Version 1.0 (1995 Version 1.1,1997 Version 1.2) Standard für die Message-Passing Passing-Programmierung Programmierung insbes. auf Maschinen mit verteiltem Hauptspeicher Programmierschnittstelle für C und Fortran77 inzwischen auf allen Parallelrechnern verfügbar mächtig und komplex: weit über 100 Befehle einfach: häufig genügen Befehle hat im techn.-wiss. Rechnen PVM weitgehend abgelöst 1997: 1997: MPI Version 2.0 Einseitige Kommunikation MPI-IOIO dynamische Generierung von Tasks Unterstützung von Fortran90 und C++ bisher noch wenige vollständige Implementierungen 33 Problemstellung und C-ProgrammkernC Die Kreiszahl π kann berechnet werden als Integral: 1 π = f(x)dx, mit f(x) = 4 /(1 + x 2 ) 0 Dieses Integral kann numerisch mit einer Quadraturformel (Mittelpunktsregel) angenähert werden: n π 1/n f(x ), i mit x i = (i-½) ) / n für f r i=1,...,n i=1 h = 1.0/(double)n; sum = 0.0; for(i=1;i<=n;i++) { x = h*((double)i - 0.5); sum += f(x); } pi = h*sum sum; 34 Serielles Fortranprogramm program pi integer :: i,n real (8),parameter ::pi25dt= d0 real (8) :: a,h,pi pi,sum,x real (8) :: f f(a) = 4.d0 / (1.d0+a*a)! statement function read (*,*) n do i = 1, n pi = h * sum write (*,*) pi,, ABS(pi-pi25dt) pi25dt) end program pi 35 MPI-Programm Programm Rahmen, Fortranversion program main include 'mpif.h' integer :: i,n,myid,ntasks,ierr,islave,master=0 integer, dimension(mpi_status_size) :: stat real (8), parameter :: pi25dt = d0 real (8) :: a,h,pi,sum,x, mypi Wer bin! Initialisierung der MPI-Umgebung ich? call MPI_INIT( ierr ) call MPI_COMM_RANK( MPI_COMM_WORLD, myid, ierr ) call MPI_COMM_SIZE( MPI_COMM_WORLD, ntasks, ierr )... Rechenkern...! Verlassen der MPI-Umgebung call MPI_FINALIZE(ierr) Wieviele sind end program main wir? 36

7 MPI-Programm Programm Rechenkern, 1. Fortranversion if ( myid == 0 ) then! nur der Master read (*,*) n Der Master (Nr. 0) do islave = 1, ntasks-1 call MPI_Send (n,1,mpi_integer,islave,...) liest ein und verschickt Daten else! alle Slaves zu den Slaves. call MPI_Recv (n,1,mpi_integer,master,...) end if Diese empfangen. do i = myid+1, n, ntasks Zyklische Aufteilung der Schleifenindizes - mypi = h * sum if ( myid /= 0 ) then! Slaves Arbeitsteilung call MPI_Send(mypi,1,MPI_DOUBLE_PRECISION,master,...) else! Master pi = mypi Verschicken/ do islave = 1, ntasks-1 call MPI_Recv(mypi,1,MPI_DOUBLE_PRECISION,islave,...) Empfangen der pi = pi + mypi Teilergebnisse, write (*,*) pi, ABS(pi-pi25dt) der Master bildet endif Endergebnis 37 MPI-Programm Programm Rechenkern, 2. Fortranversion if ( myid == 0 ) then! nur der Master read (*,*) n end if call MPI_BCAST(n,1,MPI_INTEGER,0,...) do i = myid+1, n, ntasks mypi = h * sum call MPI_REDUCE ( mypi,pi,1,mpi_double_precision,mpi_sum,0,...) if (myid == 0) then Vereinfachte write (*,*) pi, ABS(pi-pi25dt) Form: Alle senden endif an einen mit Summation - Reduktion 38 Vereinfachte Form: Einer sendet an alle anderen - Broadcasting Zyklische Aufteilung der Schleifenindizes - Arbeitsteilung MPI-Programm Programm C-Version (Auszug) #include "mpi.h"... MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&numprocs); MPI_Comm_rank(MPI_COMM_WORLD,&myid); if (myid==0){scanf("%d",&n);} MPI_Bcast(&n, 1, MPI_INT, master, MPI_COMM_WORLD); if (n == 0) break; h = 1.0 / (double) n; sum = 0.0; for (i = myid + 1; i <= n; i += numprocs) { x = h * ((double)i - 0.5); sum += f(x); } mypi = h * sum; MPI_Reduce(&mypi,&pi,1,MPI_DOUBLE,MPI_SUM,master,MPI_COMM_WORLD); if (myid == 0) printf(...", pi, fabs(pi - PI25DT)); MPI_Finalize(); Inhalt -Optimierung Shared Parallelisierung Mehrprozessorsystem mit gemeinsamem Speicher (Shared ) OpenMP- Autoparallel- -Thread -Thread / Bus -Thread 41 Matrizenmultiplikation automatische Parallelisierung, Sun Performance Library MFlop/s UltraSPARC-III/Cu 900 MHz Forte Developer 6U2 / 7U0 EA2 7U2: blas.f lsunperf export OMP_NUM_THREADS=nthreads export STACKSIZE=32000 ulimit s s U2: f90 autopar fast, 4 threads 7U0: f90 autopar fast, 4 threads 7U0: blas.f -lsunperf,, 4 threads 7U0: blas.f -lsunperf,, 8 threads 7U0: blas.f -lsunperf,16 threads n=m=l=100 in L2-cache n=m=l=1000 out of L2-cache

8 OpenMP - Geschichte 1997: 1997: OpenMP Version 1.0 für Fortran Standard für die Shared- -Programmierung inzwischen für alle namhaften SMP-Rechner verfügbar wird im techn.-wiss. Rechnen die proprietären Direktiven und die unmittelbare Verwendung der pthreads ablösen 1998:OpenMP Version 1.0 für C und C : 2000: OpenMP Version 2.0 für Fortran Unterstützung des Fortran90-Modulen Modulen-Konzeptes 2001/2002: OpenMP Version 2.0 für C und C++ 43 OpenMP-Programm Programm Fortran-Version program pi integer :: i,n real (8),parameter ::pi25dt= d0 real (8) :: a,h,pi pi,sum,x real (8) :: f f(a) = 4.d0 / (1.d0+a*a)! statement function read (*,*) n!$omp parallel do private(i,x) reduction(+:sum) do i = 1,n!$omp end parallel do pi = h * sum write (*,*) pi, ABS(pi-pi25dt) end program pi 44 OpenMP-Programm Programm C Version (Auszug) #include <omp.h> h = 1.0/(double)n; sum = 0.0; #pragma omp parallel for private(i,x) reduction(+:sum) for(i=1;i<=n;i++) { x = h*((double)i - 0.5); sum += f(x); } pi = h*sum; 45 NAG Fortran SMP Library, Rel. 2 Derzeit Demo-Lizenz auf dem Sun Fire Cluster 101 Routinen parallelisiert und -optimiert FFT Lineare Algebra (mit dicht und dünn besetzten Matrizen) Zufallszahlen Weitere 130 Routinen machen von der ersten Gruppe Gebrauch Differentialgleichungen Optimierung Statistik Die Sun Performance Library wird verwendet Die SMP-Library ist voll kompatibel zur seriellen NAG-Bibliothek Nur neues Binden erforderlich Landeslizenz für serielle NAG-Bibliothek Feedback erbeten! (Kaufentscheidung) 46 Cluster von Mehrprozessorsystemen mit gemeinsamem Speicher (SMP-Cluster Cluster) / Bus External network Hybride Parallelisierung / Bus MPI oben Hybrid-Programm in Fortran (Auszug) call MPI_INIT( ierr ) call MPI_COMM_RANK( MPI_COMM_WORLD, myid, ierr ) call MPI_COMM_SIZE( MPI_COMM_WORLD, ntasks, ierr ) if ( myid.eq. 0 ) read (*,*) n call MPI_BCAST(n,1,MPI_INTEGER,0,MPI_COMM_WORLD,ierr)!$omp parallel do reduction(+:sum) private(i,x) do i = myid+1, n, ntasks mypi = h * sum OpenMP unten call MPI_REDUCE(mypi,pi,1,MPI_DOUBLE_PRECISION,MPI_SUM,0,...) if (myid.eq. 0) write (*,*) pi, ABS(pi-pi25dt) call MPI_FINALIZE(ierr) 47 48

9 Inhalt -Optimierung Shared Parallelisierung 49 Montag, 11. März, M 9:00 17:00 UNIX Grundlagen Hans Joachim Pflug Fortran 90/95 im Überblick Dieter an Mey Zusammenfassung Dienstag, 12. März, M 9:00 17:00 Das Sun Fire SMP-Cluster Cluster: : Architektur, Konfiguration, Compiler, Intervallarithmetik Ruud van der Pas, Dieter an Mey, Bruno Lang Handwerkszeug zur Programmierung: : Versionsverwaltung, Makefiles, Fehlersuche Dieter an Mey, Hans Joachim Pflug Mittwoch, 13. März, M 9:00 17:00 Optimierung serieller Programme Ruud van der Pas Donnerstag, 14. März, M 9:00 17:00 Shared Parallelisierung, automatisch und mit OpenMP Ruud van der Pas, Dieter an Mey Freitag, 15. März, M 9:00 15:30 Message 50 Passing mit MPI Dieter an Hans Mey, Joachim SunHPC 2002, Pflug Einleitung SunTune Workshop 51