Podstawy MPI-2: część II Dynamiczne zarządzanie procesami
description
Transcript of Podstawy MPI-2: część II Dynamiczne zarządzanie procesami
Podstawy MPI-2: część II
Dynamiczne zarządzanie procesami
MPI-1 MPI-2
• Pula procesorów przydzielonych do zadania jest ustalona przy wywołaniu mpirun.
• mpirun uruchamia tę samą aplikację na wszystkich procesorach, stąd mnogość if (rank==master), itp. w kodzie.
• Nie ma narzędzi do uruchomienia komunikacji z innymi procesami.
• Można dodawać/zwalniać procesory w toku wykonywania aplikacji.
• Można uruchamiać inne aplikacje z poziomu danej aplikacji.
• Dany proces może nawiązywać komunikację z innymi procesami.
Kiedy ogranicznenia MPI-1 są uciążliwe?
• Jeżeli musimy policzyć wiele (dziesiątki a nawet setki) zadań jedno- albo niewielo-procesorowych (np. obliczenia kwantowomechaniczne dla wielu konformacji) a “trywialne” zrównoleglenie aplikacji jest niemożliwe lub nieopłacalne.
• Jeżeli chcemy napisać program, który musi wywoływać co jakiś czas inną aplikację (np. dynamiczna wizualizacja wyników).
Przykład programu z użyciem MPI-1 startującego wiele kopi
aplikacji jednoprocesorowej z różnymi argumentami linii polecenia
• Każdy procesor czyta plik fort.1 zawierający argumenty linii polecenia dla poszczególnych procesorów.
• Używając instrukcji call system, dany procesor wykonuje skrypt runall z argumentami linii polecenia odpowiadającymi jego rzędowi.
Ten schemat można uogólnić na startowanie różnych aplikacji jednoprocesorowych w zależności od rzędu procesora.
include “mpif.h” parameter (maxcom=100000) character*80 command(0:maxcom-1) integer rank, size, IERROR integer i,ncom call MPI_Init( IERROR ) call MPI_COMM_RANK( MPI_COMM_WORLD, rank, IERROR ) call MPI_COMM_SIZE( MPI_COMM_WORLD, size , IERROR ) ncom=0 do i=0,maxcom-1 read (1,'(a)',end=10) command(i) ncom=ncom+1 enddo 10 continue do i=rank,ncom-1,size print *,"Processor",rank," executes runall "//command(i) call system("./runall "//command(i)) enddo print *,"Processor",rank," has finished" call MPI_FINALIZE( IERROR ) stop end
driver.f
#!/bin/csh -fcd $1; run >! $2.monte
runall
1/0.60 11/0.60 21/0.60 31/0.60 41/0.60 51/0.60 61/0.60 71/0.60 81/0.60 91/0.60 101/0.60 111/0.60 121/0.60 131/0.60 141/0.60 151/0.60 161/0.60 171/0.60 181/0.60 191/0.60 20
fort.1
#PBS -N ZUCH#PBS -q dque#PBS -l nodes=10:ppn=2set NPROCS=`cat\ $PBS_NODEFILE | wc -l`
echo $NPROCS processors used
time mpirun –machinefile\ $PBS_NODEFILE -np $NPROCS\ -nolocal -p4wd\ $PBS_O_WORKDIR\ $PBS_O_WORKDIR/driver
skrypt PBS start.mat
Wykorzystanie rozszerzeń MPI-2: równoległe kopiowanie
pcp n-m plik_źródłowy kopia
np.
pcp 1-10 testfile /tmp/testfile_out
ma skopiować plik testfile jako testfile_out do katalogów /tmp maszyn o numerach od 1 do 10.
W “Using MPI-2”, katalog starting
pcp.c - wersja w MPI-1 (kod dla mastera robotników)
pcp-master.c pcp-slave.c – MPI-1, rozdzielone kody
pcp-spawn-master.c pcp-spawn-slave.c – MPI-2, rozdzielone kody
Motywacja
• Często zachodzi konieczność szybkiego skopiowania np. programu wykonywalnego lub pliku danych wejściowyh na dyski lokalne wszystkich maszyn przydzielonych do zadania.
• scp w pętli foreach lub while działa sekwencyjnie a zatem wolno.
Rozwiązanie
• Zorganizować kopiowanie jako czytanie fragmetów pliku a następnie rozsyłanie ich po “drzewie” do robotników, którzy zapisują część na swoich dyskach lokalnych i przesyłają dalej.
• Najlepiej zastosować do tego celu MPI_Bcast, który rozsyła wiadomości po “drzewie”.
0
1
2
3
5
4
Schemat kopiowania równoległego z wykorzystaniem MPI_Bcast
Bufor czytany
Bufor przesyłany
Bufor zapisywany na dysku lokalnym
/* pcp from SUT, in MPI */#include "mpi.h"#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#define BUFSIZE 256*1024#define CMDSIZE 80int main( int argc, char *argv[] ){ int myrank, mystatus, allstatus, done, numread; char outfilename[128], controlmsg[80]; int infd, outfd; char buf[BUFSIZE]; MPI_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &myrank );
pcp.c: początek programu
if ( myrank == 0 ) { makehostlist( argv[1], "targets" ); strcpy( outfilename, argv[3] ); if ( (infd = open( argv[2], O_RDONLY ) ) == -1 ) { fprintf( stderr, "input file %s does not exist\n", argv[2] ); sprintf( controlmsg, "exit" ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, MPI_COMM_WORLD ); MPI_Finalize(); return( -1 ); } else { sprintf( controlmsg, "ready" ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, MPI_COMM_WORLD ); } } else { MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, MPI_COMM_WORLD ); if ( strcmp( controlmsg, "exit" ) == 0 ) { MPI_Finalize(); return( -1 ); } }
pcp.c: przesyłanie nazwy pliku
if ( myrank == 0 ) sprintf( controlmsg, outfilename ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, MPI_COMM_WORLD ); if ( (outfd = open( controlmsg, O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU ) ) == -1 ) mystatus = -1; else mystatus = 0; MPI_Allreduce( &mystatus, &allstatus, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD ); if ( allstatus == -1 ) { if ( myrank == 0 ) fprintf( stderr, "output file %s could not be opened\n", outfilename ); MPI_Finalize(); return( -1 ); }
/* at this point all files have been successfully opened */ printf("all files opened\n");
pcp.c: otwieranie plików
done = 0; while ( !done ) { if ( myrank == 0 ) numread = read( infd, buf, BUFSIZE ); MPI_Bcast( &numread, 1, MPI_INT, 0, MPI_COMM_WORLD ); if ( numread > 0 ) { MPI_Bcast( buf, numread, MPI_BYTE, 0, MPI_COMM_WORLD ); write( outfd, buf, numread ); } else { close( outfd ); done = 1; } } MPI_Finalize();}
pcp.c: kopiowanie
Program pcp będzie działać ale:
• nie będzie działać jak “zwykłe” polecenie unixowe a będzie musiał być uruchomiony pod mpirun,
• lista maszyn, na które będzie kopiowany plik jest przekazywana do mpirun w postaci pliku stojącego po –machinefile.
Rozmnażanie procesów w MPI-2
• Program wywołujemy na jednym procesorze jak polecenie unixową; mpirun niepotrzebny.
• Proces wywołujący tworzy listę maszyn na podstawie argumentów linii polecenia a następnie otwiera z nimi komunikację.
• Inny kod będzie wykonywał master a inny robotnicy.
makehostlist( argv[1], "targets" ); strcpy( outfilename, argv[3] ); if ( (infd = open( argv[2], O_RDONLY ) ) == -1 ) { fprintf( stderr, "input file %s does not exist\n", argv[2] ); sprintf( controlmsg, "exit" ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, MPI_COMM_WORLD ); MPI_Finalize(); return( -1 ); } else { sprintf( controlmsg, "ready" ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, MPI_COMM_WORLD ); }
pcp-master.c: przesyłanie nazwy pliku
Najpierw podzielimy program na kod mastera (pcp-master) i robotników (pcp-slave)
sprintf( controlmsg, outfilename ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, MPI_COMM_WORLD ); if ( (outfd = open( outfilename, O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU ) ) == -1 ) mystatus = -1; else mystatus = 0; MPI_Allreduce( &mystatus, &allstatus, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD ); if ( allstatus == -1 ) { fprintf( stderr, "output file %s could not be opened\n", outfilename ); MPI_Finalize(); return( -1 ); }
pcp-master.c: otwieranie pliku danych
/* at this point all files have been successfully opened */
done = 0; while ( !done ) { numread = read( infd, buf, BUFSIZE ); MPI_Bcast( &numread, 1, MPI_INT, 0, MPI_COMM_WORLD ); if ( numread > 0 ) { MPI_Bcast( buf, numread, MPI_BYTE, 0, MPI_COMM_WORLD ); write( outfd, buf, numread ); } else { close( outfd ); done = 1; } } MPI_Finalize();}
pcp-master.c: kopiowanie
MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, MPI_COMM_WORLD ); if ( strcmp( controlmsg, "exit" ) == 0 ) { MPI_Finalize(); return -1; }
MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, MPI_COMM_WORLD ); if ( (outfd = open( controlmsg, O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU ) ) == -1 ) mystatus = -1; else mystatus = 0; MPI_Allreduce( &mystatus, &allstatus, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD ); if ( allstatus == -1 ) { MPI_Finalize(); return( -1 ); }
pcp-slave.c: odbieranie nazwy pliku i otwieranie pliku
/* at this point all files have been successfully opened */
done = 0; while ( !done ) { MPI_Bcast( &numread, 1, MPI_INT, 0, MPI_COMM_WORLD ); if ( numread > 0 ) { MPI_Bcast( buf, numread, MPI_BYTE, 0, MPI_COMM_WORLD ); write( outfd, buf, numread ); } else { close( outfd ); done = 1; } } MPI_Finalize();}
pcp-slave.c: kopiowanie
Wprowadzanie cech MPI-2
Master Robotnicy
• Tworzenie informacji o procesie wywołującym (MPI_Info_create i MPI_Info_set).
• Rozmnażanie procesów z przekazaniem informacji o procesie wywołującym (MPI_Comm_spawn).
• Tworzenie wspólnego komunikatora zawierającego mastera i robotników (MPI_Comm_merge).
• Uzyskiwanie informacji o procesie wywołującym (MPI_Get_parent).
MPI_INFO_CREATE(info)[OUT info] utworzony obiekt informacyjny (handle)
C: int MPI_Info_create(MPI_Info *info)
FORTRAN/FORTRAN90:MPI_INFO_CREATE(INFO, IERROR)INTEGER INFO, IERROR
C++:static MPI::Info MPI::Info::Create()
MPI_INFO_CREATE tworzy nowy obiekt informacyjny, niezawierający na razie żadnych (klucz,wartość).
MPI_INFO_SET(info, key, value)[INOUT info] obiekt informacyjny (handle)[IN key] klucz (string)[IN value] wartość (string)
C:int MPI_Info_set(MPI_Info info, char *key, char *value)
FORTRAN/FORTRAN90:MPI_INFO_SET(INFO, KEY, VALUE, IERROR)INTEGER INFO, IERROR CHARACTER*(*) KEY, VALUE
C++:void MPI::Info::Set(const char* key, const char* value)
MPI_INFO_SET dodaje parę (klucz, wartość) do obiektu informacyjnego; poprzednio ustalona wartość klucza jest nadpisywana.
MPI_INFO_DELETE(info, key)
[INOUT info] obiekt informacyjny (handle)[IN key] klucz (string)
C:int MPI_Info_delete(MPI_Info info, char *key)
FORTRAN/FORTRAN90:MPI_INFO_DELETE(INFO, KEY, IERROR)INTEGER INFO, IERROR CHARACTER*(*) KEY
C++:void MPI::Info::Delete(const char* key)
MPI_INFO_DELETE usuwa parę (klucz,wartość) z danego obiektu informacyjnego.
MPI_COMM_SPAWN(command, argv, maxprocs, info, root, comm, intercomm, array_of_errcodes)
[IN command] nazwa programu który ma być wystartowany na odległych procesorach; ważna tylko dla mastera (string)[IN argv] argumenty linii polecenia do przekazania dla robotników; ważne tylko dla mastera (tablica łańcuchów)[IN maxprocs] maksymalna liczba procesów potomnych; ważne tylko dla mastera (integer)[IN info] zbiór par (klucz,wartość), mówiących systemowi gdzie wystartować procesy potomne; ważne tylko dla mastera (handle)[IN root] rząd procesu, który ustala poprzednie argumenty (integer)[IN comm] komunikator (wewnętrzny) zawierający procesy tworzące procesy potomne (handle)[OUT intercomm] interkomunikator pomiędzy grupą oryginalną i noworozmnożonymi procesami (handle) [OUT array_of_errcodes] tablica kodów błędów; jeden dla procesu (array of integer)
C:
int MPI_Comm_spawn(char *command, char *argv[], int maxprocs, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *intercomm, int array_of_errcodes[])
FORTRAN/FORTRAN90:
MPI_COMM_SPAWN(COMMAND, ARGV, MAXPROCS, INFO, ROOT, COMM, INTERCOMM, ARRAY_OF_ERRCODES, IERROR)CHARACTER*(*) COMMAND, ARGV(*) INTEGER INFO, MAXPROCS, ROOT, COMM, INTERCOMM, ARRAY_OF_ERRCODES(*), IERROR
C++: MPI::Intercomm MPI::Intracomm::Spawn(const char* command, const char* argv[], int maxprocs, const MPI::Info& info, int root, int array_of_errcodes[]) const MPI::Intercomm MPI::Intracomm::Spawn(const char* command, const char* argv[], int maxprocs, const MPI::Info& info, int root) const
MPI_COMM_GET_PARENT(parent)[OUT parent] komunikator rodzicielski (handle)
C:int MPI_Comm_get_parent(MPI_Comm *parent)
FORTRAN/FORTRAN90:MPI_COMM_GET_PARENT(PARENT, IERROR) INTEGER PARENT, IERROR
C++:static MPI::Intercomm MPI::Comm::Get_parent()
MPI_COMM_GET_PARENT zwraca interkomunikator utworzony przez proces(y) rodzicielski(e) poleceniem MPI_COMM_SPAWN lub MPI_COMM_SPAWN_MULTIPLE; jeżeli takie polecenie nie zostało wydane lub interkomunikator został zwolniony, zwraca MPI_COMM_NULL.
Interkomunikator
Procesy rodzicielskie Procesy potomne
Zwracany przez MPI_Comm_spawn
Zwracany przez MPI_Comm_parent
MPI_Comm_spawn MPI_Init
Ilustracja działania MPI_Comm_spawn i MPI_Comm_parent
Procesy rodzicielskie jako grupa odległa
Procesy potomne jako grupa odległa
/* pcp from SUT, in MPI */#include "mpi.h"#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#define BUFSIZE 256*1024#define CMDSIZE 80int main( int argc, char *argv[] ){ int mystatus, allstatus, done, numread; char outfilename[128], controlmsg[80]; int infd, outfd; char buf[BUFSIZE]; char soft_limit[20]; MPI_Info hostinfo; MPI_Comm pcpslaves;
MPI_Init( &argc, &argv ); makehostlist( argv[1], "targets“, &num_hosts ); MPI_Info_create( &hostinfo ); MPI_Info_set( hostinfo, "file", "targets" ); MPI_Info_set( hostinfo, "soft", soft_limit );
pcp-spawn-master.c: początek
MPI_Comm_spawn( "pcp_slave", MPI_ARGV_NULL, num_hosts, hostinfo, 0, MPI_COMM_SELF, &pcpslaves, MPI_ERRCODES_IGNORE ); MPI_Info_free( &hostinfo );
strcpy( outfilename, argv[3] ); if ( (infd = open( argv[2], O_RDONLY ) ) == -1 ) { fprintf( stderr, "input %s does not exist\n", argv[2] ); sprintf( controlmsg, "exit" ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, pcpslaves ); MPI_Finalize(); return( -1 ); } else { sprintf( controlmsg, "ready" ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, pcpslaves ); }
pcp-spawn-master.c: przydzielanie procesorów, do których ma być kopiowany plik
sprintf( controlmsg, outfilename ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, pcpslaves ); if ( (outfd = open( outfilename, O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU ) ) == -1 ) mystatus = -1; else mystatus = 0; MPI_Allreduce( &mystatus, &allstatus, 1, MPI_INT, MPI_MIN, pcpslaves ); if ( allstatus == -1 ) { fprintf( stderr, "output file %s could not be opened\n", outfilename ); MPI_Finalize(); return( -1 ); }
pcp-spawn-master.c: przesyłanie nazwy pliku celowego
/* at this point all files have been successfully opened */
done = 0; while ( !done ) { numread = read( infd, buf, BUFSIZE ); MPI_Bcast( &numread, 1, MPI_INT, 0, pcpslaves ); if ( numread > 0 ) { MPI_Bcast( buf, numread, MPI_BYTE, 0, pcpslaves ); write( outfd, buf, numread ); } else { close( outfd ); done = 1; } } MPI_Comm_free( &pcpslaves ); MPI_Finalize();}
pcp-spawn-master.c: kopiowanie
MPI_Comm_get_parent( &slavecomm ); MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, slavecomm ); if ( strcmp( controlmsg, "exit" ) == 0 ) { MPI_Finalize(); return( -1 ); }
MPI_Bcast( controlmsg, CMDSIZE, MPI_CHAR, 0, slavecomm ); if ( (outfd = open( controlmsg, O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU ) ) == -1 ) mystatus = -1; else mystatus = 0; MPI_Allreduce( &mystatus, &allstatus, 1, MPI_INT, MPI_MIN, slavecomm ); if ( allstatus == -1 ) { MPI_Finalize(); return( -1 ); }
pcp-spawn-slave.c: uzyskiwanie informacji od procesu wywołującego i otwieranie pliku celowego
/* at this point all files have been successfully opened */
done = 0; while ( !done ) { MPI_Bcast( &numread, 1, MPI_INT, 0, slavecomm ); if ( numread > 0 ) { MPI_Bcast( buf, numread, MPI_BYTE, 0, slavecomm ); write( outfd, buf, numread ); } else { close( outfd ); done = 1; } } MPI_Comm_free( &slavecomm ); MPI_Finalize(); return 0;
pcp-spawn-slave.c: kopiowanie
Uwagi dotyczące MPI_Comm_spawn
MPI_UNIVERSE_SIZE mówi ile maksymalnie procesów potomnych można utworzyć a MPI_UNIVERSE_FLAG czy ta zmienna jest zdefiniowana przez system. MPI_UNIVERSE_SIZE definiuje “wszechświat” wszystkich komunikatoró, zarówno wystartowanych jak i potencjalnych komunikatorów potomnych.
Zmienną tę można ustawić przy uruchamianiu aplikacji pod mpiexec, np:
mpiexec –usize 4 –n 1 ./myprog
Zadanie zostanie wystartowane na jednym procesorze z możliwością rozszerzenia do czterech.
int world_size, universe_size, *universe_sizep, flag;…MPI_Attr_get(MPI_COMM_WORLD, MPI_UNIVERSE_SIZE,&universe_sizep,&flag);if (!flag){printf("This MPI does not support UNIVERSE_SIZE. How many processes total?");scanf("%d", &universe_size);}else universe_size = *universe_sizep;if (universe_size == 1) printf("No room to start workers");strcpy(worker_program, "./workers" );printf("Nome do programa: %s\n",worker_program);...error = MPI_Comm_spawn(worker_program, MPI_ARGV_NULL,universe_size-1,Info, 0, MPI_COMM_SELF, &everyone,MPI_ERRCODES_IGNORE);
Przykład
Tworzenie procesów potomnych obniża efektywność działania programu, dlatego w miarę możności należy pracować na puli od razu przydzielonej do zadania.
Przykład wywołania połączenia z innymi procesami przez serwer i zaakceptowania połączenia przez robotników
Serwer:
gets(port_name);
MPI_Comm_connect(port_name,MPI_INFO_NULL,0, MPI_COMM_WORLD,&server);
Robotnicy:
MPI_Open_port(MP_INFO_NULL,port_name);
MPI_Comm_accept(port_name,MPI_INFO_NULL,port_name);
Unifikacja startowania zadań równoległych w MPI-2
MPI-1: zwykle mpirun ale też yod i inne narzędzia. Składnia mpirun zależna od implementacji.
MPI-2: mpiexec (dla kompatybilności jest zwykle podlikowany jako mpirun).
Najprościej, np.:
mpiexec –n 4 ./myprog
działa jak
mpirun –np 4 ./myprog
Inne parametry: -soft, -host, -arch, -wdir, -path, -file, -usize
mpiexec –n 32 –soft 16 myprog
Jeżeli dostępne są 32 procesory to startuje myprog na 32, jeżeli nie na 16.
mpiexec –n 4 –host denali –wdir /home/me/outfiles myprog
Startuje myprog na 4 procesorach maszyny denali używając jako katalogu roboczego /home/me/outfiles.
mpiexec –n 12 –soft 1:12 –arch sparc-solaris \ -path /home/me/sunprogs myprog
Usiłuje wystartować myprog na 12 procesorach ale użyje od 1 do 12 w zależności od tego ile jest dostępnych, ograniczając się do maszyn o architekturze sparc-solaris i poszukując myprog w /home/me/sunprogs.
mpiexec –file myfile
Argumenty polecenia są w pliku myfile.