2 MPI MESSAGE-PASSING INTERFACE

Transkript

1 2-1 2 MPI MESSAGE-PASSING INTERFACE 2.1 IMPLEMENTIERUNGEN VON MPI Mittlerweile gibt es eine Vielzahl an Implementierungen des Message-Passing Interfaces. Sowohl freie (GNU GPL) also auch kommerziell nutzbare Libraries sind verfügbar. Trotzdem wurden nur die folgenden beiden Libraries für die Verwendung im Projekt in betracht gezogen. MPICH Diese Library wurde von der Mississippi State University und dem Argonne National Lab entwickelt und kann für die Programmiersprachen C, C++ und Fortran verwendet werden. Für diese Arbeit wurden die MPICH Library und die MPICH b verwendet. LAM Die LAM-Library wurde ursprünglich vom Ohio Supercomputer Center entwickelt, weiterentwickelt wird die Library heute jedoch von der Indiana University INSTALLATION VON MPICH B In diesem Abschnitt wird die Installation der MPICH B beschrieben. Es ist jedoch anzumerken, dass auf Grund eines Bugs in der Library deren Verwendung nur auf einem Computer möglich ist INSTALLATION DER LIBRARY Vor der eigentlichen Installation der Library müssen noch die Pakete g77 und PyXML mit dem Programm YAST2 installiert werden, da diese für die Installation der Library notwendig sind. Der Installationsvorgang muss als root-benutzer durchgeführt werden. Zu Beginn der Installation müssen zuerst die Sourcen extrahiert werden. tar xfz mpich2.tar.gz Danach muss das Zielverzeichnis für die Installation angelegt werden. mkdir /usr/local/mpich2-0.94b Nun muss in das Verzeichnis gewechselt werden, in das die Quellen extrahiert wurden. cd mpich2 Jetzt muss die Library konfiguriert werden../configure prefix=/usr/local/mpich2-0.94b Danach muss die Library kompiliert und installiert werden. make make install

2 2-2 Um die Entwicklungstools der Library in jedem Verzeichnis verwenden zu können, muss noch die Datei /etc/profile editiert werden. Am Ende der Datei muss folgende Zeile hinzugefügt werden: export PATH=/usr/local/mpich2-0.94b/bin:$PATH Um diese Änderung zu übernehmen muss der Computer neu gestartet werden. Danach muss im Home-Verzeichnis des root-benutzers die Datei.mpd.conf angelegt werden. In diese muss folgende Zeile hineingeschrieben werden, wobei <Passwort> durch ein Passwort ersetzt wird. password=<passwort> Um Programme ausführen zu können muss zuvor für jeden Prozess das Programm mpd gestartet werden. Dies geschieht mit folgendem Befehl mpd -h <Hostname> -p <port> Es war jedoch nur möglich den MPD Prozess auf dem lokalen Computer (localhost) zu starten. Sobald ein anderer Computer mit einer MPICH installation angegeben wurde, erhielt man folgende Fehlermeldung: connect failed to host mpipvm-03 port Abhängig von dem angegebenen Host und Port kann die Fehlermeldung anders aussehen. Es war jedoch nicht möglich Informationen zu dieser Fehlermeldung zu bekommen, da hier die letzte Version der Library verwendet wurde. Auch eine an die Entwickler der Library konnte bei diesem Problem nicht weiterhelfen. Einerseits deshalb, weil das Mail erst 2 Monate später beantwortet wurde und andererseits, weil auf eine andere Version der Library verwiesen wurde. Da also keine Hilfe zu diesem Problem zu finden war, wurde die Version der MPICH-Library verwendet.

3 INSTALLATION VON MPICH ÜBERBLICK ÜBER DEN INSTALLATIONSVORGANG Master Slaves MPICH an Hostsystem anpassen Automatisches Mounten der NFS Freigabe konfigurieren MPICH kompilieren SSH konfigurieren NFS Dateifreigabe konfigurieren SSH konfigurieren Systemvariablen setzen INSTALLATION DES MASTERS Die folgenden Installationsschritte müssen nur auf einem Computer im Netzwerk durchgeführt werden, nämlich dem Master. Als Master-Computer wird in diesem Fall der Rechner verwendet, der die niedrigste IP-Adresse hat. Weiters müssen diese Arbeiten unter dem Benutzer root durchgeführt werden. Zu Beginn der Installation muss in das Verzeichnis in dem sich die Sourcen der Library befinden gewechselt werden. In diesem Fall ist das das Verzeichnis /tmp. cd /tmp Nun muss das tar.gz-archiv extrahiert werden: tar zxovf mpich.tar.gz

4 2-4 Danach wechselt man in das Verzeichnis, in das die Sourcen extrahiert wurden: cd mpich Jetzt sollte das Zielverzeichnis für die Library erstellt werden: mkdir /usr/local/mpich Danach müssen die Makefiles auf das Hostsystem angepasst und die gewünschte Funktion der Library gewählt werden:./configure --prefix=/usr/local/mpich with-device=ch_p4 -rsh=ssh --enable-root --enable-debug tee configure.log Zur besseren Übersicht wurden die Parameter untereinander geschrieben. Bei der Eingabe in einer Konsole müssen sich diese jedoch in einer Zeile befinden. Mit Hilfe des --prefix Parameters wird das Installationsverzeichnis der Library, welches bereits erstellt sein muss, angegeben. Mit Angabe des Parameters --with-device wird die Art der Datenübertragung gewählt. ch_p4 bedeutet, dass es sich um ein Workstation Netzwerk auf TCP/IP-Basis handelt. Um eine sichere Datenübertragung zu gewährleisten, wird die Datenübertragung über das Programm ssh durchgeführt. Für diese Einstellung wird der Parameter -rsh angegeben. Da die Library auch dem Benutzer root zur Verfügung stehen soll muss --enable-root dem Konfigurationsskript übergeben werden. --enable-debug erlaubt es die Programme auch zu debuggen. Damit die Arbeit des Konfigurationsskripts nachvollzogen werden kann, wird die Ausgabe des Skripts an das Programm tee übergeben. Dieses Programm speichert die übergebenen Daten in die angegebene Datei configure.log, und gibt sie gleichzeitig auf der aktuellen Konsole aus. Die erstellte.log Datei kann mit jedem beliebigen Texteditor angesehen werden. Wird beim Ausführen des Skripts kein Fehler ausgegeben, kann die Installation fortgesetzt werden. make tee make.log make install tee install.log Falls auch diese beiden Schritte ohne Fehler beendet werden, kann nun mit der Konfiguration des Masters fortgesetzt werden KONFIGURATION DES MASTERS Um die Arbeit mit den Computern zu vereinfachen muss die Datei /etc/hosts bearbeitet werden. Das Ändern bzw. Erweitern dieser Datei ist für die Freigabe der MPICH Library über das Netzwerk unumgänglich. Nach folgendem Schema müssen die Computer im Cluster angegeben werden: <IP-Adresse> <Hostname>.<Domainname> <Hostname> mpipvm-01.ti.htl-hl.ac.at mpipvm mpipvm-02.ti.htl-hl.ac.at mpipvm mpipvm-21.ti.htl-hl.ac.at mpipvm-21

5 2-5 Danach muss das Verzeichnis mit der installierten Library mittels NFS (Network FileSystem) an die anderen Computer im Netzwerk freigegeben werden. Hierfür muss der Datei /etc/exports folgender Eintrag hinzugefügt werden: /usr/local/mpich mpipvm-*(ro,insecure,sync) Nach dem Speichern der Datei muss noch der NFS-Server gestartet werden: rcnfslock start rsnfsserver start Um das Starten des NFS-Servers beim Booten des Betriebssystems zu automatisieren, müssen die folgenden Befehle eingegeben werden. ln -s /etc/rc.d/nfslock /etc/rc.d/rc5.d/s10nfslock ln -s /etc/rc.d/nfsserver /etc/rc.d/rc5.d/s14nfsserver Die Programme nfslock und nfsserver werden nun beim Startvorgang des Betriebssystems im Runlevel 5 automatisch gestartet. Wie schon oben erwähnt werden die Daten verschlüsselt über das Programm ssh übertragen. Es darf jedoch kein Passwort beim Zugriff des Masters auf die Slaves verlangt werden. Aus diesem Grund muss ein Fingerprint des Masters erstellt werden. Mit Hilfe dieses Fingerprints können die Slaves den Master identifizieren und ihm den passwortlosen Zugriff erlauben. Der folgende Befehl erstellt den Fingerprint: ssh-keygen -t rsa Die Abfragen des Programms werden alle mit Enter bestätigt. Die nun erstellte Datei id_rsh.pub muss jedem Rechner im Cluster zugänglich gemacht werden. Aus diesem Grund wird sie in ein freigegebenes Verzeichnis kopiert. mkdir /usr/local/mpich-1.2.5/ssh cp /root/.ssh/id_rsh.pub /usr/local/mpich-1.2.5/ssh/authorized_keys2 Nun müssen alle Computer die zur Parallelprogrammierung verwendet werden in die Datei /usr/local/mpich-1.2.5/share/machines.linux eingetragen werden. Hierfür werden die Hostnames untereinander in die Datei eingetragen. Der Master Rechner muss nicht eingetragen werden, denn dieser wird immer bei der Programmausführung verwendet. mpipvm-02 mpipvm mpipvm-21 Um die Tools der Library aus jedem Verzeichnis starten zu können muss die $PATH Variable noch geändert werden. Dies geschieht in dem man die Datei /etc/profile ändert. Folgenden beiden Zeilen müssen am Ende der Datei hinzugefügt werden: export PATH=/usr/local/mpich-1.2.5/bin:$PATH export PATH=/usr/local/mpich-1.2.5/sbin:$PATH Nun ist der Server fertig konfiguriert und er muss neu gestartet werden, damit alle Einstellungen übernommen werden.

6 KONFIGURATION DER SLAVES Wie auch beim Master-Rechner muss auch bei den Slaves die Datei /etc/hosts editiert werden, (siehe Konfiguration des Masters) Damit alle Computer auf die MPICH Library zugreifen können, müssen diese die freigegebene Library des Masters in ihr System einbinden. Hierfür muss zuerst ein Mountpoint, also das Verzeichnis an dem die Library eingebunden wird, erstellt werden. mkdir /usr/local/mpich Danach muss die Library des Masters vom Slave gemountet werden: mount -t nfs mpipvm-01:/usr/local/mpich /usr/local/mpich Weiters muss das das freigegebene Verzeichnis beim Booten des Computers automatisch in das lokale System eingebunden werden. Dies geschieht in dem am Ende der Datei /etc/fstab folgende Zeile hinzugefügt wird: mpipvm-01:/usr/local/mpich /usr/local/mpich ro,exec 0 0 Wichtig ist, dass sich am Ende der Datei eine neue leere Zeile befindet. Das automatische Einbinden beim Starten ist jedoch nur möglich wenn der Master-Computer bereits fertig gebootet hat. Nun muss noch auf den Slaves der passwortlose Zugriff mittels SSH konfiguriert werden. Deshalb wird die Datei authorized_keys2 nun in ein lokales Verzeichnis, welches zuerst erstellt werden muss, kopiert. mkdir /root/.ssh cp /usr/local/mpich-1.2.5/ssh/authorized_keys2 /root/.ssh Dieser Vorgang muss auf allen Slaves durchgeführt werden, danach ist die Installation des Clusters komplett. 2.4 KOMPILIEREN UND AUSFÜHREN VON PROGRAMMEN KOMPILIEREN MIT MPICC Um ein Programm ausführen zu können, muss es zuerst kompiliert werden. Dies geschieht mit dem Kommando mpicc für C++ Dateien. Da der Pfad zum mpicc Skript in der $PATH Variable gespeichert ist, kann der Compiler in jedem beliebigen Verzeichnis verwendet werden. mpicc <Quelldatei> -o <Ausgabedatei> Wenn der Parameter -o und der Name der Ausgabedatei nicht angegeben werden, wird die erstellte, ausführbare Datei automatisch a.out genannt. Um auf weitere Libraries zugreifen zu können, kann ein weiterer Parameter (-l<libraryname>) hinzugefügt werden. mpicc <Quelldatei> -o <Ausgabedatei> -l<libraryname>

7 2-7 Beispiel: mpicc figur.cpp o figur lgd lpng lm Wenn keine Fehler ausgegeben werden, kann das Programm jetzt ausgeführt werden KOMPILIEREN & LINKEN OHNE MPICC Da es nicht immer möglich ist die ausführbaren Dateien mit dem Kompilierungsskript zu erstellen gibt es auch die Möglichkeit die C/C++ Dateien mit dem Programm gcc/g++ zu kompilieren. Die Parameter und Schalter für das Kompilieren können mittels folgender Eingabe ermittelt werden: mpicc --compile_info Auf den für diese Arbeit zur Verfügung stehenden Hardwaresystemen sieht die Ausgabe des Befehles wie folgt aus: g++ -DUSE_STDARG -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_UNISTD_H=1 - DHAVE_STDARG_H=1 -DUSE_STDARG=1 -DMALLOC_RET_VOID=1 -DHAVE_MPI_CPP - I/usr/local/mpich-1.2.5/include/mpi2c++ -fexceptions -c -I/usr/local/mpich /include Abhängig von der Hardware, dem Betriebssystem und dem Installationsvorgang kann die Ausgabe auch anders sein. Weiters können auch die Parameter für das Linken von Programmen ausgegeben werden. Die Ausgabe ist wieder von diversen Parametern abhängig. mpicc --link_info g++ -DUSE_STDARG -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_UNISTD_H=1 - DHAVE_STDARG_H=1 -DUSE_STDARG=1 -DMALLOC_RET_VOID=1 -L/usr/local/mpich /lib -lpmpich++ -lmpich AUSFÜHREN VON PROGRAMMEN Es ist von Vorteil wenn sich die Programme, die ausgeführt werden sollen, im Verzeichnis /usr/local/mpich-1.2.5/examples befinden, damit die Slaves automatisch auf die ausführbare Datei zugreifen können. Ausgeführt werden die Programme mittels folgenden Befehls: mpirun np <Anzahl zu verwendender Computer> <MPI-Programm> Die Anzahl der zu verwendeten Computer muss zwischen 0 und der Anzahl der angegebenen Computer in der /usr/local/mpich-1.2.5/share/machines.linux Datei liegen. 2.5 EINFÜHRUNG IN DIE C++ PROGRAMMIERUNG MIT MPI AUFBAU EINES MPI-PROGRAMMS Der folgende Quelltextausschnitt zeigt den grundlegenden Aufbau eines C++ Programms unter Verwendung der MPICH-Library.

8 2-8 #include <mpi.h> int main( int argc, char **argv ) MPI_Init( &argc, &argv );. /* MPI-subprograms */. MPI_Finalize(); return 0; Das Einbinden der Datei mpi.h ist notwendig um die MPI Funktionen nützen zu können. Um die eigentlichen Message-Passing Routinen verwenden zu können, muss die Library zuerst mit der Funktion MPI_Init initialisiert werden. Als letzte MPI Funktion muss MPI_Finalize aufgerufen werden, um reservierte Speicherbereiche wieder freizugeben. int MPI_Init( int* argc_ptr /* in/out */, char** argv_ptr /* in/out */) int MPI_Finalize( void ) PROZESSIDENTIFIKATION Wenn ein MPI-Programm mittels mpirun gestartet wird, dann wird der gleiche Programmcode auf allen Computern ausgeführt. Dies würde jedoch auch bedeuten dass jeder Computer genau dieselben Anweisungen ausführt, bzw. dass die Prozesse identisch sind. Weiters würde dies keinen Performancegewinn ermöglichen, sondern es würde Rechenleistung unnötig verbrauchen werden. Aus diesem Grund ist es möglich, dass Prozesse mittels einer eindeutigen Prozessnummer während der Laufzeit identifiziert werden können. Abhängig von dieser Prozessnummer können dann den Prozessen unterschiedliche Aufgaben zugeteilt werden. Weiters ist die Prozessnummer nötig um Daten an einen bestimmten Prozess zu senden. Das folgende Beispielprogramm gibt die Prozessnummer und die Anzahl der MPI-Prozesse an einer Konsole am Master aus. #include <iostream.h> #include <mpi.h> //Deklarationen & Prototypen fuer Compiler & Preprozessor int main( int argc, char **argv ) int prozessnummer; int prozess_anzahl; MPI_Init( &argc, &argv ); //MPI initialisieren MPI_Comm_size( MPI_COMM_WORLD, &prozess_anzahl ); //Anzahl der Prozesse MPI_Comm_rank( MPI_COMM_WORLD, &prozessnummer ); //Prozessnummer cout << "Hallo Welt von Prozess " << prozessnummer; //AUsgabe der Daten cout << " von " << prozess_anzahl << endl; MPI_Finalize(); //clean up, Speicher freigeben

9 2-9 Mit den folgenden beiden Befehlen wird das Programm kompiliert und ausgeführt. Zum Ausführen werden 4 Computer verwendet. mpicc hallo_welt.cpp o hallo_welt mpirun -np 4 hallo_welt Die Ausgabe des Programmes sieht wie folgt aus: Hallo Welt von Prozess 0 von 4 Hallo Welt von Prozess 1 von 4 Hallo Welt von Prozess 2 von 4 Hallo Welt von Prozess 3 von 4 Mit Hilfe der Funktion MPI_Comm_size kann die Anzahl der verwendeten Computer zur Laufzeit herausgefunden werden. Diese ist gleich der Anzahl der angegebenen Prozesse die beim Aufruf des Programms mit mpirun angegeben wurden. Die Prozessnummern gehen von 0 bis zur Gesamtzahl der Prozesse - 1. Die Funktion MPI_Comm_rank gibt die Prozessnummer des aktuellen Prozesses zurück. Diese Nummer ist eindeutig, da jeder Prozess eine andere Identifikationsnummer bekommt. Die Prozessnummer wird im Normalfall dazu verwendet werden um bestimmten Prozessen verschiedene Aufgaben zuzuteilen. int MPI_Comm_size( MPI_Comm comm /* in */, int* size /* out */) int MPI_Comm_rank( MPI_COMM comm /* in */, int* rank /* out */) HOSTNAME HERAUSFINDEN Das nächste Programmbeispiel zeigt wie mit einer MPI Funktion der Hostname herausgefunden werden kann. #include <iostream.h> #include <mpi.h> int main(int argc, char ** argv) int prozessnummer; int prozess_anzahl; int hostname_laenge; char hostname[ MPI_MAX_PROCESSOR_NAME ]; MPI_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &prozessnummer ); MPI_Comm_rank( MPI_COMM_WORLD, &prozess_anzahl ); MPI_Get_processor_name( hostname, &hostname_laenge ); cout << "Hallo Welt von Prozess " << prozessnummer; cout << host " << hostname; cout << " von " << prozess_anzahl << endl; MPI_Finalize();

10 2-10 Wie beim vorherigen Beispielprogramm wird der Quelltext zuerst kompiliert und danach auf 4 Computern ausgeführt. mpicc welt_hostname.cpp o welt_hostname mpirun -np 4 welt_hostname Die Ausgabe sieht wie folgt aus: Hallo Welt von Prozess mpipvm-01 von 4 Hallo Welt von Prozess mpipvm-02 von 4 Hallo Welt von Prozess mpipvm-03 von 4 Hallo Welt von Prozess mpipvm-04 von 4 Mit der Funktion MPI_Get_processor_name wird der Hostname des Computers in einen String gespeichert. Außerdem wird gleichzeitig die Länge des Hostnames zurückgegeben. Die Länge des Strings wird mit der Preprozessordirektive MPI_MAX_PROCESSOR_NAME definiert. Diese Direktive ist in der Datei mpi.h definiert und entspricht dem Wert 500. MPI_Get_processor_name( char* name /* out */, int* resultlen /* out */) DATENAUSTAUSCH MIT MPI_SEND UND MPI_RECV Das Senden und Empfangen von Daten legt die Grundlage für die Programmierung von parallelen Algorithmen und ist somit wichtig für alle weiteren Programme bzw. Algorithmen in dieser Arbeit. Das folgende Programm zeigt die Verwendung der Funktionen für den Datenaustausch. #include <stdio.h> #include <string.h> #include <mpi.h> int main(int argc, char ** argv) int prozessnummer; int prozess_anzahl; int quelle; int ziel; int tag = 0; char nachricht[100]; MPI_Status status; MPI_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &prozessnummer ); MPI_Comm_size( MPI_COMM_WORLD, &prozess_anzahl ); if ( prozessnummer!= 0 ) sprintf( nachricht, "Hi von Prozess %d", prozessnummer); ziel = 0; MPI_Send( nachricht, strlen( nachricht ) + 1, MPI_CHAR, ziel, tag, MPI_COMM_WORLD ); else

11 2-11 for ( quelle = 1; quelle < prozess_anzahl; quelle++ ) MPI_Recv( nachricht, 100, MPI_CHAR, quelle, tag, MPI_COMM_WORLD, &status ); printf("%s\n", nachricht); MPI_Finalize(); return 0; Das Programm muss wieder kompiliert und ausgeführt werden. mpicc send_recv.cpp o send_recv mpirun -np 4 send_recv Die Ausgabe des Programms sieht wie folgt aus: Hi von Prozess 1 Hi von Prozess 2 Hi von Prozess 3 Die Funktion MPI_Send sendet den String nachricht von allen Computern die nicht die Prozess-ID 0 haben an den Prozess mit der ID 0. Dieser Prozess empfängt die Nachrichten, speichert sie ebenfalls in die Variable nachricht und gibt diese aus. Hi von Prozess 1 Hi von Prozess 3 Prozessnummer = 1 Prozessnummer = 0 Prozessnummer = 3 Hi von Prozess 2 Prozessnummer = 2 int MPI_Send( void* message /* in */, int count /* in */, MPI_Datatype datatype /* in */, int dest /* in */, int tag /* in */, MPI_Comm comm /* in */)

12 2-12 int MPI_Recv( void* message /* out */, int count /* in */, MPI_Datatype datatype /* in */, int source /* in */, int tag /* in */, MPI_Comm comm /* in */, MPI_Status* status /* out */) Der Parameter message zeigt auf die Daten die gerade übermittelt werden. Aus den Parametern count - gibt die Länge der Daten an - und datatype - gibt den Datentyp an (siehe Tabelle) - ergibt sich die Größe der zu übermittelnden Nachricht. Mit den Parametern tag und comm sind die Nachrichten identifizierbar. Um eine Nachricht an einen anderen Rechner senden zu können müssen die Parameter tag und comm auf beiden Prozessen den gleichen Wert haben. Die Prozess-ID des Zielrechners wird durch dest, und die des sendenen Rechners durch source angegeben. Für die Parameter source und tag können die Wildcards MPI_ANY_SOURCE und MPI_ANY_TAG verwendet werden. Um trotzdem den Rechner, der die Nachricht schickt, identifizieren zu können wird die ID und der tag in die Struktur status gespeichert. Zugegriffen kann über die folgenden Elemente werden: status->mpi_source status->mpi_tag Bei der Übertragung der Daten darf als Datentyp nicht der normale C/C++ Datentyp angegeben werden, sondern es muss der MPI-Datentyp angegeben werden. Die folgende Tabelle zeigt welche MPI-Datentypen statt den C/C++ Datentypen angegeben werden müssen. MPI Datentyp C/C++ Datentyp MPI Datentyp C/C++ Datentyp MPI_CHAR signed char MPI_UNSIGNED unsigned int MPI_SHORT signed short int MPI_UNSIGNED_LONG unsigned long int MPI_INT signed int MPI_FLOAT float MPI_LONG signed long int MPI_DOUBLE double MPI_UNSIGNED_CHAR unsigned char MPI_LONG_DOUBLE long double MPI_UNSIGNED_SHORT unsigned short int MPI_PACKED siehe MPI_PACK

13 WELCHE PROGRAMMTEILE FÜHRT EIN PROZESS AUS? Die folgende Graphik zeigt wie sich die Einzelnen Prozesse zur Laufzeit verhalten bzw. welche Aufgaben sie durchführen. MPICH initialisieren (MPI_Init) Prozessnummer abfragen (MPI_Comm_rank) Anzahl der Prozesse abfragen (MPI_Comm_size) JA Prozess ist Master Nein Prozessid = 0 Daten von Slaves empfangen (MPI_Recv) Prozessid!= 0 Daten an Master senden (MPI_Send) Daten der Slaves ausgeben MPICH beenden (MPI_Finalize) ANALYSE DES PROGRAMMABLAUFS Um den Ablauf der Kommunikation der Prozesse zur Laufzeit analysieren zu können, kann die Übertragung mitprotokolliert werden. Dazu muss beim Kompilieren der Parameter - mpilog angegeben werden. An Hand des obigen Programmbeispiels zum Übertragen von Daten wird die Funktion dieser Analyse verdeutlicht. Zuerst wird das Programm erneut kompiliert und danach wieder auf 4 Computern ausgeführt mpicc send_recv.cpp o send_recv -mpilog mpirun -np 4 send_recv Die Ausgabe des Programms ändert sich trotz des neuen Parameters nicht. Hi von Prozess 1 Hi von Prozess 2 Hi von Prozess 3

14 2-14 Das Programm erstellt vor dem Beenden automatisch eine Log-Datei mit dem Namen send_recv.clog. Diese Datei kann nicht mit einem normalen Texteditor betrachtet werden, sondern mit dem Programm clog_print. Beim Aufruf des Programms muss als Parameter der Dateiname angegeben werden. clog_print send_recv.clog Um eine bessere Übersicht über das Verhalten der Prozesse zu bekommen, kann die Prozessinterkommunikation auch graphisch dargestellt werden. Hierfür muss die Datei vom clog-format in das alog-format konvertiert werden. Dies kann mit dem Programm clog2alog gemacht werden. Auch hier muss der Dateiname als Parameter angegeben werden. Die Erweiterung des Dateinamens darf hier nicht angegeben werden. clog2alog send_recv Die erstellte alog-datei kann danach mit dem Programm upshot (auch als logviewer bekannt) betrachtet werden. logviewer send_recv.alog Nach dieser Eingabe erscheint folgendes Fenster am Bildschirm. Beim Drücken des Setup-Buttons wird dann ein neues Fenster geöffnet, welches die Kommunikation der Prozesse graphisch darstellt. Auf der x-achse ist die Zeit aufgetragen und auf der y-achse sind die Prozesse aufgelistet. Die Balken in der Zeile 0 stellen den Receive-Vorgang, also das Warten und das Empfangen auf die Daten, dar. Der Send-Vorgang wird durch die Balken in den anderen Zeilen dargestellt. Die Pfeile zeigen an zu welchen Prozess die Daten gesendet werden. Es ist auch möglich sich während der Laufzeit das aktuelle Geschehen der einzelnen Prozesse ausgeben zu lassen. Hierfür muss der Parameter -mpitrace beim Kompilieren angegeben werden.

15 2-15 mpicc send_recv.cpp -o send_recv -mpitrace Wird das Programm auf 3 Prozessen ausgeführt, wird folgender Text am Bildschirm ausgegeben: Starting MPI_Init... Starting MPI_Init... Starting MPI_Init... [0] Ending MPI_Init [0] Starting MPI_Comm_rank... [0] Ending MPI_Comm_rank [0] Starting MPI_Comm_size... [0] Ending MPI_Comm_size [0] Starting MPI_Recv with count = 100, source = 1, tag = 0... [0] Ending MPI_Recv from 1 with tag 0 Hi von Prozess 1 [0] Starting MPI_Recv with count = 100, source = 2, tag = 0... [0] Ending MPI_Recv from 2 with tag 0 Hi von Prozess 2 [0] Starting MPI_Finalize... [1] Ending MPI_Init [1] Starting MPI_Comm_rank... [1] Ending MPI_Comm_rank [1] Starting MPI_Comm_size... [1] Ending MPI_Comm_size [1] Starting MPI_Send with count = 17, dest = 0, tag = 0... [1] Ending MPI_Send [1] Starting MPI_Finalize... [2] Ending MPI_Init [2] Starting MPI_Comm_rank... [2] Ending MPI_Comm_rank [2] Starting MPI_Comm_size... [2] Ending MPI_Comm_size [2] Starting MPI_Send with count = 17, dest = 0, tag = 0... [2] Ending MPI_Send [2] Starting MPI_Finalize... [1] Ending MPI_Finalize [2] Ending MPI_Finalize [0] Ending MPI_Finalize Beim trace Vorgang werden die einzelnen MPI-Funktionen und bei Bedarf auch Details dazu, aufgelistet. Die Prozessnummern auf denen die Funktionen ausgeführt werden, sind in der eckigen Klammer angezeigt. Außerdem wird die normale Ausgabe des Programms ebenfalls ausgegeben. Für eine genaue Analyse des Programmablaufs ist es aber vorteilhaft wenn man sich die Ausgabe in eine Datei umleiten lässt. Dies kann wieder mit dem tee-befehl, welcher schon bei der Installation verwendet wurde, durchgeführt werden. mpirun np 3 send_recv tee trace.txt Eine weitere Möglichkeit um Programme zu analysieren bzw. um Fehler zu finden ist der Debug-Vorgang, welcher im Rahmen dieses Projektes nicht getestet wurde.

16 DATEN MITTELS BROADCAST AN ALLE PROZESSE SENDEN Ein Broadcast ermöglicht das Senden von Daten eines Prozesses an alle anderen Prozesse. Die Funktion MPI_Bcast ermöglicht das Senden und Empfangen von solchen Broadcasts. int MPI_Bcast( void* buffer /* in/out */, int count /* in */, MPI_Datatype datatype /* in */, int root /* in */, MPI_Comm comm /* in */) Der Parameter buffer zeigt auf die Daten die übertragen werden. Nur auf dem Prozess root, wird ist buffer ein Eingabeparameter der Funktion. Auf allen anderen Prozessen zeigt buffer auf die zu Empfangenen Daten. count gibt die Länge und datatype den Datentyp an. Der Parameter root gibt an welcher Prozess die Daten sendet. Hier muss die Prozess-ID des Prozesses der sendet angegeben werden, alle anderen Prozesse empfangen die Daten. comm gibt wie bei den vorherigen Funktionen zum Senden und Empfangen den Communicator an. Die Funktion MPI_Bcast muss auf allen Prozessen aufgerufen werden. MPI_COMM_WORLD root-prozess MPI_Bcast Daten MPI_Bcast MPI_Bcast MPI_Bcast MPI_Bcast Host Host Host Host KOMBINIEREN VON DATEN Diese Funktion MPI_Reduce kombiniert oder vereint Daten die sich auf allen Rechnern befinden. Es ist zum Beispiel möglich Zahlen, die auf allen Rechnern verteilt sind, zu addieren und dabei noch die optimale Performance zu bekommen. int MPI_Reduce( void* operand /* in */, void* result /* out */, int count /* in */, MPI_Datatype datatype /* in */, MPI_Op operator /* in */, int root /* in */, MPI_Comm comm /* in */) operand ist ein Zeiger auf die Zahl mit der die Operation operator durchgeführt werden soll. Das Ergebnis wird nur auf dem root Prozess ausgegeben und zwar im Speicherbereich des

17 2-17 Zeigers result. datatype gibt wieder den Datentyp, count die Länge und comm den Communicator an. Die folgende Tabelle zeigt die unterstützten Operationen an. MPI-Operationsname Operation MPI-Operationsname Operation MPI_MAX Maximum MPI_BAND und bitweise MPI_MIN Minimum MPI_LOR oder logisch MPI_SUM Summe MPI_BOR oder bitweise MPI_PROD Produkt MPI_LXOR exklusiv oder bitweise MPI_LAND und logisch MPI_BXOR exklusiv oder logisch VERPACKEN UND ENTPACKEN VON DATEN Die Funktion MPI_Pack ermöglicht es mehrere Daten verschiedenster Datentypen so zu verpacken, dass sie alle mit einem einzigen Aufruf einer Funktion zum Übertragen von Daten (z.b.: MPI_Send, MPI_Bcast, ) gesendet werden können. Bei der Übertragung muss der Datentyp MPI_PACKED verwendet werden. Nach dem Empfangen können die Daten mittels der Funktion MPI_Unpack wieder in ihre ursprüngliche Form gebracht werden. Der folgende Quelltextausschnitt verdeutlicht die Funktion der beiden Funktionen, und die Übertragung mittels der Broadcast-Funktion. int *zahl1; float *zahl2; char *zahl3; char buffer[100]; int position = 0; if ( my_rank == 0 ) MPI_Pack( zahl1, 1, MPI_INT, buffer, 100, &position, MPI_COMM_WORLD ); // position wurde inkrementiert und zeigt jetzt // auf den nächsten freien Speicherbereich MPI_Pack( zahl2, 1, MPI_FLOAT, buffer, 100, &postition, MPI_COMM_WORLD ); MPI_Pack( zahl3, 1, MPI_CHAR, buffer, 100, &position, MPI_COMM_WORLD ); MPI_Bcast( buffer, 100, MPI_PACKED, 0, MPI_COMM_WORLD ); else MPI_Bcast( buffer, 100, MPI_PACKED, 0, MPI_COMM_WORLD ); MPI_Unpack( buffer, 100, &position, zahl1, MPI_INT, 1 MPI_COMM_WORLD ); // position wurde inkrementiert und zeigt jetzt // auf die nächste Variable MPI_Unpack( buffer, 100, &position, zahl2, MPI_FLOAT, 1 MPI_COMM_WORLD ); MPI_Unpack( buffer, 100, &position, zahl3, MPI_CHAR, 1 MPI_COMM_WORLD );

18 2-18 Nun zur Erklärung des obigen Programmausschnittes. Zuerst wird der Zeiger postion auf 0 gesetzt. Das bedeutet, dass position nun das Erste (freie) Element im Array indiziert. Auf dem Rechner mit der Prozessnummer 0 wird zuerst eine Integer-Variable in das Array buffer mittels MPI_Pack geschrieben. Gleichzeitig inkrementiert diese Funktion auch den Wert der Variable position, um auf das nächste freie Element im Array zu zeigen. Danach wird auch eine Float-Variable und eine Char-Variable in den buffer geschrieben. Danach wird auf allen Rechnern die Funktion MPI_Bcast aufgerufen. In diesem Fall schickt der Prozess mit der Nummer 0 den Buffer an alle anderen Prozesse. Danach werden auf allen Prozessen die nicht die Prozessnummer 0 haben die Daten aus dem Array buffer wieder extrahiert und zwar in der gleichen Reihenfolge wie sie gepackt wurden. Zu Beginn wird also der Integer gelesen, danach die Float-Variable und später die Char-Variable. Auch hier wird die Variable wieder automatisch inkrementiert und somit kann man die MPI_Pack Funktion hintereinander aufrufen, ohne sich Gedanken über diese Variable zu machen. int MPI_Pack( void *inbuf /* in */, int incount /* in */, MPI_Datatype datatype /* in */, void* pack_buf /* out */, int pack_buf_size /* in */, int* position /* in/out */, MPI_Comm comm /* in */) int MPI_Unpack( void* pack_buf /* in */, int pack_buf_size /* in */, int* position /* in/out */, void* outbuf /* out */, int outcount /* in */, MPI_Datatype datatype /* in */, MPI_Comm comm /* in */) SYNCHRONISATION Normalerweise geschieht die Synchronisation automatisch durch das Senden und Empfangen von Daten (außer in Spezialfällen). Trotzdem ist es möglich die Prozesse mit der Funktion MPI_Barrier zu synchronisieren. Die Funktion muss jedoch auf allen Rechnern im Kommunikator aufgerufen werden. Erst wenn alle Prozesse die Funktion aufgerufen haben, setzen die Prozesse ihren Programmablauf fort. int MPI_Barrier( MPI_Comm comm /* in */) Diese Synchronisation ist vor allem für die Zeitmessung von Programmen wichtig ZEITMESSUNG Um die Performance von Programmen bzw. Algorithmen messen zu können kann die Funktion MPI_Wtime verwendet werden. Diese gibt die Anzahl der vergangenen Sekunden seit irgendeinem vergangenen Zeitpunkt zurück, welcher sich während des Programmablaufes nicht ändert. Wird die Differenz zwischen 2 Zeitpunkten errechnet, so erhält man die vergangenen Sekunden. Um die tatsächlich vergangene Zeit auf allen Prozessen messen zu können, ist es notwendig die Prozesse vor dem Abfragen der Zeit zu synchronisieren.

19 2-19 double startzeit; double endzeit; MPI_Barrier( MPI_COMM_WORLD ); startzeit = MPI_Wtime( );. /* eigentlicher Algorithmus */. MPI_Barrier( MPI_COMM_WORLD ); endzeit = MPI_Wtime( ); if ( prozessnummer == MASTER ) printf( Vergangene Zeit: %f, endzeit - startzeit ); double MPI_Wtime( ); 2.6 SORTIEREN VON ZAHLEN Algorithmen zum Sortieren von Zahlen bzw. Ausdrücken sind in der Informatik von großer Bedeutung. Deshalb wird auch für diese Arbeit ein solches Verfahren, nämlich der Mergesort, getestet. Dieser Algorithmus ist ein typisches Beispiel für eine Divide-and-Conquer-Strategie (Teile und Herrsche). Die zu sortierende Zahlenfolge wird zuerst in 2 voneinander unabhängige Zahlenfolgen zerteilt (Divide), die dann jeweils für sich sortiert werden (Conquer). Danach werden die einzelnen Folgen wieder verschmolzen (engl.: to merge), also wieder kombiniert. divide conquer combine Zahlenfolge Mergesort(Teilfolge 1) Mergesort(Teilfolge 2) Merge(Teilfolge1,Teilfolge2) Die folgende Funktion mergesort sortiert die Zahlenfolge a vom unteren Index lo bis zum oberen Index hi. void mergesort( int lo, int hi ) if ( lo < hi ) int m = ( ( lo + hi ) / 2 ); mergesort( lo, m ); mergesort( m + 1, hi ); merge( lo, hi ); Zunächst wird die Mitte m der beiden Indexwerte bestimmt. Danach wird die untere Hälfte der Folge (Teilfolge 1; von lo bis m) und anschließend die obere Hälfte (Teilfolge 2; von m+1 bis hi) sportiert. Dies erfolgt durch rekursives Aufrufen der Funktion mergesort. Die

20 2-20 Rekursion endet, sobald lo und hi den gleichen Wert annehmen, wenn also die zu sortierende Teilfolge nur noch ein Element enthält. Danach werden die sortierten Hälften durch den Aufruf der Funktion merge miteinander verschmolzen. Zuerst kopiert die Funktion merge die beiden Teilfolgen hintereinander in die neue Folge b. Dann vergleicht sie die beiden Hälften mit einem Index i und einem Index j elementweise und kopiert jeweils das nächstgrößte Element zurück nach a. i j Obwohl dieser Schritt vom Konzept her einfach erscheint, ist es doch relativ schwierig ihn zu implementieren. Denn beim abwechselnden Kopieren der Zahlen in die Folge a muss immer überprüft werden ob eine der beiden Teilfolgen fertig kopiert ist. Danach muss noch der Rest der 2. Teilfolge in die Folge a kopiert werden. Kopiert man jedoch die 2. Teilfolge in umgekehrter Reihenfolge in die Folge b, lassen sich diese Schwierigkeiten umgehen. Die Prozedur merge durchläuft nun mit dem Index i die erste Hälfte von links nach rechts und mit dem Index j die zweite Hälfte von rechts nach links. Das jeweils nächst größte Folgeelement wird in die Folge a zurückkopiert. Sobald sich i und j überkreuzen (i>j) sind die beiden Teilfolgen fertig zurückkopiert. In diesem Fall ist es nicht notwendig dass die beiden Indexvariablen i und j in ihren Hälften bleiben. j i

21 2-21 Aus diesen algorithmischen Überlegungen ergibt sich folgende Implementierung der Funktion merge: void merge( int lo, int hi ) int i, j, k, m, n; n = hi - lo + 1; k = 0; m = ( ( lo + hi ) / 2 ); //untere Teilhälfte in Array b kopieren for ( i = lo; i <= m; i++) b[ k++ ] = a[ i ]; //obere Teilhälfte umgekehrter Reihenfolge in Array b kopieren for ( j = hi; j >= m+1; j-- ) b[ k++ ] = a[ j ]; i = 0; j = n - 1; k = lo; // jeweils das nächstgrößte Element zurückkopieren, // bis i und j sich überkreuzen while ( i <= j ) if ( b[ i ] <= b[ j ] ) a[k++] = b[ i++ ]; else a[k++] = b[ j-- ]; Ein vollständiges Programm zum Sortieren von Zahlen befindet sich im Anhang. Dort werden die zu sortierenden Zahlen aus der Datei zahlen.in gelesen. In der ersten Zeile der Datei steht die Anzahl der zu sortierenden Zahlen die sich noch in der Datei befinden. Diese Zahlen sind untereinander in der Datei aufgelistet und werden in weiterer Folge aus der Datei gelesen und in das Array a gespeichert. Danach wird die Funktion mergesort zum Sortieren der Zahlen aufgerufen. Diese Implementierung läuft ur in einem Prozess ab. Um diesen Algorithmus auf mehrere Prozesse aufzuteilen bedarf es einiger Änderungen im Programmaufbau PARALLELER MERGESORT MIT 2 PROZESSEN Zu Beginn wird das Sortieren auf 2 Computer ausgeweitet. Später wird eine Implementierung für n^2 und n e N Computer vorgestellt. Zu Beginn des Programms werden wieder die zu sortierenden Zahlen aus der Datei zahlen.in vom Master gelesen. Hier wird die erste Hälfte der Zahlen in das Array zufall_teil_a und die zweite Hälfte in das Array zufall_teil_b gespeichert. //1. Haelfte in zufall_teil_a speichern for ( int zaehler = 0; zaehler < zufall_teil_laenge; zaehler++ ) fscanf( datei, "%d", &zufall_teil_a[ zaehler ] ); //2. Haelfte in zufall_teil_b speichern for ( int zaehler = 0; zaehler < zufall_teil_laenge; zaehler++ ) fscanf( datei, "%d", &zufall_teil_b[ zaehler ] );

22 2-22 Nach dem Auslesen der Daten wird die Zeitmessung gestartet. MPI_Barrier( MPI_COMM_WORLD ); startwtime = MPI_Wtime(); Danach sendet der Master die Anzahl der Zahlen im Array zufall_teil_b und das Array selber an den zweiten Prozess. Dieses Zahlen werden am 2. Prozess auch in das Array zufall_teil_a gespeichert. //auf Master MPI_Send( &zufall_teil_laenge, 1, MPI_INT, 1, 1, MPI_COMM_WORLD ); MPI_Send( zufall_teil_b, zufall_teil_laenge, MPI_INT, 1, 2, MPI_COMM_WORLD ); //auf client if ( mynode == 1 ) MPI_Recv( &zufall_teil_laenge, 1, MPI_INT, 0, 1, MPI_COMM_WORLD, &status ); zufall_teil_a = new int[ zufall_teil_laenge ]; MPI_Recv( zufall_teil_a, zufall_teil_laenge,mpi_int, 0, 2, MPI_COMM_WORLD, &status ); Somit muss jeder Prozess nur das Array zufall_teil_a sortieren, obwohl in jedem Array andere Zahlen gespeichert sind. Das speichern der Zahlen in zufall_teil_a ist desshalb notwendig, weil die Funktion mergesort auf genau dieses Array zugreift. Nachdem das Array gesendet bzw. empfangen worden ist, werden die Zahlen sortiert auf jedem der Rechner einzeln sortiert. mergesort(0, zufall_teil_laenge); Danach wird das sortierte Array zufall_teil_a vom Client wieder an den Master gesendet. Dieser speichert die nun sortierten Zahlen wieder zurück in das Array zufall_teil_a. if ( mynode!= MASTER ) MPI_Send( zufall_teil_a, zufall_teil_laenge, MPI_INT, 0, 3, MPI_COMM_WORLD ); else MPI_Recv( zufall_teil_b, zufall_teil_laenge, MPI_INT, 1, 3, MPI_COMM_WORLD, &status ); Jetzt müssen die zwei sortierten Arrays zu einem sortierten Array zusammengefügt werden. Hierfür werden 2 Arrays mit einer Elementanzahl die der Anzahl der gesamten Zahlen entspricht, definiert. sortierte_zahlen = new int[ zufall_teil_laenge * 2 ]; sortierte_zahlen_temp = new int[ zufall_teil_laenge * 2 ];

23 2-23 Danach wird wieder ein Algorithmus der der Funktion merge gleicht, ausgeführt. for ( int zaehler = 0; zaehler < zufall_teil_laenge; zaehler++ ) sortierte_zahlen_temp[ zaehler ] = zufall_teil_a[ zaehler ]; int zaehler2 = zufall_teil_laenge; for ( int zaehler = zufall_teil_laenge-1; zaehler >= 0; zaehler-- ) sortierte_zahlen_temp[ zaehler2++ ] = zufall_teil_b[ zaehler ]; int i = 0; int j = anzahl - 1; int k = 0; while ( i <= j ) if ( sortierte_zahlen_temp[i] <= sortierte_zahlen_temp[j]) sortierte_zahlen[k++] = sortierte_zahlen_temp[i++]; else sortierte_zahlen[k++] = sortierte_zahlen_temp[j--]; Nachdem dem Sortieren werden nun die Zahlen ausgegeben. for ( int zaehler = 0; zaehler < anzahl; zaehler++ ) printf("%d#x %d\n", mynode, sortierte_zahlen[zaehler]); Nun müssen die Prozesse wieder synchronisiert werden um die Zeitmessung zu stoppen und die Laufzeit des Programms auszugeben. MPI_Barrier( MPI_COMM_WORLD ); endwtime = MPI_Wtime(); printf("zeit: %f\n", endwtime-startwtime); Der gesamte Quelltext dieses Programms befindet sich wieder im Anhang PARALLELER MERGESORT AUF 2^N PROZESSEN Um das Sortieren der Zahlen auf mehrere Prozesse zu verteilen ist es notwendig den gesamten Programmablauf neu zu gestalten. Hierfür wird die Prozesskommunikation in Form einer Baumstruktur realisiert. Auf Grund dieser Baumstruktur ist es notwendig dass eine Anzahl von n^2 (n e N) Prozessen verwendet wird.

24 Zahlen einlesen Broadcast der Zahlen Ebene 1 0 mergesort 1 mergesort 2 mergesort 3 mergesort 4 mergesort 5 mergesort 6 mergesort 7 mergesort 2 0 merge 2 merge 4 merge 6 merge 3 0 merge 4 merge 4 0 merge Zu Beginn des Algorithmus sendet der Master Prozess die zu sortierenden Zahlen mittels Broadcast an alle anderen Prozesse. Nun sortiert jeder Prozess (auch der Master) einen Teil der Zahlen. Dann sendet ein Teil der Prozesse die sortierten Zahlen an die anderen Prozesse weiter (siehe Graphik), danach werden die Prozesse, die gesendet haben, für den weiteren Programmablauf nicht mehr benötigt. Auf den Prozessen die die sortierten Zahlen empfangen haben, befinden sich noch immer die zuvor selber sortierten Zahlen, somit also zwei sortierte Arrays. Diese Daten werden danach wieder sortiert. Ab dieser Stelle wiederholt sich der Algorithmus wieder, denn ein Teil der Prozesse sendet wieder die sortierten Zahlen weiter, der andere Teil empfängt diese wieder. Nach jeder Wiederholung wird die Variable Ebene inkrementiert, da von dieser abhängt welcher Prozess senden und welcher empfangen muss. Dies geschieht so lange bis nur mehr der Prozess 0 aktiv an dem Sortierverfahren beteiligt ist. Abhängig von der Anzahl der verwendeten Prozesse ändert sich die Anzahl der Ebenen und auch die Anzahl der zu sortierenden Zahlen auf den einzelnen Prozessen. Wie schon bei den vorherigen Implementierungen werden die zu sortierenden Zahlen vom Master wieder aus einer Textdatei gelesen. Bei diesem Programm werden die Zahlen aber wieder in ein einziges Array gespeichert. Danach sendet der Master einen Broadcast an die anderen Prozesse mit der Anzahl der zu sortierenden Zahlen. Die Zahlen selber werden mit dem nächsten Broadcast an die anderen Prozesse gesendet. //anzahl der zu sortierenden Zahlen an die anderen Prozesse senden MPI_Bcast( &gesamt_anzahl, 1, MPI_INT, MASTER, MPI_COMM_WORLD ); if ( mynode!= MASTER ) //Speicher auf den Prozessen reservieren zahlen = new int[ gesamt_anzahl ]; //die zu sortierenden Zahlen an die anderen Prozesse senden MPI_Bcast( zahlen, gesamt_anzahl, MPI_INT, MASTER, MPI_COMM_WORLD );

25 2-25 In der Folge errechnet jeder Prozess für sich wie viele Zahlen er sortieren muss. zahlen_pro_node = gesamt_anzahl / totalnodes; Nun speichert jeder Prozess zahlen_pro_node Zahlen des Arrays zahlen in das neue Array Namens zahlen_node. Der Teil der in das neue Array gespeichert wird, ist abhängig von der Prozessnummer. Der Kopiervorgang beginnt also vom Index zahlen_pro_node und kopiert die Zahlen so lange bis die Laufvariable nicht mehr kleiner als ( mynode + 1 ) * zahlen_pro_node ist. Um den Kopiervorgang zu verdeutlichen wird ein Beispiel mit 4 Prozessen und 16 Zahlen pro Prozess (zahlen_pro_node=16) in der nächsten Tabelle dargestellt. Zahlen Prozessnummer von bis mynode * zahlen_pro_node ( mynode + 1 ) * zahlen_pro_node Zu beachten ist, dass der Prozess 0 also alle Zahlen von 0 bis 15 in das neue Array kopiert, da die Laufvariable kleiner als der angegebene Wert sein muss. zahlen_node = new int[ zahlen_pro_node ]; zahlen_node_temp = new int[ zahlen_pro_node ]; int zaehler2 = 0; for( int zaehler = ( mynode * zahlen_pro_node ); zaehler < ( mynode + 1 ) * zahlen_pro_node; zaehler++ ) zahlen_node[ zaehler2++ ] = zahlen[ zaehler ]; Nach dem Umspeichern kann dann das eigentliche Sortieren der Zahlen beginnen. Hierfür muss der Zeiger merge_pointer auf die zu sortierenden Zahlen zeigen und der Zeiger merge_pointer_temp auf ein temporäres Array. merge_pointer = zahlen_node; merge_pointer_temp = zahlen_node_temp; mergesort( 0, zahlen_pro_node - 1 ); Anschließend startet der Datenaustausch in der Baumstruktur. Alle Prozesse beginnen nun eine Schleife zu durchlaufen, welche jeder Prozess solange ausführt, bis er seine Daten an einen anderen Prozess gesendet hat. Der Master-Prozess beendet den Durchlauf der Schleife, wenn er der einzige aktive Rechner im Cluster ist, also wenn die Anzahl der Prozesse gleich 2^ebene ist (totalnodes = 2^ebene). Am Beginn der Schleife wird errechnet, welcher Prozess die Zahlen senden, und welcher diese empfangen muss. Ist das Ergebnis der Formel mynode mod 2^ebene gleich 0, dann empfängt dieser Prozess Daten. Die anderen Prozesse müssen dann die Daten senden. Die sendenden Prozesse schicken die Daten an die Prozesse, deren Nummer sich über folgende Formel errechnen lässt:

26 2-26 mynode - 2^(ebene - 1) Die Prozesse die die sortierten Zahlen empfangen, errechnen die Prozessnummer der sendenden Prozesse über die nächste Formel: mynode + 2^(ebene 1) Als tag der Übertragungsfunktionen wird die Prozessnummer des sendenden Prozesses verwendet. Hat ein Prozess die Daten versendet, so wird die Variable gesendet auf TRUE gesetzt und der Prozess verlässt die Schleife. Soll nun ein Prozess die Zahlen eines anderen empfangen, so sind zuerst einige Vorbereitungen zu treffen. Die Zahlen des eigenen Prozesses müssen zuerst in ein neues Array der doppelten Größe umgespeichert werden, da die empfangenen Daten in das gleiche Array nach den eigenen Zahlen hinzugefügt werden. zahlen_node_temp = new int[ zahlen_pro_node ]; for ( int zaehler = 0; zaehler < zahlen_pro_node; zaehler++ ) zahlen_node_temp[ zaehler ] = zahlen_node[ zaehler ]; delete [] zahlen_node; zahlen_node = new int[ zahlen_pro_node * 2 ]; for ( int zaehler = 0; zaehler < zahlen_pro_node; zaehler++ ) zahlen_node[ zaehler ] = zahlen_node_temp[ zaehler ]; delete [] zahlen_node_temp; printf("%d RECV von %d\n", mynode,mynode + hoch( ebene - 1 )); MPI_Recv( zahlen_node + zahlen_pro_node, zahlen_pro_node, MPI_INT, mynode + hoch( ebene - 1 ), mynode + hoch( ebene - 1 ), MPI_COMM_WORLD, &status ); In der Folge muss ein temporäres Array für die Funktion merge erstellt werden. Da sich die Anzahl der zu sortierenden Zahlen auf das doppelte erhöht hat, muss die Variable zahlen_pro_node verdoppelt werden. Somit muss auch das temporäre Array mit dieser neuen Größe erstellt werden. zahlen_pro_node *= 2; zahlen_node_temp = new int[ zahlen_pro_node ]; Da die Funktion merge auf die Zeiger merge_pointer und merge_pointer_temp zugreift, müssen diese zuvor noch auf die richtigen Arrays zeigen. merge_pointer zeigt dabei auf die beiden Teilfolgen im Array und merge_pointer_temp auf das temporäre Array. merge_pointer = zahlen_node; merge_pointer_temp = zahlen_node_temp; merge( 0, zahlen_pro_node - 1 ); Nach dem Aufruf der Funktion merge ist nun das gesamte Array fertig sortiert. Danach muss noch die Variable ebene inkrementiert werden, da von dieser abhängig ist welcher Prozess sendet und welcher empfängt. Anschließend wird abgefragt ob nur noch der Master am

27 2-27 sortieren beteiligt ist. Wenn ja, sind alle Zahlen fertig sortiert und der Master beendet das Ausführen der Schleife. if ( totalnodes == hoch(ebene) ) gesendet = TRUE; Weiters werden die sortierten Zahlen ausgegeben und es wird auch eine Zeitmessung durchgeführt. Die Berechnung von 2^n wird mit der Funktion hoch durchgeführt. Diese führt einen einfachen Schiebe-Befehl um n Bits durch, welcher einer 2^n Rechnung entspricht. int hoch( int exponent ) return ( 1 << exponent ); 2.7 VERWENDUNG DER GRAPHIKLIBRARY GD Da im nächsten Kapitel das Ausgeben einer Graphik in eine Datei notwendig ist, wird in diesem Abschnitt eine Einführung in die Verwendung der Graphiklibrary gd gegeben. Mit dieser Library ist es auf einfache Art und Weise möglich eine png-datei zu erstellen. Zuerst muss allerdings die Library mit YAST2 installiert werden. Weiters ist die devel- Version (gd devel) der Library zu installieren, da sie beim Kompiliern und Linken benötigt wird GRAPHIK ERSTELLEN Um eine Graphik im Hauptspeicher erstellen zu können wird die Funktion gdimagecreate verwendet. gdimageptr gdimagecreate( int sx /* in */, int sy /* in */) Der Übergabeparameter gibt dabei die sx Breite und der Parameter sy die Höhe in Pixel an. Zurückgegeben wird dabei ein Zeiger auf die Graphik LINIE ZEICHNEN Für das Zeichnen einer Linie kann die Funktion gdimageline verwendet werden. void gdimageline( gdimageptr im /* in */, int x1 /* in */, int y1 /* in */, int x2 /* in */, int y2 /* in */, int color /* in */) Die Linie wird zwischen dem Punkt x1 y1 und dem Punkt x2 y2 gezeichnet. Die Farbe der Linie wird durch den 6. Parameter color angegeben und wird deshalb vorher erst mit der Funktion gdimagecolorallocate zugewiesen.

28 FARBEN ZUWEISEN Um Elemente in der Graphik zeichnen zu können muss eine Farbe angegeben werden. Diese wird mit folgender Funktion allociert. int gdimagecolorallocate( gdimageptr im /* in */, int r /* in */, int g /* in */, int b /* in */) Der Parameter im gibt dabei an für welche Graphik die Farbe zugewiesen werden soll. Die weiteren 3 Parameter geben die Farbe im RGB-Format an. Die Werte der einzelnen Farben können von 0 und 255 gewählt werden. Die Funktion gibt die allocierte Farbe zurück. Wenn die Funktion das erste Mal im Programm aufgerufen wird, wird die definierte Farbe auch als Hintergrundfarbe der Graphik verwendet PNG BILD ERSTELLEN Es ist wichtig, dass die Graphik auf der Festplatte gespeichert werden kann. Dies kann mit der Funktion gdimagepng durchgeführt werden. void gdimagepng( gdimageptr im /* in */, FILE* out /* in */) Um die Graphik zu speichern muss die Variable out zuvor mit der Funktion fopen geöffnet werden. Nach dem Aufruf der Funktion gdimagepng muss dann noch die fclose Funktion aufgerufen werden SPEICHER FREIGEBEN Um die Graphik aus dem Hauptspeicher wieder zu löschen wird die Funktion gdimagedestroy verwendet. void gdimagedestroy( gdimageptr im /* in */) Die angegebene Graphik im wird beim Aufruf aus dem Hauptspeicher gelöscht BEISPIELPROGRAMM Nun folgt ein Beispielprogramm welches die Verwendung der obigen Funktionen aufzeigt. #include "gd.h" //Deklarationen & Prototypen für Compiler & Preprozessor #include <stdio.h> //fuer Dateiausgabe int main() gdimageptr gd_image; //Bild definieren FILE *pngout; //Ausgabedateien int gd_c_black; //Farbe: schwarz int gd_c_white; //Farbe: weiß gd_image = gdimagecreate(100, 100); //Bild erstellen 100x100 Pixel //Farbe definieren - weiß; Hintergrundfarbe setzen gd_c_white = gdimagecolorallocate(gd_image, 255, 255, 255);

29 2-29 //Farbe definieren - schwarz gd_c_black = gdimagecolorallocate(gd_image, 0, 0, 0); gdimageline( gd_image, 10, 10, 90, 90, gd_c_black ); //Linie zeichnen pngout = fopen("test.png", "wb"); //Bilde oeffnen gdimagepng(gd_image, pngout); //Bild speichern fclose(pngout); //Bilde schliessen gdimagedestroy(gd_image); //Bild loeschen return 0; Zu Beginn des Programms wird eine Graphik der Größe 100x100 Pixel im Hauptspeicher erstellt. Dann wird die Hintergrundfarbe und eine weitere Farbe definiert, eine Linie gezeichnet und die Graphik auf der Festplatte gespeichert. 2.8 BERECHNUNG EINER DRACHENKURVE WAS IST EINE DRACHENKURVE? Eine Drachenkurve ist eine Figur, die durch einen rekursiven Algorithmus definiert ist. Beim Zeichnen bzw. Berechnen einer Drachenkurve wird von folgender Anweisung ausgegangen: FX Die Rekursion besteht darin, dass das X durch folgenden Text ersetzt wird: X+YF+ Das Y muss ebenfalls ersetzt werden. Jedoch durch folgende Anweisung: -FX-Y