Programmierung in C, C++, Fortran77 und Fortran90 und
Parallelisierung mit OpenMP und MPI
unter Linux

 

Auf dem Linux-Rechner des Rechen- und Kommunikationszentrums sind sowohl kommerzielle als auch public domain Compiler und Tools installiert.
So können Sie mit denselben Hilfsmitteln arbeiten, die in den gängigen Linux-Distributionen enthalten sind oder die frei aus dem Internet heruntergeladen werden können.
Sie können aber auch die kommerzielle Software nutzen, um vielleicht zu entscheiden, ob es lohnt, Lizenzen dafür zu erwerben.

Während die C++ und C-Programmierer mit den freien GNU-Compilern ausgezeichnet bedient sind, lohnt es sich für die Fortran-Programmierer auch kommerzielle Compiler auszuprobieren. Bei einem Geschwindigkeitsvorteil von 1,5 - 1,8 wie im Vergleich zwischen dem GNU-Fortran77-Compiler g77 und den Portland Group Fortran-Compilern, empfiehlt es sich unter Umständen einmal Hard- und Softwarekosten gemeinsam zu betrachten.

Wer an Parallelisierung interessiert ist hat die Wahl, die neuen Doppelprozessor-Linux-PCs zu nutzen und mit OpenMP zu parallelisieren oder mehrere über tcp/ip verbundene Linux-PCs mit MPI zusammen arbeiten zu lassen. OpenMP ist der sich in jüngster Zeit durchsetzende Standard zur Shared-Memory-Programmierung und MPI ist der aktuelle Standard für die Message-Passing-Programmierung. Die Kombination dieser beiden Möglichkeiten durch die sog. hybride Parallelisierung mit MPI und OpenMP ist eine aktuelle Herausforderung.

Die public domain-Softwareliste bestehend aus den Compiler gcc, g++ und g77, dem Debugger ddd und dem Profiler gprof kann noch ergänzt werden durch den freien Vast/Fortran90-Compiler von Passific Sierra. Dieser wandelt Fortran90-Programme um in Fortran77-Programme und ruft danach den g77-Compiler auf. Zur Parallelisierung gibt es neuerdings auch freie OpenMP-Compiler für C und Fortran77, eine C++-Version ist in Vorbereitung und in Kombination mit dem Vast/Compiler kann auch den Fortran90-Programmieren weitergeholfen werden. Das public domain MPI-Paket mpich vom Argonne National Lab ist Teil der neusten Linux-Distributionen.

Die kommerzielle Compiler-Familie von Portland Group zeichnet sich durch eine einheitlich Parametrisierung und die sehr ansprechende Beschreibung, sowie durch die Fähigkeit zur automatischen Shared-Memory-Parallelisierung und die Unterstützung des OpenMP-Standards aus. Dazu gehören der Debugger pgdbg und der Profiler pgprof. Alternativ steht der anerkannt beste kommerzielle Debugger für parallele Programme TotalView zur Verfügung, der natürlich auch für serielle Progamme gut geeignet ist.
Die Portland Group Compiler und TotalView können über die Firma Pallas bezogen werden.

 

Installierte Software

Compiler und InterpreterC, C++, Fortran77, Fortran90, HPFDie kommerzielle Portland Group Compiler-Familie
Aufrufe: pgcc, pgCC, pgf77, pgf90, pghpf
C,C++,Fortran77Die GNU Compiler-Familie,
Aufrufe: gcc, g++, g77
Fortran90VAST/f90 Fortran90 Compiler
Public domain-Version, nutzt g77, Aufruf: f90 bzw. vf90
perlPerl-Interpreter
python 
Tcl/tk 
Java
Parallelverarbeitung OpenMP für C, C++, Fortran77 und Fortran90Shared Memory Parallelisierung.
Bestandteil der kommerziellen Portland Group Compiler
Aufrufe: pgcc, pgCC, pgf77, pgf90
OpenMP für C und Fortran77Shared Memory Parallelisierung.
mit den public domain OMNI-Compilern
Aufrufe: ompcc, ompf77 (Bemerkung: für Fortran90-Programme kann der Vast-Präprozessor vf90 vorgeschaltet werden, s.o.)
MPI für C, C++, Fortran77 und Fortran90Message passing Library mpich-1.1.2 zur Programmierung von Rechnern mit verteiltem Hauptspeicher
Debugger, Profiler TotalViewkommerzieller Debugger für serielle und parallele Programme
dddData Display Debugger
ein komfortables, graphisches Frontend zum gdb, public domain
gbd / xxgdbDebugger für Programme die in C, C++, oder GNU Fortan 77 geschrieben sind.
xxgdb ist ein graphisches Frontend zum gdb
kdbdEine graphische Schnittstelle zum gdb, welches sich in die Benutzeroberfläche KDE einbettet
pgdbgDebugger für die Portland Group Compiler
pgprofProfiler für die Portland Group Compiler
gprofPublic domain Profiler für die GNU Compiler
Editorenemacs / xemacsEditor und Entwicklungsumgebung
vi, vim, nedit, kwriteweitere Editoren, zum Teil mit Syntax-Highlighting

 

Programm-Beispiele

Die näherungsweisen Berechnung der Kreiszahl pi kann durch die numerische Integration der Funktion f(x) = 4/(1 + x**2) geschehen.
Die einfachen Programme können auch leicht mit OpenMP oder MPI parallelisiert werden.

ProgrammierspracheCC++Fortran77Fortran90
Serielle Versionserial_pi.cserial_pi.c++serial_pi.fserial_pi.f90
Message Passing mit MPImpi_pi.cmpi_pi.c++mpi_pi.fmpi_pi.f90
Shared Memory Parallelisierung mit OpenMPomp_pi.comp_pi.c++omp_pi.fomp_pi.f90
Kombination von OpenMP und MPIompi_pi.compi_pi.c++ompi_pi.fompi_pi.f90

 

Übersetzen und Binden

Jeder Compiler hat zahlreiche Parameter über die Interpretierung des Programmes als auch der Grad der Optimierung und der Überprüfung des Programmes gesteuert werden kann. Bitte sehen Sie nötigenfalls in den detaillierten Beschreibungen genauer nach. Die häufigsten Optionen, die alle der gennanten Compiler verstehen, sind einerseits -g, damit das ausführbare Programm mit einem der Debugger gestartet werden kann, und andererseits -O2 zur Reduzierung der Ausführungszeit.
Die folgende Tabelle zeigt Kommandos zum Übersetzen, Binden und Starten eines Programmes im seriellen, und in den verschiedenen parallelen Fällen.


Zur Nutzung von MPI einige Bemerkungen:

  • Bei einer MPI-Anwendung werden gezielt mehrere Prozesse (sog. MPI-Tasks) auf den beteiligten Rechnern gestartet, die miteinander über Nachrichten kommunizieren. Im Falle des Linux-Clusters werden die Prozesse implizit mit rsh gestartet und kommunizieren miteinander über tcp/ip sockets. Die Prozesse führen i.A. dasselbe Programm aus, das auf einem gemeinsamem Dateisystem (hier: nfs) liegen sollte.
  • Die verschiedenen MPI-Versionen unterscheiden sich in den Pfaden. Am Rechenzentrum steht eine (ksh/bash-) Prozedur namens mpich.init zur Verfügung, die die nötigen Pfade in die Umgebungsvariablen ${MPI_INCLUDE} und ${MPI_LIBDIR} schreibt und das Kommando zum Starten des ausführbaren MPI-Programmes in ${MPI_RUN}. (Aufruf der Initialisierungsprozedur nur mit Punkt! . mpich.init)
  • Die MPI-Anwendung wird mit einem vorbereiteten Skript (mpirun) gestartet. Dabei wird die Liste der beteiligten Rechner in dem sog. Machinefile erwartet. Die Rechner können dort mehrfach aufgeführt werden, entsprechend werden dort mehre Tasks gestartet. In der Regel sollten aber nicht mehr Tasks als ein Rechner Prozessoren hat gestartet werden, es sei denn während der Programmentwicklung, die durchaus auf einer einzelnen Maschine durchgeführt werden kann. Die Anzahl der Tasks wird mit dem Parameter -np angegeben.

Verwendung der public domain Compiler

ProgrammierspracheCC++Fortran77Fortran90
Serielle Versiongcc -c serial_pi.c; gcc -o serial_pi.exe serial_pi.o; serial_pi.exe;g++ -c serial_pi.c++; g++ -o serial_pi.exe serial_pi.o; serial_pi.exe;g77 -c serial_pi.f; g77 -o serial_pi.exe serial_pi.o; serial_pi.exe;f90 -c serial_pi.f90; f90 -o serial_pi.exe serial_pi.o; serial_pi.exe;
MPI

gcc -c -I${MPI_INCLUDE} mpi_pi.c; gcc -o mpi_pi.exe mpi_pi.o -L${MPI_LIBDIR} -lmpich; ${MPI_RUN} -nolocal -np ${NPROC} -machinefile  ${MACHFILE} mpi_pi.exe;

g++ -c -I${MPI_INCLUDE} -I${MPI_INCLUDE}/c++ mpi_pi.c++; g++ -o mpi_pi.exe mpi_pi.o -L${MPI_LIBDIR} -lmpich++ -lmpich; ${MPI_RUN} -nolocal -np ${NPROC} -machinefile ${MACHFILE} mpi_pi.exe;g77 -c -I${MPI_INCLUDE} mpi_pi.f; g77 -o mpi_pi.exe mpi_pi.o -L${MPI_LIBDIR} -lmpich; ${MPI_RUN} -nolocal -np ${NPROC} -machinefile  ${MACHFILE} mpi_pi.exe;

f90 -c -I${MPI_INCLUDE} mpi_pi.f90; f90 -o mpi_pi.exe mpi_pi.o -L${MPI_LIBDIR} -lmpich; ${MPI_RUN} -nolocal -np ${NPROC} -machinefile  ${MACHFILE} mpi_pi.exe;

OpenMPompcc -c omp_pi.c; ompcc -o omp_pi.exe omp_pi.o; omp_pi.exe;# Noch nicht verfügbarompf77 -c omp_pi.f; ompf77 -o omp_pi.exe omp_pi.o; omp_pi.exe;# Kopplung der Vast/Fortran90 und Omni-OpenMP -Präprozesoren vf90 -c omp_pi.f90 -o Vomp_pi.f90; awk '{h=$$0;  sub(/^[ \t]*!/,"C",h); sub(/^C[ ]*\$omp/,"C$omp",h);  sub(/[cC][ \t]*\$[oO][mM][pP]/,"C$omp",h);  print h}' Vomp_pi.f90 > Vomp_pi.f; ompf77 -c Vomp_pi.f; ompf77 -o omp_pi.exe omp_pi.o; omp_pi.exe;

Verwendung der kommerziellen Portland Group Compiler

ProgrammierspracheCC++Fortran77Fortran90
Serielle Versionpgcc -c serial_pi.c; pgcc -o serial_pi.exe serial_pi.o; serial_pi.exe;pgCC -c serial_pi.c++; pgCC -o serial_pi.exe serial_pi.o; serial_pi.exe;pgf77 -c serial_pi.f; pgf77 -o serial_pi.exe serial_pi.o; serial_pi.exe;pgf90 -c serial_pi.f90; pgf90 -o serial_pi.exe serial_pi.o; serial_pi.exe;
MPIpgcc -c -I${MPI_INCLUDE} mpi_pi.c; pgcc -o mpi_pi.exe mpi_pi.o -L${MPI_LIBDIR} -lmpich; ${MPI_RUN} -nolocal -np ${NPROC} -machinefile  ${MACHFILE} mpi_pi.exe;pgCC -c -I${MPI_INCLUDE} -I${MPI_INCLUDE}/c++ mpi_pi.c++; pgCC -o mpi_pi.exe mpi_pi.o -L${MPI_LIBDIR} -lmpich++ -lmpich; ${MPI_RUN} -nolocal -np ${NPROC} -machinefile ${MACHFILE} mpi_pi.exe;pgf77 -c -I${MPI_INCLUDE} mpi_pi.f; pgf77 -o mpi_pi.exe mpi_pi.o -L${MPI_LIBDIR} -lmpich; ${MPI_RUN} -nolocal -np ${NPROC} -machinefile ${MACHFILE} mpi_pi.exe;pgf90 -c -I${MPI_INCLUDE} mpi_pi.f90; pgf90 -o mpi_pi.exe mpi_pi.o -L${MPI_LIBDIR} -lmpich; ${MPI_RUN} -nolocal -np ${NPROC} -machinefile ${MACHFILE} mpi_pi.exe;
OpenMPpgcc -mp -c omp_pi.c; pgcc -mp -o omp_pi.exe omp_pi.o; export OMP_NUM_THREADS=${NPROC}; omp_pi.exe;pgCC -mp -c omp_pi.c++; pgCC -mp -o omp_pi.exe omp_pi.o; export OMP_NUM_THREADS=${NPROC}; omp_pi.exe;pgf77 -mp -c omp_pi.f; pgf77 -mp -o omp_pi.exe omp_pi.o; export OMP_NUM_THREADS=${NPROC}; omp_pi.exe;pgf90 -mp -c omp_pi.f90; pgf90 -mp -o omp_pi.exe omp_pi.o; export OMP_NUM_THREADS=${NPROC}; omp_pi.exe;

Mit Anregungen, Kritik oder Wünschen wenden Sie sich bitte elektronisch an den

Support Server des Rechen- und Kommunikationszentrums.

Für Programmierung und Parallelisierung ist zuständig:
 
Kontakt:

  Dieter an Mey

                              Tel.: +49 241 80 24377

                              mailto: hpc@rz.rwth-aachen.de


                            


Stand: 26.05.03

 


Abschlußinformationen

  • Keine Stichwörter