Macierzowe algorytmy równoległe

Transkrypt

1 Macierzowe algorytmy równoległe Zanim przedstawimy te algorytmy zapoznajmy się z metodami dekompozycji macierzy, możemy wyróżnić dwa sposoby dekompozycji macierzy: Dekompozycja paskowa - kolumnowa, wierszowa - blokowa, cykliczna, blokowo-cykliczna Dekompozycja szachownicowa (ang. checkerboard partitioning) - blokowa, cykliczna, blokowo-cykliczna 1 1

2 Dekompozycja paskowa P 0 P 1 P 2 P P 0 P P 0 P 1 P P P P a) Dekompozycja kolumnowa b) Dekompozycja wierszowa c) Dekompozycja kolumnowa cykliczna 2 2

3 Dekompozycja szachownicowa a 00 a 01 a 02 a 03 a 04 a 05 a 06 a 07 P 0 a 11 P 1 P 2 P 3 a 10 a 12 a 13 a 14 a 15 a 16 a 17 a 20 a 21 a 22 a 23 a 24 a 25 a 26 a 27 P 4 a 31 P 5 P 6 P 7 a 30 a 32 a 33 a 34 a 35 a 36 a 37 a 40 a 41 a 42 a 43 a 44 a 45 a 46 a 47 P 8 P 10 P 11 a 50 a 52 a 51 P 9 a 53 a 54 a 55 a 56 a 57 a 60 a 61 a 62 a 63 a 64 a 65 a 66 a 67 P 12 P 13 P 14 P 15 a 70 a 71 a 72 a 73 a 74 a 75 a 76 a 77 Blokowa dekompozycja szachownicowa 3 3

4 Mnożenie macierzy przez wektor W algorytmach mnożenia macierzy przez wektor możemy zastosować obie z wymienionych metod dekompozycji macierzy: Dekompozycje paskową - przydzielając jeden wiersz do każdego z procesorów - przydzielając więcej wierszy do każdego z procesorów Dekompozycja szachownicową - przydzielając jeden element do każdego z procesorów - przydzielając więcej elementów do każdego z procesorów 4 4

5 Mnożenie macierzy przez wektor 1. procedure MATRIX_VECTOR(A,x,y) 2. begin 3. for i:=0 to n-1 do 4. begin 5. y[i]:=0; 6. for j:=0 to n-1 do 7. y[i]:=y[i]+a[i,j] x[j]; 8. endfor; 9. end MATRIX_VECTOR Sekwencyjny algorytm mnożenia macierzy o rozmiarze n*n przez wektor X o rozmiarze n*1, w wyniku otrzymujemy wektor Y o rozmiarze n*1 5 5

6 Dekompozycja paskowa Macierz o rozmiarze n*n jest rozdzielona pomiędzy n procesorów, każdy z nich pamięta więc jeden cały wiersz i jeden z elementów wektora X o rozmiarze n 1. Wynika stąd, że każdy P i początkowo pamięta x[i] oraz A[i,0], A[i,1],..., A[i,n - 1] i jest odpowiedzialny za obliczenie y[i]. Kroki algorytmu; 1. Każdy z procesorów potrzebuje całego wektora X, wymagana jest więc przesłanie typu all-to-all aby rozesłać wszystkie składowe wektora do każdego z procesorów 2. Po pierwszym kroku procesor P i wylicza y[i] według następującej formuły n 1 j 0 y[ i] ( A[ i, j] x[ j]) 6 6

7 Mnożenie macierzy przez wektor dekompozycja paskowa P 0 x 0 P 0 x 0 P 1 x 1 P 1 x 1 P p-1 x p-1 P p-1 x p-1 Początkowe rozmieszczenie macierzy A oraz wektora X Realizacji przesłania typu all-to-all elementów wektora 7 7

8 Mnożenie macierzy przez wektor dekompozycja paskowa P 0 x 0 x 1 x p-1 P 0 y 0 P 1 x 0 x 1 x p-1 P 1 y 1 P p-1 x 0 x 1 x p-1 P p-1 y p-1 Rozmieszczenie wektora po realizacji przesłania typu all-to-all Końcowe rozmieszczenie macierzy oraz wektora wynikowego 8 8

9 Dekompozycja szachownicowa Macierz n n jest rozmieszczona w n 2 procesorach w taki sposób, że każdy z procesorów pamięta jeden element. Wektor n 1 vector x jest rozmieszczony w ostatniej kolumnie n procesorów, każdy z procesorów pamięta tylko jedną współrzędna wektora. Kroki algorytmu: 1. Prześlij składowe wektora X do procesorów leżących na głównej przekątnej macierzy 2. Skopiuj składowe wektora z procesora leżącego na głównej przekątnej do wszystkich pozostałych procesorów w każdej z kolumn 3. Wykonaj mnożenie we wszystkich procesorach elementu macierzy przez odpowiadającą mu składową wektora 4. Wykonaj operację single-node accumulation w każdym wierszu w taki sposób, że procesorem przeznaczenia jest procesor w ostatniej kolumnie 9 9

10 Mnożenie macierzy przez wektor dekompozycja szachownicowa P 0 P 1 P p P p 1 1 p-1 P p 1 p-1 Początkowe rozmieszczenie danych oraz oraz przesłanie składowych wektora do procesorów leżących na głównej przekątnej macierzy Przesłanie typu One-to-all w każdej z kolumn 10 10

11 Mnożenie macierzy przez wektor dekompozycja szachownicowa P 0 P 1 P p 1 0 P p 1 p-1 P p 1 Operacja single-node accumulation w wierszach Rozmieszczenie składowych wektora wynikowego 11 11

12 Mnożenie macierzy Zostaną przedstawione dwa algorytmy: Algorytm standardowy (prosty) Algorytm Cannona Założenia wstępne: A, B - n n macierze danych (kwadratowe) C = A B macierz wynikowa c ij n 1 k 0 a ik b kj dla 0 i, j n 12 12

13 Standardowy algorytm mnożenia macierzy rozmiaru n*n 1. procedure MATRIX_ MULTIPLICATION(A,B,C) 2. begin 3. for i := 0 to n - 1 do 4. for j := 0 to n - 1 do 5. begin 6. C[i,j] := 0; 7. for k := 0 to n - 1 do 8. C[i,j] := C[i,j] + A[i,k] B[k,j]; 9. endfor; 10. end MATRIX_MULTIPLICATION 13 13

14 Blokowy algorytm mnożenia macierzy rozmiaru n/q*n/q 1. procedure BLOCK_MATRIX_MULT(A,B,C) 2. begin 3. for i := 0 to q - 1 do 4. for j := 0 to q - 1 do 5. begin 6. Initialize all elements of C i,j to zero; 7. for k := 0 to q - 1 do 8. C i,j := C + A i,k B k,j ; 9. endfor; 10. end BLOCK_MATRIX_MULT 14 14

15 Rozmieszczenie macierzy A,B i C na procesorach A 0,0 A 0,1 A 0,2 A 0,3 B 0,0 B 0,1 B 0,2 B 0,3 A 1,0 A 1,1 A 1,2 A 1,3 B 1,0 B 1,1 B 1,2 B 1,3 A 2,0 A 2,1 A 2,2 A 2,3 B 2,0 B 2,1 B 2,2 B 2,3 A 3,0 A 3,1 A 3,2 A 3,3 B 3,0 B 3,1 B 3,2 B 3,3 Początkowe rozmieszczenie podmacierzy A i B C 0,0 C 0,1 C 0,2 C 0,3 C 1,0 C 1,1 C 1,2 C 1,3 C 2,0 C 2,1 C 2,2 C 2,3 C 3,0 C 3,1 C 3,2 C 3,3 Rozmieszczenie podmacierzy wynikowych C 15 15

16 Algorytm standardowy (prosty) 1. Wykonaj przesłanie typu all-to-all bloków macierzy A w każdym z wierszy. 2. Wykonaj przesłanie typu all-to-all bloków macierzy B w każdej kolumnie. 3. Wykonaj mnożenie podmacierzy, oraz ich dodawanie (instrukcje z 7 oraz 8 wiersza programu)

17 Algorytm standardowy (prosty) 16 procesorów A 0,0 A 0,1 A 0,2 A 0,3 B 0,0 B 0,1 B 0,2 B 0,3 A 1,0 A 1,1 A 1,2 A 1,3 B 1,0 B 1,1 B 1,2 B 1,3 A 2,0 A 2,1 A 2,2 A 2,3 B 2,0 B 2,1 B 2,2 B 2,3 A 3,0 A 3,1 A 3,2 A 3,3 B 3,0 B 3,1 B 3,2 B 3,

18 Algorytm standardowy (prosty) 16 procesorów A 0,0 3 A 0,0 3 A 0,0 3 A 0,0 3 B 0 3,0 B 0 3,1 B 0 3,2 B 0 3,3 C 1,0 = A 1,0 B 0,0 + A 1,1 B 1,0 + A 1,2 B 2,0 + A 1,0 3 A 1,0 3 A 1,0 3 A 1,0 3 B 0 3,0 B 0 3,1 B 0 3,2 B 0 3,3 A 1,3 B 3,0 A 2,0 3 A 2,0 3 A 2,0 3 A 2,0 3 B 0 3,0 B 0 3,1 B 0 3,2 B 0 3,3 A 3,0 3 A 3,0 3 A 3,0 3 A 3,0 3 B 0 3,0 B 0 3,1 B 0 3,2 B 0 3,

19 Algorytm Cannona Algorytm Cannona wykorzystuje podział szachownicowy dziedziny, czyli macierzy. Zarówno wejściowe macierze, jak i macierz wyjściowa podzielone są na podmacierze o takim samym rozmiarze i rozproszone pomiędzy procesory tworzące sieć połączeń typu krata (ang. mesh). Rozważmy dwie macierze A i B rozmiaru n*n które podzielone są na bloki A i,j i B i,j rozmiaru (n/ p)*(n/ p). Bloki są odwzorowane na sieć p* p procesorów etykietowanych od P 0,0 do P p-1, p-1. Początkowe rozmieszczenie podmacierzy przyporządkowuje bloki A i,j i B i,j do procesora P i,j

20 Algorytm Cannona Algorytm rozpoczyna się od przesunięcia cyklicznego realizowanego w każdym wierszu i kolumnie, przesyłającego wszystkie podmacierze A i,j w lewo oraz B i,j w górę o odpowiednio i oraz j kroków Następnie realizowane jest pierwsze mnożenie podmacierzy przez każdy z procesorów (blokowe mnożenie macierzy). Po wykonaniu mnożenia podmacierzy realizowany jest kolejny krok komunikacyjny w wierszach oraz kolumnach. Każdy blok A jest przesyłany o jeden procesor w lewo natomiast każdy blok B o jeden do góry, Następnie wykonywane jest mnożenie kolejnych podmacierzy oraz dodawanie wyników częściowych mnożenia podmacierzy. Po wykonaniu p mnożeń operacja mnożenia jest zakończona

21 Algorytm Cannona A 0,0 A 0,1 A 0,2 A 0,3 circular 0-shift B 0,0 B 0,1 B 0,2 B 0,3 A 1,0 A 1,1 A 1,2 A 1,3 circular 1-shift B 1,0 B 1,1 B 1,2 B 1,3 A 2,0 A 2,1 A 2,2 A 2,3 circular 2-shift B 2,0 B 2,1 B 2,2 B 2,3 A 3,0 A 3,1 A 3,2 A 3,3 circular 3-shift B 3,0 B 3,1 B 3,2 B 3,3 Pierwszy krok komunikacyjny 21 21

22 Algorytm Cannona A 0,0 A 0,1 A 0,2 A 0,3 Przed tym krokiem C 1,0 = A 1,1 B 1,0 B 0,0 B 1,1 B 2,2 B 3,3 A 1,1 A 1,2 A 1,3 A 1,0 B 1,0 B 2,1 B 3,2 B 0,3 A 2,2 A 2,3 A 2,0 A 2,1 B 2,0 B 3,1 B 0,2 B 1,3 A 3,3 A 3,0 A 3,1 A 3,2 B 3,0 B 0,1 B 1,2 B 2,

23 Algorytm Cannona A 0,1 A 0,2 A 0,3 A 0,0 Przed tym krokiem C 1,0 = C 1,0 + A 1,2 B 2,0 B 1,0 B 2,1 B 3,2 B 0,3 A 1,2 A 1,3 A 1,0 A 1,1 B 2,0 B 3,1 B 0,2 B 1,3 A 2,3 A 2,0 A 2,1 A 2,2 B 3,0 B 0,1 B 1,2 B 2,3 A 3,0 A 3,1 A 3,2 A 3,3 B 0,0 B 1,1 B 2,2 B 3,

24 Algorytm Cannona A 0,2 A 0,3 A 0,0 A 0,1 Przed tym krokiem C 1,0 = C 1,0 + A 1,3 B 3,0 B 2,0 B 3,1 B 0,2 B 1,3 A 1,3 A 1,0 A 1,1 A 1,2 B 3,0 B 0,1 B 1,2 B 2,3 A 2,0 A 2,1 A 2,2 A 2,3 B 0,0 B 1,1 B 2,2 B 3,3 A 3,1 A 3,2 A 3,3 A 3,0 B 1,0 B 2,1 B 3,2 B 0,

25 Algorytm Cannona A 0,3 A 0,0 A 0,1 A 0,2 B 3,0 B 0,1 B 1,2 B 2,3 Po ostatnim kroku C 0,0 C 0,1 C 0,2 C 0,3 A 1,0 A 1,1 A 1,2 A 1,3 C 1,0 = C 1,0 + A 1,0 B 0,0 B 0,0 B 1,1 B 2,2 B 3,3 C 1,0 C 1,1 C 1,2 C 1,3 A 2,1 A 2,2 A 2,3 A 2,0 B 1,0 B 2,1 B 3,2 B 0,3 A 3,2 A 3,3 A 3,0 A 3,1 C 2,0 C 2,1 C 2,2 C 2,3 C 3,0 C 3,1 C 3,2 C 3,3 B 2,0 B 3,1 B 0,2 B 1,3 Wynik 25 25

26 Algorytm Fox a mnożenia macierzy (1/4) A 0,0 after this communication step B 0,0 B 0,1 B 0,2 B 0,3 A 1,1 C 1,0 = A 1,1 B 1,0 B 1,0 B 1,1 B 1,2 B 1,3 A 2,2 B 2,0 B 2,1 B 2,2 B 2,3 A 3,3 B 3,0 B 3,1 B 3,2 B 3,

27 Algorytm Fox a mnożenia macierzy (2/4) A 0,1 after this communication step B 0,0 B 0,1 B 0,2 B 0,3 A 1,2 C 1,0 = C 1,0 + A 1,2 B 2,0 B 1,0 B 1,1 B 1,2 B 1,3 A 2,3 B 2,0 B 2,1 B 2,2 B 2,3 A 3,0 B 3,0 B 3,1 B 3,2 B 3,

28 Algorytm Fox a mnożenia macierzy (3/4) A 0,2 after this communication step B 1,0 B 1,1 B 1,2 B 1,3 A 1,3 C 1,0 = C 1,0 + A 1,3 B 3,0 B 2,0 B 2,1 B 2,2 B 2,3 A 2,0 B 3,0 B 3,1 B 3,2 B 3,3 A 3,1 B 0,0 B 0,1 B 0,2 B 0,

29 Algorytm Fox a mnożenia macierzy (4/4) A 0,3 after this communication step A 1,0 B 2,0 B 2,1 B 2,2 B 2,3 C 1,0 = C 1,0 + A 1,0 B 0,0 B 3,0 B 3,1 B 3,2 B 3,3 A 2,1 B 0,0 B 0,1 B 0,2 B 0,3 A 3,2 B 1,0 B 1,1 B 1,2 B 1,