1 / 72

Capitolul 5 Exemple de algoritmi paraleli. Proiectare si analiza.

Capitolul 5 Exemple de algoritmi paraleli. Proiectare si analiza. Prelucrare de matrici/masive regulate de date. Caracteristici: structuri masive regulate de date (tip matrice) => descompunere de date Scop: algoritm paralel eficient, cost-optimal, scalabil

urvi
Download Presentation

Capitolul 5 Exemple de algoritmi paraleli. Proiectare si analiza.

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Capitolul 5 Exemple de algoritmi paraleli.Proiectare si analiza.

  2. Prelucrare de matrici/masive regulate de date • Caracteristici: structuri masive regulate de date (tip matrice) => descompunere de date • Scop: algoritm paralel eficient, cost-optimal, scalabil • Puncte de variabilitate a solutiei: • Descompunere • 1D • 2D • 3D • Granularitate: • P=n • P<n; • Distributie: pe blocuri, ciclica • Exemple: • Inmultirea matrice-vector • Sistem de n ecuatii liniare • Modelarea bazata pe diferente finite

  3. Reminder: performantele operatiilor pentru comunicatii colective

  4. Exemplul 1 Inmultire matrice*vector

  5. Inmultirea matrice-vector Timpul de executie secvential Ts=W=n*n

  6. Inmultirea matrice-vector: paralelizare prin descompunere de date 1D pe linii • Se presupune ca dimensiunea matricii este n*n si se utilizeaza p<n procese • Fiecare proces Pi detine n/p linii ale matricii A si n/p elemente ale vectorului x si calculeaza n/p elemente ale rezultatului y[i]=sumj=0,n-1(A[i,j]*x[j]), n/p valori ale lui i • Fiecare proces Pi are nevoie de toate elementele vectorului x => acestea sunt distribuite printr-o operatie de tip all-to-all broadcast intre p procese, cu mesaje de lungime n/p

  7. Evaluarea performantelor – cazul 1D cu p<n procese • Difuzarea vectorului x prin operatia all-to-all broadcast: • Tbroadc= ts* log(p) + tw*m*(p-1), m=n/p • Tbroadc≈ ts* log(p) + tw* n • Fiecare proces Pi: n*n/p calcule • Timpul de executie paralel: • Tp=Tbroadc+Tpi=n*n/p + ts* log(p) + tw* n • Cost=Tp*p= n*n + ts* p*log(p) + tw* n*p • Alg cost-optimal (Cost=O(Ts)): daca p=O(n) • Eficienta E=S/p=Ts/(p*Tp) • E=n*n/(n*n+ts* p*log(p) + tw* n*p)

  8. Evaluarea performantelor – cazul 1D cu p<n procese • Analiza scalabilitatii: calculul functiei de izoeficienta • To=Cost-W= ts* p*log(p) + tw* n*p • W(p)=K*To(W,p) • W=K*(ts* p*log(p) + tw* n*p) • W=n*n • Rezulta ecuatie de grd 2 in n: n*n-b*n-c=0 • => n functie de p (n=O(b)) => n*n functie de p • W=O(p*p)

  9. Inmultirea matrice-vector: paralelizare prin descompunere de date 2D • p<n*n procese, organizate sub forma de masiv bidimensional • Fiecare proces detine un bloc de dimensiune n/sqrt(p)*n/sqrt(p) • Elementele vectorului x sunt initial distribuite in blocuri de dimensiune n/sqrt(p) intre procesele din ultima coloana • Fiecare bloc j trebuie sa fie difuzat tuturor proceselor de pe coloana j (sqrt(p) operatii simultane de one-to-all broadcast pe fiecare coloana, de n/sqrt(p) valori per mesaj) • Dupa efectuarea inmultirilor, rezultatele acestora trebuie adunate pe linii (all-to-one reduction)

  10. Evaluarea performantelor – cazul 2D cu p<n*n procese • Comunicare: • One-to-one communication (alinierea pe diagonala a lui x): ts+tw*n/sqrt(p) • One-to-all broadcast (difuzarea fiecarui x[j] pe coloana j): (ts+tw*n/sqrt(p))*log(sqrt(p)) • All-to-one reduction (insumarea pe linii): (ts+tw*n/sqrt(p))*log(sqrt(p)) • Calcule: n*n/p • Tp≈n*n/p+ts*log(p)+tw*n/sqrt(p)*log(p)

  11. Evaluarea performantelor – cazul 2D cu p<n*n procese • Analiza scalabilitatii: calculul functiei de izoeficienta • To=Cost-W=p*Tp-W= ts*p*log(p)+tw*n*sqrt(p)*log(p) • W(p)=K*To(W,p) • W=K*(ts*p*log(p)+tw*n*sqrt(p)*log(p)) • W=n*n • Rezulta o ecuatie de grd 2 in n => n => W=n*n • W=O(p*log(p)*log(p))

  12. Comparatia solutiilor: partitionare 1D vs. 2D • Timpul paralel de executie: • Solutia 1D: Tp=n*n/p + ts* log(p) + tw* n • Solutia 2D: Tp≈n*n/p+ts*log(p)+tw*n/sqrt(p)*log(p) • La utilizarea aceluiasi numar p de procese, solutia 2D este mai rapida • Solutia 1D poate utiliza maxim n procese • Solutia 2D poate utiliza maxim n*n procese • Scalabilitate: • Solutia 1D: W=O(p*p) • Solutia 2D: W=O(p*log(p)*log(p)) • Solutia 2D este mai scalabila

  13. Exemplul 2 Inmultirea matrice*matrice

  14. Inmultire matrice*matrice • Matrici dense de dimensiune n x n : C =A x B. • Complexitatea seriala este O(n3). • Operatii matriceale pe blocuri: o matrice A de n*n elemente este echivalenta cu o matrice de q*q blocuri Ai,j (0 ≤i, j < q) unde fiecare bloc este o submatrice de dimensiune (n/q) x (n/q) • Se executa q3 inmultiri de matrici de dimensiune (n/q) x (n/q)

  15. Inmultire matrice*matrice: paralelizare prin descompunere de date 2D • Matricile A si B de dimensiune n*n se partitioneaza 2D in p blocuri Ai,j si Bi,j (0 ≤i, j < ) de dimensiune • Fiecare proces Pi,j detine initial Ai,j si Bi,j si calculeaza blocul Ci,j al matricii rezultat

  16. Inmultire matrice*matrice: paralelizare prin descompunere de date 2D • Pentru calculul submatricii Ci,j este nevoie de toate submatricile Ai,k si Bk,j pentru 0 ≤k < . • All-to-all broadcast blocuri din A pe linii si blocuri din B pe coloane. • Inmultirea submatricilor (blocurilor) se face local

  17. Evaluarea performantelor • Operatiile de broadcast pe linii si pe coloane: participa procesoare si se transmit n*n/p cuvinte: • Calculele pe care le realizeaza fiecare proces: inmultiri de matrici de dimensiune • Timpul paralel este aprox • Algoritmul este cost optimal pentru p=O(n*n) • Functia de izoeficienta W=O(p1.5) • Dezavantaj major al algoritmului: fiecare proces va memora la sfarsitul operatiilor de broadcast blocuri => se utiliz de ori mai multa memorie decat secv

  18. Inmultire matrice*matrice: algoritmul lui Cannon • Matricile A si B de dimensiune n*n se partitioneaza 2D in p blocuri Ai,j si Bi,j (0 ≤i, j < ) de dimensiune • Fiecare proces Pi,j detine initial Ai,j si Bi,j si calculeaza blocul Ci,j al matricii rezultat • Se urmareste ca fiecare proces sa nu detina in memoria locala mai mult de un bloc din A si un bloc din B la fiecare moment • Se schimba ordinea calculului termenilor, astfel incat pentru orice linie i, la un moment dat, toate procesele utilizeaza un bloc diferit Ai,k. • Blocurile Ai,k sunt rotite intre procesele de pe o linie, dupa fiecare inmultire de blocuri • Analog pentru blocurile Bkj pe coloane • Este nevoie de un pas de initializare, in care fiecare proces primeste perechea sa de start Ai,k si Bkj

  19. Inmultire matrice*matrice: algoritmul lui Cannon • Se aliniaza blocurile lui A si B astfel incat fiecare proces sa detina blocurile pe care le inmulteste. Alinierea se face shift-and pe linii toate blocurile Ai,j la stanga cu i pozitii si toate blocurile Bi,j pe coloane in sus cu j pozitii. • Executa inmultirea blocurilor in fiecare proces. • Fiecare bloc din A se shift-eaza cu o pozitie la stanga si fiecare blod din B se shift-eaza cu o pozitie in sus • In fiecare proces, executa inmultirea blocurilor curente si aduna la rezultatul partial. • Repeta pasii 3 si 4 pentru toate cele perechi de blocuri

  20. Evaluarea performantelor - Algoritmul lui Cannon • Pasul de aliniere initiala a blocurilor: • distanta maxima de shiftare este • Cantitatea de date transportata = un bloc • Timpul necesar pentru cele 2 shiftari: • Cei pasi de calcul: • Inmultirea blocurilor: • Shift-are. • Timpul de calcul paralel: • Din punct de vedere al costului si izoeficientei, algoritmul lui Cannon se comporta ca si varianta simpla anterioara • Algoritmul lui Cannon este optimal din punct de vedere al necesarului de memorie

  21. Inmultire matrice*matrice: algoritmul Dekel-Nassimi-Sahni DNS • Limitarile algoritmilor care utilizeaza partitionari 2D: • Se pot utiliza maximum n2 procese • Oricat s-ar imbunatati algoritmul paralel de inmultire, nu poate depasi performanta paralela de O(n), deoarece W=O(n3) • Algoritmul DNS: utilizeaza o partitionare 3-D bazata pe partitionarea datelor intermediare • Exista n3 inmultiri A[i,k]*B[k,j] => acestea vor fi efectuate in paralel de n3 procese Pi,j,k • Fiecare element C[i,j] al rezultatului se obtine insumand rezultatele partiale de la cele n procese Pi,j,k , 0<=k<n. Insumarea se poate face paralel in O(log n) => inmultirea matricilor in paralel poate fi facuta in principiu in O(log n)

  22. Inmultire matrice*matrice: algoritmul Dekel-Nassimi-Sahni DNS p=n3 procesoare • Procesoarele sunt organizate sub forma unui cub • Initial fiecare procesor din planul orizontal k=0 detine perechea de elemente Aij si Bij • Elementele trebuie replicate pe celelalte plane k, astfel : • orice Pijk sa detina Aik si Bkj • Valoarea Aik trebuie sa se gaseasca pe toata linia i din planul k • Valoarea Bkj trebuie sa se gaseasca pe toata coloana j din planul k • Aranjarea elementelor se obtine astfel: • Muta elementul Aij din planul k=0 Pi,j,0 in planul k=j Pi,j,j • Difuzeaza one-to-all broadcast elementul Aij pe toata linia i din planul sau • Analog pentru B

  23. Evaluarea performantelor – algoritmul DNS cu p=n3 procesoare • Fiecare procesor calculeaza o adunare. Aceasta este urmata de o insumare pe axa k – insumarea se poate face sub forma unei operatii de all-to-one reduction • Timpul paralel este dat de timpii de comunicare: • Mutarea coloanelor lui A si a liniilor lui B • One-to-all broadcast pe axa j pentru A si one-to-all broadcast pe axa i pentru B • All-to-one reduction pe axa k • Fiecare dintre aceste operatii este O(log n) • TP=O(log n) Nu este cost-optimal

  24. Inmultire matrice*matrice: algoritmul Dekel-Nassimi-Sahni DNS p=q3 <n3procesoare • Matricile sunt partitionate in blocuri de (n/q) x(n/q). • Algoritmul descris anterior se adapteaza astfel incat lucreaza cu blocuri in loc de elemente

  25. Evaluarea performantelor – algoritmul DNS cu p=q3<n3 procesoare • Mutarea liniilor si coloanelor in alte plane: one-to-one communication • Difuzarile in plane: one-to-all broadcasts • Insumarea prin all-to-one reduction . • Inmultirea a doua blocuri de dimensiune dureaza • Timpul paralel este aproximativ: • Algoritmul este cost-optimal pentru p=O(n3/(log n)3)

  26. Exemplul 3 Rezolvarea sistemelor de ecuatii liniare

  27. Rezolvarea unui sistem de n ecuatii cu n necunoscute • Etapele rezolvarii sistemului prin • metoda Gauss de eliminare: • Reducerea sistemului la o forma tridiagonala • Substitutia regresiva

  28. Reducerea sistemului la o forma tridiagonala

  29. Exemplu eliminare Gaussiana – etapa 1 Ec1 se imparte la 2 Din Ec2 se scade 1*Ec1 Din Ec3 se scade 3*Ec1 Din Ec4 se scade 1*Ec1

  30. Exemplu eliminare Gaussiana – etapa 2 Ec2 se imparte la 2 Din Ec3 se scade -Ec2 Din Ec4 se scade 0*Ec2

  31. Exemplu eliminare Gaussiana – etapa 3 Ec3 se imparte la -4 Din Ec4 se scade Ec3

  32. Exemplu substitutii regresive Pentru un sistem de ecuatii adus la forma tridiagonala:

  33. Paralelizare prin descompunere 1D pe linii • Matricea A este partitionata pe linii intre n procese: procesul Pi detine linia i a matricii pe care o transforma • La un moment dat toate procesele executa aceeasi iteratie k • Exista dependente de date intre instructiunile 12 (scadere) si 6 (impartire)

  34. Evaluarea performantelor - descompunere 1D pe linii • Intr-un pas k: • Calcule impartire (instructiunile 5-6): Procesul Pk: n-k-1 operatii aritmetice de impartire • Calcule scadere (instructiunile 11-12): procesele Pi, k<i<n: 2*(n-k-1) operatii aritmetice( de inmultire si scadere) • Comunicare: one-to-all broadcast Tcomm=(ts+(n-k-1)*tw)*log(n)

  35. Evaluarea performantelor (continuare) • Timpul total in toti pasii k: • Cost: • Timpul secvential:

  36. Descompunere 1D pe linii cu procesare pipeline • Solutia prezentata anterior: La un moment dat toate procesele executa aceeasi iteratie k => executia iteratiei k+1 incepe dupa terminarea tuturor actiunilor iteratiei k • Posibilitate de imbunatatire a performantei: executia iteratiei k+1 poate incepe inainte de terminarea completa a iteratiei k => algoritm pipeline • Reguli: • Daca un proces detine date cerute de alte procese, le transmite • Daca un proces are suficiente date pentru a executa o secventa de calcul, o executa

  37. Descompunere 1D pe linii cu procesare pipeline (cont.) • Operatiile one-to-all broadcast sunt inlocuite de comunicatii simple: Procesul Pk transmite procesului Pk+1 care transmite mai departe la Pk+2. In timp ce Pk+1 transmite mai departe, Pk poate deja incepe calculele.

  38. Exemplu – pipeline pentru matrice 5*5 • P0: Impartire0 • P0: transmite Linia0 • P1: transmite Linia0 • P1: Scadere0; P2: transmite Linia0

  39. Exemplu – pipeline pentru matrice 5*5 (cont.) • P1: Impartire1; P2: Scadere0; P3: transmite Linia 0 • P1: transmite Linia1; P3: Scadere0 • P2: transmite Linia1; P4: Scadere0 • P2: Scadere1; P3: transmite Linia1

  40. Exemplu – pipeline pentru matrice 5*5 (cont.) • P2: Impartire2; P3: Scadere1 • P2: transmite Linia2; P4: Scadere1 • P3: transmite Linia2; • P3: Scadere2

  41. Exemplu – pipeline pentru matrice 5*5 (cont.) • P3: impartire3; P4: Scadere2 • P3: transmite Linia 3 • P3: Scadere 3 • P4: impartire 4

  42. Evaluarea performantelor - Descompunere 1D pe linii cu procesare pipeline • Cazul p=n • Numarul total de pasi in pipeline: 4*(n-1) • Fiecare pas consta din una din operatiile: • Impartire O(n) • Scadere O(n) • Comunicare directa O(n) • Timpul total : Tp=O(n*n) • Cost: O(n*n*n) – varianta pipeline este cost-optimala

  43. Partitionare 1D, pipeline, distributie pe blocuri • Se utilizeaza p<n procese • Fiecare proces detine n/p linii succesive • Descompunere 1D, procesare pipeline • Se schimba raportul dintre timpul de comunicare si timpul de calcul: • Impartire: (n-k-1)*n/p operatii, O(n*n/p) • Scadere: 2*(n-k-1)*n/p operatii, O(n*n/p) • Comunicare directa: (n-k-1) cuvinte, O(n)

More Related