PRZETWARZANIE RÓWNOLEGŁE I ROZPROSZONE. Mnożenie macierzy kwadratowych metodą klasyczną oraz blokową z wykorzystaniem OpenMP.

Transkrypt

1 P O L I T E C H N I K A S Z C Z E C I Ń S K A Wydział Informatyki PRZETWARZANIE RÓWNOLEGŁE I ROZPROSZONE. Mnożenie macierzy kwadratowych metodą klasyczną oraz blokową z wykorzystaniem OpenMP. Autor: Wojciech Zatorski Szczecin, 2006

2 Naszym zadaniem było wykonanie kilkunastu testów mnożenia macierzy metodą blokową oraz klasyczna z wykorzystaniem środowiska OpenMP i na podstawie tych testów wyciągnięcie wniosków. OpenMP to jednolite środowisko dyrektyw zrównoleglających dla maszyn z pamięcią wspólną. OpenMP rozszerza sekwencyjny model programowania o Single-Program Multiple Data (SPMD), pracę dzieloną i synchronizację, oraz wspomaga operowanie na wspólnych i prywatnych danych. Równoległość programu musimy wskazać jawnie i do nas należy przewidywanie wszelkich zależności, konfliktów i uwarunkowań. Zostały wykonane testy dla macierzy kwadratowych o wymiarach :10x10, 20x20, 30x30, 90x90, 100x100, 150x150, 200x200, 250x250, 300x300, 500x500, 1000x1000, a także 600x600, 800x800, 1000x1000, 1200x1200, 1400x1400. Każda macierz zawiera wartości dwucyfrowe wygenerowane losowo rozdzielone spacją oraz każdy wiersz macierzy rozdzielony pojedynczym enterem. Przykładowy wygenerowany plik dla macierzy A i B o rozmiarze 10x10 wygląda:

3 a dla macierzy A i B zmiennoprzecinkowej o rozmiarze 10x10 wygląda: Czas mnożenia macierzy jest obliczany za pomocą prostej procedury zwracającej aktualny czas w sekundach i milisekundach. Procedura jest wywoływana przed każdym mnożeniem macierzy oraz po mnożeniu, a następnie obliczana jest różnica, która jest podawana w niniejszym sprawozdaniu. Procedura podająca aktualny czas przedstawia się następująco: double second() { struct timeval tm; double t; gettimeofday(&tm,null); t = (double) (tm.tv_sec) + ((double) (tm.tv_usec))/1.0e6; return t; } Zostały napisane dwa odrębne programy, jeden dla metody klasycznej, drugi dla metody blokowej wczytujące z pliku macierze, a następnie wykonujące operacje mnożenia. W wyniku (na ekran) zwracany jest czas obliczeń np. 100x100 = Wykonano również modyfikacje na kopiach w/w programów umożliwiające wczytywanie i mnożenie liczb zmiennoprzecinkowych. 3

4 Fragment kodu odpowiedzialny za mnożenie macierzy metodą klasyczną (program A): #pragma omp parallel { #pragma omp for private(j,k) for (i=0; i<ry; i++) for (j=0; j<rx; j++) { for (k=0; k<ry; k++) { tab3[i][j]=tab3[i][j]+(tab1[i][k]*tab2[k][j]); } } } Zmodyfikowane mnożenie macierzy metodą klasyczną (program B): #pragma omp parallel { #pragma omp for private(j,k,suma) for (i=0; i<ry; i++) for (j=0; j<rx; j++) { suma=0; for (k=0; k<ry; k++) { suma+=tab1[i][k]*tab2[k][j]; } tab3[i][j]=suma; } } Fragment kodu odpowiedzialny za mnożenie macierzy metodą blokową: #pragma omp parallel { #pragma omp for private(i,j,k,x,y,z) schedule(runtime) for (x=0; x<n_prime; x++) for (y=0; y<n_prime; y++) for (z=0; z<n_prime; z++) for (i=x*sub_n; i<(x+1)*sub_n; i++) for (j=y*sub_n; j<(y+1)*sub_n; j++) for (k=z*sub_n; k<(z+1)*sub_n; k++) tab3[i][j] += tab1[i][k] * tab2[k][j]; } 4

5 Zostały wykonane testy dla 1,2,3,4 oraz 8 wątków (ustalanych statycznie za pomocą zmiennej OMP_NUM_THREADS) na podanych wcześniej macierzach z wykorzystaniem prostego skryptu zawierającego: export OMP_NUM_THREADS=1./mac_klas 10x10.mac./mac_klas 20x20.mac./mac_klas 30x30.mac./mac_klas 90x90.mac./mac_klas 100x100.mac./mac_klas 150x150.mac./mac_klas 200x200.mac./mac_klas 250x250.mac./mac_klas 300x300.mac./mac_klas 500x500.mac./mac_klas 1000x1000.mac (...) export OMP_NUM_THREADS=1./mac_block 10x10.mac./mac_block 20x20.mac./mac_block 30x30.mac./mac_block 90x90.mac./mac_block 100x100.mac./mac_block 150x150.mac./mac_block 200x200.mac./mac_block 250x250.mac./mac_block 300x300.mac./mac_block 500x500.mac./mac_block 1000x1000.mac (...) 5

6 JOTA 1 Obliczenia wykonane na JOTA 1 przedstawiają się następująco: Metoda blokowa threads x10 0, , , , , x20 0, , , , , x30 0, , , , , x90 0, , , , , x100 0, , , , , x150 0, , , , , x200 0, , , , , x250 0, , , , , x300 0, , , , , x500 1, , , , , x , , , , , Metoda klasyczna threads x10 0, , , , , x20 0, , , , , x30 0, , , , , x90 0, , , , , x100 0, , , , , x150 0, , , , , x200 0, , , , , x250 0, , , , , x300 0, , , , , x500 3, , , , , x , , , , , Najlepiej różnice w działaniu algorytmu widać na największej mnożonej macierzy 1000x1000, gdzie różnice są dosyć sporawe (w sekundach), metoda klasyczna jest prawie dwukrotnie wolniejsza na jednym wątku w porównaniu z metodą blokową. Natomiast w przypadku dwóch wątków działanie metody blokowej dłużej niż klasycznej jest niewytłumaczalne (testy przeprowadzone zostały dwukrotnie), widocznie w tym momencie większy dostęp do procesorów miały inne procesy lub urządzenia (I/O).

7 JOTA 4 Obliczenia dla porównania wykonano również na JOTA 4 i wyglądają następująco: Metoda blokowa threads x10 0, , , , , x20 0, , , , , x30 0, , , , , x90 0, , , , , x100 0, , , , , x150 0, , , , , x200 0, , , , , x250 0, , , , , x300 0, , , , , x500 1, , , , , x , , , , , Metoda klasyczna threads x10 0, , , , , x20 0, , , , , x30 0, , , , , x90 0, , , , , x100 0, , , , , x150 0, , , , , x200 0, , , , , x250 0, , , , , x300 0, , , , , x500 3, , , , , x , , , , , I tutaj również widać najlepiej na największej macierzy, że metoda blokowa jest znacznie wydajniejsza niezależnie od ilości wątków. W tym wypadku również na 2 wątkach metoda blokowa była wydajniejsza. Ogólnie czasy są porównywalne z tymi otrzymanymi z JOTA 1. Obie metody zadziałały najwydajniej na trzech wątkach, natomiast najgorzej metoda blokowa na 8, a klasyczna na 1 wątku. 7

8 Oprócz tego dodatkowo przeprowadzono testy dla macierzy 600x600, 800x800, 1000x1000, 1200x1200, 1400x1400 dla programu równoległego (1,2,3,4,8 wątków) oraz programu sekwencyjnego na tych samych danych metodą klasyczną oraz blokową. threads seq 600x600 3, , , , , , x800 9, , , , , , x , , , , , , x , , , , , , x , , , , , , x600 2, , , , , , x800 6, , , , , , x , , , , , , x , , , , , , x , , , , , , Procentowe różnice w porównaniu do programu sekwencyjnego wyglądają następująco: threads seq 600x x x x x x x x x x Jak widać na zamieszczonych tablicach nie opłaca się przeprowadzać zrównoleglenia dla jednego wątku, gdyż procedury tworzące wątek zmniejszają wydajność metody. Największą procentową wydajność uzyskano w porównaniu do metody sekwencyjnej na 4 wątkach zmodyfikowaną metodą klasyczną (program B). Metoda blokowa na 4 wątkach była w tej sytuacji mniej wydajna. Ogólny wniosek jaki wypływa z przeprowadzonego testu to, że zmodyfikowana metoda klasyczna jest wydajniejsza w porównaniu z metodą blokową dla wyżej przeprowadzonych testów. 8

9 Wszystkie testy zostały wykonane na maszynach dwuprocesorowych z procesorami Pentium 4 Xeon (2.8GHz) oraz pamięcią 2GB, graficznie rezultaty dla poszczególnych metod wyglądają następująco: JOTA 1 - metoda blokowa 60 time (seconds) thread 2 threads 3 threads 4 threads 8 threads 1000x x x x x x x100 90x90 30x30 20x20 10x10 JOTA 4 - metoda blokowa time (seconds) thread 2 threads 3 threads 4 threads 8 threads 1000x x x x x x x100 90x90 30x30 20x20 10x10 W przypadku małych macierzy rezultaty czasowe są poniżej 2 sekund, co skutkuje tym, że są na wyżej pokazanych wykresach ich wartości nierozpoznawalne. Skok czasu obliczeń następuje już od macierzy 300x300, gdzie prawie wykładniczo rośnie do góry. Im więcej wątków nie oznacza od razu lepszej wydajności, różne maszyny i różny rozkład prędkości działania wątków dla JOTA 1 to 2,4,8,1,3, a dla JOTA 4 8,1,2,4,3. 9

10 Dla metody klasycznej rozkład wątków jest identyczny co w metodzie blokowej, tutaj również widoczny skok długości obliczeń następuje od macierzy 300x300: JOTA 4 - metoda klasyczna time (seconds) thread 2 threads 3 threads 4 threads 8 threads JOTA 1 - metoda klasyczna 30 time (seconds) thread 2 threads 3 threads 4 threads 8 threads

11 Porównaniu obu metod pod względem wydajności czasowej wygląda następująco: JOTA 1 threads x10 16% 7% 7% 22% 2% 20x20 3% -6% -19% 13% -19% 30x30 0% 19% 13% 51% -18% 90x90 3% -11% -109% 25% 5% 100x100 1% 0% 52% -35% 30% 150x150 20% 18% 30% 2% 13% 200x200 30% 57% 19% 13% 3% 250x250 31% 30% 47% -9% 5% 300x300 37% 40% 17% 22% 6% 500x500 46% -1% 40% 21% 66% 1000x % -140% 51% -106% 28% JOTA 4 threads x10-79% 2% 24% 15% 29% 20x20 3% 12% -15% 39% -51% 30x30-91% -27% 1% -14% 1% 90x90-56% -9% -141% 13% 29% 100x100-34% -83% -14% 5% 43% 150x150-49% 53% -78% -69% 4% 200x200 20% 33% 19% 24% -4% 250x250 31% 33% 27% 21% 19% 300x300 35% -21% 20% -29% 18% 500x500 45% -2% -171% 36% 16% 1000x % 39% 28% 45% 23% Największy wzrost wydajności uzyskujemy na 1 wątku w metodzie blokowej. Gdy zwiększa się ilość wątków tym mniejszy zysk w porównaniu z 1 wątkiem i niestety niekiedy ten zysk zamienia się w stratę (jeśli chodzi o JOTA 1). Najlepszy czas uzyskano dla 3 wątków ale wzrost wydajności pomiędzy metodami jest jednym z najmniejszych dla JOTA 4 (choć dalej jest przewaga), natomiast dla JOTA 1 wyszedł największy (choć nie jest wiadome skąd taki rezultat). W niektórych obliczeniach wydajniejsza była metoda klasyczna co widać szczególnie na JOTA 1 (w przypadku największej macierzy). Ze względu na działanie innych aplikacji i osób na serwerach trudno jest dojść do jednoznacznych wniosków. 11

12 Jednymi z ostatnich wykonanych testów był pomiar wydajności czasowej dla klauzuli schedule z parametrami static oraz dynamic oraz kwantem 5%,10%,20% (jednego rozmiaru macierzy) JOTA 3 OMP_SCHEDULE="static[5%,10%,20%]" threads classic bloc 100x100 0, , , , , , , , x200 0, , , , , , , , x300 0, , , , , , , , x500 3, , , , , , , , x100 0, , , , , , , , x200 0, , , , , , , , x300 0, , , , , , , , x500 2, , , , , , , , x100 0, , , , , , , , x200 0, , , , , , , , x300 0, , , , , ,4457 0, , x500 2, , , , , , , , OMP_SCHEDULE="dynamic[5%,10%,20%]" threads classic bloc 100x100 0, , , , , , , , x200 0, , , , , , , , x300 0, , , , , , , , x500 2, , , , , , , , x100 0, , , , , , , , x200 0, , , , , , , , x300 0, , , , , , , , x500 2, , , , , , , , x100 0, , , , , , , , x200 0, , , , , , , , x300 0, , , , , , , , x500 2, , , , , , , , W rezultacie można stwierdzić, że ogólnie parametr dynamic powodował nieznaczne zmniejszenie czasu obliczeń w porównaniu do parametru static. Natomiast kwant miał wpływ na metodę blokową powodując znaczący wzrost czasu obliczeń dla 4 i 8 wątków w przypadku zwiększania kwanta niezależnie od parametru static/dynamic. Ze względu na małą czytelność uzyskanych wyników przeprowadzono testy również dla większych macierzy. 12

13 JOTA 1 OMP_SCHEDULE="static[5%,10%,15%]" threads classic bloc 600x600 4,07 2,14 2,19 2,45 3,05 2,58 3,05 5,80 800x800 9,87 7,26 5,34 5,86 7,13 6,50 11,35 14, x ,45 14,08 10,68 13,06 14,32 8,25 14,52 27, x ,90 23,38 20,87 26,43 24,73 14,34 24,95 46, x ,33 41,23 48,08 55,05 38,68 22,97 125,50 75,15 600x600 5,35 3,37 2,51 2,46 2,94 4,02 5,71 11,26 800x800 14,41 6,86 5,89 5,83 6,90 10,49 13,12 26, x ,08 13,45 12,23 12,74 13,86 26,38 25,05 50, x ,06 25,31 25,24 40,19 24,11 31,78 44,71 90, x ,06 53,48 52,01 52,17 38,31 52,76 73,72 139,60 600x600 4,28 3,10 2,27 2,49 2,98 4,00 5,87 10,49 800x800 10,10 6,87 5,80 6,01 7,11 9,35 13,54 25, x ,07 22,79 12,77 12,89 13,91 20,67 26,55 52, x ,14 25,20 25,40 25,64 24,80 37,94 46,38 87, x ,38 52,01 48,14 50,25 39,08 52,51 73,84 139,15 OMP_SCHEDULE="dynamic[5%,10%,15%]" threads classic bloc 600x600 3,97 2,10 2,14 2,19 2,91 1,53 3,86 5,15 800x800 9,61 7,06 5,19 5,34 7,09 6,42 7,35 12, x ,94 15,66 10,39 11,19 13,84 7,08 14,52 24, x ,82 24,66 20,25 23,39 23,98 12,07 24,97 41, x ,52 30,33 52,25 46,53 37,66 25,07 39,80 68,03 600x600 3,96 2,11 2,19 2,83 2,97 3,37 5,54 11,37 800x800 9,42 7,12 5,06 5,40 7,02 7,80 13,48 27, x ,58 14,14 10,40 11,21 13,74 15,80 29,20 52, x ,28 17,38 22,13 22,74 24,06 27,26 43,78 78, x ,88 28,96 60,18 49,95 38,30 42,69 70,10 125,93 600x600 3,98 3,04 2,26 2,26 2,92 3,32 5,38 9,99 800x800 9,65 7,19 5,02 5,36 7,07 7,94 12,90 26, x ,74 10,13 10,30 11,53 13,92 15,64 25,40 52, x ,39 17,64 20,76 23,72 24,88 28,18 43,79 78, x ,23 29,79 38,99 48,26 37,59 55,51 69,39 143,27 Wcześniejsze wnioski potwierdzają się na w/w większych wielkościach macierzy, gdzie dokładnie widać jaki wpływ na metodę blokową miało zwiększanie kwanta, czasy rosną 13

14 prawie dwukrotnie. W przypadku metody klasycznej trudno jest wnioskować jednoznacznie (nawet już na tak dużych macierzach) jaki wpływ ma zmiana wielkości kwanta oraz schedule. Zmiany wielkości czasowych można powiedzieć są losowe, nie widać tutaj żadnej zależności. Graficzne przedstawienie niektórych uzyskanych rezultatów: METODA KLASYCZNA static 5%,10%,15% 120,0 100,0 80,0 60,0 40, ,0 0,0 5% 5% 5% 10% 10% 15% 15% 15% Rysunek 1 Na powyższym wykresie widać, że zwiększanie kwantu powoduje skok czasu obliczeń, choć niektóre w wyniki przy 15% wartości kwanta są lepsze, niż przy 10%. Im większe macierze tym bardziej wyrównane wyniki czasowe, jedynie w przypadku operacji na 1 wątku czas wybija się ponad przeciętność. 14

15 dynamic 5%,10%,15% 70,0 60,0 50,0 40,0 30, ,0 10,0 0,0 5% 5% 5% 10% 10% 15% 15% 15% Rysunek 2 METODA BLOKOWA static 5%,10%,15% 140,0 120,0 100,0 80,0 60, ,0 20,0 0,0 5% 5% 5% 10% 10% 15% 15% 15% Rysunek 3 15

16 dynamic 5%,10%,15% 160,0 140,0 120,0 100,0 80,0 60, ,0 20,0 0,0 5% 5% 5% 10% 10% 15% 15% 15% Rysunek 4 Podsumowując 4 ostatnie wykresy można powiedzieć, że w metodzie blokowej przy static i dynamic dla 8 wątków najgorzej wypadają obliczenia, zajmują nieporównywalnie więcej czasu niż przy mniejszej ilości wątków, co różni się znacząco od metody klasycznej, gdzie wyniki czasowe były porównywalne nawet i dla 8 wątków.w blokowej static najlepsze rezultaty osiągnięto dla najmniejszej procentowej wartości (czyli dla 5%), natomiast blokowej dynamic rezultaty rozkładają się nieznacznie rosnąco z zyskiem również dla 5%, Najwydajniejsza czasowo okazała się metoda klasyczna przy zastosowanych rozmiarach kwantów. Ostatnimi testami jakie przeprowadzono było wykonanie testów na liczbach zmiennoprzecinkowych, jaki mają wpływ na szybkość obliczeń. 16

17 JOTA 3 Metoda klasyczna (zmiennoprzecinkowe) threads seq 600x600 6, , , , , , x800 15, , , , , , x , , , , , , x , , , , , , x , , , , , ,87497 Metoda blokowa (zmiennoprzecinkowe) threads seq 600x600 3, , , , , , x800 7, , , , , , x , , , , , , x , , , , , , x , , , , , ,59089 Jak widać na przedstawionych tabelach, użycie liczb zmiennoprzecinkowych diametralnie zwiększa czas obliczeń w porównaniu z liczbami całkowitymi w przypadku metody klasycznej, przy największych macierzach różnice sięgają nawet dwukrotnemu spadkowi wydajności. Natomiast metoda blokowa nie wykazuje większych różnic czasowych pomiędzy różnymi typami liczb. Procentowe różnice w porównaniu do programu sekwencyjnego wyglądają następująco: - dla metody klasycznej threads x ,40 55,30 54,24 55,66 56, x800 98,35 60,31 56,78 54,65 57, x ,55 58,00 62,81 58,51 63, x ,37 102,24 66,04 61,15 74, x ,22 75,56 71,67 79,16 86, Najlepsze czasy uzyskano dla 3 i 4 wątków, tak więc nie widać różnicy pomiędzy typami zmiennych, a najgorsze dla 1 wątku równoległego co również zgadza się z poprzednimi obliczeniami. 17

18 - dla metody blokowej threads x ,31 102,19 64,06 95,61 180, x ,54 82,34 63,58 98,19 136, x ,06 56,07 60,01 102,67 128, x ,42 55,20 66,33 99,57 125, x ,99 66,23 60,46 95,37 122, Najgorzej wypadły testy dla 8 wątków, tak samo jak dla poprzednich testów, a najlepiej dla 3 wątków. 18