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

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

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: 10 10 83 86 77 15 93 35 86 92 49 21 62 27 90 59 63 26 40 26 72 36 11 68 67 29 82 30 62 23 67 35 29 2 22 58 69 67 93 56 11 42 29 73 21 19 84 37 98 24 15 70 13 26 91 80 56 73 62 70 96 81 5 25 84 27 36 5 46 29 13 57 24 95 82 45 14 67 34 64 43 50 87 8 76 78 88 84 3 51 54 99 32 60 76 68 39 12 26 86 94 39 95 70 34 78 67 1 97 2 17 92 52 56 1 80 86 41 65 89 44 19 40 29 31 17 97 71 81 75 9 27 67 56 97 53 86 65 6 83 19 24 28 71 32 29 3 19 70 68 8 15 40 49 96 23 18 45 46 51 21 55 79 88 64 28 41 50 93 0 34 64 24 14 87 56 43 91 27 65 59 36 32 51 37 28 75 7 74 21 58 95 29 37 35 93 18 28 43 11 28 29

a dla macierzy A i B zmiennoprzecinkowej o rozmiarze 10x10 wygląda: 10 10 83.86 77.15 93.35 86.92 49.21 62.27 90.59 63.26 40.26 72.36 11.68 67.29 82.30 62.23 67.35 29. 2 22.58 69.67 93.56 11.42 29.73 21.19 84.37 98.24 15.70 13.26 91.80 56.73 62.70 96.81 5.25 84.27 36. 5 46.29 13.57 24.95 82.45 14.67 34.64 43.50 87. 8 76.78 88.84 3.51 54.99 32.60 76.68 39.12 26.86 94.39 95.70 34.78 67. 1 97. 2 17.92 52.56 1.80 86.41 65.89 44.19 40.29 31.17 97.71 81.75 9.27 67.56 97.53 86.65 6.83 19.24 28.71 32.29 3.19 70.68 8.15 40.49 96.23 18.45 46.51 21.55 79.88 64.28 41.50 93. 0 34.64 24.14 87.56 43.91 27.65 59.36 32.51 37.28 75. 7 74.21 58.95 29.37 35.93 18.28 43.11 28.29 76. 4 43.63 13.38 6.40 4.18 28.88 69.17 17.96 24.43 70.83 90.99 72.25 44.90 5.39 54.86 69.82 42.64 97. 7 55. 4 48.11 22.28 99.43 46.68 40.22 11.10 5. 1 61.30 78. 5 20.36 44.26 22.65 8.16 82.58 24.37 62.24 0.36 52.99 79.50 68.71 73.31 81.30 33.94 60.63 99.81 99.96 59.73 13.68 90.95 26.66 84.40 90.84 76.42 36. 7 45.56 79.18 87.12 48.72 59. 9 36.10 42.87 6. 1 13.72 21.55 19.99 21. 4 39.11 40.67 5.28 27.50 84.58 20.24 22.69 96.81 30.84 92.72 72.50 25.85 22.99 40.42 98.13 98.90 24.90 9.81 19.36 32.55 94. 4 79.69 73.76 50.55 60.42 79.84 93. 5 21.67 4.13 61.54 26.59 44. 2 2. 6 84.21 42.68 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 = 0.010047. Wykonano również modyfikacje na kopiach w/w programów umożliwiające wczytywanie i mnożenie liczb zmiennoprzecinkowych. 3

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

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

JOTA 1 Obliczenia wykonane na JOTA 1 przedstawiają się następująco: Metoda blokowa threads 1 2 3 4 8 10x10 0,000026 0,000054 0,000063 0,000063 0,000368 20x20 0,000115 0,000132 0,000177 0,000195 0,000506 30x30 0,000362 0,000286 0,000287 0,000341 0,001066 90x90 0,009463 0,010048 0,013957 0,010857 0,013621 100x100 0,013037 0,006705 0,014092 0,015175 0,013595 150x150 0,043758 0,023541 0,027994 0,068945 0,063211 200x200 0,104373 0,055154 0,069615 0,106848 0,155408 250x250 0,206817 0,107692 0,134123 0,242906 0,305060 300x300 0,360869 0,207506 0,330748 0,331668 0,533264 500x500 1,680570 1,576156 0,993254 1,724430 2,181863 1000x1000 13,948957 50,964042 7,734231 38,682916 16,593316 Metoda klasyczna threads 1 2 3 4 8 10x10 0,000031 0,000058 0,000068 0,000081 0,000374 20x20 0,000119 0,000125 0,000149 0,000225 0,000425 30x30 0,000362 0,000354 0,000331 0,000694 0,000906 90x90 0,009707 0,009057 0,006672 0,014423 0,014308 100x100 0,013208 0,006703 0,029181 0,011268 0,019340 150x150 0,054846 0,028623 0,039787 0,070628 0,072472 200x200 0,149157 0,127428 0,085716 0,123389 0,159935 250x250 0,300338 0,152955 0,255237 0,222040 0,322763 300x300 0,569440 0,346918 0,399821 0,422962 0,564349 500x500 3,109292 1,555967 1,656596 2,190746 6,463781 1000x1000 24,896141 21,197483 15,919022 18,766199 22,891585 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).

JOTA 4 Obliczenia dla porównania wykonano również na JOTA 4 i wyglądają następująco: Metoda blokowa threads 1 2 3 4 8 10x10 0,000043 0,000056 0,000052 0,000064 0,000350 20x20 0,000116 0,000115 0,000139 0,000154 0,000527 30x30 0,000693 0,000463 0,000281 0,000790 0,000782 90x90 0,015068 0,009940 0,015133 0,007481 0,011687 100x100 0,017579 0,012455 0,010047 0,017126 0,022919 150x150 0,082271 0,023690 0,060444 0,075555 0,063317 200x200 0,119734 0,100570 0,069949 0,093071 0,174144 250x250 0,209095 0,197199 0,133937 0,186671 0,248761 300x300 0,357030 0,337341 0,257624 0,585903 0,439960 500x500 1,679371 1,585536 4,473357 1,456645 2,151474 1000x1000 13,681394 12,756228 10,234570 12,426907 16,082782 Metoda klasyczna threads 1 2 3 4 8 10x10 0,000024 0,000057 0,000068 0,000075 0,000494 20x20 0,000119 0,000130 0,000121 0,000251 0,000349 30x30 0,000363 0,000365 0,000283 0,000693 0,000793 90x90 0,009690 0,009142 0,006281 0,008586 0,016356 100x100 0,013158 0,006792 0,008776 0,017973 0,040242 150x150 0,055356 0,050222 0,034031 0,044719 0,065736 200x200 0,149625 0,150460 0,086435 0,122944 0,166714 250x250 0,301783 0,295358 0,183327 0,236429 0,306372 300x300 0,549205 0,279011 0,321778 0,453870 0,536989 500x500 3,054147 1,553610 1,649795 2,261170 2,576029 1000x1000 25,148571 20,742484 14,275051 22,645060 20,786926 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

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 1 2 3 4 8 seq 600x600 3,971718 2,941780 2,992503 2,093031 2,244277 3,838465 800x800 9,517204 5,066294 7,070090 5,011917 5,468413 9,172082 1000x1000 19,989076 14,098432 11,179552 9,803591 11,960254 18,676235 1200x1200 34,736572 24,930074 19,823246 21,684441 23,515891 33,125007 1400x1400 57,870222 31,088342 38,621858 39,896587 47,840604 56,069911 600x600 2,898841 1,462619 1,824898 2,596068 3,494977 2,741235 800x800 6,883031 3,604426 4,377041 6,676073 8,631512 6,491331 1000x1000 13,528506 12,505292 9,858915 12,232248 16,701746 12,941232 1200x1200 23,505972 12,013971 15,588380 22,149768 29,083074 22,002066 1400x1400 37,507355 35,240471 23,562440 34,234262 46,214019 36,356573 Procentowe różnice w porównaniu do programu sekwencyjnego wyglądają następująco: threads 1 2 3 4 8 seq 600x600 103 77 78 55 58 100 800x800 104 55 77 55 60 100 1000x1000 107 75 60 52 64 100 1200x1200 105 75 60 65 71 100 1400x1400 103 55 69 71 85 100 600x600 106 53 67 95 127 100 800x800 106 56 67 103 133 100 1000x1000 105 97 76 95 129 100 1200x1200 107 55 71 101 132 100 1400x1400 103 97 65 94 127 100 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

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) 50 40 30 20 10 0 1 thread 2 threads 3 threads 4 threads 8 threads 1000x1000 500x500 300x300 250x250 200x200 150x150 100x100 90x90 30x30 20x20 10x10 JOTA 4 - metoda blokowa time (seconds) 18 16 14 12 10 8 6 4 2 0 1 thread 2 threads 3 threads 4 threads 8 threads 1000x1000 500x500 300x300 250x250 200x200 150x150 100x100 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

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 30 25 time (seconds) 20 15 10 5 1 thread 2 threads 3 threads 4 threads 8 threads 0 11 10 9 8 7 6 5 4 3 2 1 JOTA 1 - metoda klasyczna 30 time (seconds) 25 20 15 10 5 1 thread 2 threads 3 threads 4 threads 8 threads 0 11 10 9 8 7 6 5 4 3 2 1 10

Porównaniu obu metod pod względem wydajności czasowej wygląda następująco: JOTA 1 threads 1 2 3 4 8 10x10 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% 1000x1000 44% -140% 51% -106% 28% JOTA 4 threads 1 2 3 4 8 10x10-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% 1000x1000 46% 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

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 1 2 4 8 1 2 4 8 classic bloc 100x100 0,013186 0,006746 0,022385 0,017715 0,012920 0,007015 0,012663 0,027194 200x200 0,146906 0,074115 0,115908 0,163914 0,104036 0,053817 0,110901 0,233456 300x300 0,549077 0,282606 0,480301 0,567811 0,355703 0,182415 0,482425 0,734505 500x500 3,013674 1,587237 2,128644 2,593945 1,697260 0,841281 1,604180 3,095062 100x100 0,013197 0,012498 0,016356 0,015613 0,012884 0,012916 0,024524 0,024708 200x200 0,147082 0,074990 0,121735 0,173113 0,104626 0,147346 0,193661 0,328759 300x300 0,538736 0,483275 0,453235 0,556119 0,355325 0,402246 1,78287 1,292049 500x500 2,990646 1,617048 2,155262 2,624000 1,716151 1,840177 3,084981 5,688228 100x100 0,013186 0,056655 0,022866 0,021328 0,012880 0,01292 0,024186 0,024373 200x200 0,146253 0,075551 0,155631 0,149610 0,103462 0,116213 0,193825 0,322068 300x300 0,546283 0,488789 0,448895 0,549814 0,354869 0,4457 0,664884 1,302697 500x500 2,981646 1,68702 2,418173 2,64172 1,671929 1,904967 3,087125 5,689235 OMP_SCHEDULE="dynamic[5%,10%,20%]" threads 1 2 4 8 1 2 4 8 classic bloc 100x100 0,013215 0,006698 0,017469 0,055017 0,012923 0,006726 0,014841 0,032036 200x200 0,147011 0,126117 0,187059 0,170546 0,103652 0,099227 0,105121 0,146250 300x300 0,543873 0,283342 0,454483 0,537147 0,355592 0,182996 0,354437 0,619608 500x500 2,959661 2,503099 2,241075 2,580026 1,671812 1,757645 1,751892 2,803440 100x100 0,013178 0,012558 0,022788 0,017558 0,013463 0,024109 0,024231 0,02434 200x200 0,146990 0,074461 0,120354 0,166121 0,103987 0,119234 0,194876 0,361305 300x300 0,535718 0,288352 0,449967 0,557998 0,356237 0,417627 0,669081 3,421737 500x500 2,992087 1,546371 2,245621 2,524005 1,712474 1,826913 3,068943 5,631416 100x100 0,013240 0,006754 0,022764 0,015352 0,012857 0,012966 0,065647 0,064968 200x200 0,147790 0,075368 0,134164 0,168577 0,103817 0,151183 0,194567 0,371345 300x300 0,546976 0,279889 0,453328 0,535140 0,356685 0,392476 0,659728 1,292866 500x500 2,991749 1,797936 2,254158 2,593329 1,678641 1,784661 3,076881 5,602962 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

JOTA 1 OMP_SCHEDULE="static[5%,10%,15%]" threads 1 2 4 8 1 2 4 8 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,08 1000x1000 19,45 14,08 10,68 13,06 14,32 8,25 14,52 27,31 1200x1200 41,90 23,38 20,87 26,43 24,73 14,34 24,95 46,07 1400x1400 56,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,22 1000x1000 31,08 13,45 12,23 12,74 13,86 26,38 25,05 50,07 1200x1200 36,06 25,31 25,24 40,19 24,11 31,78 44,71 90,75 1400x1400 101,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,88 1000x1000 30,07 22,79 12,77 12,89 13,91 20,67 26,55 52,56 1200x1200 56,14 25,20 25,40 25,64 24,80 37,94 46,38 87,49 1400x1400 76,38 52,01 48,14 50,25 39,08 52,51 73,84 139,15 OMP_SCHEDULE="dynamic[5%,10%,15%]" threads 1 2 4 8 1 2 4 8 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,02 1000x1000 18,94 15,66 10,39 11,19 13,84 7,08 14,52 24,14 1200x1200 33,82 24,66 20,25 23,39 23,98 12,07 24,97 41,14 1400x1400 56,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,26 1000x1000 18,58 14,14 10,40 11,21 13,74 15,80 29,20 52,72 1200x1200 33,28 17,38 22,13 22,74 24,06 27,26 43,78 78,76 1400x1400 56,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,67 1000x1000 18,74 10,13 10,30 11,53 13,92 15,64 25,40 52,78 1200x1200 33,39 17,64 20,76 23,72 24,88 28,18 43,79 78,42 1400x1400 53,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

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 1 2 4 8 20,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

dynamic 5%,10%,15% 70,0 60,0 50,0 40,0 30,0 1 2 4 8 20,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 1 2 4 8 40,0 20,0 0,0 5% 5% 5% 10% 10% 15% 15% 15% Rysunek 3 15

dynamic 5%,10%,15% 160,0 140,0 120,0 100,0 80,0 60,0 1 2 4 8 40,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

JOTA 3 Metoda klasyczna (zmiennoprzecinkowe) threads 1 2 3 4 8 1 seq 600x600 6,394054 3,521446 3,454225 3,544468 3,614861 6,368388 800x800 15,375743 9,429358 8,877041 8,543726 8,983994 15,63447 1000x1000 30,494364 17,765827 19,240217 17,923491 19,459207 30,63147 1200x1200 57,437480 59,099497 38,173037 35,347806 42,923047 57,8024 1400x1400 99,028844 73,200063 69,427077 76,689158 84,173731 96,87497 Metoda blokowa (zmiennoprzecinkowe) threads 1 2 3 4 8 1 seq 600x600 3,000541 2,779830 1,742641 2,600739 4,900697 2,720174 800x800 7,176294 5,651971 4,364435 6,740387 9,393682 6,864376 1000x1000 14,146803 7,340200 7,856324 13,441776 16,887230 13,09168 1200x1200 24,847342 12,767902 15,341500 23,032322 29,086725 23,13067 1400x1400 40,220284 24,898112 22,727609 35,852033 45,908512 37,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 1 2 3 4 8 1 600x600 100,40 55,30 54,24 55,66 56,76 100 800x800 98,35 60,31 56,78 54,65 57,46 100 1000x1000 99,55 58,00 62,81 58,51 63,53 100 1200x1200 99,37 102,24 66,04 61,15 74,26 100 1400x1400 102,22 75,56 71,67 79,16 86,89 100 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

- dla metody blokowej threads 1 2 3 4 8 1 600x600 110,31 102,19 64,06 95,61 180,16 100 800x800 104,54 82,34 63,58 98,19 136,85 100 1000x1000 108,06 56,07 60,01 102,67 128,99 100 1200x1200 107,42 55,20 66,33 99,57 125,75 100 1400x1400 106,99 66,23 60,46 95,37 122,13 100 Najgorzej wypadły testy dla 8 wątków, tak samo jak dla poprzednich testów, a najlepiej dla 3 wątków. 18