komunikacja zbiorowa – część i

Komunikacja zbiorowa – część I

Komunikacja zbiorowa: przesyłanie danych pomiędzy wszystkimi procesorami grupy zdefiniowanymi przez dany komunikator.

Typy komunikacji zbiorowej:

1. Bariera (synchronizacja).

2. Globalna wymiana danych.

3. Globalne operacje redukcji.

Szczegółowy opis procedur komunikacji zbiorowej można znaleźć w książce „MPI - the complete reference” pod adresem http://www.netlib.org/utk/papers/mpi-book/node91.html

Bariera

Bariera: synchronizacja wszystkich procesorów grupy (MPI_BARRIER).

Składnia procedury MPI_BARRIER w C i Fortranie 77:

MPI_Barrier(MPI_Comm comm)

MPI_BARRIER(COMM, IERROR)

INTEGER COMM, IERROR

comm - komunikator

Globalna wymiana danych:

Broadcast: rozesłanie wiadomości przez jeden procesor (root) do pozostałych procesorów grupy (MPI_BCAST).

Gather: zebranie wiadomości przez jeden procesor (root) od wszystkich procesorów grupy (MPI_GATHER, MPI_GATHERV).

Scatter: rozproszenie danych od jednego procesora (roota) do wszystkich elementów grupy (MPI_SCATTER, MPI_SCATTERV).

Allgather: każdy procesor zbiera wiadomości od pozostałych procesorów grupy (MPI_ALLGATHER, MPI_ALLGATHERV).

All-to-all (all-scatter-all-gather): każdy procesor rozprasza swoje dane do wszystkich procesorów grupy i zbiera wiadomości od wszystkich procesorów grupy (MPI_ALLTOALL, MPI_ALLTOALLV).

Składnia procedury MPI_BCAST w C i Fortranie 77:

MPI_Bcast(void* buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm )

MPI_BCAST(BUFFER, COUNT, DATATYPE, ROOT, COMM, IERROR) <type> BUFFER(*) INTEGER COUNT, DATATYPE, ROOT, COMM, IERROR

buffer - początkowy adres bufora transmitowanych danychcount - liczba transmitowanych elementów danychdatatype - identyfikator typu transmitowanych danych (w sensie MPI)root - rząd (numer) procesora, który rozsyła danecomm - komunikator.

Przykład (C): rozesłanie przez procesor 0 tablicy 100 liczb całkowitych:

MPI_Comm comm; int array[100]; int root=0; ...MPI_Bcast( array, 100, MPI_INT, root, comm);

Przykład (Fortran): rozsyłanie rozkazu oraz danych do „robotników” przez „nadzorcę”:

subroutine func1(n,What,x,zz,obf,obg)...integer Whatdouble precision x(n)...call MPI_Bcast( What, 1, MPI_INTEGER, Master, Comm1, IERROR)call MPI_Bcast(x(1),n,MPI_DOUBLE_PRECISION, Master, Comm1, IERROR)if (What.le.0) return

Składnia procedur MPI_GATHER w C i Fortranie 77:

MPI_Gather(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

MPI_GATHER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR) <type> SENDBUF(*), RECVBUF(*) INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR

sendbuf - początkowy adres bufora transmitowanych danych

recvbuf - początkowy adres bufora przyjmowanych danych

sendcount, sendcounts - liczba wysyłanych elementów danych (w przypadku MPI_Gatherv jest to tablica)

recvcount, recvcounts - liczba przyjmowanych elementów danych (w przypadku MPI_Gatherv jest to tablica)

sendtype - identyfikator typu wysyłanych danych (w sensie MPI)

recvtype - identyfikator typu przyjmowanych danych (w sensie MPI)

root - rząd (numer) procesora, który przyjmuje dane

comm - komunikator.

Efekt działania MPI_Gather dla układu n procesorów można przedstawić jako wykonanie instrukcji MPI_Send przez każdy procesor (łącznie z rootem) a następnie przyjęcie przez root danych od kolejnych procesorów (łącznie z sobą samym) w ten sposób, że dane zawarte w buforze procesora pierwszego są lokowane na początku bufora przyjmującego, dane pochodzące od procesora drugiego są w buforze przyjmującym przesunięte o RECVCOUNT, itd.:

Oddzielna specyfikacja dla SENDCOUNT i SENDTYPE oraz RECVCOUNT i RECVTYPE umożliwia inną specyfikację danych dla roota a inną dla pozostałych procesorów; należy jednak pamiętać, że całkowita długość SENDBUF musi się zgadzać z długością części RECVBUF, do której root przyjmuje te dane.

Przykład: zebranie przez procesor 0 (root) tablicy 100 liczb całkowitych od każdego procesora:

integer comm, gsize, sendarray(100)integer root, rbuf(100*MaxProcs) ... call MPI_Comm_size(comm, gsize)call MPI_Gather( sendarray, 100, MPI_INT, rbuf, 100, MPI_INT, root, comm)

Składnia procedur MPI_GATHER w C i Fortranie 77:

MPI_Gatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int *recvcounts, int *displs, MPI_Datatype recvtype, int root, MPI_Comm comm)

MPI_GATHERV(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNTS, DISPLS, RECVTYPE, ROOT, COMM, IERROR) <type> SENDBUF(*), RECVBUF(*) INTEGER SENDCOUNT, SENDTYPE, RECVCOUNTS(*), DISPLS(*), RECVTYPE, ROOT, COMM, IERROR

recvcounts - tablica zawierająca liczbę elementów danych przyjmowanych od poszczególnych procesorów

displs - tablica zawierająca przesunięcia porcji danych przyjmowanych od poszczególnych procesorów w buforze przyjmującym.

Przykład: Zbieranie przez „nadzorcę” od „robotników” wyliczonych przez nich części energii struktur:

ii=0do i=indstart(me),indend(me)

ii=ii+1call restore_coords(iprot,ii)call chainbuildcall etotal(energia(0))enetb(i,0)=energia(0)

enddo...if (What.eq.2) then

call MPI_Gatherv(enetb(indstart(me),0), scount(me),MPI_DOUBLE_PRECISION,

enetb(1,0),scount(0),idispl(0),MPI_DOUBLE_PRECISION,Master,Comm1, IERROR)

endif

Składnia procedur MPI_SCATTER, MPI_ALLGATHER i MPI_ALLTOALL w C i Fortranie 77

MPI_Scatter(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

MPI_SCATTER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR) <type> SENDBUF(*), RECVBUF(*) INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR

MPI_Allgather(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)

MPI_ALLGATHER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, IERROR) <type> SENDBUF(*), RECVBUF(*) INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, IERROR

MPI_Alltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)

MPI_ALLTOALL(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, IERROR) <type> SENDBUF(*), RECVBUF(*) INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, IERROR

Globalne operacje redukcji

Redukcja: Wykonywanie danej operacji (np. dodawania) na grupie danych zebranych od wszystkich procesorów. Wynik jest zwracany albo do jednego procesora (roota; zwykła redukcja) albo do wszystkich (allreduce) (MPI_REDUCE, MPI_ALLREDUCE).

Redukcja z rozproszeniem wyników (MPI_REDUCE_SCATTER).

Redukcja „od procesorów wstecz” (MPI_SCAN).

Globalne operatory redukcji

MPI_MAX maksimum

MPI_MIN minimum

MPI_SUM suma

MPI_PROD iloczyn

MPI_LAND logiczne „and”

MPI_BAND bitowe „and”

MPI_LOR logiczne „or”

MPI_BOR bitowe „or”

MPI_LXOR logiczne „xor”

MPI_BXOR bitowe „xor”

MPI_MAXLOC maksimum oraz jego położenie

MPI_MINLOC minimum oraz jego położenie

Użytkownik może również definiować własne operatory redukcji, za pomocą funkcji MPI_OP_CREATE.

Składnia procedury MPI_REDUCE w C i Fortranie 77

MPI_Reduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)

MPI_REDUCE(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, ROOT, COMM, IERROR) <type> SENDBUF(*), RECVBUF(*) INTEGER COUNT, DATATYPE, OP, ROOT, COMM, IERROR

sendbuf - adres buforu wysyłanych danych

recvbuf - adres bufora przechowującego wynik operacji redukcji

count - liczba wysyłanych przez każdy procesor elementów danych

datatype - identyfikator typu wysyłanych/przyjmowanych danych

op - identyfikator operacji redukcji

root - rząd (numer) roota

comm - komunikator

Przykład: obliczanie iloczynu skalarnego dwóch wektorów. Poszczególne m-elementowe części wektorów zostały już wcześniej rozprowadzone pomiędzy procesory:

SUBROUTINE PAR_BLAS1(m, a, b, c, comm)REAL a(m), b(m) ! zawieraja czesci wektorow a i b ! przypisane danemu procesorowi REAL c ! wynik (otrzymany przez procesor 0 - root) REAL sum ! suma czastkowa dla kazdego procesora INTEGER m, comm, i, ierr

! suma czastkowa dla danego procesora sum = 0.0 DO i = 1, m

sum = sum + a(i)*b(i) ENDDO

! obliczanie sumy calkowitej przez procesor 0 CALL MPI_REDUCE(sum, c, 1, MPI_REAL, MPI_SUM, 0, comm, ierr) RETURN END

Składnia procedur MPI_ALLREDUCE, MPI_REDUCE_SCATTER i MPI_SCAN w C i Fortranie 77

MPI_Allreduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)

MPI_ALLREDUCE(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, IERROR)<type> SENDBUF(*), RECVBUF(*) INTEGER COUNT, DATATYPE, OP, COMM, IERROR

MPI_Reduce_scatter(void* sendbuf, void* recvbuf, int *recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)

MPI_REDUCE_SCATTER(SENDBUF, RECVBUF, RECVCOUNTS, DATATYPE, OP, COMM, IERROR)<type> SENDBUF(*), RECVBUF(*) INTEGER RECVCOUNTS(*), DATATYPE, OP, COMM, IERROR

MPI_Scan(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )

MPI_SCAN(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, IERROR) <type> SENDBUF(*), RECVBUF(*) INTEGER COUNT, DATATYPE, OP, COMM, IERROR

Przykład użycia procedury MPI_REDUCESCATTER

Rozproszone obliczanie iloczynu wektora a przez macierz b z dystrybucją wynikowego wektora c pomiędzy procesory:

b a = c

Macierz b oraz wektor a są podzielone pomiędzy procesory na odpowiadające sobie ,,plasterki''. Każdy procesor oblicza wkład do elementów wektora wynikowego odpowiadający swoim danym. Następnie przy pomocy procedury MPI_REDUCESCATTER wkłady te są sumowane a wynikowy wektor c jest dystrybuowany pomiędzy procesory.

subroutine matvec( n, m, lmatrix, lx, ly, counts, comm )use mpiinteger n, m, comm, counts(*)real lmatrix(n,m), lx(m), ly(m)integer i, jreal sumreal, allocatable :: tmp(:)allocate (tmp(n))! Perform the local matrix-vector multiply! Should use the level-2 BLAS routine SGEMVdo i=1,n sum = 0 do j=1,m sum = sum + lmatrix(i,j)*lx(j) enddo tmp(i) = sumenddo! Perform the local matrix-vector productcall MPI_REDUCE_SCATTER( tmp, ly, counts, MPI_REAL, MPI_SUM, comm, ierr)deallocate (tmp)! We're done!end

Kod źródłowy (Fortran90)

Kompletny przykladowy program (FORTRAN 77)

Wyniki (2 procesory)

Przykład programu wykorzystującego procesury komunikacji zbiorowej: obliczanie liczby przez całkowanie numeryczne

dxx

1

021

14)1arctan(4

n

ii

n

i

fn

nin 11

2

4

5.01

14

Ilustracja przybliżonego obliczania liczby p przez całkowanie numeryczne dla liczby przedziałów n=10.

Zrównoleglenie algorytmu

1. Przedział całkowania dzieli się na n części: 1, 2,..., n

2. W układzie m procesorów, procesor 1 sumuje wkłady dla części 1, m+1, procesor 2 dla 2, m+2itd.

3. Procesory przesyłają swoje obliczone cząstkowe sumy do mastera, który oblicza sumę całkowitą.

Źródło programu w CŹrodło programu w Fortranie77

Wyniki (4 procesory)

adaml@galera ~/MPI/scali > mpirun -np 4 pif/opt/scali/bin/mpimon -stdin all pif -- gal72 1 gal71 1 gal65 1 gal64 1Enter the number of intervals: (0 quits)100 Processor 1 mypi 0.7879260283629753 Processor 0 mypi 0.7928763409009609 Processor 3 mypi 0.7778741525634217 Processor 2 mypi 0.7829244650957667 pi is approximately: 3.1416009869231250 Error is: 0.0000083333333314Enter the number of intervals: (0 quits)0FORTRAN STOPFORTRAN STOPFORTRAN STOPFORTRAN STOP

OPERATORY MIN_LOCK i MAX_LOCK

Te operatory redukcji służą do wyszukania minimalnych (maksymalnych) wartości rozproszonych danych oraz odpowiadających im indeksów (np. indeks może być rzędem procesora). Bufor danych musi być wtedy strukturą zawierającą zarówno porównywane wartości, jak i stowarzyszone z nimi indeksy, np.

proc1 x1 ind1 x2 ind2 x3 ind3proc2 x1 ind1 x2 ind2 x3 ind3proc3 x1 ind1 x2 ind2 x3 ind3proc4 x1 ind1 x2 ind2 x3 ind3

x1min ind1min x2min ind2min x3min ind3min

W celu stworzenia bufora danych o strukturze jak podanej tabeli w MPI zdefiniowano następujące złożone typy danych:

MPI_FLOAT_INT float+int

MPI_DOUBLE_INT double+int

MPI_LONG_INT long+int

MPI_2INT int+int

MPI_SHORT_INT short+int

MPI_LONG_DOUBLE long+double

C:

FORTRAN:

MPI_2REAL 2*REAL

MPI_2DOUBLEPRECISION 2*DOUBLE PRECISION

MPI_2INTEGER 2*INTEGER

W przypadku FORTRANu indeks ma typ zgodny z typem danych, w zbiorze których jest wyszukiwane minimum/maksimum. Jest to spowodowane brakiem typów złożonych w standarcie FORTRANu 77. Aby w tym przypadku posługiwać się parami dana-indeks jak w C należy zdefiniować własne operatory i typy danych.

Definicja typu MPI_2REAL oraz MPI_FLOAT_INT:

FORTRANcall MPI_TYPE_CONTIGUOUS(2, MPI_REAL, MPI_2REAL)

Ctype[0] = MPI_FLOATtype[1] = MPI_INTdisp[0] = 0disp[1] = sizeof(float)block[0] = 1block[1] = 1MPI_TYPE_STRUCT(2, block, disp, type, MPI_FLOAT_INT)

Przykład programu wykorzystującego operator MAX_LOC

Każdy procesor wypełnia tablicę 10 liczb podwójnej precyzji, zgodnie z następującą formułą:

A[i] = sin(rank*i), i=1,2,...10

gdzie rank jest rzędem procesora. Następnie jest wyszukiwana największa wartość danego elementu tablicy po wszystkich procesorach oraz rząd odpowiadającego jej procesora. Wielkości te są zbierane przez procesor o rzędzie 0.

Źródło programu w CŹródło programu w FORTRANie 77

/opt/scali/bin/mpimon -stdin all maxloc -- gal72 1 gal71 1 gal65 1 gal64 1

1 0 0.00000 1 1 0.84147 1 2 0.90930 1 3 0.1411 2 0 0.00000 2 1 0.90930 2 2 -0.75680 2 3 -0.2794 3 0 0.00000 3 1 0.14112 3 2 -0.27942 3 3 0.4121 4 0 0.00000 4 1 -0.75680 4 2 0.98936 4 3 -0.5365 5 0 0.00000 5 1 -0.95892 5 2 -0.54402 5 3 0.6502 6 0 0.00000 6 1 -0.27942 6 2 -0.53657 6 3 -0.7509 7 0 0.00000 7 1 0.65699 7 2 0.99061 7 3 0.8366 8 0 0.00000 8 1 0.98936 8 2 -0.28790 8 3 -0.9055 9 0 0.00000 9 1 0.41212 9 2 -0.75099 9 3 0.9563 10 0 0.00000 10 1 -0.54402 10 2 0.91295 10 3 -0.9880

i 1 ind 2 value 0.90930i 2 ind 1 value 0.90930i 3 ind 3 value 0.41212i 4 ind 2 value 0.98936i 5 ind 3 value 0.65029i 6 ind 0 value 0.00000i 7 ind 2 value 0.99061i 8 ind 1 value 0.98936i 9 ind 3 value 0.95638i 10 ind 2 value 0.91295

Wyniki (4 procesory)