PROGRAMAREA MULTICALCULATOARELOR

1
PROGRAMAREA MULTICALCULATOARELOR

• OCCAM
• APLICATII PARALELE PE UN HIPERCUB
• MPI
• PVM

2
CARACTERISTICI ALE PROGRAMARII MULTICALCULATOARELO
R
-nu exista spatiu unic de adresa (programarea
fara memorie partajata) -programul paralel se
executa ca o multime de procese concurente, numai
cu memorie locala -comunicatia intre procese se
face prin transfer de mesaje (operatie send
dintr-un proces lt-gt operatie receive a altui
proces) -nu exista variabile partajate (fara
mecanisme de protectie a accesului la acestea).
Limbaje de programare in transfer de
mesaje -limbaje secventiale (Pascal, C,
Fortran) cu extensii pentru transmisia si
receptia mesajelor -limbaje de programare
paralela speciale Ada, Occam, Linda, Orca, SR,
Parlog, Emerald, etc.   Biblioteci de
comunicatie -PVM Parallel Virtual
Machine -MPI Message Passing Interface.
3
LIMBAJUL OCCAM
-realizat in 1986 de INMOS -bazat pe limbajul
CSP (Communicating Sequential Processes) din
1978 -algoritm paralel -gt colectie de procese
asincrone, care comunica prin canale -canalul
entitate abstracta de comunicatie, punct la
punct, directionata, sincrona si fara buffer
intre doua procese paralele.
4
Procese fundamentale   -asignare variabila
expresie   -citire dintr-un canal de
comunicatie canal ? variabila   -scriere
intr-un canal de comunicatie canal !
expresie   -orice alt proces structura
ierarhica de subprocese -subproces colectie de
procese mai simple executate in serie sau in
paralel pe acelasi transputer sau pe transputere
diferite -procesele create static (nu se pot
crea dinamic) in momentul compilarii.
5
Operatori de constructie (constructori) pentru
definirea proceselor complexe   -SEQ creaza un
proces complex dintr-un numar de procese minore
care se vor executa secvential
SEQ proces_1 proces_2 proces_3 . .
. . . . . . proces_n   -PAR creaza un proces
complex care lanseaza executia paralela a mai
multor procese
PAR proces_1 proces_2 proces_3 . .
. . . . . . proces_n
6
-IF creaza un proces complex care lanseaza in
executie unul din procesele componente,
corespunzand primei conditii adevarate (testarea
se face in ordinea scrierii conditiilor)
IF conditie_1 proces_1 conditie_2
proces_2 conditie_3 proces_3 . . . . .
. . . conditie_n proces_n  
7
-ALT creaza un proces complex care lanseaza in
executie un singur proces corespunzand primului
canal de intrare care este gata de comunicatie
ALT canal_1 ? x proces_1 canal_2 ?
x proces_2 canal_3 ? x proces_3 . .
. . . . . . . . . canal_n ? x proces_n Ord
inea specificarii canalelor nu conteaza, selectia
se face in functie de momentul de timp cand
canalul este gata de comunicatie.
8
-nu se pot defini variabile partajate intre doua
procese (chiar daca procesele se executa pe
acelasi transputer).   gt Canalele de
comunicatie Occam sunt sincrone si fara buffer
(procesel A si B fac parte din componentele unei
constructii PAR).
9
Aplicatie calculul unei aproximatii a numarului
p   gt prin integrare numerica
(inaltimea fiecarui dreptunghi este valoarea
functiei in mijlocul subintervalului respectiv).
10
Algoritmul secvential   define n . . . . . sum
0.0 w 1/n for (i0 iltn i) x
(i0.5)w sum 4/(1xx) sum w   gt
Timpul de calcul este O(n).
11
Se considera o retea de p transputere inlantuite,
primul transputer fiind conectat la calculatorul
gazda
gtfiecarui transputer n/p subintervale pentru
suma ariilor dreptunghiurilor. Etape 1)fiecare
transputer calculeaza secvential si insumeaza
n/p arii 2)fiecare transputer primeste de la
vecinul dreapta suma partiala, o insumeaza cu
propria valoare si o trimite la vecinul stanga,
astfel incat se obtine rezultatul in nodul 0.
12
VAL INT p IS 8 VAL INT n IS 1024 p CHAN OF
REAL chan --vector de canale INT
s SEQ sn/p PAR i0 FOR p-1 --vector de
procese paralele REAL x, partial_sum, w
SEQ partial_sum0.0 w1/n x((is)
0.5)w SEQ j0 FOR s-1
SEQ partial_sumpartial_sum(4/(1xx))
xxw partial_sumpartial_sumw
13
--transferul sumelor partiale si acumulare in
procesorul 0 IF ip-1 chanp-1 !
partial_sum iltp-1 SEQ REAL sum
chani1 ? sum chani ! sumpartial_sum
14
APLICATII PARALELE PE UN HIPERCUB
Algoritmi pe un hipercub   Structura hipercub -gt
implementarea unui numar mare de algoritmi
necesitand comunicatii all-to-all. Sablon un
formular de program care poate fi completat cu
informatii specifice aplicatiei pentru
implementarea unui algoritm paralel.   Hipercubul
conecteaza fiecare din toate cele P taskuri
(procesoare) la log2P alte taskuri. -model
SPMD -initial o variabila de stare lt- o data
furnizata la intrare -log2P pasi -la fiecare
pas fiecare task -schimba starea locala cu unul
din vecini -combina mesajul primit de la vecin
cu starea curenta -gt starea urmatoare gt
rezultatul starea generata la pasul final.
15
procedure hypercube (myid, input, logp,
output) begin stateinput //starea locala init
cu input for i0,logp-1 //repeta de logp
ori destmyid XOR 2i //determina vecinul send
state -gt dest //schimba datele receive message
lt- dest stateOP(state,message) //executa
operatia endfor outputstate //rezultatul
final end   Implementarea unui algoritm
particular prin definirea operatiei OP.
16
Reducere de vector  Algoritmul pecedent se poate
utiliza pentru o reducere de vector utilizand
orice operator comutativ asociativ (ex adunare,
maxim, inmultire).
Reducerea a patru vectori de lungime N4
distribuiti la patru taskuri gt algoritmul in
log242 pasi. La fiecare pas fiecare
task -executa schimbul a N date cu un
vecin -realizeaza N operatii de combinare.
17
In cazul general de reducere vectoriala fiecare
task dintre P taskuri -furnizeaza un vector de
N valori -executa N operatii separate de
reducere gt vector de N rezultate. Reducerea
in log2P pasi. Timpul necesar   Treducere
log2P (ts N (tw top))   unde -top timpul
cerut de operatia de reducere -tw timpul de
comunicatie -ts timpul de lansare
(start-up). Algoritmul este eficient pentru
valori mici ale lui N (cand predomina timpul de
lansare).  
18
Varianta a algoritmului algoritm recursiv cu
injumatatire gt reducerea semnificativa a
volumului mesajelor comunicate. Algoritmul
aplicat de doua ori in faza de reducere fiecare
procesor comunica si combina N/2 date in prima
iteratie, apoi jumatate N/4 in a doua, etc. gt
fiecare procesor comunica in total N(P-1)P date
in log2P pasi. Se obtine suma globala, iar
vectorul rezultat de N componente este uniform
distribuit la cele P procese.
19
Timpul consumat Solutia trimite de doua
ori mai multe mesaje, dar cu mai putine date si
face mai putine calcule gt mai eficient pentru
anumte valori ale lui N si P, si pe anumite
masini.
20
Broadcast   Similar se poate defini un algoritm
eficient de broadcast. N valori localizate in
nodul radacina sunt trasnmise la toate cele P-1
noduri, utilizand un arbore binar de comunicatie.
21
Timpul necesar Tbroadcast log2P (ts
twN) Algoritmul eficient pentru valori mici ale
lui N si P. Pentru valori mari ale lui N si P
multe procesoare sunt inactive cea mai mare parte
a timpului si Tbroadcast este dominat de log2P
twN. gt mai eficient sa se sparga mesajul in
componente mai mici si sa se routeze componentele
separat prin reteaua hipercub. Timpul necesar
Tbroadcast 2(ts log2P twN)
22
Transpunerea de matrici.   Matricea A de
transpus si transpusa A' sunt distribuite printre
procese gt executia algoritmului implica
comunicatii. Se considera o descomunere pe
coloane a celor doua matrici repartizate
proceselor gt comunicatii all-to-all. Algoritmul
P-1 pasi. La fiecare pas fiecare task
interschimba N2/P2 date cu un alt task. Timpul
necesar
23
NP8 gt log2P pasi.. Fiecare proces are o
singura coloana din A, iar in final fiecare va
avea o singura linie din A'. La fiecare pas
fiecare proces schimba ½ din datele sale
(reprezentate umbrit in desen). In partea a doua
a desenului sursele componentelor detinute de
procesul 0, la fiecare pas al algoritmului.
24
Procesele sunt partitionate in doua seturi
taskurile corespunzatoare din cele doua seturi
interschimba ½ dintre datele lor taskurile
0p/2-1 comunica jumatatea inferioara a datelor
lor, iar taskurile P/2P-1 comunica jumatatea
superioara. Aceasta partitionare si interschimb
se repeta pana cand fiecare set contine un singur
task. Daca fiecare dintre cele log2P mesaje are
dimensiunea N2/(2P) timpul necesar este
Algoritmul hipercub transmite aprox. P/log2P mai
putine mesaje, dar de (log2P)/2 ori mai multe
date. Algoritmul hipercub eficient in probleme
mici cu timp de lansare mare si timp de transfer
mic!
25
Sortare Algoritm de sortare "mergesort" pentru N
valori (multiplu al numarului de procesoare
P2d). Algoritmul secvential daca lungimea
secventei de intrare lt2 atunci return partitionea
za secventa de intrare in doua jumatati sorteaza
cele doua subsecvente utilizand acelasi
algoritm fuzioneaza cele doua subsecvente
sortate gt secventa de iesire Exemplu
Timpul necesar O(N log2N).   Solutia paralela
necesita doi algoritmi "compare-exchange" si
"parallel merge".
26
Compare-exchange fuzioneaza doua secvente
ordonate de lungime M, continute in taskurile A
si B. -ambele taskuri contin M valori si toate
elementele din A sunt elementele din
B -fiecare task trimite datele sale la celalalt
task -taskul A identifica M elemente cele mai
mici, iar restul le descarca (necesitand intre
M/2 pana la M comparatii) -taskul B identifica M
elemente cele mai mari. Exemplu M4.
27
Parallel Merge. Un algoritm parallel merge"
executa o operatie de fuzionare peste doua
secvente de lungime M2d, fiecare distribuita
peste 2d taskuri pentru a produce o secventa
singulara sortata de lungime M2d1 distribuita
peste 2d1 taskuri. Aceasta se obtine prin
utilizarea sablonului de comunicatie
hipercub. Exemplu algoritmul paralel merge-sort
in hipercuburi

Intr-un hipercub de dimensiune d fiecare task
executa d operatii de comparatie si interschimb.
Sagetile orientate de la taskul "high" catre
taskul "low" in fiecare interschimb.
28
Fiecare din cele 2d1 taskuri se implica in d1
pasi compara-interschimba, cate un pas cu fiecare
vecin. Fiecare nod executa algoritmul general,
aplicand la fiecare pas urmatorul operator  
if ( myid AND 2i gt 0 ) then state
compare_exchange_high(state,message) else
state compare_exchange_low(state,message)
endif   Operatorul logic AND este utilizat pentru
a determina daca taskul este "high" sau "low"
intr-un interschimb particular, iar myid si i
sunt ca in algoritmul general.
29
Mergesort. Algoritmul parallel mergesort"
(fiecare task)   procedure
parallel_mergesort(myid, d, data, newdata)
begin data sequential_mergesort(data)
for dim 1 to d data
parallel_merge(myid, dim, data) endfor
newdata data end   -fiecare task sorteaza
secventa sa locala utilizand mergesort
secvential -utilizand structura de comunicatie
hipercub fiecare dintre cele P2d taskuri
executa algoritmul mergesort paralel de d ori
pentru subcuburi de dimensiune 1..d -fuziunea
paralela numarul i ia doua secvente fiecare
distribuita peste 2i-1 taskuri si genereaza o
secventa sortata distribuita peste 2i
taskuri -dupa d astfel de fuziuni se obtine o
singura lista distribuita peste 2d taskuri.
30
Analiza performantei. Numarul total de operatii
comparatie-interschimb este Fiecare operatie
de comparatie-interschimb necesita un mesaj
continand N/P date gt timpul necesar de
comunicatie per procesor sunt cuprinse
sortarea initiala din procesor (implica
Nlog2(N/P) comparatii) si comparatiile executate
in timpul fazei de comunicatie (cel putin
Nd(d1)/2 comparatii) gt timpul total pentru
cele P procesoare
31
Algoritmul perfect echilibrat gt se presupune ca
timpii inactivi sunt neglijabili. Astfel
32
Programarea aplicatiilor paralele pe nCUBE-2
nCUBE-2 ( de la nCUBE Corporation) cu 8192 de
noduri (procesor RISC, 32 biti, 64 MB memorie)
conectate in retea hipercub. Primitivele de
transfer de mesaje in reteaua hipercub -gt C si
Fortran.   Transmisia (neblocanta) de
mesaje   int nwrite (char buffer, int dim,
int address, int type)   unde type tipul de
transfer de mesaje (sincron sau
asincron) buffer adresa de memorie (in
procesul care executa functia) de unde se
transmite mesajul dim lungimea
mesajului address adresa de destinatie a
mesajului (un nod, grup de noduri la "multicast",
toate nodurile la "broadcast").
33
Receptia (blocanta)   int nread (char buffer,
int dim, int source, int type)   Identificarea
nodului curent (in care se desfasoara executia
functiei)   void whoami (int node, int
res1, int res2, int cube) unde node pointer
la variabilele in care whoami depune numarul
(eticheta) nodului cube pointer la variabila
in care se depune dimensiunea subcubului alocat
programului curent res1, 2 nu se
utilizeaza.   Proiectarea algoritmului -se
partitioneaza programul intr-un numar de
procese -se distribuie aceste procese nodurilor
sistemului.
34
Exemplu calculul aproximatiei numarului
p.   /functia de transfer de mesaje in
hipercub/ void fan_in (float value, int node,
int d) int dest, i, source, type float
temp typeFANIN for (id-1 igt0 i--) if
(nodelt(1ltlti)) //00..00XX..X 0 in pozitia
i sourcenode(1ltlti) nread (temp,
sizeof(float), source, type) valuetemp
else if (nodelt(1ltlt(i1)))
//00..01XX..X destnode(1ltlti) nwrite(val
ue,sizeof(float),dest, type)
35
/functia principala a programului/ void main
(int argc, char argv) define n 1024 int
i int d /dimensiunea hipercubului/ int
p /numar de noduri/ int node /eticheta
nodului curent/ int s /numar de
subintervale/procesor/ float x /mijloc
dreptunghi pe axa x/ float w1/n /latimea
intervalului/ int res1, res2 float
sum whoami (node, res1, res2,
d) p1ltltd /2 la puterea d/ sn/p /se
presupune n divizibil cu p/ sum0.0 x((nodes
)0.5)w for (inodes ilt(node1)s i)
sum4/(1xx) xw fan_in (sum,
node, d) if (node0) /rezultat nodul
0/ printf ("Aproximatia numarului pi este
f\n", sum)
36
Etape -fiecare nod calculeaza un rezultat
partial pentru n/p subintervale (n numar total
de subintervale, p numar de procesoare) -etapa
de comunicatie pentru calcularea sumei
finale.   Fiecare nod -executa functia main
(fiecare nod are o copie) -gt calcule
locale -apeleaza functia de transfer de mesaje
fan_in. p procesoare gt subcub d-dimensional
(apel functie whoami p 2d). Rezultatul final
(suma rezultatelor partiale in p noduri) gt nodul
0 (00...0).
37
Comunicatia in hipercub
38
Performante. Fiecare procesor executa n/p pasi
pentru rezultatul partial, iar comunicatia
necesita log2p pasi -timpul de
executie   -accelerarea     -eficien
ta  
39
BIBLIOTECA MPI
-biblioteca de functii C sau subrutine Fortran
gt comunicatia intre procese Avantaje -porta
bilitatea codului sursa -implementari
eficiente pe o varietate de platforme (inclusiv
Unix si Windows NT/XP) -functionalitate
(tipuri diferite de comunicatie, tipuri de date
definite de utilizator, topologii definite de
utilizator) Dezavantaje -mecanismul de
lansare a unei aplicatii MPI dependent de
platforma -nu permite gestiunea dinamica a
proceselor (modificarea numarului de procese in
timpul rularii).
40
Forma generala a unui program MPI   include
fisiere header MPI declaratii
variabile initializarea mediului
MPI executa operatii si transfer de
mesaje incheie mediu MPI   gt functiile MPI
rezultat intreg cod succes / insucces daca
cod ? MPI_SUCCESS gt eroare!
41
Comunicatori -transferul de mesaje intre
procese in cadrul unor comunicatori. -comunicator
initial predefinit MPI_COMM_WORLD (cuprinde
toate procesele)
-se pot defini noi comunicatori -in cadrul
unui comunicator fiecare proces are un
identificator (rank) -un proces poate sa
apartina la mai multi comunicatori in acelasi
timp, cu identificatori diferiti.
42
Functii pentru gestiunea mediului
MPI    MPI_Init (argc,argv)   initializeaza
mediul MPI, unde parametrii functiei reprezinta
argumentele liniei de comanda.   MPI_Comm_size
(comm,size)   furnizeaza pentru comunicatorul
comm numarul de procese componente
size.   MPI_Comm_rank (comm,rank)
furnizeaza identificatorul procesului care a
apelat-o (rank) in cadrul comunicatorului
(comm).   MPI_Finalize () incheie mediul de
executie MPI.
43
Exemplu utilizarea unor functii de gestiune a
mediului MPI.
include "mpi.h" include ltstdio.hgt int
main(int argc,char argv) int numtasks,
rank, rc rc MPI_Init(argc,argv) if
(rc ! MPI_SUCCESS) printf ("Error
starting MPI program. Terminating.\n")
MPI_Abort(MPI_COMM_WORLD, rc)
MPI_Comm_size(MPI_COMM_WORLD,numtasks)
MPI_Comm_rank(MPI_COMM_WORLD,rank) printf
("Number of tasks d My rank d\n",
numtasks,rank) / do some work
/ MPI_Finalize() return 0
44
Comunicatii punct-la-punct   gt comunicatie
punct-la-punct un proces transmite (executa
send) si al doilea receptioneaza (executa
receive).
45
Functiile utilizate pentru transmisie sunt
Functiile utilizate pentru receptie sunt
46
Pentru comunicatia blocanta standard se
utilizeaza la transmisie   MPI_Send
(buf,count,datatype,dest,tag,comm)   care,
transmite din zona buf, count date de tipul
datatype la procesul destinatie dest, din cadrul
comunicatorului comm, mesajul avand
identificatorul tag. Pentru receptie MPI_Recv
(buf,count,datatype,source,tag,comm,status)   d
atele fiind recptionate in zona buf la procesul
care a apelat functia, in lungime count de tipul
datatype, de la procesul sursa source din cadrul
comunicatorului comm, mesajul avand
identificatorul tag. Informatii de stare pentru
mesajul receptionat sunt depuse la status.
47
Exemplu utilizarea functiilor de transmisie /
receptie blocante.
include "mpi.h" include ltstdio.hgt int main(int
argc,char argv) int numtasks, rank, dest,
source, rc, count, tag1 char inmsg,
outmsg'x' MPI_Status Stat MPI_Init(argc,argv
) MPI_Comm_size(MPI_COMM_WORLD,
numtasks) MPI_Comm_rank(MPI_COMM_WORLD, rank)
48
if (rank 0) dest 1 source 1 rc
MPI_Send(outmsg, 1, MPI_CHAR, dest, tag,
MPI_COMM_WORLD) rc MPI_Recv(inmsg, 1,
MPI_CHAR, source, tag, MPI_COMM_WORLD, Stat)
else if (rank 1) dest 0 source
0 rc MPI_Recv(inmsg, 1, MPI_CHAR, source,
tag, MPI_COMM_WORLD, Stat) rc
MPI_Send(outmsg, 1, MPI_CHAR, dest, tag,
MPI_COMM_WORLD) rc MPI_Get_count(Stat,
MPI_CHAR, count) printf("Task d Received d
char(s) from task d with tag d \n",
rank, count, Stat.MPI_SOURCE, Stat.MPI_TAG) MPI
_Finalize() return 0
49
Transmisia si receptia neblocante -faza de
initiere a operatiei -faza de asteptare pentru
terminarea operatiei. Initierea
transmisiei   MPI_Isend (buf,count,datatype,de
st,tag,comm,request)   Initierea
receptiei   MPI_Irecv (buf,count,datatype,sour
ce,tag,comm,request)   (parametrii asemanatori
cu functiile blocante).
50
Pentru incheierea unei operatii de transmisie sau
receptie fara blocare   MPI_Wait
(request,status)  functie blocanta
si   MPI_Test (request,flag,status)  functie
neblocanta pentru o singura cerere transmisie /
receptie   MPI_Waitall (count,array_of_requests
,array_of_statuses)functie blocanta
si MPI_Testall (count,array_of_requests,flag,
array_of_statuses)functie neblocanta pentru
mai multe cereri.
51
Exemplu comunicatie punct-la-punct neblocanta.
include "mpi.h" include ltstdio.hgt int main(int
argc,char argv) int numtasks, rank, next,
prev, buf2, tag11, tag22 MPI_Request
reqs4 MPI_Status stats4 MPI_Init(argc,arg
v) MPI_Comm_size(MPI_COMM_WORLD,
numtasks) MPI_Comm_rank(MPI_COMM_WORLD, rank)
52
prev rank-1 next rank1 if (rank 0)
prev numtasks - 1 if (rank (numtasks - 1))
next 0 MPI_Irecv(buf0, 1, MPI_INT, prev,
tag1, MPI_COMM_WORLD, reqs0) MPI_Irecv(buf1
, 1, MPI_INT, next, tag2, MPI_COMM_WORLD,
reqs1) MPI_Isend(rank, 1, MPI_INT, prev,
tag2, MPI_COMM_WORLD, reqs2) MPI_Isend(rank,
1, MPI_INT, next, tag1, MPI_COMM_WORLD,
reqs3) executa secventa de
operatii MPI_Waitall(4, reqs,
stats) MPI_Finalize() return 0
53
Comunicatii colective       -un numar mai mare
de procese comunica intre ele in diferite
moduri -avantaje in raport cu operatiile
punct-la-punct -reducerea posibilitatii de
eroare -reducerea numarului de linii de
program -sursa este mai lizibila pentru
depanare si modificare -viteza de executie
creste.
54
Broadcast un singur proces trimite cate o copie
a unei date la toate celelalte procese dintr-un
grup.
MPI_Bcast (buffer,count,datatype,root,comm)   P
rocesul root trimite blocul de date din buffer de
lungime count si tip datatype la toate procesele
din cadrul comunicatorului, fiecare proces
plasand datele in memoria sa in zona buffer.
55
Scatter un bloc de date (un tablou de un anumit
tip) de la un proces este impartit in bucati si
distribuit uniform la diferite procese.
MPI_Scatter (sendbuf,sendcnt,sendtype,recvbuf,

recvcnt,recvtype,root,comm)   Procesul root
trimite din zona sendbuf de lungime sendcnt si
tip sendtype la fiecare proces al comunicatorului
comm cate un set de date depus in zona recvbuf,
de lungime recvcnt si tip recvtype.
56
Gather colecteaza blocuri de date de la un grup
de procese si le reasambleaza in ordinea corecta
la un singur proces.
MPI_Gather (sendbuf,sendcnt,sendtype,recvbuf,
...... recvcount,recvtype,
root,comm)   Procesul root receptioneaza in
recvbuf de lungime recvcount si tip recvtype cate
un bloc de date de la fiecare proces al
comunicatorului comm din zona sendbuf lungime
sendcnt si tip sendtype.
57
Reducere un singur proces (procesul radacina)
colecteaza datele de la celelalte procese
dintr-un grup si le combina pe baza unei operatii
intr-o singura data.
MPI_Reduce (sendbuf,recvbuf,count,datatype,op,ro
ot,comm)   Datele de la toate procesele
comunicatorului comm din zona sendbuf lungime
count si tip datatype sunt prelucrate cu operatia
de reducere op si rezultatul inscris la procesul
root in zona recvbuf.
58
Operatia poate sa fie
59
Sincronizare prelucrarile pot continua numai
daca toate procesele au ajuns intr-un anumit
punct al prelucrarilor.   MPI_Barrier
(comm)   Blocheaza procesele comunicatorului comm
pe masura ce functia este apelata de catre
acestea pana cand toate procesele comunicatorului
au apelat aceasta functie. La revenirea din
functie toate procesele sunt sincronizate.
60
Exemplu operatie scatter pentru liniile unei
matrici.
include "mpi.h" include ltstdio.hgt define SIZE
4 int main(int argc,char argv) int
numtasks, rank, sendcount, recvcount,
source float sendbufSIZESIZE 1.0,
2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0,
10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0
float recvbufSIZE
61
MPI_Init(argc,argv) MPI_Comm_rank(MPI_COMM_WORL
D, rank) MPI_Comm_size(MPI_COMM_WORLD,
numtasks) if (numtasks SIZE) source
1 sendcount SIZE recvcount SIZE
MPI_Scatter(sendbuf,sendcount,MPI_FLOAT,recvbuf,re
cvcount, MPI_FLOAT,source,MPI_COMM_WO
RLD) printf("rank d Results f f f
f\n",rank,recvbuf0,
recvbuf1,recvbuf2,recvbuf3) else
printf("Must specify d processors.
Terminating.\n",SIZE) MPI_Finalize() return
0
62
Biblioteca PVM
-functii portabile de nivel inalt pentru C si
Fortran -gt comunicatia in cadrul unui grup de
procese -compozitia grupului de procese este
dinamica gt cost suplimentar destul de
ridicat -un multicalculator (o retea de
calculatoare) -gt calculator virtual paralel, prin
transfer de mesaje -permite controlul
proceselor, transmiterea si receptia mesajelor,
sincronizarea intre procese.   Masina virtuala
paralela PVM -procesele server PVM (demonii
PVM) -biblioteca de functii PVM.
63
Initializarea masinii virtuale PVM prin lansarea
procesului server master cu functia   pvm_start_
pvmd   urmata de apelul functiei de setare a
optiunilor de comunicatie   pvm_setopt   Pe
procesorul server master hostfile (numele
statiilor, caile de fisiere executabile, caile
pentru procesele server (demonii) din fiecare
statie, contul utilizatorului, parola
etc.).   Adaugare statii noi   pvm_addhosts   Ex
cludere statii   pvm_delhosts  
64
Oprirea masinii virtuale   pvm_halt   Atasarea
la masina virtuala PVM   pvm_mytid
gt identificator de task (tid), numar intreg pe
32 de biti.   Crearea dinamica de
procese   pvm_spawn   Exemplu   numtpvm_spawn
("my_task", NULL, PvmTaskDefault, 0, n_task,
tids)   creaza n_task procese care executa
programul "my_task". Rezultatul functiei este
numarul efectiv de procese create (numt).
Identificatorul fiecarui task creat este depus
intr-un element al vectorului tids.   Un proces
poate parasi configuratia masinii
PVM   pvm_exit   sau poate fi terminat de alt
proces   pvm_halt (tid)
65
Exemplu program "Hello World!"
main() int cc, tid, msgtag char
buf100 printf("i'm tx\n", pvm_mytid())
cc pvm_spawn("hello_other", (char)0, 0, "",
1, tid) if (cc 1) msgtag 1
pvm_recv(tid, msgtag) pvm_upkstr(buf)
printf("from tx s\n", tid, buf)
else printf("can't start hello_other\n")
pvm_exit()
66
Modele de programare ale interfetei PVM   -SPMD
(Single Program Multiple Data) n instante ale
aceluiasi program sunt lansate ca n taskuri ale
unei aplicatii paralele, folosind comanda spawn
de la consola PVM sau manual in cele n statii
simultan. Initializarea mediului de programare
specificarea statiilor pe care se executa cele n
taskuri (nu se apeleaza pvm_spawn).   -MPMD
(Multiple Program Multiple Data) unul sau mai
multe taskuri sunt lansate in diferite statii si
acestea creaza dinamic alte taskuri.
67
Comunicatia punct-la-punct   Mesaj proces A -gt
proces B gt procesul A initializeaza bufferul de
transmisie   int pvm_initsend (int
encode)   (encode stabileste tipul de codare a
datelor in buffer) gt identificator al bufferului
de transmisie in care se depun datele impachetate
cu   pvm_pack   Transmiterea mesajului   int
pvm_send (int tid, int msgtag)   (functie
blocanta) tid identificatorul mesajului de
receptie, msgtag tipul mesajului (specifica
prelucrari la receptie) gt valoarea 0 pentru
transmisie corecta si 1 la eroare.
68
Receptia   int pvm_recv (int tid, int
msgtag)   (functie blocanta) tid
identificatorul procesului sursa. Receptia si
pentru orice transmitator (tid -1) si orice tip
de mesaj (msgtag -1). gt identificatorul
bufferului de receptie (bufid), de unde datele
sunt extrase cu   pvm_unpack   Receptia
neblocanta   pvm_nrecv
69
Comunicatia colectiva Atasarea unui proces la
un grup (daca grupul nu exista, el este
creat)   int pvm_joingroup (char
group_name)   gt 0 pentru procesul care creaza
grupul si valoarea cea mai mica disponibila in
grup pentru fiecare proces urmator (un proces
poate sa apartina la unul sau mai multe
grupuri).   Parasirea unui grup de catre un
proces int pvm_lvgroup (char group_name)   Ob
tinerea de informatii despre grup pvm_getinst
gt identificatorul instantei procesului in
grup   pvm_getid gt identificatorul
procesului   pvm_gsize gt dimensiunea
grupului.  
70
Comunicatiile colective (intre procesele membre
ale unui grup)   int pvm_bcast (char
group_name, int msgtag)   difuzeaza asincron
mesajul cu flagul msgtag din bufferul de
transmisie al procesului apelant catre toate
procesele membre ale grupului group_name
(procesul apelant poate sa fie sau nu membru al
grupului).   int pvm_gather (void g_arrray,
void myarray, int dim, int type, int msgtag,
char group_name, int root)   colecteaza
mesajele cu flagul msgtag, de la toate procesele
grupului, in procesul radacina (definit de
utilizator) root, colectarea facandu-se in
vectorul g_array, de dimensiune dim si tip type.
Fiecare proces trebuie sa apeleze pvm_gather.
71
int pvm_scatter (void myarray, void s_arrray,
int dim, int type, int msgtag, char group_name,
int root)   distribuie uniform tuturor
proceselor din grup un vector de date de tipul
type, cu numele s_array si de dimensiune dim,
aflat in spatiul de adresa al procesului radacina
root. Fiecare proces apeleaza pvm_scatter.
Receptia se face in vectorul my_array.   int
pvm_reduce (int operation, void myvals, int dim,
int type, int msgtag, char group_name, int
root)   efectueaza operatia de reducere paralela
intre toate procesele membre ale unui grup.
Argumentul operation defineste operatorul de
reducere (PvmMin, PvmMax, PvmSum, PvmProduct).
Fiecare proces efectueaza operatia de reducere a
datelor din vectorul local de date myvals, de
tipul type, de dimensiune dim, iar valoarea
rezultata este transferata procesului radacina
root, care obtine valoarea de reducere
finala.   int pvm_barrier (char group_name,
int ntasks)   sincronizeaza procesele membre ale
unui grup (procesul este blocat pana cand un
numar ntasks procese din grupul group_name au
apelat aceasta functie).
72
Exemplu operatia de reducere paralela in masina
virtuala PVM.
include ........ include "pvm3.h" define
NTASKS 4 int main () int mytid,
tidsNTASKS-1, groupid, sum, info /crearea
grupului de comunicatie/ mytidpvm_mytid() gro
upidpvm_joingroup("summax") sumgroupid /pri
mul proces creaza celelalte NTASK-1 procese/ if
(groupid0) infopvm_spawn("summax",NULL,PvmT
askDefault," ", NTASKS-1, tids) printf("GroupId
d spawned d tasks\n", groupid, info)
73
/bariera prin inghetare pana ce NTASKS procese
s-au alaturat grupului/ pvm_freezgroup("summax",
NTASKS) /calculul sumei in grup/ pvm_reduce
(PvmSum, sum, 1, PVM_INT, 1, "summax",
0) /procesul 0 tipareste rezultatul/ if
(groupid0) printf("sumd\n",
sum) /sincronizare pentru ca toate
procesele sa execute operatia inainte de
parasirea grupului/ pvm_barrier ("summex",
NTASKS) pvm_lvgroup ("summax") pvm_exit() re
turn 0