Sunteți pe pagina 1din 10

Felicia Ionescu, Valentin Pupezescu Laborator de Calcul paralel

1
Lucrarea 6 ALGORITMI PARALELI DE REZOLVARE
A SISTEMELOR DE ECUAII LINEARE



n acest lucrare se vor studia i implementa n OpenMP i MPI algoritmii de rezolvare a
sistemelor de ecuaii lineare prin Eliminare Gaussiana (GE) i eliminare Gauss-Jordan (GJ).

Forma matriceal a unui sistem de n necuaii lineare: A*X = B, unde:
A: matricea coeficientilor, A[i, j] = a i,j unde 0 i, j < n
B: vectorul termenilor liberi, B = [b0, b1, ..., bn-1]
T
X vector solutii, X = [x0, x1, ..., xn-1]
T

0,0 0,1 0, 1 0 0
1,0 1,1 1, 1 1 1
1,0 1,1 1, 1 1 1
...
...
... ... ... ... ... ...
...
n
n
n n n n n n
a a a x b
a a a x b
a a a x b








6.1. Algoritmii secveniali GE i GJ

n algoritmii GE i GJ se construiete mai nti o matrice de lucru (A | B), prin augmentarea
matricei A cu matricea B; aceasta are n linii si n+1 coloane, unde: a
i,n
= b
i
, 0 i < n.
Folosind operatii elementare asupra liniilor matricelor:
n algoritmul GE matricea se reduce la o matrice triangular, dup care se calculeaz
soluiile prin substituie napoi (back substitution)
n algoritmul GJ matricea se reduce la o matrice diagonal, din care rezult soluiile

Algoritmul GE const din 2 etape:
Prima etap: reducerea matricei de lucru la forma matrice triangular superioar unitate, n care
toi coeficientii diagonalei principale sunt 1, iar coeficientii sub diagonala principal sunt 0, adic: a
i,i
=
1 i a
i,j
= 0, pentru j < i.

0,1 0, 1 0,
1, 1 1,
1,
1
0 1
0 0 1
n n
n n
n n
a a a
a a
a






A doua etap: calculul soluiilor prin substituie napoi, ncepnd cu xn-1:
x
n-1
= a
n-1,n
............................
x
i
= a
i,n
(a
i, i+1
*x
i+1
+ ... + a
i,n -2
*x
n-2
+ a
i,n-1
*x
n-1
)
.............................................................................
x
0
= a
0,n
(a
0,1
*x
1
..... +a
0, i
*x
i
.....+ a
0,n-2
*x
n-2
+ a
0,n-1
*x
n-1
)
Pentru calculul soluiei x
i
sunt necesare soluiile precedente x
n-1
,x
n-2
,.. x
i+1
Lucrarea 6 Algoritmi paraleli de rezolvare a sistemelor de ecuaii lineare
n etapa de reducere a matricei la forma triangular:
Se parcurg n iteraii (cu variabila k de control a buclei)
n fiecare iteraie k se selecteaz o linie pivot (linia cu elementul din coloana k maxim,
dintre liniile i, unde k i < n), se interschimb linia curent k cu linia pivot i se scaleaz
linia k (care este acum linie pivot)
Linia pivot din iteraia k este folosit pentru reducerea liniilor i (k < i < n), cu anularea
termenilor din coloana k, adic se face a[i][k] = 0.










































2
Felicia Ionescu, Valentin Pupezescu Laborator de Calcul paralel

// Algoritmul secvential GE
3

#include <stdio.h>
int main(int argc, char **argv) {
int n = 1024; // n se intr. ca param in linia de comanda
int i, j, k, r;
float max;
double sum;

// Citire parametru din linia de comanda
if (argc >= 2) n = atoi(argv[1]);

// Alocare date
float *x = (float*)malloc(sizeof(float)*n);
float *pivot = (float*)malloc(sizeof(float)*(n+1));
float **a = (float**)malloc(sizeof(float*)*n);
for (i = 0; i < n; i++)
a[i] = (float*)malloc(sizeof(float)*(n+1));

// Initializare matrice .....

// Prima etapa: reducerea matricei A|B
for (k = 0; k < n; k++){
// Selectia liniei pivot (linia r)
max = 0; // Valoarea elem. pivot maxim
for (i = k; i < n; i++)
if(abs(a[i][k]) > max){max = abs(a[i][k]); r = i; }
// Interschimb intre liniile r si k
for (j = k; j < n; j++) {
pivot[j] = a[r][j]; // Se fol. vector pivot[n+1]
a[r][j] = a[k][j]; a[k][j] = pivot[j];
}
// Scalarea liniei pivot k
for (j = k+1; j <= n; j++)
a[k][j] = a[k][j]/a[k][k];
a[k][k] = 1;
// Reducerea liniilor submatricei active
for (i = k+1; i < n; i++) {
// Reducerea liniei i
for(j = k+1; j <= n; j++)
a[i][j] -= a[i][k]*a[k][j];
a[i][k] = 0;
}
}
// A doua etapa calculul solutiilor prin substituie inapoi
// Insumarea termenilor ecuatiei i se face in variabila sum
for (i = n1; i >= 0; i--){
sum = 0; for (j = i+1; j < n; j++) sum += a[i][j]*x[j];
x[i] = a[i][n] sum;
}
return 0;
}


Lucrarea 6 Algoritmi paraleli de rezolvare a sistemelor de ecuaii lineare
Pivotarea parial se execut la nceputul fiecrei iteraii k i se poate face orientat pe linii
sau pe coloane. n pivotarea partial orientat pe linii se execut operaiile:
Selecia liniei pivot: se selecteaz linia r care are cea mai mare valoare absolut a
coeficientului pe coloana k din liniile k...n-1
Interschimb ntre liniile r i k: se interschimb ntre ele elementele din coloanele k....n
(restul sunt zero). Interschimbul dintre linia k si linia r (astfel nct linia r devine linie pivot
n poziia k) se poate face explicit (se interschimb ntre ele liniile r si k n matricea A | B)
sau se face o mapare ntre liniile din matrice i pozitionarea logic (dup interschimb). n
continuare presupunem interschimbul explicit.
Scalarea liniei k: se mpart la a
k,k
elementele liniei k din coloanele k....n (restul sunt 0). Apoi,
linia k este folosit ca linie pivot n iteraia k.
Se poate face i o pivotare partial pe coloane: n iteraia k se alege acea coloan j (k <= j < n)
care are coeficientul a
k,j
cu valoare absolut maxim n linia k, dup care se face interschimb ntre
aceast coloan i coloana k.
Pentru reducerea liniilor submatricei active se nlocuiete fiecare linie i de sub linia pivot (k < i
< n) cu rezultatul obinut prin scderea din aceasta a liniei pivot multiplicat cu a
i,k
, astfel nct
termenul k al ecuaiei i este eliminat (coeficientul a
i,k
devine zero). n fiecare iteraie k, elementele din
submatricea activ se nlocuiesc cu valorile nou calculate pe baza vechilor valori.
Ca un exemplu, la sfritul iteraiei k = 2 matricea de lucru A | B (cu n = 8) arat astfel:

1 a
01
a
02
a
03
a
04
a
05
a
06
a
07
a
08
0 1 a
12
a
13
a
14
a
15
a
16
a
17
a
18
0 0 1 a
23
a
24
a
25
a
26
a
27
a
28
0 0 0 a
33
a
34
a
35
a
36
a
37
a
38
0 0 0 a
43
a
44
a
45
a
46
a
47
a
48
0 0 0 a
53
a
54
a
55
a
56
a
57
a
58
0 0 0 a
63
a
64
a
65
a
66
a
67
a
68
0 0 0 a
73
a
74
a
75
a
76
a
77
a
78











Timpul total de execuie secvenial a algoritmului GE (T
SGE
) se obine [Grama, 2004]
( )
3
2 3
2
3 O
3 3
SGE
n n
T n = + + = n

Rezult c algoritmul GE are o complexitate polinomial (cubic) i c majoritatea operaiilor
au loc n etapa de reducere a liniilor submatricei active (termenul
3
2 3 n ), iar celelalte operaii sunt
neglijabile n comparaie cu aceasta, mai ales pentru n foarte mare.

Algoritmul Gauss-Jordan (GJ) este asemntor cu GE, dar matricea de lucru este redus la
form diagonal, din care soluiile rezult direct: x
i
= a
i, n


0,
1,
1,
1 0 0
0 1 0
0 0 1
n
n
n n
a
a
a










4
Felicia Ionescu, Valentin Pupezescu Laborator de Calcul paralel

// Algoritmul secvential GJ
#include <stdio.h>
int main(int argc, char **argv) {

// Datele, alocarile si initializarile la fel ca la GE ...
// Prima etapa: reducerea matricei de lucru
for (k = 0; k < n; k++){
// Pivotare la fel ca la GE ...
//
// Reducerea liniilor matricei de lucru
for (i = 0; i < n; i++)
if (i != k) {
for (j = k+1; j <= n; j++)
a[i][j] -= a[i][k]*a[k][j];
a[i][k] = 0;
}
}
// A doua etapa: calculul solutiilor
for (i = 0; i < n; i++)
x[i] = a[i][n];
return 0;
}

Ca un exemplu, la sfritul iteraiei k = 2 a execuiei algoritmului GJ, matricea de lucru A | B
(cu n = 8) arat astfel:

1 0 0 a
03
a
04
a
05
a
06
a
07
a
08
0 1 0 a
13
a
14
a
15
a
16
a
17
a
18
0 0 1 a
23
a
24
a
25
a
26
a
27
a
28
0 0 0 a
33
a
34
a
35
a
36
a
37
a
38
0 0 0 a
43
a
44
a
45
a
46
a
47
a
48
0 0 0 a
53
a
54
a
55
a
56
a
57
a
58
0 0 0 a
63
a
64
a
65
a
66
a
67
a
68
0 0 0 a
73
a
74
a
75
a
76
a
77
a
78











Timpul de execuie secvenial a algoritmului GJ (T
SGJ
) se calculeaz i se obine:
( )
3 2
4 3 O
SGJ
T n n n n = + + =
3

Algoritmii GE i GJ au aceeai complexitate asimptotic
( )
3
O n , dar numrul de operaii este
mai mare la algoritmul GJ fa de GE, pentru orice valoare a lui n.


6.2. Paralelizarea algoritmilor GE i GJ

Algoritmii GE i GJ parcurg dou etape de calcul: etapa de reducere a matricei de lucru i
etapa de calcul a soluiilor sistemului; ntre aceste etape exist dependene, deci se execut secvenial,
folosind o barier de sincronizare.

5
Lucrarea 6 Algoritmi paraleli de rezolvare a sistemelor de ecuaii lineare
Etapa de reducere a matricei de lucru const dintr-o bucl cu n iteraii (dup k) ntre care exist
dependente (modific succesiv matricea a), deci bucla este neparalelizabil i iteraiile trebuie s fie
executate secvenial.
n fiecare iteraie k, operaia de pivotare (selecie i scalare linie pivot) i reducere a liniilor
submatricei active prezint dependene ntre ele, deci se prevede cte o barier ntre aceste bucle.
Operaia de pivotare se execut la fel pentru ambii algoritmi: const n mai multe bucle
succesive, fiecare bucl poate fi paralelizat, dar ntre aceste bucle exist dependene i se prevd
bariere de sincronizare ntre bucle.
Reducerea liniilor submatricei active este o bucl paralelizabil, deoarece fiecare linie i se
calculeaz independent de celelalte; se execut la fel pentru cei doi algoritmi, difer doar limita
contorului buclei (i).

Paralelizarea operaiei de reducere a liniilor submatricei active. Reducerea liniilor
submatricei active se realizeaz n a doua bucl imbricat n bucla exterioar a primei etape a
algoritmului avnd contorul i. n iteraia i a acestei bucle (k < i < n pentru algoritmul GE, i != k
pentru algoritmul GJ) se opereaz asupra liniei i a matricei de lucru, folosind linia pivot k. Iteraiile
acestei bucle sunt independente i pot fi distribuite pentru a fi executate n paralel.
In algoritmul GE dimensiunea submatricei active este egal cu (n k 1) linii, deci variaz cu
valoarea k a iteraiei buclei exterioare, de la n 1 (pentru k = 0) pn la 0 (pentru k = n 1).
Dac se partiioneaz ntreaga matrice de lucru A | B n p partiii cu linii grupate continuu,
atunci unele partiii ar putea conine numai linii inactive, ceea ce produce o dezechilibrare a ncrcrii
procesoarelor. Pentru a avea partiii echilibrate se folosete partiionarea ciclic (ntreesut). n
partiionarea ciclic a ntregii matrice de lucru A | B, fiecrui task (procesor) i revin partiii echilibrate
de s = n / p linii ntreesute, dintre care o parte sunt active, iar alt parte inactive, n funcie de numrul
iteraiei k executate. O astfel de partiionare orientat pe linii distribuite ciclc (ntreesute) se folosete
pentru algoritmul GE n sistemele cu transfer de mesaje (MPI).
Dac se partiioneaz numai submatricea activ (cele n k 1 linii) n p partiii, atunci oricare
din partiionri (cu linii grupate continuu sau ntreesute) produce partiii echilibrate i se poate utiliza.
De exemplu, implementarea OpenMP a algoritmului paralel GE folosete partiionarea numai a
submatricei active (n k 1 linii) deci se poate folosi orice fel de partiionare (cu partiii continue sau
ntreesute).
n algoritmul GJ, n care numrul de linii ale submatricei active este constant (n 1) indiferent
de iteraia k, att partiionarea continu (cu linii succesive) a matricei de lucru A | B ct i partiionarea
ciclic (cu linii ntreesute) produc partiii echilibrate (cu numr aproximativ egal de linii), deci poate fi
folosit oricare dintre ele.
Etapa de calcul a soluiilor n GE se face prin substituie napoi: se distribuie iteraiile buclei de
calcul a fiecreia din cele n soluii. n GJ calculul soluiilor este realizat printr-o bucl cu iteraii
independente, care se pot distribui task-urilor paralele.
Paralelizarea algoritmilor GE i GJ se poate face n dou moduri:
Paralelizarea direct: se definete cte o regiune paralel n fiecare iteraie a buclelor
paralelizabile din cele dou etape; rezult un algoritm cu 2n regiuni paralele pentru GE i cu
n+1 regiuni paralele pentru GJ, care se poate implementa direct folsind biblioteca OpenMP.
Se poate transforma algoritmul cu 2n (respectiv n+1) regiuni paralele n algoritm cu o
regiune paralel n care fiecare thread (proces) execut succesiv partiia proprie din buclele
paralelizate i se sincronizeaz cu celelalte prin bariere de sincronizare (sau transfer sincron
de mesaje); aceast variant este folosit n MPI, i poate fi folosit i n OpenMP.
6
Felicia Ionescu, Valentin Pupezescu Laborator de Calcul paralel

6.3. Implementarea OpenMP a algoritmilor GE i GJ

Program OpenMP de Eliminare Gaussian cu 2n regiuni paralele. Se definete cte o
regiune paralel n fiecare iteraie a primei bucle a programului (reducerea matricei de lucru) i n
fiecare iteraie a celei de-a doua bucle (substituia napoi); rezult 2n regiuni paralele.
n prima etap, de reducere a matricei de lucru la forma triangular, se parcurg n iteraii; n
fiecare iteraie k se definete o regiune paralel n care se execut succesiv pivotarea i red. liniilor
submatr active, cu barier de sincr. ntre ele
Pentru pivotarea parial se execut urmtoarele operaii:
Selecia liniei pivot r (linia care conine elem. din coloana k cu valoare abs. maxim)
Este o operaie asemntoare reducerii paralele (cu operatorul max), dar nu se poate folosi
directiva reduction deoarece, pe lng selecia elementului cu valoare absolut maxim, mai este
necesar i indicele liniei care l conine
De aceea se face o operaie de selecie parial n fiecare partiie, urmat de selecia valorii
maxime globale folosind directiva critical.
Dup selecia liniei pivot, se execut succesiv (cu barier de sincronizare ntre ele) dou bucle
paralele (pentru interschimbul liniei pivot r cu linia curent k i pentru scalarea liniei pivot k) folosind
directive #pragma omp for.
Reducerea liniilor submatricei active este o bucl for care se paralelizeaz folosind directiva
#pragma omp for.
OpenMP execut o distribuire dinamic: la ntlnirea directivei #pragma omp for sunt
distribuite echilibrat cele (n-k) iteraii ale buclei ntre p thread-uri ale regiunii paralele.
n a doua etap, de calcul soluii prin substituie napoi, se parcurg n iteraii; n fiecare iteraie i
se definete o regiune paralel n care se calculeaz soluia x[i].

// GE_OpenMP.c
#include <omp.h>
int main(int argc, char *argv[]) {
n = 1024, p = 1; // n si p se introduc ca param
int i, j, k, r, pr;
float max, pmax;
double sum;
// Citire parametri, alocare date, initializare matrice de lucru ...
if (p == 1) {
// Algoritmul secvential ...
}
else {
// Algoritmul paralel OpenMP

// Prima etapa: reducerea matricei A|B
for (k = 0; k < n; k++){
#pragma omp parallel num_threads(p)shared(a,x,pivot,r,max)\
private(i, j, pr, pmax)
{
#pragma omp single
max = 0; // Init elem. pivot global
// Selectia liniei pivot local (linia pr)
pmax = 0; pr = 0;
#pragma omp for
for (i = k; i < n; i++)
if (fabs(a[i][k]) > pmax){
7
Lucrarea 6 Algoritmi paraleli de rezolvare a sistemelor de ecuaii lineare
pmax = fabs(a[i][k]);
pr = i;
}
// Selectie linie pivot global (linia r)
#pragma omp critical
if (max < pmax) { max = pmax; r = pr;}
#pragma omp barrier
// Interschimb intre liniile r si k
#pragma omp for
for (j = k; j <= n; j++) {
pivot[j] = a[r][j]
a[r][j] = a[k][j];
a[k][j] = pivot[j];
}
//Scalarea liniei pivot k
#pragma omp for
for (j = k+1; j <= n; j++)
a[k][j] = a[k][j]/a[k][k];
#pragma omp single
a[k][k] = 1;
// Reducerea liniilor submatricei active
#pragma omp for
for (i = k+1; i < n; i++) {
for(j = k+1; j <= n; j++)
a[i][j] -= a[i][k]*a[k][j];
a[i][k] = 0;
}
} // end parallel
} // end etapa 1 - for (k)

// A doua etapa - calculul solutiilor prin substitutie inapoi
for (i = n-1; i >= 0; i--) {
sum = 0;
#pragma omp parallel for reduction(+:sum) num_threads(p)\
shared(a,x,i) private(j)
for (j = i+1; j < n; j++)
sum += a[i][j]*x[j];
x[i] = a[i][n] - sum;
} // end etapa 2 - for (i)

} // end algoritm paralel

// Memorare, afisare rezultate ...
return 0;
}
Program OpenMP de Eliminare Gauss-Jordan cu n + 1 regiuni paralele. Programul este
asemntor cu programul GE, cu dou diferente:
Instruciunile de reducere a submatricei active difer (sunt cele de la algoritmul secvenial),
dar bucla for se paralelizeaz la fel (cu #pragma omp for)
Etapa a doua este o bucl for paralelizabil, pentru care se creez o regiune paralel.


8
Felicia Ionescu, Valentin Pupezescu Laborator de Calcul paralel

Exerciiul E6.3.a. Folosind explicaiile i codul parial din lucrare, implementai
programele GE_OpenMP.c i GJ_OpenMP.c de rezolvare a sistemelor de ecuaii lineare. Fiecare
program va conine versiunea secvenial (care se execut pentru p = 1) i versiunea OpenMP (care se
execut pentru p = (2, 4, 8, 12, 16). Creai cte un fiier de execuie Exec_GE_OpenMP i
Exec_GJ_OpenMP, i executati programele cu parametrii n = (512, 1024, 2046, 4096, 8192).
Reprezentai grafic performanele obinute n execuie pe HPC, comparai i explicai diferenele.

Exerciiul E6.3.b. Transformai fiecare din algoritmii de mai sus n algoritm OpenMP cu o
singur regiune paralel. Executai aceste programe i comparai rezultatele cu cele ale programelor
iniiale.


6.4. Implementarea MPI a algoritmilor GE i GJ

n MPI de creaz o singur regiune paralel cu p procese; matricea de lucru (a[n][n+1]) se
partiioneaz static pe linii n p partiii.
Pentru echilibrarea ncrcrii procesoarelor partiionare trebuie s fie cu linii ntreesute. n
aceast situaie este mai eficient ca matricea de lucru, iniializat n procesul root, s fie transmis n
ntregime celorlalte procese (cu MPI_Bcast).
Chiar dac are memorat ntreaga matrice de lucru, fiecare proces q (0 q < p) are asignat o
partiie (cu acelai indice q ca i procesul) compus din s = n / p linii (n divizibil cu p) cu indici i, unde
i = m*p + q, iar 0 m < s i prelucreaz numai liniile acesteia.
Alocarea matricei a este diferit de alocarea din programul OpenMP. Pentru transfer de partiii
(sau chiar ntreaga matrice) trebuie ca liniile s fie adiacente i alocarea arat astfel:

float *x = (float*)malloc(sizeof(float)*n);
float *pivot = (float*)malloc(sizeof(float)*(n+1));
float **a = (float**)malloc(sizeof(float*)*n);
float *ma = (float*)malloc(sizeof(float)*n*(n+1));
for (i = 0; i < n; i++){
a[i] = ma; ma += n+1;
}
n plus, fiecare proces mai aloc un vector pivot [n+1] n care memoreaz linia pivot, care poate
s nu aparin partiiei proprii a matricei de lucru.
Pentru selecia liniei pivot, fiecare proces selecteaz o linie pivot local, i anume linia care
conine cea mai mare valoare absolut (pmax) a elementului pivot, din coloana k, linia pr, unde pr este
una din liniile i ale propriei partiii i k < i < n.
Apoi, pentru selecia elementului pivot maxim global se folosete funcia MPI_Allreduce cu
operatorul MPI_MAXLOC pentru tipul de date MPI_FLOAT_INT. Se definete o structur (struct) cu
dou atribute max i r de tipul float, respectiv int corespunztoare tipului MPI_FLOAT_INT i dou
variabile (red_in, red_out) de acest tip:
struct {
float max;
int r:
} red_in, red_out;
n prima structur (in) se memoreaz valorile locale ale fiecrui proces pmax i pr, iar dup
execuia funciei MPI_Allreduce, n structura out toate procesele primesc valoarea maxim a
elementului pivot (max) i poziia liniei acestuia (r).
9
Lucrarea 6 Algoritmi paraleli de rezolvare a sistemelor de ecuaii lineare
Partea de selecie a liniei pivot n iteraia k (att n GE ct i n GJ) este urmtoarea:

// Selectie locala, n fiecare partiie
pmax = 0; // maxim local
pr = 0; // index maxim local
for (m = 0; m < s; m++) {
i = m*p + rank; // partitionare ntretesut
if (i >= k)
if(fabs(a[i][k]) > pmax) {
pmax = fabs(a[i][k]);
pr = i;
}
}
red_in.max = pmax;
red_in.r = pr;
// Selectie globala
MPI_Allreduce(&red_in, &red_out, 1, MPI_FLOAT_INT, MPI_MAXLOC,
MPI_COMM_WORLD);
max = red_out.max; // maxim global
r = red_out.r; // index linie pivot global
Pentru interschimbul ntre liniile r i k : cele dou linii implicate n operaia de pivotare (linia k,
curent n iteraia k i linia r cu rol de pivot global) aparin proceselor (partiiilor): q
k
= plk = k % p,
respectiv q
r
= plr = r % p; exist dou situaii posibile:
Dac q
k
= q
r
(cele dou linii se afl n aceeai partiie), se face interschimb local ntre cele
dou linii numai n procesul de indice q = q
k
= q
r
, se scaleaz linia pivot i se transmite
(prin MPI_Bcast) tuturor celorlalte procese care o recepioneaz n vectorul pivot[n+1].
Dac q
k
q
r
, se face interschimbul liniilor k i r ntre procesele q
k
i q
r
, ; linia r devine linie
pivot, se scaleaz i se transfer (prin MPI_Bcast) tuturor celorlalte procese.
Dup stabilirea liniei pivot n iteraia k, fiecare proces execut local reducerea liniilor din
partiia proprie folosind linia pivot memorat n vectorul pivot[n].
Programul complet este dat n fiierul GE_MPI.c, iar scriptul executabil n fiierul
Exec_GE_MPI.
Exerciiul E6.4.a. Studiai implementarea MPI a algoritmului GE. Executati pe HPC pentru
aceleai valori ale lui n ca i programul GE_OpenMP, pentru p = (1, 2, 4, 8, 16, 32, 64). Reprezentai
graficele performanelor msurate.

Exerciiul 6.4.b. Modificai programul GE_MPI.c pentru a obine implementarea MPI a
algoritmului GJ. Executati pe HPC pentru aceleai valori ale lui n ca i programul GE_MPI, pentru
p = (1, 2, 4, 8, 16, 32, 64). Reprezentai graficele performanelor msurate i comparai cu ale
programului GE_MPI.

Bibliografie

Toate referinele de la celelalte lucrri i, n plus:
[Grama-2003] A. Grama,V. Kumar, A. Gupta, G. Karpis, Introduction to Parallel Computing,
Addison-Wesley, 2003
10