Programowanie Równoległe Rlucjan/PRiR/wyklad9.pdf · Operacje zmiennoprzecinkowe mogą być...

1

Programowanie Równoległe i RozproszoneWykład 9

Przygotował: Lucjan Stapp

1/95 PRiR Wykład 9

Programowanie Równoległei

Rozproszone

Lucjan StappWydział Matematyki i Nauk Informacyjnych

Politechnika Warszawska

([email protected])

2/95 PRiR Wykład 9

MNOŻENIE MACIERZYWykład ten jest oparty o materiały prof. Jamesa

Demmela, z University of California at Berkeley z 1996 roku,

http://www.cs.berkeley.edu/~demmel/

zwłaszcza prezentacja algorytmu Cannona.

3/95 PRiR Wykład 9

MNOŻENIE MACIERZYPokażemy, w jaki sposób zaimplementować mnożenie

macierzyC=C+A*B

dla kilku różnych rodzajów architektur (z pamięcią dzieloną lub na różnych rodzajach sieci).

Niech A,B i C będą gęstymi macierzami rzędu n × n.

(Macierz gęsta to taka, w której większość elementów jest niezerowa).

2



4/95 PRiR Wykład 9

MNOŻENIE MACIERZYWydajność zależy od kilku czynników.

Pamięć dzielona lub sieć:Dla sieci: sposób połączenia

Sieci z gęstszą siatką połączeń między węzłami, takie jak sieć o topologii hiperkostki czy też siatki (mesh), pozwalają na szybsze algorytmy od sieci pierścieniowych czy też połączonych szynami.

5/95 PRiR Wykład 9

MNOŻENIE MACIERZYAlgorytm. Użyjemy standardowego algorytmu wymagającego

2*n3 operacji arytmetycznych: dla każdego elementu Ci,j macierzy C musimy obliczyć

Tym samym optymalny czas obliczeń równoległych na p procesorach wynosić będzie2*n3/p jednostek (czasów operacji arytmetycznych).

Zaplanowanie tych operacji będzie najbardziej interesującą częścią projektowania algorytmu.

∑=

+=n

kjkkijiji BACC

1,,,,

*

6/95 PRiR Wykład 9

MNOŻENIE MACIERZY1. Rozkład danych, czyli jak A, B i C są zapamiętane

na procesorach. Dwa najbardziej podstawowe rozkłady to rozkłady blokowe jedno- i dwuwymiarowe (ang. 1D blocked layout i 2D blocked layout).

3



7/95 PRiR Wykład 9

MNOŻENIE MACIERZY1. Rozkład danych

Mnożenie macierzy C=A*B dla macierzy A,B i Cpodzielonych jednowymiarowo (rozkład blokowy jednowymiarowy).

Mnożenie macierzy C= A*B dla macierzy A, B i Cpodzielonych dwuwymiarowo (rozkład blokowy dwuwymiarowy).

8/95 PRiR Wykład 9

M M na maszynach z pamięcią wspólną

Pamięci komputerowe budowane są hierarchicznie, przy użyciu różnych rodzajów pamięci, począwszy od bardzo szybkich i drogich, ale małych pamięci na szczycie hierarchii, a kończąc na wolnych, tanich i bardzo dużych pamięciach na jej dole.

Na przykład: rejestry, zazwyczaj budowane jako najszybsza pamięć, potem pamięć podręczna, pamięć główna, dyski i na końcu taśmy, jako najwolniejsze, największe i najtańsze.

Operacje zmiennoprzecinkowe mogą być wykonywane tylko na samej górze hierarchii – w rejestrach.

9/95 PRiR Wykład 9


Skoro cała, duża macierz nie mieści się w rejestrach, musi być przesuwana w górę i w dół hierarchii:w górę do rejestrów, kiedy muszą być wykonane obliczenia, a potem z powrotem na dół do pamięci głównej (czy też dysku lub taśmy), kiedy już nie jest potrzebna. Poruszanie się między poziomami hierarchii zabiera czas i zabiera go tym więcej, im niżej w hierarchii się odbywa.

4



10/95 PRiR Wykład 9


Jedno takie przesunięcie danych trwa znacznie dłużej, niż wykonanie operacji zmienno-przecinkowej. Czynnikiem ograniczającym wiele algorytmów staje się więc NIE czas niezbędny do wykonania operacji zmiennoprzecinkowych, ale właśnie czas potrzebny do przesuwania danychw hierarchii pamięci.

Z tego powodu, „sprytny” algorytm będzie starał się zminimalizować liczbę tych przesunięć (nawet, jeżeli będzie to oznaczało wykonanie kilku dodatkowych operacji zmiennoprzecinkowych).



Niech q będzie stosunkiem liczby operacji zmiennoprzecinkowych (flops) do liczby odwołań do pamięci.

Znaczenie q polega na tym, że współczynnik ten mówi nam szacunkowo ile operacji (flopów) przypada na jedno odwołanie do pamięci, czyli jak dużo użytecznej pracy możemy wykonać w porównaniu do czasu przenoszenia danych. Algorytmy z większą wartością q są lepszą bazą do budowy rzeczywistych algorytmów.



Przyjrzyjmy się bardziej szczegółowo, jak zaimplementować mnożenie macierzy minimalizując liczbę przemieszczania danych w pamięci.

Załóżmy, że mamy tylkodwa poziomy w hierarchii pamięci:szybką

wolną,przy czym pamięć wolna jest wystarczająco duża, aby

pomieścić macierze A,B i C, a szybka pamięć zawiera tylko M elementów, gdzie:

n < M <<n2

5





Załóżmy również, że dane są w optymalny sposób ponownie wykorzystywane (co jest raczej optymistycznym założeniem, jeżeli decyzje podejmowane są automatycznie przez sprzęt i/lub system operacyjny) – specjalne algorytmy przeznaczone do rozwiązywania powyższego problemu nie są częścią tego wykładu.



Najprostszy algorytm składa się z trzech pętli:

for (i=0; i < n ;i++)for (j=0;j < n;j++)

for (k=0;k < n ;k++)C[i,j] = C[i,j] + A[i,k] * B[k,j];


M M na maszynach z pamięcią wspólnąPoliczmy liczbę odwołań do wolnej pamięci:n3 aby odczytać B n-krotnie,n2 aby odczytywać A po jednym wierszu (trzymamy go

w szybkiej pamięci dopóty, dopóki jest potrzebny), 2*n2 aby odczytywać C po jednym wyrazie (trzymając

go w szybkiej pamięci, aż zostanie całkowicie wyliczony).

To daje nam liczbę odwołań do pamięciR = n3 + 3 * n 2 ≈ n3,

oraz liczbę operacji zmiennoprzecinkowychac= 2 * n3.

Stądq =ac/R ≈ 2,

co nie jest dobrym wynikiem, dalekim od najlepszego z możliwych.

6





Uwagi:1. Jeżeli M << n tak, że nie możemy trzymać całego

wiersza macierzy A w szybkiej pamięci, q zmniejsza się aż do 1, gdyż wtedy algorytm staje się sekwencją iloczynów skalarnych.

1. Dla każdej permutacji trzech pętli algorytmu (i, j, k) otrzymujemy inny algorytm z niemalże takim samym rezultatem.


M M na maszynach z pamięcią wspólnąMnożenie macierzy z jednowymiarowym

rozkładem blokowymKolejną możliwością jest podzielenie B i C na bloki

wierszowe oraz obliczanie C blok po bloku.

Mnożenie macierzy C=A*B dla macierzy A, B i Cpodzielonych jednowymiarowo (z rozkładem

blokowym jednowymiarowym)Części macierzy A, B i C przydzielone do pojedynczego

zadania są pokolorowane na czarno.Podczas wykonywania zadanie to wymaga wszystkich

kolumn macierzy B (żółtych).



Mnożenie macierzy z jednowymiarowym rozkładem blokowym

Notacja:Przyjmijmy, że zapis A[i:j,k:l] oznacza podmacierz

macierzy A z rzędami od i do j i kolumnami od k do l.DzielimyB=[B(1), B(2),..., B(N)],gdzie każde B(i) jest macierzą rzędu n/N * n.Analogicznie tworzymy wierszowe bloki dla C.

7






Nasz kolumnowy algorytm blokowy przyjmuje postaćfor (j=0;j < N/n;j++)

for (k=0;k < n;k++)C(j) = C(j) + A[k,0 :(n-1)] * B(j)




Zakładając, że M ≥ 2* n2/N + n(by szybka pamięć pomieściła B[i], C[j] oraz jednen

wiersz z macierzy A równocześnie) nasza ilość odwołań do pamięci wynosi:

1. 2*n2 aby jednokrotnie odczytać i zapisać każdy blok C

2. n2 aby odczytać jednokrotnie każdy blok B 3. N*n2 aby odczytać A N-krotnie .To daje:

R= 2* n2 + n2+ N*n2 = (3+N)*n2

ac =2 *n3




Przy założeniu M ≥ (≈ ) 2* n2/N + n,

R=(3+N)*n2

ac =2 *n3

stądq = ac / R

=2*n3/(3+N)*n2

≈ 2*n/N = 2*n2/(N*n) ≈ (2*n2/N)/n≈ M/n

Aby q było wysokie, to M musi zwiększać się wraz ze wzrostem n .

8





Mnożenie macierzy z dwuwymiarowym rozkładem blokowym

Rozważmy teraz podział na bloki kwadratowe taki, żeA jest podzielone na N*N – blokową macierz zblokami A[i,j] o wymiarach n/N * n/N,

B i C są podzielone analogicznie.




Mnożenie macierzy C= A*B dla macierzy A, B i C podzielonych dwuwymiarowo

(rozkład blokowy dwuwymiarowy).Części macierzy A, B i C przydzielone do pojedynczego zadania są

pokolorowane na czarno.Podczas wykonywania, to zadanie wymaga odpowiednich

(żółtych) wierszy i kolumn macierzy A i B.




Algorytm wygląda następująco: for (i=0; i < N; i++)

for (j=0; j < N; j++)for (k=0; k < N; k++)

C[i,j] = C[i,j] + A[i,k]* B[k,j]

9






Zakładając, że M ≥ 3 * (n/N)2

czyli w pamięci szybkiej mieści się równocześnie po jednym bloku z A, B i C,

ilość odwołań do pamięci wynosi: 2*n2 aby jednokrotnie odczytać i zapisać każdy blok C,N*n2 aby odczytać A N–krotnie,N*n2 aby odczytać A N–krotnie.Stąd liczba odwołań do pamięci

R= (2+2*N)*n2

orazac= 2*n3




Przy założeniu M ≥ 3 * (n/N)2

M ≈ 3 * (n/N)2

n/N ≈ sqrt(M/3)Ponieważ

R= (2+2*N)*n2

ac= 2*n3

otrzymujemyq = ac/R ≈ 2*n3/(2*N*n2) = n/N ≈ sqrt(M/3)

co jest o wiele lepszym rezultatem od poprzednich algorytmów.



X. Hong i H. T. Kung, w Obradach 13 Sympozjum Teorii Obliczeń (org. Proceedings of the 13th Symposium on the Theory of Computing)(ACM,1981) dokonali analizy tego problemu i udowodnili, że górna granica dla q jest bliskasqrt (M).

10




Mnożenie Macierzy na sieci Rozkład blokowy jednowymiarowy na szynie

bez rozgłaszania (broadcast)Założymy, że n jest podzielne przez p, gdzie p równe

jest liczbie procesorów.A[i] oznacza część o wymiarze (n , (n/p) ), macierzy

A należącą do procesora i,gdzie i = 0, 1, 2 ... p-1.

B[i] oraz C[i] analogicznie.

A(j,i) oznacza podmacierz o wymiarze ((n/p),(n/p)) macierzy A, która jest zarazem podmacierzą A[i] leżącą w wierszach od j*(n/p) do (j+1)*(n/p)-1.


Mnożenie Macierzy na sieciRozkład blokowy jednowymiarowy na szynie

bez rozgłaszania (broadcast)Algorytm opiera się na następującym prostym

wzorze:

∑−

=

+=+=1

0

],[*][][][*][][p

j

ijBjAiCiBAiCiC


Mnożenie Macierzy na sieciRozkład blokowy jednowymiarowy na szynie bez

rozgłaszania (broadcast)Skoro procesor i posiada C[i] oraz B[i], ale nie każde

A[j], jak jest to wymagane przez wzór, algorytm będzie musiał przesłać każde A[j] do każdego procesora.

Mnożenie macierzy C=C+A*B dla macierzy A, B i C z rozkładem blokowym jednowymiarowym

Części macierzy A, B i C przydzielone do pojedynczego zadania są pokolorowane na czarno.

Podczas wykonywania zadanie to wymaga wszystkich wierszy macierzy A (żółtych).

11




Mnożenie Macierzy na sieciRozkład blokowy jednowymiarowy na szynie bez

rozgłaszania (broadcast)Naszym modelem komunikacyjnym (topologią sieci) jest

szyna, co oznacza, że co najwyżej jeden procesor może wysyłać i co najwyżej jeden odbierać dane jednocześnie.

Przyjmujemy, że operacja zmiennoprzecinkowa kosztuje 1 jednostkę

czasu, inicjalizacja wiadomości kosztuje alfa jednostek czasu, praca podczas wysyłania jednego słowa beta jednostek

czasu.Innymi słowy, wysłanie wiadomości z n słów kosztuje:

alfa + beta*n jednostek czasu.Korzystamy z synchronicznego wysyłania i odbierania.


Mnożenie Macierzy na sieciPierwsze rozwiązanie:

Mnożenie macierzy z jednowymiarowym rozkładem blokowym na szynie bez

rozgłaszania, z synchronizacją (blokadą)

C[MYPROC] = C[MYPROC]+ A[MYPROC]*B[MYPROC,MYPROC];for( i= 0; i++; i < p)

for (j=0;j++; j<p) {

if (j != i){

if ( MYPROC == i ) send A[i] to processor j;if ( MYPROC == j ) {

receive A[j] from processor j;

C[MYPROC] = C[MYPROC] + A[j]*B[j,MYPROC];

}barrier(); /* synchronizacja */

};};




rozgłaszania, z synchronizacją (blokadą)Wydajność:Koszt operacji arytmetycznej w wewnętrznej pętli

wynosi 2*n*(n/p)2 = 2*n3/p2,

koszt komunikacji w wewnętrznej pętli wynosi alpha + n*(n/p)*beta,

w sumie czas wynosi Czas = (p*(p-1)+1)*(2*n3/p2) +

(p*(p-1)+1)*( alpha + n*(n/p)*beta) =≈ 2*n3 + p2*alpha + p*n2*beta

gdzie zignorowaliśmy wyrażenia niższego rzędu przy p w drugim wzorze.

12






rozgłaszania, z synchronizacją (blokadą)

Czas ≈ 2*n3 + p2*alpha + p*n2*beta

Otrzymaliśmy wynik gorszy od czasu działania sekwencyjnego ( 2*n3).

Co więcej, wartość ze wzrostem p czas rośnie - a nie maleje - tak że jest to raczej słaby algorytm równoległy.


Mnożenie Macierzy na sieciDrugi algorytm:


rozgłaszania, bez synchronizacji

C(MYPROC) =C[MYPROC] + A[MYPROC]*B[MYPROC,MYPROC];for (i= 0; i <MYPROC; i ++){

receive A[i] from processor i;C[MYPROC] = C[MYPROC] + A[i]*B[i,MYPROC];

};for (i=0 ; i < p-1; i++) {

if (i != MYPROC) send A[MYPROC] to processor i;};for (i=MYPROC+1; i < p; i++){

receive A[i] from processor i;C[MYPROC] = C[MYPROC] + A[i]*B[i,MYPROC];

};




rozgłaszania, bez synchronizacjiPowyższy algorytm jest niedeterministyczny w

takim sensie, że wysyłanie i odbieranie wiadomości odbywające się bez żadnego ograniczenia (synchronizacji) nie zawsze zachowuje odpowiednią kolejność operacji, jak w przypadku algorytmu z blokadą.

13






rozgłaszania, bez synchronizacjiNa przykład, dwie wymiany informacji od procesora 1

do 3 i od 2 do 0 mogą odbyć się w dowolnej kolejności. Technicznie możemy powiedzieć, że częściowe porządki - nałożone na zdarzenia komunikacyjne przez programy na każdym procesorze - nie ustanawiają całkowitego porządku.




rozgłaszania, bez synchronizacjiPowyższy algorytm jest niedeterministyczny.Ten warunek jest nieistotny, ponieważ te same

wyniki są obliczane bez względu na to, jaka jest kolejność (suma nie zależy od kolejności dodawania składników).




rozgłaszania, bez synchronizacjiWydajnośćIntuicyjnie, jeżeli koszt komunikacji w pętli

wewnętrznej cm = alpha + n*(n/p)*beta

jest wystarczająco mniejszy od kosztu operacji arytmetycznych

ar = 2*n3/p2

to wydajność powinna być wysoka. Natomiast jeżeli koszt komunikacji jest

porównywalny, lub też dominuje nad obliczeniami, oczekujemy niskiej wydajności.

14






rozgłaszania, bez synchronizacjiWydajność

Jeżeli będziemy mieć stałą liczbę procesorów – p, a rozmiar tablicy n będzie rósł, wtedy ar rośnie jak n3, a cm jak n2.Oczekujemy, że ar zdominuje cm dla dostatecznie

dużych problemów, co umożliwi osiągnięcie dużej wydajności.




rozgłaszania, bez synchronizacjiWydajnośćNaszkicujmy linię czasu dla tego algorytmu, przy

założeniu, że cm <=ar Na wykresie blok czasowy oznaczony i->j oznacza

komunikację od procesora i do j, co trwa czas cm, a blok czasowy oznaczony jC oznacza obliczenia na

procesorze j, co trwa czas ar.Dla prostoty zakładamy, że komunikacja odbywa się

w takim samym porządku, co w programie z blokadą, chociaż - jak jest zaznaczone powyżej -nie ma to znaczenia.




rozgłaszania, bez synchronizacjiWydajność|0C||1C|...

|p-1C||0->1||1C| |1 ->2|

|0->2||2C| |2C||0->3||3C|

...|0->p-1||p-1C|

czas

15





Mnożenie macierzy z jednowymiarowym rozkładem blokowym na szynie bez rozgłaszania,

bez synchronizacjiWydajnośćJak pokazano na diagramie, obliczenia tworzą strumień. Aby obliczyć długość trwania tego strumienia, musimy rozważyć, czy nie ma w nim żadnych przerw („bąbelków”), tzn. czy bloki komunikacyjne nie mogą się odbywać bez opóźnień. Konkretnie, wymianą wiadomości następującą po 0�p-1 jest 1�0. 1�0 będzie mogło się rozpocząć bez opóźnienia,jak tylko 0->p-1 się zakończy, zakładając że procesor 1 nie jest zajęty (tzn. jeżeli ukończył obliczać 1C).




rozgłaszania, bez synchronizacjiWydajnośćTak właśnie będzie, jeżeli ar <= (p-2)*cm.W tym przypadku całkowity czas wynosi Czas = p*(p-1)*cm + 2*ar .Korzystając z nierówności ar <= (p-2)*cm i prostych

przekształcen algebraicznych otrzymujemy2*n3/p = p*ar <= Czas <= (p2+p-4)*cm.

Dolna granica 2*n3/p jest (prawie) osiągana, gdy cmrówne jest swojej dolnej granicy ar/(p-2).

To odpowiada (prawie) idealnemu wzrostowi prędkości,czas obliczeń sekwencyjnych wynosi 2*n3.




rozgłaszania, bez synchronizacjiWydajnośćStąd, jeżeli komunikacja jest na tyle szybka, że

cm ≈ ar/(p-2)fakt, że szyna jest szeregowym wąskim gardłem

rozwiązania, nie ma znaczenia. Jeżeli cm jest jeszcze mniejsze od ar/(p-2), tak, że są

„bąble” w strumieniu , wzrost prędkości może się jeszcze trochę polepszyć, ale niewiele.

16






rozgłaszania, bez synchronizacjiWydajnośćWraz ze wzrostem cm przyśpieszenie (wzrost

prędkości) maleje.Kiedy cm=ar, czas działania wynosi

(p2-p+2)*ar ≈ 2*n3,jest w przybliżeniu równy czasowi działania

szeregowego. Innymi słowy, równoległość nic nie daje.

Jeżeli cm jest większe od ar, czas działania jest gorszy od algorytmu szeregowego .




rozgłaszania, bez synchronizacjiWydajnośćWidać to wyraźnie we wzorze na wydajnośćEfektywność = Czas_sekwencyjny / ( p * Czas_równoległy )

)1(**

*2

)(*

*2

_*

_ 33

ar

cmarp

n

arcmp

n

RównoległóCzasp

ysekwencyjnCzasćEfektywnoś

+=

+==




rozgłaszania, bez synchronizacjiWydajnośćW naszym przypadkucm = (p*(p-1)+1)*(alpha + n*(n/p)*beta)ar = (p*(p-1)+1)*2*n3/p2

stąd

)1(**

*2

)(*

*2

_*

_ 33

ar

cmarp

n

arcmp

n

RównoległóCzasp


+=

+==

17






rozgłaszania, bez synchronizacjiWydajnośćZałożyliśmy, że

Gdy jest bliskie do ,wydajność jest bliska 1.

Kiedy jest bliskie do 1, wydajności jest bliska do ,

czyli równoległość nie przyspiesza obliczeń.

Z postaci wyrażenia dla n/p widzimy, że jest małegdy n>>p i gdy alfa i beta nie są za duże .

12

1 <=<=− ar

cm

p

2

1

−par

cm

ar

cmp

1

ar

cm




rozgłaszania, bez synchronizacji

WydajnośćMożna łatwo sprawdzić wydajność dla konkretnej

macierzy i/lub na konkretnej maszynie, podstawiając wartości n, p, alfa i beta.


Mnożenie Macierzy na sieciTrzecie rozwiazanie:

Jednowymiarowy Rozkład Blokowy na szynie z rozgłaszaniem

Naturalnym jest pytanie: jak bardzo możliwość odebrania pojedynczej wiadomości przez wiele procesorów poprawia wydajność powyższego algorytmu.

18






C(MYPROC) =C[MYPROC] + A[MYPROC]*B[MYPROC,MYPROC];for (i=0; i < p; i++){

if ( MYPROC == i ) broadcast A[MYPROC];

elsereceive A[i] from processor i;

C(MYPROC) = C[MYPROC] + A[i]*B[i,MYPROC];};




WydajnośćZakładając taki sam model komunikacji, czas wynosi

Stąd

betanalphapp

n

p

betanalphap

p

npCzas **

*2)

*(*

*2* 232

2

3

++=++=

n

betap

n

alphapar

cmRównoległóCzasp

ySekwencyjnCzasćEfektywnoś

*2*

*2*

1

1

1

1

_*

_

3

2

++=

+==




Wydajność

W przeciwieństwie do szyny bez rozgłaszania, wyraz

w mianowniku jest p-1 razy mniejszy, tym samym wydajność jest znacznie mniej wrażliwą funkcją od p.

ar

cm

n

betap

n

alphapar

cmRównoległóCzasp

ySekwencyjnCzasćEfektywnoś

*2*

*2*

1

1

1

1

_*

_

3

2

++=

+==

19






WydajnośćTak jak wcześniej, skoro oczekujemy, że alfa>>1 i

beta>>1 oraz wymagamy, by n>>p, aby równoległość była efektywna.

Jednakże, skoro jest p-krotnie mniej czasu spędzonego na komunikacji, nasza dolna granica na n/p dla wydajnej równoległości jest znacznie niższa od tej dla szyny bez rozgłaszania, potwierdzając naszą intuicję, że więcej komunikacji wspomaga równoległość.


Mnożenie Macierzy na sieci

Mnożenie macierzy dla Jednowymiarowego Rozkładu Blokowego na pierścieniu

Dla prostoty zakładamy, że każdy procesor może wysyłać i odbierać równocześnie; w najgorszym przypadku spowoduje to 2-krotne niedoszacowanie czasu komunikacji, gdy będziemy mieli procesory nieparzyste wysyłające do parzystych, a potem odwrotnie.


Mnożenie Macierzy na sieciMnożenie macierzy dla Jednowymiarowego

Rozkładu Blokowego na pierścieniu

copy A[MYPROC] into T;C(MYPROC) = C[MYPROC] + T*B[MYPROC,MYPROC];for (i=1; i < p; i++){

send T to processor (MYPROC+1) % p;receive T from processor (MYPROC-1) % p;C[MYPROC] =C[MYPROC] + T * B[(MYPROC-1)%p, MYPROC];

};

20





Rozkładu Blokowego na pierścieniu

WydajnośćZakładając taki sam model komunikacji, czas wynosi:

Stąd

ar

cmpprównogłóczasp


)1(*1

1

_*

_

−+==

betanp

palphap

p

n

betap

nalphap

p

npCzas **

1*)1(

*2)

*(*)1(

*2* 232

2

3 −+−+=+−+=



Rozkładu Blokowego na pierścieniuWydajność

co jest trochę lepszym wynikiem niż w algorytmie na szynie z rozgłaszaniem.

ar

cmpprównoległóczasp

ysekwencyjnCzascEfektywnoś

)1(*1

1

_*

_

−+==



Rozkładu Blokowego na pierścieniuNietrudno zauważyć, że jest to optimum dla

jednowymiarowego rozkładu blokowego na szynie czy pierścieniu, ponieważ wzór mnożenia macierzy przez nas wykorzystywany wymaga, aby każdy wynik A(i)*B(i,j) ostatecznie został zgromadzony na procesorze j, co pociąga za sobą pewne przemieszczenia danych o rozmiarze n*(n/p) -przemieszczenia od każdego procesora i do każdego procesora j, a to wymaga co najmniej p-1wiadomości o rozmiarze n2/p każda.

21





Rozkładu Blokowego na pierścieniuSkoro pierścień może być zagnieżdżony w siatce czy też

sieci o topologii hiperkostki, ten sam algorytm będzie działał w tych sieciach. Jednak zostały opracowane znacznie lepsze algorytmy dla takich struktur topologicznych.


MNOŻENIE MACIERZYAlgorytm Cannona na siatce dwuwymiarowej

(2D)Najpierw opiszemy algorytm Cannona mnożenia

macierzy dla rozkładu dwuwymiarowego macierzy blokowych bez wykorzystywania sieci, a później –dodamy sieć.

Załóżmy, że• p (= liczba procesorów) jest pełnym kwadratem:

p=s2, • jest podzielne przez s, gdzie s = sqrt (p).

Niech B[i,j] oznacza podmacierz pamiętaną przez procesor P(i,j).



(2D)

Algorytm Cannona zmienia porządek sumowania w pętli wewnętrznej mnożenia macierzy blokowej następująco:

∑−

=

×+=1

0

],[],[],[],[s

k

jkBkiAjiCjiC

∑−

=

++×+++=1

0

],mod)[(]mod)(,[],[s

k

jskjiBskjiiAjiC

22




MNOŻENIE MACIERZYAlgorytm Cannona na siatce dwuwymiarowej (2D)Idea algorytmu Cannona

for all (i=0 to s-1) /*równoległe przesuwanie ukośne "skew" A */

{ cykliczne przesunięcie w lewo wierszy macierzy A o i ,

tak że A[i,j] nadpisywane jest przez A[i, (j+i) mod s] }for all (i=0 to s-1) /* równoległe przesuwanie ukośne B */

{cykliczne przesunięcie do góry kolumny macierzy B o i,tak że B[i,j] nadpisywane jest przez B[ (i+j) mod s, j] }

for (k=0; k <s; k++)for all (i=0 to s-1, j=0 to s-1) /*wykonywane równolegle */{ C[i,j] = C[i,j] + A[i,j] * B[i,j]

cykliczne przesunięcie w lewo wierszy macierzy A o 1,tak że A[i,j] nadpisywane jest przez A[i, (j+1) mod s]

cykliczne przesuniecie do góry każdej kolumny macierzy B o 1,tak że B[i,j] nadpisywane jest przez B[(i+1) mod s, j]

}



(2D)

Niebieski bloki : C[1,2]=C[1,2] + A[1,0] * B[0,2]Zielone bloki: C[1,2]=C[1,2] + A[1,1] * B[1,2]Czerwone bloki: C[1,2]=C[1,2] + A[1,2] * B[2,2]

dane Po ukośnym Pierwsze o 1 Drugie o 1



(2D)Na poprzednim slajdzie:3 kolorowe bloki są potrzebne do obliczenia C(1,2). Najpierw niebieskie bloki A[1,0] i B[0,2] są pamiętane

w P(1,2) oraz mnożone i dodawane do C[1,2]. Potem zielone bloki A[1,1] i B[1,2] są mnożone i

dodawane do C[1,2]. Na końcu czerwone bloki A[1,2] i B[2,2] są mnożone i

dodawane do C[1,2].

23





(2D)Innymi słowy, po przesunięciach początkowych (dwóch

przesunięcia ukośne przed pętlą główną),w każdym ruchu danych A[i,k] i B[k,j] są dostarczane

do procesora P(i,j), gdzie są mnożone i dodawane do C[i,j].

Parametr k określa kolejność, w jakiej bloki są dostarczane do różnych procesorów, zgodnie ze wzorem

(i+j+k) mod s.


MNOŻENIE MACIERZYModel komunikacji

Naszym modelem komunikacyjnym (topologią sieci) jest szyna, co oznacza, że co najwyżej jeden procesor może wysyłać i co najwyżej jeden odbierać dane jednocześnie.

Przyjmujemy, że operacja zmiennoprzecinkowa kosztuje 1 jednostkę

czasu, inicjalizacja wiadomości kosztuje alfa jednostek czasu, praca podczas wysyłania jednego słowa beta jednostek

czasu.Innymi słowy, wysłanie wiadomości z n słów kosztuje:

alfa + beta*n jednostek czasu.Korzystamy z synchronicznego wysyłania i odbierania.



(2D)Algorytm ten jest odpowiedni dla siatki procesorów o

wymiarach s na s, dla której teraz zmierzymy wydajność.

Przesuwanie ukośne (skewing) A.Każdy rząd A może być przesyłany niezależnie od pozostałych. Jeżeli komunikacja będzie z najbliższymi sąsiadami, wiadomości będą wysyłane najkrótszymi ścieżkami (lewo, prawo). Ponieważ - jak założyliśmy wcześniej - procesor będzie mógł odbierać i wysyłać równocześnie, koszt wynosi:

(s/2)*(alpha + (n/s)2*beta) =sqrt(p)*alpha/2 + n2/(2*sqrt(p))*beta

24





(2D)Algorytm ten jest odpowiedni dla siatki procesorów o

wymiarach s na s, dla której teraz zmierzymy wydajność.

Przesuwanie ukośne (skewing) B.Koszt taki sam , jak dla macierzy A.

Przesuwanie (ang. shifting) A (lub B) w lewo (do góry) o 1. Potrzebny czas

alpha+n2/p*beta.



(2D)

Lokalne ( na procesorze) dodawania A * B do C.Koszt: 2*(n/s)3 = 2*n3/p (3/2).Stąd czas całkowity TTTT = 2*n3/p + 3*sqrt(p)*alpha + 3*n2/sqrt(p) * beta

Stąd efektywność:

betanalpha

pn

p*

*5.1

*

*5.11

1

2

1

3

2

3

++



(2D)

Porównując z czasem dla pierścienia, widzimy że czas obliczeń jest taki sam,

natomiast czas komunikacji jest około sqrt(p) razy mniejszy.

To odzwierciedla fakt, że „spójność połączeniowa” (ang. "bisection width" – minimalna liczba połączeń, które trzeba przeciąć, aby podzielić sieć na dwie części o podobnej wielkości)jest dla siatki sqrt(p) razy większa niż dla pierścienia .

25




MNOŻENIE MACIERZYMnożenie macierzy na siatce trójwymiarowej

Możliwe jest dalsze obniżenie kosztu komunikacji o współczynnik p1/6 przy użyciu siatki trójwymiarowej- zamiast (jak powyżej) siatki dwuwymiarowej. Pomysł polega na tym, aby mnożenie A(i,k)*B(k,j) ze wzoru

było wykonywane przez procesor (i,j,k) w trójwymiarowej siatce. Wtedy sumy są gromadzone wzdłuż wierszy siatki.

Szczegóły:"A three-dimensional approach to parallel matrix

multiplication" by R. Agarwal et al, IBM J. of Res. and Dev., v. 39, n. 5, pp 521-600, Sept. 1995.

∑−

=×+=

1

0

],[],[],[],[s

k

jkBkiAjiCjiC


MNOŻENIE MACIERZYMnożenie macierzy na hiper-kostce

Skoro pierścień może być zagnieżdżony w hiper-kostce, to można tu użyć tego samego algorytmu, co dla pierścienia.

Są rozwiązania zdecydowanie lepsze.

Najpierw pokażemy, jak zastosować algorytm Canona dla takiej sieci, a potem jak go przyspieszyć.



Najpierw fakty pomocnicze.Def. Binarny kod Gray’a

Niech b będzie d-bitową liczbą w kodzie binarnym

b = bd bd-1 .... b1.

Binarny kod Gray’a G (b)= gd gd-1... g1

jest zdefiniowany następująco :

gi = (bi + bi+1) mod 2 dla i=1,2, ... , d-1.

gd = bd .

PrzykładG(92) = G(1011100) =

=1110010 = 114

26





Istnieje funkcja odwrotna do G: G-1 .

Jak nietrudno zauważyć,

jeżeli r= rd rd-1 ... r1 ,

to

G-1(r) = hd hd-1 .... h1 , gdzie

hd = rd oraz hi = (hi+1 - ri) mod 2.

Przykład (c.d.)

G-1(114) = G-1(1110010) = 1011100=92



Procesory połączone równolegle o topologii hiper-kostki.

Jeżeli p=2d

oraz bd bd-1 ... b1 są binarną reprezentacją liczby

b ∈ {0, 1, ... , p-1}

oraz b(j) - dla 0 ≤ j < d - jest tą liczbą, której

reprezentacja binarna ma postać bd bd-1....νj...b1,

gdzie νj jest dopełnieniem bj,

wtedy w komputerze z

procesorami połączonymi

topologią hiperkostki

procesor b jest połączony

ze wszystkimi procesorami b(j)



Procesory połączone równolegle o topologii hiper-kostki.

Sąsiadami procesora 0 (=000) są:1(=001), 2(=010) oraz 4(=100).

Sąsiadami procesora 3 (=011) są:1(=001), 2(010) oraz 7 (111).

27





Jak zrzutować dwuwymiarową siatkę na hiper-kostkę?

Załóżmy, że wymiary siatki to 2m na 2m oraz s = 2m.

Niech G(m) będzie m-tym bitem kodu Gray’a . Procesor (i,j) z siatki jest wtedy rzutowany na

procesor G(i)* 2m +G(j) na hiper-kostce.Innymi słowy, po prostu scalamy m bitów z G(i)

z m bitami G(j), aby otrzymać poszukiwanyadres na hiper-kostce.




Załóżmy, że wymiary siatkito 2m na 2m oraz s = 2m.

Przykład dla m= 2.

Ten przykład pokazuje,że kolumny macierzy

są rzutowane naniezależne pod-hiper-kostkiAnalogicznie rzędy.




Załóżmy, że wymiary siatkito 2m na 2m oraz s = 2m.

Przykład dla m= 2.Na przykład, niebieskiwiersz powyżej jestrzutowany naniebieski podsześcian.Tak samoczerwona kolumnanaczerwonypodsześcian.

28





Możemy użyć większej liczby połączeń, aby przyspieszyć proces przesuwania z algorytmu Cannona. Ta modyfikacja opracowana została przez zespół: Dekel, Nassimi i Sahni.

Zakładamy, z zachowaniem poziomu ogólności, że A(i,j) jest pamiętane na procesorze i*2m + j.



Algorytm Dekela, Nassimi’ego i Sahni’ego

for (k= 0; k < m ; k++){ jk = 2k and j; /*"logical and" of 2k oraz j */

ik = 2k and i; /*"logical and" of 2k oraz i */for all (i=0 to s-1, j=0 to s-1) /* wykonanie równoległe */

{swap A[i, j xor ik] and A[i, j]; /*"exclusive or" of j oraz ik */swap B[jk xor i, j] and B[i, j]; /*"exclusive or" of jk oraz i */}

};};for (k=0; k <s; k++)

for all (i=0 to s-1, j=0 to s-1) /* wykonanie równoległe */{

C[i,j] = C[i,j] + A[i,j]*B[i,j];/*cykliczne przesunięcie w lewo wierszy A o 1,zgodnie z kodem Gray’a */

/*cykliczne przesunięcie do góry kolumn B o 1, zgodnie z kodem Gray’a */

};

};



Algorytm Dekela, Nassimi’ego i Sahni’egoZasada działania algorytmu jest następująca:Po fazie przesunięć A[i,j] zostało przemieszczone do A[i,j xor i]. Osiągane jest to przez zmianę po jednym bicie liczby j (od bitu k=0 do bitu k=m-1), dopasowując go do odpowiedniego bitu liczby j xor i. j xor ik może się różnić od j tylko na pozycji k-tego bitu, także wymiana danych z procesorem wymaga tylko komunikacji z najbliższym sąsiedztwem. Podobnie, B(i,j) jest przesuwane do B[j xor i, j], też w najbliższym sąsiedztwie.

29





Algorytm Dekela, Nassimi’ego i Sahni’ego

Koszt fazy przesuwania wynosi2*m*(alpha + (n/s)2*beta).

Jest o współczynnik

(sqrt(p)/2)/(2*m) = sqrt(p)/(2*log2 p)

szybszy niż algorytm Cannona na siatce.

Następująca po niej faza mnożenia/dodawania

kosztuje tyle samo, co w oryginalnym algorytmie.



Istnieje jeszcze jeden algorytm mnożenia macierzydla hiper-kostki. Aby być szybszym odpoprzedniego, algorytm ten zakłada, że wszystkiepołączenia (log(p)) wychodzące z każdego procesoramogą być używane równolegle, aby osiągnąćrównoległość komunikacji log(p); odpowiada tosprzętowi dostępnemu na CM-2.Algorytm ten nie jest prezentowany w ramach tegowykładu.



Podsumowanie:Dla macierzy n*2n by n*2n

na 2*n-wymiarowej hiper-kostce:

Algorytm Inicjalizacja Przesyłanie

danych obliczenia

Cannon 2*(2n-1) 2*n2*(2n-1) 2*n3*23n

Dekel et al n+2n-1 n3 + n2*(2n-1) 2*n3*23n

Ho et al n+2n-1 n3 + n2*(2n-1) 2*n3*23n

30




Algorytm StrassenaAlgorytm Strassena do mnożenia macierzy

Literatura:1. Higham,N.J., ”Exploiting fast matrix multiplication

within the Level 3 BLAS”, A.C.M. Trans.Math.Software, vol. 16, pp. 352-368.

2. Strassen, v., 1969, “Gaussian elimination is not optimal”, Numer. Math., vol. 13, pp. 354-356.



Rozważmy obliczenie następującego wyrażenia macierzowego

C=A*Bgdzie A, B, C, są macierzami o wymiarze 2n*2n.

Podzielmy A, B, C na macierze blokowe o wymiarze n*n

=

=

=

CCCCC

BBBBB

AAAAA

2221

1211

2221

1211

2221

1211



Korzystając z tego zapisu macierzy, nasze wyrażenie może zostać zapisane jako:

Przy klasycznym sposobie na policzenie bloków wymagane jest 8 mnożeń macierzy (plus 4 dodawania). Mnożenie macierzy wymaga n3 operacji zmiennoprzecinkowych, a dodawanie macierzy n2

operacji zmiennoprzecinkowych.

BABACBABACBABACBABAC

2222122122

2122112121

2212121112

2112111111

+=

+=

+=

+=

31





Jest to algorytm typu Dziel i Rządź: mnożenie macierzy 2n*2n zostało podzielone na

operacje na macierzach n*n: 8 mnożeń i 4 dodawania .

Oczywiście, każdy z tych “podzielonych” problemów (mnożeń macierzy n*n) mógłby być dalej dzielony na 8 mnożeń macierzy n/2*n/2 itd .

Do tego konkretnego podejścia do mnożenia macierz*macierz zastosowanie metody Dziel i Rządź może nie dawać zysków .



Jeżeli jednak zdefiniujemy macierze pośrednie Pi

następująco:

))((

))((

)(

)(

)(

)(

))((

222122127

121111216

2212115

1121224

2212113

1122212

221122111

BBAAPBBAAP

BAAPBBAPBBAPBAAP

BBAAP

+−=

+−=

+=

−=

−=

+=

++=



wtedy bloki C możemy otrzymać w ten sposób:

Wymagane jest teraz 7 mnożeń macierzy (oraz 18 dodawań macierzy).

PPPPCPPCPPC

PPPPC

623122

4221

5312

754111

+−+=

+=

+=

+−+=

32





• Znowu jest to algorytm typu Dziel i Rządź, ale teraz mnożenie macierzy 2n*2n zastępowane jest przez 7 mnożeń macierzy n*n (i 18 dodawań macierzy), co przynosi zyski dla dużych macierzy.

• Algorytm stosowany jest rekursywnie tak, że 7 mnożeń macierzy n*n jest zastępowanych przez 49 mnożeń macierzy n/2 *n/2 itd.

• Rekursja jest kontynuowana dopóty, dopóki “podzielone” macierze nie są na tyle małe, że standardowy algorytm będzie dawał lepsze wyniki od podejścia rekursywnego.



• Algorytm ten zaproponował Strassen (1969). • Algorytm ten nie jest tak silnie stabilny, jak

podejście konwencjonalne, ale jest dostatecznie stabilny dla wielu aplikacji.

Programowanie Równoległe Rlucjan/PRiR/wyklad9.pdf · Operacje zmiennoprzecinkowe mogą być...

Documents

Transcript of Programowanie Równoległe Rlucjan/PRiR/wyklad9.pdf · Operacje zmiennoprzecinkowe mogą być...