This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Uniwersytet Marii Curie-Skłodowskiej Wydział Matematyki, Fizyki i Informatyki Instytut Informatyki
Podstawy programowania obliczeń równoległych
Przemysław Stpiczyński Marcin Brzuszek
Lublin 2011
Instytut Informatyki UMCS Lublin 2011 Przemysław Stpiczyński (Instytut Matematyki UMCS) Marcin Brzuszek
Podstawy programowania obliczeń równoległych Recenzent: Marcin Paprzycki Opracowanie techniczne: Marcin Denkowski Projekt okładki: Agnieszka Kuśmierska
Praca współfinansowana ze środków Unii Europejskiej w ramach Europejskiego Funduszu Społecznego
Publikacja bezpłatna dostępna on-line na stronach Instytutu Informatyki UMCS: informatyka.umcs.lublin.pl.
Wydawca Uniwersytet Marii Curie-Skłodowskiej w Lublinie Instytut Informatyki pl. Marii Curie-Skłodowskiej 1, 20-031 Lublin Redaktor serii: prof. dr hab. Paweł Mikołajczak www: informatyka.umcs.lublin.pl email: [email protected]
Druk ESUS Agencja Reklamowo-Wydawnicza Tomasz Przybylak ul. Ratajczaka 26/8 61-815 Poznań www: www.esus.pl
Model wykonania programu . . . . . Ogólna postać dyrektyw . . . . . . . Specyfikacja równoległości obliczeń . Konstrukcje dzielenia pracy . . . . . Połączone dyrektywy dzielenia pracy
Przedmowa Konstrukcja komputerów oraz klastrów komputerowych o dużej mocy obliczeniowej wiąże się z istnieniem problemów obliczeniowych, które wymagają rozwiązania w akceptowalnym czasie. Pojawianie się kolejnych typów architektur wieloprocesorowych oraz procesorów zawierających mechanizmy wewnętrznej równoległości stanowi wyzwanie dla twórców oprogramowania. Zwykle kompilatory optymalizujące nie są w stanie wygenerować kodu maszynowego, który w zadowalającym stopniu wykorzystywałby teoretyczną maksymalną wydajność skomplikowanych architektur wieloprocesorowych. Stąd potrzeba ciągłego doskonalenia metod obliczeniowych, które mogłyby być efektywnie implementowane na współczesnych architekturach wieloprocesorowych i możliwie dobrze wykorzystywać moc oferowaną przez konkretne maszyny. Trzeba tutaj podkreślić, że w ostatnich latach nastąpiło upowszechnienie architektur wieloprocesorowych za sprawą procesorów wielordzeniowych, a zatem konstrukcja algorytmów równoległych stała się jednym z ważniejszych kierunków badań nad nowymi algorytmami. Pojawiają się nawet głosy, że powinno się utożsamiać programowanie komputerów z programowaniem równoległym1 . Niniejsza książka powstała na bazie wcześniejszych publikacji autorów, w szczególności prac [54, 60, 64] oraz przygotowywanych materiałów do zajęć z przedmiotu Programowanie równoległe. Stanowi ona wprowadzenie do programowania obliczeń (głównie numerycznych) na komputerach równoległych z procesorami ogólnego przeznaczenia (CPU). Nie omawia ona zagadnień związanych z programowaniem z wykorzystaniem procesorów kart graficznych, gdyż będzie to tematem odrębnej publikacji. Zawiera ona przegląd współczesnych komputerowych architektur wieloprocesorowych, omawia metody teoretycznej analizy wydajności komputerów oraz prezentuje szczegółowo programowanie z wykorzystaniem standardów OpenMP i MPI.
1 Justin R. Rattner, wiceprezes firmy Intel, dyrektor Corporate Technology Group oraz Intel Chief Technology Officer, http://www.computerworld.pl/
news/134247 1.html
viii
Przedmowa Poruszone jest również zagadnienie programowania komputerów równoległych przy pomocy bibliotek podprogramów realizujących ważne algorytmy numeryczne. Książka stanowi podręcznik do przedmiotu Programowanie równoległe prowadzonego dla studentów kierunków matematyka oraz informatyka na Wydziale Matematyki, Fizyki i Informatyki Uniwersytetu Marii Curie-Skłodowskiej w Lublinie, choć może być ona również przydatna studentom innych kierunków studiów oraz wszystkim zainteresowanym tematyką programowania komputerów wieloprocesorowych. Materiał wprowadzany na wykładzie odpowiada poszczególnym rozdziałom podręcznika. Każdy rozdział kończą zadania do samodzielnego zaprogramowania w ramach laboratorium oraz prac domowych.
1. Przegląd architektur komputerów równoległych W pierwszym rozdziale przedstawimy krótki przegląd zagadnień związanych ze współczesnymi równoległymi architekturami komputerowymi wykorzystywanymi do obliczeń naukowych oraz omówimy najważniejsze problemy związane z dostosowaniem kodu źródłowego programów w celu efektywnego wykorzystania możliwości oferowanych przez współczesne komputery wektorowe, równoległe oraz klastry komputerowe. Więcej informacji dotyczących omawianych zagadnień można znaleźć w książkach [21,25,38,40,55].
1.1. Równoległość wewnątrz procesora i obliczenia wektorowe Jednym z podstawowych mechanizmów stosowanych przy konstrukcji szybkich procesorów jest potokowość. Opiera się on na prostym spostrzeżeniu. W klasycznym modelu von Neumanna, procesor wykonuje kolejne rozkazy w cyklu pobierz–wykonaj. Każdy cykl jest realizowany w kilku etapach. Rozkaz jest pobierany z pamięci oraz dekodowany. Następnie pobierane są potrzebne argumenty rozkazu, jest on wykonywany, po czym wynik jest umieszczany w pamięci lub rejestrze. Następnie w podobny sposób przetwarzany jest kolejny rozkaz. W mechanizmie potokowości każdy taki etap jest wykonywany przez oddzielny układ (segment), który działa równolegle z pozostałymi układami, odpowiedzialnymi za realizację innych etapów. Wspólny zegar synchronizuje przekazywanie danych między poszczególnymi segmentami, dostosowując częstotliwość do czasu działania najwolniejszego segmentu [40]. Zakładając, że nie ma bezpośredniej zależności między kolejnymi rozkazami, gdy pierwszy rozkaz jest dekodowany, w tym samym czasie może być pobrany z pamięci następny rozkaz. Następnie, gdy realizowane jest pobieranie argumentów pierwszego, jednocześnie trwa dekodowanie drugiego i pobieranie kolejnego rozkazu. W ten sposób, jeśli liczba etapów wykonania pojedynczego rozkazu wynosi k oraz za jednostkę czasu przyjmiemy czas wykonania jednego etapu, wówczas potokowe wykonanie n rozkazów zajmie n + k − 1 zamiast k · n, jak miałoby to miejsce w klasycznym modelu von Neumanna. Gdy istnieje bezpośrednia zależność między rozkazami (na przykład w postaci instrukcji skoku warunkowego), wówczas jest wybierana najbardziej prawdopodobna gałąź selekcji (mechanizm branch prediction [45]). Idea potokowości została dalej rozszerzona w kierunku mechanizmu wektorowości. W obliczeniach naukowych większość działań wykonywanych jest na wektorach i macierzach. Zaprojektowano zatem specjalne potoki dla realizacji identycznych obliczeń na całych wektorach oraz zastosowano mechanizm łańcuchowania (ang. chaining) potoków, po raz pierwszy w komputerze
1.1. Równoległość wewnątrz procesora i obliczenia wektorowe
3
Cray-1. Przykładowo, gdy wykonywana jest operacja postaci y ← y + αx,
(1.1)
wówczas jeden potok realizuje mnożenie wektora x przez liczbę α, drugi zaś dodaje wynik tego mnożenia do wektora y, bez konieczności oczekiwania na zakończenie obliczania pośredniego wyniku αx [15]. Co więcej, lista rozkazów procesorów zawiera rozkazy operujące na danych zapisanych w specjalnych rejestrach, zawierających pewną liczbę słów maszynowych stanowiących elementy wektorów, a wykonanie takich rozkazów odbywa się przy użyciu mechanizmów potokowości i łańcuchowania. Takie procesory określa się mianem wektorowych [15]. Zwykle są one wyposażone w pewną liczbę jednostek wektorowych oraz jednostkę skalarną realizującą obliczenia, które nie mogą być wykonane w sposób wektorowy. Realizując idee równoległości wewnątrz pojedynczego procesora na poziomie wykonywanych równolegle rozkazów (ang. instruction-level parallelism) powstała koncepcja budowy procesorów superskalarnych [41, 43], wyposażonych w kilka jednostek arytmetyczno-logicznych (ALU) oraz jedną lub więcej jednostek realizujących działania zmiennopozycyjne (FPU). Jednostki obliczeniowe otrzymują w tym samym cyklu do wykonania instrukcje pochodzące zwykle z pojedynczego strumienia. Zależność między poszczególnymi instrukcjami jest sprawdzana dynamicznie w trakcie wykonania programu przez odpowiednie układy procesora. Przykładem procesora, w którym zrealizowano superskalarność, jest PowerPC 970 firmy IBM. Ciekawym pomysłem łączącym ideę wektorowości z użyciem szybkich procesorów skalarnych jest architektura ViVA (ang. Virtual Vector Architecture [46]) opracowana przez IBM. Zakłada ona połączenie ośmiu skalarnych procesorów IBM Power5 w taki sposób, aby mogły działać jak pojedynczy procesor wektorowy o teoretycznej maksymalnej wydajności na poziomie 60-80 Gflops1 . Architektura ViVA została wykorzystana przy budowie superkomputera ASC Purple zainstalowanego w Lawrence Livermore National Laboratory, który w listopadzie 2006 uplasował się na czwartym miejscu listy rankingowej Top500 systemów komputerowych o największej mocy obliczeniowej na świecie [11]. Warto wspomnieć, że podobną ideę zastosowano przy budowie superkomputera Cray X1, gdzie połączono cztery procesory SSP (ang. single-streaming processor) w procesor MSP (ang. multi-streaming processor). 1
1 Gflops (= 1000 Mflops) jest miarą wydajności komputerówi oznacza 109 operacji zmiennopozycyjnych na sekundę. Szczegółowo wyjaśniamy to pojęcie w rozdziale 2.
4
1. Przegląd architektur komputerów równoległych
xmm0:
xmm1:
xmm0:
x3
x2
x1
x0
+
+
+
+
y3
y2
y1
y0
=
=
=
=
x3+y3
x2+y2
x1+y1
x0+y0
Rysunek 1.1. Dodawanie wektorów przy użyciu rozkazu addps xmm0,xmm1
Idea wektorowości została wykorzystana w popularnych procesorach Intela, które począwszy od modelu Pentium III zostały wyposażone w mechanizm SSE (ang. streaming SIMD extensions [32, 33]), umożliwiający działanie na czteroelementowych wektorach liczb zmiennopozycyjnych pojedynczej precyzji, przechowywanych w specjalnych 128-bitowych rejestrach (ang. 128-bit packed single-precision floating-point) za pomocą pojedynczych rozkazów, co stanowi realizację koncepcji SIMD (ang. single instruction stream, multiple data stream) z klasyfikacji maszyn cyfrowych według Flynna [22]. Rysunek 1.1 pokazuje sposób realizacji operacji dodawania dwóch wektorów czteroelementowych za pomocą rozkazów SSE. W przypadku działania na dłuższych wektorach stosowana jest technika dzielenia wektorów na części czteroelementowe, które są przetwarzane przy użyciu rozkazów SSE. Wprowadzono również rozkazy umożliwiające wskazywanie procesorowi konieczności załadowania do pamięci podręcznej potrzebnych danych (ang. prefetching). Mechanizm SSE2, wprowadzony w procesorach Pentium 4 oraz procesorach Athlon 64 firmy AMD, daje możliwość operowania na wektorach liczb zmiennopozycyjnych podwójnej precyzji oraz liczb całkowitych przechowywanych również w 128-bitowych rejestrach. Dalsze rozszerzenia SSE3 i SSE4 [34,35] wprowadzone odpowiednio w procesorach Pentium 4 Prescot oraz Core 2 Duo poszerzają zestaw operacji o arytmetykę na wektorach liczb zespolonych i nowe rozkazy do przetwarzania multimediów, wspierające przykładowo obróbkę formatów wideo. Użycie rozkazów z repertuaru SSE na ogół znacznie przyspiesza działanie programu, gdyż zmniejsza się liczba wykonywanych rozkazów w stosunku do liczby przetworzonych danych.
1.2. Wykorzystanie pamięci komputera
5
bank 0
bank 1
bank 6
bank 7
A(1)
A(2)
A(7)
A(8)
A(9)
A(10)
A(15)
A(16)
A(17)
A(18)
A(23)
A(24)
... A(25)
A(26)
A(31)
A(32)
A(33)
A(34)
A(39)
A(40)
...
...
...
...
Rysunek 1.2. Rozmieszczenie składowych tablicy w ośmiu bankach pamięci
1.2. Wykorzystanie pamięci komputera Kolejnym ważnym elementem architektury komputerów, który w znacznym stopniu decyduje o szybkości obliczeń, jest system pamięci, obejmujący zarówno pamięć operacyjną, zewnętrzną oraz, mającą kluczowe znaczenie dla osiągnięcia wysokiej wydajności obliczeń, pamięć podręczną. 1.2.1. Podział pamięci na banki Aby zapewnić szybką współpracę procesora z pamięcią, jest ona zwykle dzielona na banki, których liczba jest potęgą dwójki. Po każdym odwołaniu do pamięci (odczyt lub zapis) bank pamięci musi odczekać pewną liczbę cykli zegara, zanim będzie gotowy do obsługi następnego odwołania. Jeśli dane są pobierane z pamięci w ten sposób, że kolejne ich elementy znajdują się w kolejnych bankach pamięci, wówczas pamięć jest wykorzystywana optymalnie, co oczywiście wiąże się z osiąganiem pożądanej dużej efektywności wykonania programu. Kompilatory języków programowania zwykle organizują rozmieszczenie danych w pamięci w ten sposób (ang. memory interleaving), że kolejne elementy danych (najczęściej składowe tablic) są alokowane w kolejnych bankach pamięci (rysunek 1.2). Niewłaściwa organizacja przetwarzania danych
6
1. Przegląd architektur komputerów równoległych umieszczonych w pamięci w ten właśnie sposób może spowodować znaczne spowolnienie działania programu. Rozważmy przykładowo następującą konstrukcję iteracyjną. 1 2 3
f o r ( i =1; i<=n ; i+=k ) { A[ i ]++; }
Jeśli składowe tablicy A przetwarzane są kolejno (K=1), wówczas nie występuje oczekiwanie procesora na pamięć, gdyż aktualnie przetwarzane składowe znajdują się w kolejnych bankach pamięci. Jeśli zaś przykładowo K=4, wówczas będą przetwarzane kolejno składowe A(1), A(5), A(9), A(11) itd. Zatem co druga składowa będzie się znajdować w tym samym banku. Spowoduje to konflikt w dostępie do banków pamięci, procesor będzie musiał czekać na pamięć, co w konsekwencji znacznie spowolni obliczenia. W praktyce, konflikty w dostępie do banków pamięci mogą spowodować nawet siedmiokrotny wzrost czasu obliczeń [17, 52, 53]. Należy zatem unikać sytuacji, gdy wartość zmiennej K będzie wielokrotnością potęgi liczby dwa. 1.2.2. Pamięć podręczna Kolejnym elementem architektury komputera, który ma ogromny wpływ na szybkość wykonywania obliczeń, jest pamięć podręczna (ang. cache memory). Jest to na ogół niewielka rozmiarowo pamięć umieszczana między procesorem a główną pamięcią operacyjną, charakteryzująca się znacznie większą niż ona szybkością działania. W pamięci podręcznej składowane są zarówno rozkazy, jak i dane, których wykorzystanie przewidują odpowiednie mechanizmy procesora [57]. Nowoczesne systemy komputerowe mają przynajmniej dwa poziomy pamięci podręcznej. Rejestry procesora, poszczególne poziomy pamięci podręcznej, pamięć operacyjna i pamięć zewnętrzna tworzą hierarchię pamięci komputera. Ogólna zasada jest następująca: im dalej od procesora, tym pamięć ma większą pojemność, ale jest wolniejsza. Aby efektywnie wykorzystać hierarchię pamięci, algorytmy powinny realizować koncepcję lokalności danych (ang. data locality). Pewna porcja danych powinna być pobierana „w stronę procesora”, czyli do mniejszej, ale szybszej pamięci. Następnie, gdy dane znajdują się w pamięci podręcznej najbliżej procesora, powinny być realizowane na nich wszystkie konieczne i możliwe do wykonania na danym etapie działania programu. W optymalnym przypadku algorytm nie powinien więcej odwoływać się do tych danych. Koncepcję lokalności danych najpełniej wykorzystano przy projektowaniu blokowych wersji podstawowych algorytmów algebry liniowej w projekcie ATLAS [65]. Pobieranie danych do pamięci podręcznej „bliżej procesora” jest zwykle realizowane automatycznie przez odpowiednie układy procesora,
1.2. Wykorzystanie pamięci komputera choć lista rozkazów procesora może być wyposażona w odpowiednie rozkazy „powiadamiania” procesora o konieczności przesłania określonego obszaru pamięci w stronę procesora, jak to ma miejsce w przypadku rozszerzeń SSE [33]. Dzięki temu, gdy potrzebne dane znajdują się w pamięci podręcznej pierwszego poziomu, dany rozkaz będzie mógł być wykonany bez opóźnienia. W przypadku konieczności ładowania danych z pamięci operacyjnej oczekiwanie może trwać od kilkudziesięciu do kilkuset cykli [32, rozdział 6]. W przypadku obliczeń na macierzach rzeczą naturalną wydaje się użycie tablic dwuwymiarowych. Poszczególne składowe mogą być rozmieszczane wierszami (języki C/C++) albo kolumnami (język Fortran), jak przedstawiono na rysunku 1.3. Rozważmy przykładowo macierz a11 . . . a1n .. ∈ IRm×n . A = ... (1.2) . am1 . . . amn Przy rozmieszczeniu elementów kolumnami istotny jest parametr LDA (ang. leading dimension of array), określający liczbę wierszy tablicy dwuwymiarowej, w której przechowywana jest macierz (1.2). Zwykle przyjmuje się LDA = m, choć w pewnych przypadkach z uwagi na możliwe lepsze wykorzystanie pamięci podręcznej, korzystniej jest zwiększyć wiodący rozmiar tablicy (ang. leading dimension padding), przyjmując za LDA liczbę nieparzystą większą niż m [39], co oczywiście wiąże się z koniecznością alokacji większej ilości pamięci dla tablic przechowujących dane programu. W pewnych przypadkach użycie tablic dwuwymiarowych może się wiązać z występowaniem zjawiska braku potrzebnych danych w pamięci podręcznej (ang. cache miss). Ilustruje to rysunek 1.4. Przypuśćmy, że elementy tablicy dwuwymiarowej rozmieszczane są kolumnami (ang. column major storage), a w pewnym algorytmie elementy macierzy są przetwarzane wierszami. Gdy program odwołuje się do pierwszej składowej w pierwszym wierszu, wówczas do pamięci podręcznej ładowany jest blok kolejnych słów z pamięci operacyjnej (ang. cache line), zawierający potrzebny element. Niestety, gdy następnie program odwołuje się do drugiej składowej w tym wierszu, nie znajduje się ona w pamięci podręcznej. Gdy rozmiar bloku ładowanego do pamięci podręcznej jest mniejszy od liczby wierszy, przetwarzanie tablicy może wiązać się ze słabym wykorzystaniem pamięci podręcznej (duża liczba cache miss). Łatwo zauważyć, że zmiana porządku przetwarzania tablicy na kolumnowy znacznie poprawi efektywność, gdyż większość potrzebnych składowych tablicy będzie się znajdować w odpowiednim momencie w pamięci podręcznej (ang. cache hit). Trzeba jednak zaznaczyć, że taka zmiana porządku przetwarzania składowych tablicy (ang. loop interchange) nie zawsze jest możliwa.
7
8
1. Przegląd architektur komputerów równoległych
A =
1 2 3 4 5 6 7 *
9 10 11 12 13 14 15 *
17 18 19 20 21 22 23 *
25 26 27 28 29 30 31 *
33 34 35 36 37 38 39 *
41 42 43 44 45 46 47 *
49 50 51 52 53 54 55 *
57 58 59 60 61 62 63 *
65 66 67 68 69 70 71 *
73 74 75 76 77 78 79 *
Rysunek 1.3. Kolumnowe rozmieszczenie składowych tablicy dwuwymiarowej 7×10 dla LDA=8
Rysunek 1.4. Zjawisko cache miss przy rozmieszczeniu kolumnowym
1.2.3. Alternatywne sposoby reprezentacji macierzy W celu ograniczenia opisanych w poprzednim punkcie niekorzystnych zjawisk, związanych ze stosowaniem tablic dwuwymiarowych, zaproponowano alternatywne sposoby reprezentacji macierzy [28, 29], które prowadzą do konstrukcji bardzo szybkich algorytmów [20]. Podstawową ideą jest podział macierzy na bloki według następującego schematu A11 . . . A1ng .. m×n A = ... . (1.3) ∈ IR . Amg 1 . . . Amg ng Każdy blok Aij jest składowany w postaci kwadratowego bloku o rozmiarze nb × nb , w ten sposób, aby zajmował zwarty obszar pamięci operacyjnej,
co pokazuje rysunek 1.5. Oczywiście w przypadku, gdy liczby wierszy i kolumn nie dzieli się przez nb , wówczas dolne i prawe skrajne bloki macierzy nie są kwadratowe. Rozmiar bloku nb powinien być tak dobrany, aby cały blok mógł zmieścić się w pamięci podręcznej pierwszego poziomu. Dzięki temu pamięć podręczna może być wykorzystana znacznie bardziej efektywnie, oczywiście pod warunkiem, że algorytm jest ukierunkowany na przetwarzanie poszczególnych bloków macierzy. Wymaga to odpowiedniej konstrukcji algorytmu, ale pozwala na bardzo dobre wykorzystanie mocy obliczeniowej procesora [28]. Postuluje się również implementację wsparcia nowych sposobów reprezentacji na poziomie kompilatora, co znacznie ułatwiłoby konstrukcję efektywnych i szybkich algorytmów [20]. W pracy [61] przedstawiono zastosowanie nowego sposobu reprezentacji macierzy dla numerycznego rozwiązywania równań różniczkowych zwyczajnych, zaś w pracy [62] podano nowy format reprezentacji macierzy wykorzystujący bloki prostokątne.
1.3. Komputery równoległe i klastry Istnieje wiele klasyfikacji komputerów równoległych (wyposażonych w więcej niż jeden procesor). W naszych rozważaniach będziemy zajmować się maszynami pasującymi do modelu MIMD (ang. multiple instruction stream, multiple data stream) według klasyfikacji Flynna [22], który to model obejmuje większość współczesnych komputerów wieloprocesorowych. Z punktu widzenia programisty najistotniejszy będzie jednak dalszy podział wynikający z typu zastosowanej pamięci (rysunek 1.6). Będziemy zatem zajmować się komputerami wieloprocesorowymi wyposażonymi we wspólną pamięć (ang.
9
10
1. Przegląd architektur komputerów równoległych
cache
cache
cache
cache
P1
P0
P2
P3
interconnection network
M
M0
M1
M2
M3
P0
P1
P2
P3
interconnection network
Rysunek 1.6. Komputery klasy MIMD z pamięcią wspólną i rozproszoną
shared memory), gdzie każdy procesor będzie mógł adresować dowolny fragment pamięci, oraz komputerami z pamięcią rozproszoną, które charakteryzują się brakiem realizowanej fizycznie wspólnej przestrzeni adresowej. 1.3.1. Komputery z pamięcią wspólną W tym modelu liczba procesorów będzie na ogół niewielka2 , przy czym poszczególne procesory mogą być wektorowe. Systemy takie charakteryzują się jednolitym (ang. uniform memory access, UMA) i szybkim dostępem procesorów do pamięci i w konsekwencji krótkim czasem synchronizacji i komunikacji między procesorami, choć próba jednoczesnego dostępu procesorów do modułów pamięci może spowodować ograniczenie tej szybkości. Aby zminimalizować to niekorzystne zjawisko, procesory uzyskują dostęp do modułów pamięci poprzez statyczną lub dynamiczną sieć połączeń (ang. interconnection network). Może mieć ona postać magistrali (ang. shared bus) lub przełącznicy krzyżowej (ang. crossbar switch). Możliwa jest też konstrukcja układów logicznych przełącznicy we wnętrzu modułów pamięci (pamięć wieloportowa, ang. multiport memory) bądź też budowa wielostopniowych sieci połączeń (ang. multistage networks). Więcej informacji na ten temat można znaleźć w książce [40]. Trzeba podkreślić, że w tym modelu kluczowe dla efektywności staje się właściwe wykorzystanie pamięci podręcznej. Dzięki temu procesor, odwołując się do modułu pamięci zawierającego potrzebne dane, pobierze większą ich ilość do pamięci podręcznej, a następnie będzie mógł przetwarzać je bez konieczności odwoływania się do pamięci operacyjnej. Wiąże się to również 2
Pod pojęciem „niewielka” w obecnej chwili należy rozumieć „rzędu kilku”, a maksymalnie kilkudziesięciu.
1.3. Komputery równoległe i klastry z koniecznością zapewnienia spójności pamięci podręcznej (ang. cache coherence), gdyż pewne procesory mogą jednocześnie modyfikować te same obszary pamięci operacyjnej przechowywane w swoich pamięciach podręcznych, co wymaga użycia odpowiedniego protokołu uzgadniania zawartości. Zwykle jest to realizowane sprzętowo [25, podrozdział 2.4.6]. Zadanie możliwie równomiernego obciążenia procesorów pracą jest jednym z zadań systemu operacyjnego i może być realizowane poprzez mechanizmy wielowątkowości, co jest określane mianem symetrycznego wieloprzetwarzania [38] (ang. symmetric multiprocessing – SMP).
1.3.2. Komputery z pamięcią rozproszoną Drugim rodzajem maszyn wieloprocesorowych będą komputery z pamięcią fizycznie rozproszoną (ang. distributed memory), charakteryzujące się brakiem realizowanej fizycznie wspólnej przestrzeni adresowej. W tym przypadku procesory będą wyposażone w system pamięci lokalnej (obejmujący również pamięć podręczną) oraz połączone ze sobą za pomocą sieci połączeń. Najbardziej powszechnymi topologiami takiej sieci są pierścień, siatka, drzewo oraz hipersześcian (ang. n-cube), szczególnie ważny z uwagi na możliwość zanurzenia w nim innych wykorzystywanych topologii sieci połączeń. Do tego modelu będziemy również zaliczać klastry budowane z różnych komputerów (niekoniecznie identycznych) połączonych siecią (np. Ethernet, Myrinet, InfiniBand). Komputery wieloprocesorowe budowane obecnie zawierają często oba rodzaje pamięci. Przykładem jest Cray X1 [49] składający się z węzłów obliczeniowych zawierających cztery procesory MSP, które mają dostęp do pamięci wspólnej. Poszczególne węzły są ze sobą połączone szybką magistralą i nie występuje wspólna dla wszystkich procesorów, realizowana fizycznie, przestrzeń adresowa. Podobną budowę mają klastry wyposażone w wieloprocesorowe węzły SMP, gdzie najczęściej każdy węzeł jest dwuprocesorowym lub czteroprocesorowym komputerem. Systemy komputerowe z pamięcią rozproszoną mogą udostępniać użytkownikom logicznie spójną przestrzeń adresową, podzieloną na pamięci lokalne poszczególnych procesorów, implementowaną sprzętowo bądź programowo. Każdy procesor może uzyskiwać dostęp do fragmentu wspólnej przestrzeni adresowej, który jest alokowany w jego pamięci lokalnej, znacznie szybciej niż do pamięci, która fizycznie znajduje się na innym procesorze. Architektury tego typu określa się mianem NUMA (ang. non-uniform memory access). Bardziej złożonym mechanizmem jest cc-NUMA (ang. cache coherent NUMA), gdzie stosuje się protokoły uzgadniania zawartości pamięci podręcznej poszczególnych procesorów [25, 38].
11
12
1. Przegląd architektur komputerów równoległych 1.3.3. Procesory wielordzeniowe W ostatnich latach ogromną popularność zdobyły procesory wielordzeniowe, których pojawienie się stanowi wyzwanie dla twórców oprogramowania [5,42]. Konstrukcja takich procesorów polega na umieszczaniu w ramach pojedynczego pakietu, mającego postać układu scalonego, więcej niż jednego rdzenia (ang. core), logicznie stanowiącego oddzielny procesor. Aktualnie (zima 2010/11) dominują procesory dwurdzeniowe (ang. dual-core) oraz czterordzeniowe (ang. quad-core) konstrukcji firmy Intel oraz AMD, choć na rynku dostępne są również procesory ośmiordzeniowe (procesor Cell zaprojektowany wspólnie przez firmy Sony, Toshiba i IBM). Poszczególne rdzenie mają własną pamięć podręczną pierwszego poziomu, ale mogą mieć wspólną pamięć podręczną poziomu drugiego (Intel Core 2 Duo, Cell). Dzięki takiej filozofii konstrukcji procesory charakteryzują się znacznie efektywniejszym wykorzystaniem pamięci podręcznej i szybszym zapewnianiem jej spójności w ramach procesora wielordzeniowego. Dodatkowym atutem procesorów multicore jest mniejszy pobór energii niż w przypadku identycznej liczby procesorów „tradycyjnych”. Efektywne wykorzystanie procesorów wielordzeniowych wiąże się zatem z koniecznością opracowania algorytmów równoległych, szczególnie dobrze wykorzystujących pamięć podręczną. W pracy [30] wykazano, że w przypadku obliczeń z zakresu algebry liniowej szczególnie dobre wyniki daje wykorzystanie nowych sposobów reprezentacji macierzy opisanych w podrozdziale 1.2.3.
1.4. Optymalizacja programów uwzględniająca różne aspekty architektur Wykorzystanie mechanizmów oferowanych przez współczesne komputery możliwe jest dzięki zastosowaniu kompilatorów optymalizujących kod pod kątem własności danej architektury. Przedstawimy teraz skrótowo rodzaje takiej optymalizacji. Trzeba jednak podkreślić, że zadowalająco dobre wykorzystanie własności architektur komputerowych jest możliwe po uwzględnieniu tak zwanego fundamentalnego trójkąta algorytmy–sprzęt–kompilatory (ang. algorithms–hardware–compilers [20]), co w praktyce oznacza konieczność opracowania odpowiednich algorytmów. 1.4.1. Optymalizacja maszynowa i skalarna Podstawowymi rodzajami optymalizacji kodu oferowanymi przez kompilatory jest zależna od architektury komputera optymalizacja maszynowa
1.4. Optymalizacja programów uwzględniająca różne aspekty architektur oraz niezależna sprzętowo optymalizacja skalarna [1,2]. Pierwszy rodzaj dotyczy właściwego wykorzystania architektury oraz specyficznej listy rozkazów procesora. W ramach optymalizacji skalarnej zwykle rozróżnia się dwa typy: optymalizację lokalną w ramach bloków składających się wyłącznie z instrukcji prostych bez instrukcji warunkowych oraz optymalizację globalną obejmującą kod całego podprogramu. Optymalizacja lokalna wykorzystuje techniki, takie jak eliminacja nadmiarowych podstawień, propagacja stałych, eliminacja wspólnych części kodu oraz nadmiarowych wyrażeń, upraszczanie wyrażeń. Optymalizacja globalna wykorzystuje podobne techniki, ale w obrębie całych podprogramów. Dodatkowo ważną techniką jest przemieszczanie fragmentów kodu. Przykładowo rozważmy następującą instrukcję iteracyjną. 1 2 3
f o r ( i =0; i
Wyrażenie (1+b)*(c+d) jest obliczane przy każdej iteracji pętli, dając za każdym razem identyczny wynik. Kompilator zastosuje przemieszczenie fragmentu kodu przed pętlę, co da następującą postać powyższej instrukcji iteracyjnej. 1 2 3 4
f l o a t temp1=(1+b ) ∗ ( c+d ) ; f o r ( i =0; i
Zatem, optymalizacja skalarna będzie redukować liczbę odwołań do pamięci i zmniejszać liczbę i czas wykonywania operacji, co powinno spowodować szybsze działanie programu. 1.4.2. Optymalizacja wektorowa i równoległa W przypadku procesorów wektorowych oraz procesorów oferujących podobne rozszerzenia (na przykład SSE w popularnych procesorach firmy Intel) największy przyrost wydajności uzyskuje się dzięki optymalizacji wektorowej oraz równoległej (zorientowanej na wykorzystanie wielu procesorów), o ile tylko postać kodu źródłowego na to pozwala. Konstrukcjami, które są bardzo dobrze wektoryzowane, to pętle realizujące przetwarzanie tablic w ten sposób, że poszczególne itaracje pętli są od siebie niezależne. W prostych przypadkach uniemożliwiających bezpośrednią wektoryzację stosowane są odpowiednie techniki przekształcania kodu źródłowego [68]. Należy do nich usuwanie instrukcji warunkowych z wnętrza pętli, ich rozdzielanie, czy też przenoszenie poza pętlę przypadków skrajnych. Niestety, w wielu
13
14
1. Przegląd architektur komputerów równoległych przypadkach nie istnieją bezpośrednie proste metody przekształcania kodu źródłowego w ten sposób, by możliwa była wektoryzacja pętli. Jako przykład rozważmy następujący prosty fragment kodu źródłowego. 1 2 3
f o r ( i =0; i
Do obliczenia wartości każdej następnej składowej tablicy jest wykorzystywana obliczona wcześniej wartość poprzedniej składowej. Taka pętla nie może być automatycznie zwektoryzowana i tym bardziej zrównoleglona. Zatem wykonanie konstrukcji tego typu będzie się odbywało bez udziału jednostek wektorowych i na ogół przebiegało z bardzo niewielką wydajnością obliczeń. W przypadku popularnych procesorów będzie to zaledwie około 10% maksymalnej wydajności, w przypadku zaś procesorów wektorowych znacznie mniej. Z drugiej strony, fragmenty programów wykonywane z niewielką wydajnością znacznie obniżają wypadkową wydajność obliczeń. W pracy [49] zawarto nawet sugestię, że w przypadku programów z dominującymi fragmentami skalarnymi należy rozważyć rezygnację z użycia superkomputera Cray X1, gdyż takie programy będą w stanie wykorzystać jedynie znikomy ułamek maksymalnej teoretycznej wydajności pojedynczego procesora. Dzięki automatycznej optymalizacji równoległej możliwe jest wykorzystanie wielu procesorów w komputerze. Instrukcje programu są dzielone na wątki (ciągi instrukcji wykonywanych na pojedynczych procesorach), które mogą być wykonywane równolegle (jednocześnie). Zwykle na wątki dzielona jest pula iteracji pętli. Optymalizacja równoległa jest często stosowana w połączeniu z optymalizacją wektorową. Pętle wewnętrzne są wektoryzowane, zewnętrzne zaś zrównoleglane.
1.5. Programowanie równoległe Istnieje kilka ukierunkowanych na możliwie pełne wykorzystanie oferowanej mocy obliczeniowej metodologii tworzenia oprogramowania na komputery równoległe. Do ważniejszych należy zaliczyć zastosowanie kompilatorów optymalizujących [2, 66, 68], które mogą dokonać optymalizacji kodu na poziomie języka maszynowego (optymalizacja maszynowa) oraz użytego języka programowania wysokiego poziomu (optymalizacja skalarna, wektorowa i równoległa). Niestety, taka automatyczna optymalizacja pod kątem wieloprocesorowości zastosowana do typowych programów, które implementują klasyczne algorytmy sekwencyjne, na ogół nie daje zadowalających rezultatów.
1.5. Programowanie równoległe Zwykle konieczne staje się rozważenie czterech aspektów tworzenia efektywnych programów na komputery równoległe [21, rozdział 3.2], [25]. 1. Identyfikacja równoległości obliczeń polegająca na wskazaniu fragmentów algorytmu lub kodu, które mogą być wykonywane równolegle, dając przy każdym wykonaniu programu ten sam wynik obliczeń jak w przypadku programu sekwencyjnego. 2. Wybór strategii dekompozycji programu na części wykonywane równolegle. Możliwe są dwie zasadnicze strategie: równoległość zadań (ang. task parallelism), gdzie podstawę analizy stanowi graf zależności między poszczególnymi (na ogół) różnymi funkcjonalnie zadaniami obliczeniowymi oraz równoległość danych (ang. data parallelism), gdzie poszczególne wykonywane równolegle zadania obliczeniowe dotyczą podobnych operacji wykonywanych na różnych danych. 3. Wybór modelu programowania, który determinuje wybór konkretnego języka programowania wspierającego równoległość obliczeń oraz środowiska wykonania programu. Jest on dokonywany w zależności od konkretnej architektury komputerowej, która ma być użyta do obliczeń. Zatem, możliwe są dwa główne modele: pierwszy wykorzystujący pamięć wspólną oraz drugi, oparty na wymianie komunikatów (ang. message-passing), gdzie nie zakłada się istnienia wspólnej pamięci dostępnej dla wszystkich procesorów. 4. Styl implementacji równoległości w programie, wynikający z przyjętej wcześniej strategii dekompozycji oraz modelu programowania (przykładowo zrównoleglanie pętli, programowanie zadań rekursywnych bądź model SPMD). Przy programowaniu komputerów równoległych z pamięcią wspólną wykorzystuje się najczęściej języki programowania Fortran i C/C++, ze wsparciem dla OpenMP [6]. Jest to standard definiujący zestaw dyrektyw oraz kilku funkcji bibliotecznych, umożliwiający specyfikację równoległości wykonania poszczególnych fragmentów programu oraz synchronizację wielu wątków działających równolegle. Zrównoleglanie możliwe jest na poziomie pętli oraz poszczególnych fragmentów kodu (sekcji). Komunikacja między wątkami odbywa się poprzez wspólną pamięć. Istnieje również możliwość specyfikowania operacji atomowych. Program rozpoczyna działanie jako pojedynczy wątek. W miejscu specyfikacji równoległości (za pomocą odpowiednich dyrektyw definiujących region równoległy) następuje rozdzielenie wątku głównego na grupę wątków działających równolegle aż do miejsca złączenia. W programie może wystąpić wiele regionów równoległych. Programowanie w OpenMP omawiamy szczegółowo w rozdziale 4. Architektury wieloprocesorowe z pamięcią rozproszoną programuje się zwykle wykorzystując środowisko MPI (ang. Message Passing Interface [51]), wspierające model programu typu SPMD (ang. Single Program, Multiple
15
16
1. Przegląd architektur komputerów równoległych Data) lub powoli wychodzące z użycia środowisko PVM (ang. Parallel Virtual Machine [19]). Program SPMD w MPI zakłada wykonanie pojedynczej instancji programu (procesu) na każdym procesorze biorącym udział w obliczeniach [36]. Standard MPI definiuje zbiór funkcji umożliwiających programowanie równoległe za pomocą wymiany komunikatów (ang. message-passing). Oprócz funkcji ogólnego przeznaczenia inicjujących i kończących pracę procesu w środowisku równoległym, najważniejszą grupę stanowią funkcje przesyłania danych między procesami. Wyróżnia się tu komunikację między dwoma procesami (ang. point-to-point) oraz komunikację strukturalną w ramach grupy wątków (tak zwaną komunikację kolektywną oraz operacje redukcyjne). Programowanie w MPI omawiamy szczegółowo w rozdziałach 5 oraz 6 Innymi mniej popularnymi narzędziami programowania komputerów z pamięcią rozproszoną są języki Co-array Fortran (w skrócie CAF [21, podrozdział 12.4]) oraz Unified Parallel C (w skrócie UPC [8]). Oba rozszerzają standardowe języki Fortran i C o mechanizmy umożliwiające programowanie równoległe. Podobnie jak MPI, CAF zakłada wykonanie programu w wielu kopiach (obrazach, ang. images) posiadających swoje własne dane. Poszczególne obrazy mogą się odwoływać do danych innych obrazów, bez konieczności jawnego użycia operacji przesyłania komunikatów. Oczywiście CAF posiada również mechanizmy synchronizacji działania obrazów. Język UPC, podobnie jak MPI oraz CAF, zakłada wykonanie programu, opierając się na modelu SPMD. Rozszerza standard C o mechanizmy definiowania danych we wspólnej przestrzeni adresowej, która fizycznie jest alokowana porcjami w pamięciach lokalnych poszczególnych procesów i umożliwia dostęp do nich bez konieczności jawnego użycia funkcji przesyłania komunikatów.
Rozdział 2 Modele realizacji obliczeń równoległych
2. Modele realizacji obliczeń równoległych W niniejszym rozdziale przedstawimy wybrane modele realizacji obliczeń na współczesnych komputerach wektorowych oraz równoległych.
2.1. Przyspieszenie Podstawową miarą charakteryzującą wykonanie programu na komputerze jest czas obliczeń. Stosowane techniki optymalizacji „ręcznej”, gdzie dostosowuje się program do danej architektury komputera poprzez wprowadzenie zmian w kodzie źródłowym, bądź też opracowanie nowego algorytmu dla danego typu architektury komputera mają na celu skrócenie czasu działania programu. W konsekwencji możliwe jest rozwiązywanie w pewnym, akceptowalnym dla użytkownika czasie problemów o większych rozmiarach lub też w przypadku obliczeń numerycznych uzyskiwanie większej dokładności wyników, na przykład poprzez zagęszczenie podziału siatki lub wykonanie większej liczby iteracji danej metody. Jednakże operowanie bezwzględnymi czasami wykonania poszczególnych programów bądź też ich fragmentów realizujących konkretne algorytmy może nie odzwierciedlać w wystarczającym stopniu zysku czasowego, jaki uzyskuje się dzięki optymalizacji. Stąd wygodniej jest posługiwać się terminem przyspieszenie (ang. speedup), pokazującym, ile razy szybciej działa program (lub jego fragment realizujący konkretny algorytm) zoptymalizowany na konkretną architekturę komputera względem pewnego programu uznanego za punkt odniesienia. Podamy teraz za książkami [38], [50] oraz [15] najważniejsze pojęcia z tym związane. Definicja 2.1. ( [38]) Przyspieszeniem bezwzględnym algorytmu równoległego nazywamy wielkość t? s?p = 1 , (2.1) tp gdzie t?1 jest czasem wykonania najlepszej realizacji algorytmu sekwencyjnego, a tp czasem działania algorytmu równoległego na p procesorach. Często wielkość t?1 nie jest znana, a zatem w praktyce używa się również innej definicji przyspieszenia. Definicja 2.2. ( [38]) Przyspieszeniem względnym algorytmu równoległego nazywamy wielkość t1 sp = , (2.2) tp gdzie t1 jest czasem wykonania algorytmu na jednym procesorze, a tp czasem działania tego algorytmu na p procesorach. W przypadku analizy programów wektorowych przyspieszenie uzyskane dzięki wektoryzacji definiuje się podobnie, jako zysk czasowy osiągany względem najszybszego algorytmu skalarnego.
2.1. Przyspieszenie
19
Definicja 2.3. ( [50]) Przyspieszeniem algorytmu wektorowego względem najszybszego algorytmu skalarnego nazywamy wielkość s?v =
t?s , tv
(2.3)
gdzie t?s jest czasem działania najlepszej realizacji algorytmu skalarnego, a tv czasem działania algorytmu wektorowego. Algorytmy wektorowe często charakteryzują się większą liczbą operacji arytmetycznych w porównaniu do najlepszych (najszybszych) algorytmów skalarnych. W praktyce użyteczne są algorytmy, które charakteryzują się ograniczonym wzrostem złożoności obliczeniowej (traktowanej jako liczba operacji zmiennopozycyjnych w algorytmie) w stosunku do liczby operacji wykonywanych przez najszybszy algorytm skalarny, co intuicyjnie oznacza, że zysk wynikający z użycia wektorowości nie będzie „pochłaniany” przez znaczący wzrost liczby operacji algorytmu wektorowego dla większych rozmiarów problemu. Algorytmy o tej własności nazywamy zgodnymi (ang. consistent) z najlepszym algorytmem skalarnym rozwiązującym dany problem. Formalnie precyzuje to następująca definicja. Definicja 2.4. ( [50]) Algorytm wektorowy rozwiązujący problem o rozmiarze n nazywamy zgodnym z najszybszym algorytmem skalarnym, gdy V (n) = C < +∞ n→∞ S(n) lim
(2.4)
gdzie V (n) oraz S(n) oznaczają odpowiednio liczbę operacji zmiennopozycyjnych algorytmu wektorowego i najszybszego algorytmu skalarnego. Jak zaznaczyliśmy w podrozdziale 1.1, większość współczesnych procesorów implementuje równoległość na wielu poziomach dla osiągnięcia dużej wydajności obliczeń, co oczywiście wymaga użycia odpowiednich algorytmów, które będą w stanie wykorzystać możliwości oferowane przez architekturę konkretnego procesora. Użycie komputerów wieloprocesorowych wiąże się dodatkowo z koniecznością uwzględnienia równoległości obliczeń również na poziomie grupy oddzielnych procesorów. Zatem opracowywanie nowych algorytmów powinno uwzględniać możliwości optymalizacji kodu źródłowego pod kątem użycia równoległości na wielu poziomach oraz właściwego wykorzystania hierarchii pamięci, dzięki czemu czas obliczeń może skrócić się znacząco. Definicje 2.2 i 2.3 uwzględniające jedynie równoległość na poziomie grupy procesorów oraz wektorowości nie oddają w pełni zysku czasowego, jaki otrzymuje się poprzez zastosowanie algorytmu opracowanego z myślą o konkretnym sprzęcie komputerowym, gdzie równoległość może być zaimplementowana na wielu poziomach. Zatem podobnie jak w książce [21, podrozdział
20
2. Modele realizacji obliczeń równoległych 8.8], będziemy definiować przyspieszenie jako miarę tego, jak zmienia się czas obliczeń dzięki zastosowanej optymalizacji dla danej architektury komputerowej. Otrzymamy w ten sposób następującą definicję. Definicja 2.5. ( [50]) Przyspieszeniem algorytmu A względem algorytmu B nazywamy wielkość tB s= , (2.5) tA gdzie tA jest czasem działania algorytmu A, a tB czasem działania algorytmu B na danym systemie komputerowym dla takiego samego rozmiaru problemu. Wydajność obliczeniową współczesnych systemów komputerowych 1 (ang. computational speed of modern computer architectures inaczej performance of computer programs on modern computer architectures [15]) będziemy podawać w milionach operacji zmiennopozycyjnych na sekundę (Mflops) i definiować jako N r= Mflops, (2.6) t gdzie N oznacza liczbę operacji zmiennopozycyjnych wykonanych w czasie t mikrosekund. Producenci sprzętu podają opierając się na wzorze (2.6) teoretyczną maksymalną wydajność obliczeniową rpeak (ang. peak performance). Na ogół dla konkretnych programów wykonywanych na danym sprzęcie zachodzi r < rpeak . Oczywiście, im wartość obliczona ze wzoru (2.6) jest większa, tym lepsze wykorzystanie możliwości danej architektury komputerowej. Oczywiście, różne programy rozwiązujące dany problem obliczeniowy różnymi metodami mogą się charakteryzować różnymi liczbami wykonywanych operacji, stąd wydajność będziemy traktować jako pomocniczą charakterystykę jakości algorytmu wykonywanego na konkretnym sprzęcie. W przypadku gdy różne algorytmy charakteryzują się identyczną liczbą operacji, wielkość (2.6) stanowi ważne kryterium porównania algorytmów przy jednoczesnym wskazaniu na stopień wykorzystania możliwości sprzętu. Przekształcając wzór (2.6), wnioskujemy, że czas wykonania programu spełnia następującą zależność t=
N µs, r
(2.7)
t=
N s. 106 r
(2.8)
co jest równoważne
1
Innym polskim tłumaczeniem tego terminu jest szybkość komputerów w zakresie obliczeń numerycznych [38].
2.2. Prawo Amdahla 1000
21
Prawo Amdahla
900 800
Mflops
700 600 500 400 300 200 100 0 0
0.2
0.4
0.6
0.8
1
f
Rysunek 2.1. Prawo Amdahla dla V = 1000 oraz S = 50 Mflops
Dla poszczególnych fragmentów programu może być osiągnięta różna wydajność, a zatem wzór (2.6) opisuje tylko średnią wydajność obliczeniową danej architektury. Poniżej przedstawimy najważniejsze modele, które znacznie lepiej oddają specyfikę wykonania programów na współczesnych komputerach.
2.2. Prawo Amdahla Niech f będzie częścią programu składającego się z N operacji zmiennopozycyjnych, dla którego osiągnięto wydajność V , a 1 − f częścią wykonywaną przy wydajności S, przy czym V S. Wówczas korzystając z (2.7), otrzymujemy łączny czas wykonywania obliczeń obu części programu t=f
N N f 1−f + (1 − f ) = N ( + ) V S V S
oraz uwzględniając (2.6) otrzymujemy wydajność obliczeniową komputera, który wykonuje dany program r=
1 f V
+
(1−f ) S
Mflops.
(2.9)
Wzór (2.9) nosi nazwę prawo Amdahla [15,16] i opisuje wpływ optymalizacji fragmentu programu na wydajność obliczeniową danej architektury. Jako przykład rozważmy sytuację, gdy V = 1000 oraz S = 50 Mflops. Rysunek 2.1 pokazuje osiągniętą wydajność (Mflops) w zależności od wartości f . Możemy zaobserwować, że relatywnie duża wartość f = 0.8, dla
22
2. Modele realizacji obliczeń równoległych której osiągnięta jest maksymalna wydajność, skutkuje wydajnością wykonania całego programu równą 200 Mflops, a zatem cały program wykorzystuje zaledwie 20% teoretycznej maksymalnej wydajności. Oznacza to, że aby uzyskać zadowalająco krótki czas wykonania programu, należy zadbać o zoptymalizowanie jego najwolniejszych części. Zauważmy też, że w omawianym przypadku największy wzrost wydajności obliczeniowej danej architektury uzyskujemy przy zmianie wartości f od 0.9 do 1.0. Zwykle jednak fragmenty programu, dla których jest osiągnięta niewielka wydajność, to obliczenia w postaci rekurencji bądź też realizujące dostęp do pamięci w sposób nieoptymalny, które wymagają zastosowania specjalnych algorytmów dla osiągnięcia zadowalającego czasu wykonania.
2.3. Model Hockneya-Jesshope’a Innym modelem, który dokładniej charakteryzuje obliczenia wektorowe jest model Hockneya - Jesshope’a obliczeń wektorowych [15,31], pokazujący wydajność komputera wykonującego obliczenia w postaci pętli. Może on być również przydatny przy analizie i predykcji czasu działania programów wykonywanych na komputerach z popularnymi procesorami wyposażonymi w rozszerzenia wektorowe (np. SSE). Rozważmy pętlę o N iteracjach. Wydajność, jaką osiąga komputer wykonując takie obliczenia, wyraża się wzorem r∞ rN = Mflops, (2.10) n1/2 /N + 1 gdzie r∞ oznacza wydajność komputera (Mflops) wykonującego „nieskończoną” pętlę (bardzo długą), n1/2 zaś jest długością (liczbą iteracji) pętli, dla której osiągnięta jest wydajność około r∞ /2. Przykładowo, operacja DOT wyznaczenia iloczynu skalarnego wektorów x, y ∈ IRN dot ← xT y ma postać następującej pętli o liczbie iteracji równej N . 1 2 3 4
dot = 0 . 0 ; f o r ( i =0; i
Łączna liczba operacji zmiennopozycyjnych wykonywanych w powyższej konstrukcji wynosi zatem 2N . Stąd czas wykonania operacji DOT dla wektorów o N składowych wynosi w sekundach TDOT (N ) =
2N 2 · 10−6 = (n1/2 + N ). 106 rN r∞
(2.11)
2.3. Model Hockneya-Jesshope’a
23
Podobnie zdefiniowana wzorem (1.1) operacja AXPY może być w najprostszej postaci2 zaprogramowana jako następująca konstrukcja iteracyjna. 1 2 3
f o r ( i =0; i
Na każdą iterację pętli przypadają dwie operacje arytmetyczne, stąd czas jej wykonania wyraża się wzorem TAXP Y (N ) =
2N 2 · 10−6 = (n1/2 + N ). 106 rN r∞
(2.12)
Oczywiście, wielkości r∞ oraz n1/2 występujące odpowiednio we wzorach (2.11) i (2.12) są na ogół różne, nawet dla tego samego procesora. Wadą modelu jest to, że nie uwzględnia on zagadnień związanych z organizacją pamięci w komputerze. Może się zdarzyć, że taka sama pętla, operująca na różnych zestawach danych alokowanych w pamięci operacyjnej w odmienny sposób, będzie w każdym przypadku wykonywana przy bardzo różnych wydajnościach. Może to być spowodowane konfliktami w dostępie do banków pamięci bądź też innym schematem wykorzystania pamięci podręcznej. 2.3.1. Przykład zastosowania Jako przykład ilustrujący zastosowanie modelu Hockneya-Jesshope’a do analizy algorytmów, rozważmy dwa algorytmy rozwiązywania układu równań liniowych Lx = b, (2.13) gdzie x, b ∈ IRN oraz L=
a11 a21 .. .
a22
aN,1 · · ·
.
..
. ···
aN,N
Układ może być rozwiązany za pomocą następującego algorytmu [59]: ( x1 = b1 /a11 P (2.14) xi = bi − i−1 k=1 aik xk /aii dla i = 2, . . . , N. 2
W rzeczywistości kod źródłowy operacji DOT i AXPY w bibliotece BLAS jest bardziej skomplikowany. Składowe wektorów nie muszą być kolejnymi składowymi tablic oraz zaimplementowany jest mechanizm rozwijania pętli w sekwencje instrukcji (ang. loop unrolling).
24
2. Modele realizacji obliczeń równoległych Zauważmy, że w algorytmie dominuje operacja DOT. Stąd pomijając czas potrzebny do wykonania N dzieleń zmiennopozycyjnych wnosimy, że łączny czas działania algorytmu wyraża się wzorem T1 (N ) =
N −1 X
N −1 X 2 · 10−6 n1/2 (N − 1) + TDOT (k) = k r∞ k=1 k=1 N 2 · 10−6 (N − 1) n1/2 + . r∞ 2
=
!
(2.15)
Inny algorytm otrzymamy wyznaczając postać macierzy L−1 . Istotnie, macierz L może być zapisana jako L = L1 L2 · · · LN , gdzie
W algorytmie opartym na wzorach (2.16) i (2.17) nie trzeba składować wszystkich wyznaczanych wektorów. Każdy kolejny wektor yi będzie składowany na miejscu poprzedniego, to znaczy yi−1 . Stąd operacja aktualizacji wektora we wzorze (2.17) przyjmie postać sekwencji operacji skalarnej yi ← yi /aii ,
(2.18)
a następnie wektorowej yi+1 yi+1 ai+1,i .. . . . ← .. − yi .. . yN yN aN,i
(2.19)
Zauważmy, że (2.19) to właśnie operacja AXPY. Stąd podobnie jak w przypadku poprzedniego algorytmu, pomijając czas potrzebny do wykonania dzielenia (2.18), otrzymujemy T2 (N ) = =
Zatem, dla obu algorytmów czas wykonania operacji wektorowych wyraża się podobnie w postaci funkcji zależnych od parametrów r∞ , n1/2 , właściwych dla operacji DOT i AXPY. Dla komputera wektorowego C3210 wartości r∞ oraz n1/2 dla operacji DOT wynoszą odpowiednio r∞ = 18, n1/2 = 36, zaś dla operacji AXPY mamy r∞ = 16, n1/2 = 26. Zatem T1 (1000) = 0.059 oraz T2 (1000) = 0.066. Zauważmy, że mimo jednakowej, wynoszącej w przypadku obu algorytmów, liczby operacji arytmetycznych N 2 , wyznaczony czas działania każdego algorytmu jest inny. W pracy [63] przedstawiono inne zastosowanie omówionego wyżej modelu Hockney’a-Jesshope’a dla wyznaczania optymalnych wartości parametrów metody divide and conquer wyznaczania rozwiązania liniowych równań rekurencyjnych o stałych współczynnikach.
2.4. Prawo Amdahla dla obliczeń równoległych Prawo Amdahla ma swój odpowiednik również dla obliczeń równoległych [15]. Przypuśćmy, że czas wykonania programu na jednym procesorze wynosi t1 . Niech f oznacza część programu, która może być idealnie zrównoleglona na p procesorach. Pozostała sekwencyjna część programu (1 − f )
26
2. Modele realizacji obliczeń równoległych
16
Prawo Amdahla
14
przyspiszenie
12 10 8 6 4 2 0 0
0.2
0.4
0.6
0.8
1
f
Rysunek 2.2. Prawo Amdahla dla obliczeń równoległych, p = 16
będzie wykonywana na jednym procesorze. Łączny czas wykonania programu równoległego przy użyciu p procesorów wynosi tp = f
t1 t1 (f + (1 − f )p) + (1 − f )t1 = . p p
Stąd przyspieszenie w sensie definicji 2.2 wyraża się wzorem [15]: sp =
t1 p = . tp f + (1 − f )p
(2.21)
Rysunek 2.2 pokazuje wpływ zrównoleglonej części f na przyspieszenie względne programu. Można zaobserwować bardzo duży negatywny wpływ części sekwencyjnej (niezrównoleglonej) na osiągnięte przyspieszenie – podobnie jak w przypadku podstawowej wersji prawa Amdahla określonego wzorem (2.9).
2.5. Model Gustafsona Prawo Amdahla zakłada stały rozmiar rozwiązywanego problemu. Tymczasem zwykle wraz ze wzrostem dostępnych zasobów (zwykle procesorów) zwiększa się również rozmiar problemu. W pracy [26] Gustafson zaproponował model alternatywny dla prawa Amdahla. Głównym jego założeniem jest fakt, że w miarę wzrostu posiadanych zasobów obliczeniowych (liczba procesorów, wydajność komputera) zwiększa się rozmiar rozwiązywanych problemów. Zatem w tym modelu przyjmuje się za stały czas obliczeń.
2.6. Zadania
27
Niech ts oraz tp oznaczają odpowiednio czas obliczeń sekwencyjnych (na jednym procesorze) oraz czas obliczeń na komputerze równoległym o p procesorach. Niech dalej f będzie częścią czasu tp wykonywaną na w sposób równoległy, zaś 1 − f częścią sekwencyjną (wykonywaną na jednym procesorze). Dla uproszczenia przyjmijmy, że tp = 1. Wówczas czas wykonania tego programu na jednym procesorze wyrazi się wzorem ts = pf + 1 − f. Przyspieszenie3 programu równoległego wyraża się wzorem [15] sp,f = 1 + f (1 − p) = p + (1 − p)(1 − f ). Użyteczność tego modelu została wykazana w pracy [27] przy optymalizacji programów na komputer NCube [15]. Model uwzględnia również typowe podejście stosowane obecnie w praktyce. Gdy dysponujemy większymi zasobami obliczeniowymi (np. liczbą procesorów), zwiększamy rozmiary rozwiązywanych problemów i przyjmujemy, że czas obliczeń, który jest dla nas akceptowalny, pozostaje bez zmian.
2.6. Zadania Poniżej zamieściliśmy kilka zadań do wykonania samodzielnego. Ich celem jest utrwalenie wiadomości przedstawionych w tym rozdziale. Zadanie 2.1. System wieloprocesorowy składa się ze 100 procesorów, z których każdy może pracować z wydajnością równą 2 Gflopy. Jaka będzie wydajność systemu (mierzona w Gflopach) jeśli 10% kodu jest sekwencyjna, a pozostałe 90% można zrównoleglić? Zadanie 2.2. Prawo Amdahla dla obliczeń równoległych mówi jakie będzie przyspieszenie programu na p procesorach, w przypadku gdy tylko pewna część f czasu obliczeń może zostać zrównoleglona. 1. Wyprowadź wzór na to przyspieszenie. 2. Udowodnij, że maksymalne przyspieszenie na procesorach, w przypadku gdy niezrównoleglona pozostanie część f programu, wynosi 1/(f ). 3
Przyspieszenie wyznaczane przy użyciu modelu Gustafsona nazywa się czasami przyspieszeniem skalowalnym (ang. scaled speedup) [67].
28
2. Modele realizacji obliczeń równoległych Zadanie 2.3. Korzystając z prawa Amdahla dla obliczeń równoległych wyznaczyć przyspieszenie programu, w którym 80% czasu obliczeń wykonywana jest na czterech procesorach, zaś pozostałe 20% stanowią obliczenia sekwencyjne. Zakładamy, że ten algorytm wykonywany na jednym procesorze jest optymalnym algorytmem sekwencyjnym rozwiązującym dany problem. Zadanie 2.4. Niech będzie dany program, w którym 80% czasu obliczeń może być zrównoleglona (wykonywana na p procesorach), zaś pozostałe 20% stanowią obliczenia sekwencyjne. Zakładamy, że ten program wykonywany na jednym procesorze jest realizacją optymalnego algorytmu sekwencyjnego rozwiązującego dany problem. Wyznaczyć minimalną liczbę procesorów, dla której zostanie osiągnięte przyspieszenie równe 4. Zadanie 2.5. Niech będzie dany program, w którym część f czasu obliczeń może być zrównoleglona (wykonywana na 10 procesorach), zaś pozostałe 1 − f to obliczenia sekwencyjne. Zakładamy, że ten program wykonywany na jednym procesorze jest realizacją optymalnego algorytmu sekwencyjnego rozwiązującego dany problem. Ile musi wynosić (co najmniej) wartość f aby efektywność programu nie była mniejsza od 0.5 ? Zadanie 2.6. Niech A ∈ IRm×n , y ∈ IRm oraz x ∈ IRn . Rozważ dwa algorytmy mnożenia macierzy przez wektor postaci y ← y + Ax: 1. zwykły – iloczyn skalarny wierszy przez wektor, yi ← yi +
n X
aij xj , dla i = 1, . . . , m,
j=1
2. wektorowy – suma kolumn macierzy przemnożonych przez składowe wektora, n X y←y+ xj A∗,j . j=1
Wyznacz czas działania obu algorytmów na tym samym komputerze (przy danych r i dla obu pętli: AXPY i DOT). Zadanie 2.7. Spróbuj opracować wzór na przyspieszenie dla równoległego algorytmu szukającego zadanej wartości w tablicy. Niech ts to będzie czas sekwencyjny.
2.6. Zadania W wersji równoległej przeszukiwaną tablicę elementów dzielimy na p części. Załóż, że szukany element został znaleziony po czasie ∆t, gdzie ∆t < ts /p. Dla jakiego układu danych w przestrzeni rozwiązań przyspieszenie to będzie najmniejsze, a dla jakiego równoległa wersja daje największe korzyści? Przyspieszenie, jakie uzyskamy w przypadku równoległego algorytmu szukającego określane jest mianem przyspieszenia superliniowego. Oznacza to, że dla algorytmu równoległego wykonywanego na p procesorach można uzyskać przyspieszenie większe niż p, czasem nawet wielokrotnie większe. Zadanie 2.8. Łącząc wzór na przyspieszenie wynikający z prawa Amdahla dla obliczeń równoległych z analizą na przyspieszenie superliniowe z zadania 2.7, napisz wzór na przyspieszenie dla algorytmu szukającego w przypadku gdy część f algorytmu musi wykonać się sekwencyjnie.
3. BLAS: podstawowe podprogramy algebry liniowej Jedną z najważniejszych metod opracowywania bardzo szybkich algorytmów spełniających postulaty właściwego wykorzystania pamięci podręcznej, które wykorzystywałyby w dużym stopniu możliwości współczesnych procesorów, jest zastosowanie do ich konstrukcji podprogramów z biblioteki BLAS, które umożliwiają efektywne wykorzystanie hierarchii pamięci [9,37] i zapewniają przenośność kodu między różnymi architekturami [4, 18]. Podejście to zostało zastosowane przy konstrukcji biblioteki LAPACK [3], zawierającej zestaw podprogramów rozwiązujących typowe zagadnienia algebry liniowej (rozwiązywanie układów równań liniowych o macierzach pełnych i pasmowych oraz algebraiczne zagadnienie własne).
3.1. BLAS poziomów 1, 2 i 3 W roku 1979 zaproponowano standard dla podprogramów realizujących podstawowe operacje algebry liniowej (ang. Basic Linear Algebra Subprograms – BLAS) [44]. Twórcy oprogramowania matematycznego wykorzystali fakt, że programy realizujące metody numeryczne z dziedziny algebry liniowej składają się z pewnej liczby podstawowych operacji typu skalowanie wektora, dodawanie wektorów czy też iloczyn skalarny. Powstała kolekcja podprogramów napisanych w języku Fortran 77, które zostały użyte do konstrukcji biblioteki LINPACK [12], zawierającej podprogramy do rozwiązywania układów równań liniowych o macierzach pełnych i pasmowych. Zaowocowało to nie tylko klarownością i czytelnością kodu źródłowego programów wykorzystujących BLAS, ale również dało możliwość efektywnego przenoszenia kodu źródłowego między różnymi rodzajami architektur komputerowych, tak by w maksymalnym stopniu wykorzystać ich własności (ang. performance portability). Twórcy oprogramowania na konkretne komputery mogli dostarczać biblioteki podprogramów BLAS zoptymalizowane na konkretny typ procesora. Szczególnie dobrze można zoptymalizować podprogramy z biblioteki BLAS na procesory wektorowe [17]. Następnym krokiem w rozwoju standardu BLAS były prace nad biblioteką LAPACK [3], wykorzystującą algorytmy blokowe, której funkcjonalność pokryła bibliotekę LINPACK oraz EISPACK [23], zawierającą podprogramy do rozwiązywania algebraicznego zagadnienia własnego. Zdefiniowano zbiór podprogramów zawierających działania typu macierz - wektor (biblioteka BLAS poziomu drugiego [14]) oraz macierz - macierz (inaczej BLAS poziomu trzeciego [13]), wychodząc naprzeciw możliwościom oferowanym przez nowe procesory, czyli mechanizmom zaawansowanego wykorzystania hierarchii pamięci. Szczególnie poziom 3 oferował zadowalającą lokalność danych i w konsekwencji bardzo dużą efektywność. Oryginalny zestaw podprogramów BLAS przyjęto określać mianem BLAS poziomu 1.
3.1. BLAS poziomów 1, 2 i 3 Poniżej przedstawiamy najważniejsze operacje z poszczególnych poziomów BLAS-u. Pełny wykaz można znaleźć pod adresem http://www.netlib. org/blas/blasqr.ps oraz w książkach [3, 15]. Poziom 1: operacje na wektorach — y ← αx + y, x ← αx, y ← x, y ↔ x, dot ← xT y, nrm2 ← kxk2 , asum ← kre(x)k1 + kim(x)k1 . Poziom 2: operacje typu macierz-wektor — iloczyn macierz-wektor: y ← αAx + βy, y ← αAT x + βy — aktualizacje macierzy typu „rank-1”: A ← αxyT + A — aktualizacje macierzy symetrycznych typu „rank-1” oraz „rank-2”: A ← αxxT + A, A ← αxyT + αyxT + A, — mnożenie wektora przez macierz trójkątną: x ← T x, x ← T T x, — rozwiązywanie układów równań liniowych o macierzach trójkątnych: x ← T −1 x, x ← T −T x. Poziom 3: operacje typu macierz-macierz — mnożenie macierzy: C ← αAB + βC, C ← αAT B + βC, C ← αAB T + βC, C ← αAT B T + βC — aktualizacje macierzy symetrycznych typu „rank-k” oraz „rank-2k”: C ← αAAT + βC, C ← αAT A + βC, C ← αAT B + αB T A + βC, C ← αAB T + αBAT + βC, — mnożenie macierzy przez macierz trójkątną: B ← αT B, B ← αT T B, B ← αBT , B ← αBT T , — rozwiązywanie układów równań liniowych o macierzach trójkątnych z wieloma prawymi stronami: B ← αT −1 B, B ← αT −T B, B ← αBT −1 , B ← αBT −T . Tabela 3.1 pokazuje zalety użycia wyższych poziomów BLAS-u [15]. Dla reprezentatywnych operacji z poszczególnych poziomów (kolumna 1) podaje liczbę odwołań do pamięci (kolumna 2), liczbę operacji arytmetycznych (kolumna 3) oraz ich stosunek (kolumna 4), przy założeniu że m = n = k. Im wyższy poziom BLAS-u, tym ten stosunek jest korzystniejszy, gdyż realizowana jest większa liczba operacji arytmetycznych na danych pobieranych z pamięci.
33
34
3. BLAS: podstawowe podprogramy algebry liniowej BLAS (operacja) y ← αx + y (AXPY) y ← αAx + βy (GEMV) C ← αAB + βC (GEMM)
pamięć 3n mn + n + 2m 2mn + mk + kn
operacje 2n 2m + 2mn 2mkn + 2mn
stosunek 3:2 1:2 2:n
Tabela 3.1. BLAS: odwołania do pamięci, liczba operacji arytmetycznych oraz ich stosunek, przy założeniu że n = m = k [15]
3.2. Mnożenie macierzy przy wykorzystaniu różnych poziomów BLAS-u Aby zilustrować wpływ tego faktu na szybkość obliczeń, rozważmy cztery równoważne sobie algorytmy mnożenia macierzy1 postaci C = βC + αAB.
(3.1)
Zauważmy, że każdy wykonuje identyczną liczbę działań arytmetycznych. Algorytm 3.1, to klasyczne mnożenie macierzy, a algorytmy 3.2, 3.3, 3.4 wykorzystują odpowiednie operacje z kolejnych poziomów BLAS-u. Algorytm 3.1. Sekwencyjne (skalarne) mnożenie macierzy. Wejście: C ∈ IRm×n , A ∈ IRm×k , B ∈ IRk×n , α, β ∈ IR Wyjście: C = βC + αAB 1: for j = 1 to n do 2: for i = 1 to m do 3: t←0 4: for l = 1 to k do 5: t ← t + ail blj 6: end for 7: cij ← βcij + αt 8: end for 9: end for Algorytm mnożenia macierzy może być łatwo zrównoleglony na poziomie operacji blokowych. Rozważmy operację (3.1). Dla uproszczenia przyjmijmy, 1 Przy ich opisie oraz w dalszych rozdziałach wykorzystamy następujące oznaczenia. Niech M ∈ IRm×n , wówczas Mi:j,k:l oznacza macierz powstającą z M jako wspólna część wierszy od i do j oraz kolumn od k do l.
3.2. Mnożenie macierzy przy wykorzystaniu różnych poziomów BLAS-u Algorytm 3.2. Mnożenie macierzy przy użyciu podprogramów BLAS 1. Wejście: C ∈ IRm×n , A ∈ IRm×k , B ∈ IRk×n , α, β ∈ IR Wyjście: C = βC + αAB 1: for j = 1 to n do 2: C∗j ← βC∗j {operacja SCAL} 3: for i = 1 to k do 4: C∗j ← C∗j + (αbij )A∗i {operacja AXPY} 5: end for 6: end for Algorytm 3.3. Mnożenie macierzy przy użyciu podprogramów BLAS 2. Wejście: C ∈ IRm×n , A ∈ IRm×k , B ∈ IRk×n , α, β ∈ IR Wyjście: C = βC + αAB 1: for j = 1 to n do 2: C∗j ← αAB∗j + βC∗j {operacja GEMV} 3: end for że A, B, C są macierzami kwadratowymi o liczbie wierszy równej n. Zakładając, że n jest liczbą parzystą, możemy zapisać operację w następującej postaci blokowej C11 C12 B11 B12 A11 A12 C11 C12 , +β =α C21 C22 B21 B22 A21 A22 C21 C22 (3.2) gdzie każdy blok Aij , Bij , Cij jest macierzą kwadratową o liczbie wierszy równej n/2. Stąd wyznaczenie wyniku operacji może być rozłożone na osiem operacji takiej samej postaci jak (3.1). C11 C11 C12 C12 C21 C21 C22 C22
Zauważmy, że najpierw można równolegle wykonać operacje o numerach nieparzystych, a następnie (również równolegle) operacje o numerach parzystych. Opisane postępowanie pozwala na wyrażenie operacji (3.1) w terminach tej samej operacji. Liczbę podziałów według schematu (3.2) można dostosować do wielkości pamięci podręcznej.
35
36
3. BLAS: podstawowe podprogramy algebry liniowej Algorytm 3.4. Mnożenie macierzy przy użyciu podprogramów BLAS 3. Wejście: C ∈ IRm×n , A ∈ IRm×k , B ∈ IRk×n , α, β ∈ IR Wyjście: C = βC + αAB 1: C ← βC + αAB {operacja GEMM}
Tabela 3.2. Wydajność i czas wykonania algorytmów mnożenia macierzy na różnych procesorach dla wartości m = n = k = 1000
Tabela 3.2 pokazuje czas działania i wydajność osiąganą przy wykonaniu poszczególnych algorytmów na trzech różnych typach starszych komputerów, przy czym m = n = k = 1000. W każdym przypadku widać, że algorytm wykorzystujący wyższy poziom BLAS-u jest istotnie szybszy. Co więcej, wykonanie algorytmu 3.4 odbywa się z wydajnością bliską teoretycznej maksymalnej. W przypadku procesorów Pentium czas wykonania każdego algorytmu wykorzystującego BLAS jest mniejszy niż czas wykonania algorytmu 3.1, który wykorzystuje jedynie kilka procent wydajności procesorów. W przypadku komputera Cray X1 czas wykonania algorytmu 3.1 utrzymuje się na poziomie czasu wykonania algorytmu wykorzystującego BLAS poziomu 2, co jest wynikiem doskonałej optymalizacji prostego kodu algorytmu 3.1, realizowanej przez kompilator Cray, który jest powszechnie uznawany za jeden z najlepszych kompilatorów optymalizujących. Zauważmy, że stosunkowo słabą optymalizację kodu przeprowadza kompilator Intela, a zatem w przypadku tych procesorów użycie podprogramów z wyższych poziomów biblioteki BLAS staje się koniecznością, jeśli chcemy pełniej wykorzystać moc oferowaną przez te procesory. Tabela 3.3 pokazuje wydajność, czas działania oraz przyspieszenie w sensie definicji 2.2 dla algorytmów 3.1, 3.2, 3.3 oraz 3.4 na dwuprocesorowym komputerze Quad-Core Xeon (łącznie 8 rdzeni). Można zauważyć, że algorytmy 3.1, 3.2 i 3.3 wykorzystują niewielki procent wydajności komputera, a dla algorytmu 3.4 osiągana jest bardzo duża wydajność. Wszystkie algorytmy dają się dobrze zrównoleglić, choć najlepsze przyspieszenie względne jest osiągnięte dla algorytmów 3.1 i 3.2. Zauważmy również, że dla algorytmów 3.1, 3.2 można zaobserwować przyspieszanie ponadliniowe (większe niż liczba użytych rdzeni). Taką
3.3. Rozkład Cholesky’ego
37
sytuację obserwuje się często, gdy w przypadku obliczeń równoległych, dane przetwarzane przez poszczególne procesory (rdzenie) lepiej wykorzystują pamięć podręczną [48]. Warto również zwrócić uwagę na ogromny wzrost wydajności w porównaniu z wynikami przedstawionymi w tabeli 3.2. Zauważmy również, że podprogramy z biblioteki BLAS dowolnego poziomu mogą być łatwo zrównoleglone, przy czym ze względu na odpowiednio duży stopień lokalności danych najlepsze efekty daje zrównoleglenie podprogramów z poziomu 3 [10]. Biblioteka PBLAS (ang. parallel BLAS, [7]) zawiera podprogramy realizujące podstawowe operacje algebry liniowej w środowisku rozproszonym, wykorzystuje lokalnie BLAS oraz BLACS w warstwie komunikacyjnej.
3.3. Rozkład Cholesky’ego Przedstawiony w poprzednim podrozdziale problem mnożenia macierzy należy do takich, które raczej łatwo poddają się optymalizacji. Dla kontrastu rozważmy teraz problem efektywnego zaprogramowania rozkładu Cholesky’ego [24] przy wykorzystaniu poszczególnych poziomów BLAS-u. Będzie to jednocześnie przykład ilustrujący metodę konstrukcji algorytmów blokowych dla zagadnień algebry liniowej. Niech A=
a11 a21 .. .
a12 a22 .. .
an1 an2
. . . a1n . . . a2n .. .. . . . . . ann
∈ IRn×n
będzie macierzą symetryczną (aij = aji ) i dodatnio określoną (dla każdego x 6= 0, xT Ax > 0). Istnieje wówczas macierz dolnotrójkątna L taka, że LLT = A. Algorytm 3.5 jest prostym (sekwencyjnym) algorytmem wyznaczania komponentu rozkładu L. Zauważmy, że pętle z linii 3–5 oraz 8–10 algorytmu 3.5 mogą być zapisane w postaci wektorowej. Otrzymamy wówczas algorytm wektorowy 3.6. Instrukcja 3 może być zrealizowana w postaci wywołania operacji AXPY, zaś instrukcja 6 jako wywołanie SCAL z pierwszego poziomu BLAS-u. Pętla z linii 2–4 algorytmu 3.6 może być zapisana w postaci w postaci wywołania operacji GEMV (mnożenie macierz-wektor) z drugiego poziomu BLAS-u. Otrzymamy w ten sposób algorytm 3.7.
1 core Mflops czas (s) 350.9 5.6988 1573.8 1.2708 4195.5 0.4767 16026.3 0.1248
Quad-Core Mflops czas (s) 1435.0 1.3937 6502.0 0.3076 13690.1 0.1461 54094.9 0.0370
sp 4.09 4.13 3.26 3.38
2x Quad-Core Mflops czas (s) 2783.4 0.7185 12446.1 0.1607 22326.9 0.0896 86673.5 0.0231
sp 7.93 7.90 5.32 5.41
Tabela 3.3. Wydajność, czas wykonania i przyspieszenie względne algorytmów mnożenia macierzy na dwuprocesorowym komputerze Xeon Quad-Core dla wartości m = n = k = 1000
3.3. Rozkład Cholesky’ego
39
Algorytm 3.5 Sekwencyjna (skalarna) metoda Cholesky’ego Wejście: A ∈ IRn×n , Wyjście: aij = lij , 1 ≤ j ≤ i ≤ n 1: for j = 1 to n do 2: for k = 1 to j − 1 do 3: for i = j to n do 4: aij ← aij − ajk aik 5: end for 6: end for √ 7: ajj ← ajj 8: for i = j + 1 to n do 9: aij ← aij /ajj 10: end for 11: end for
Algorytm 3.6 Wektorowa metoda Cholesky’ego Wejście: A ∈ IRn×n , Wyjście: aij = lij , 1 ≤ j ≤ i ≤ n 1: for j = 1 to n do 2: fork = 1 to j − 1 do ajj ajj ajk .. . . 3: . ← .. − ajk .. 4: 5:
6: 7:
anj end for √ a ← ajj jj aj+1,j .. ← . anj end for
Aby wyrazić rozkład Cholesky’ego w postaci wywołań operacji z trzeciego poziomu BLAS-u, zapiszmy rozkład w następującej postaci blokowej:2 T A11 A12 A13 L11 L11 LT21 LT31 A21 A22 A23 = L21 L22 LT22 LT32 . A31 A32 A33 L31 L32 L33 LT33
Stąd po dokonaniu mnożenia odpowiednich bloków otrzymamy następującą postać macierzy A: L11 LT11 L11 LT21 L11 LT31 . A = L21 LT11 L21 LT21 + L22 LT22 L21 LT31 + L22 LT32 T T T T T T L31 L11 L31 L21 + L32 L22 L31 L31 + L32 L32 + L33 L33
Przyjmijmy, że został już zrealizowany pierwszy krok blokowej metody i powstał następujący rozkład: T L11 L11 LT21 LT31 0 A22 A23 , A = L21 I L31 0 I 0 A32 A33
co uzyskujemy dokonując najpierw rozkładu A11 = L11 LT11 , a następnie rozwiązując układ równań postaci
2
L21 L31
LT11
=
A21 A31
.
Dla prostoty przyjmujemy, że macierz można zapisać w postaci dziewięciu bloków – macierzy kwadratowych o takiej samej liczbie wierszy.
3.3. Rozkład Cholesky’ego
41
W kolejnym kroku rozpoczynamy od aktualizacji pozostałych bloków przy pomocy bloków już wyznaczonych. Otrzymamy w ten sposób: A22 A22 L21 ← − LT21 A32 A32 L31 oraz
A23 A33
←
A23 A33
−
L21 L31
LT31 .
Łącząc powyższe operacje w jedną, otrzymujemy A22 A23 A22 A23 L21 ← − LT21 LT31 . A32 A33 A32 A33 L31 Następnie dokonujemy rozkładu A22 = L22 LT22 , po czym dokonujemy aktualizacji rozwiązując układ równań liniowych o macierzy dolnotrójkątnej A32 = L32 LT22 . Otrzymujemy wówczas następujący rozkład T L11 L11 LT21 LT31 0 LT22 LT32 . A = L21 L22 L31 L32 I 0 0 A33 W kolejnych krokach w analogiczny sposób zajmujemy się rozkładem bloku A33 . Niech teraz macierz A będzie dana w postaci blokowej A11 A12 . . . A1p A21 A22 . . . A2p A= . .. .. , . . . . . . . Ap1 Ap2 . . . App gdzie Aij = ATji oraz Aij ∈ IRn/p×n/p dla 1 ≤ i, j ≤ p. Algorytm 3.8 dokonuje rozkładu Cholesky’ego przy wykorzystaniu BLAS-u poziomu trzeciego. Trzeba podkreślić, że niewątpliwą zaletą algorytmu 3.8 jest możliwość prostego zastosowania nowych formatów reprezentacji macierzy (podrozdział 1.2.3). Istotnie, każdy blok Aij może zajmować zwarty obszar pamięci operacyjnej. Table 3.4–3.8 pokazują czas działania oraz wydajność komputera Dual Xeon Quadcore 3.2 GHz dla algorytmów wykorzystujących poszczególne poziomy BLAS-u (Alg. 1, 2 oraz 3) oraz algorytmu 3.8 wykorzystującego format reprezentacji macierzy przedstawiony w sekcji 1.2.3 (Alg. T). Dla algorytmów Alg. 1 oraz Alg. 2 nie zastosowano równoległości, Alg. 3 to jedno
42
3. BLAS: podstawowe podprogramy algebry liniowej Algorytm 3.8 Macierzowa (blokowa) metoda Cholesky’ego Wejście: A ∈ IRn×n , Wyjście: aij = lij , 1 ≤ j ≤ i ≤ n 1: for j = 1 to p do 2: Ajj ← chol(Ajj ) 3: if j < p then Aj+1,j Aj+1,j .. .. −T 4: ← × Ajj . . Apj Apj Aj+1,j+1 . . . Aj+1,p .. .. ← . . Ap,j+1 . . . App Aj+1,j .. T T × A . . . A . j+1,j pj 5:
Tabela 3.4. Czas działania i wydajność algorytmów dla n = 1024
wywołanie podprogramu spotrf z biblioteki Intel MKL (wersja równoległa). Alg. T został zrównoleglony przy pomocy OpenMP.3 Dla większych rozmiarów danych (n = 16384, n = 32768) podano wyniki jedynie dla Alg. 3 oraz Alg. T. Czas wykonania pozostałych jest rzędu kilku godzin, co w praktyce czyni je bezużytecznymi. Zauważmy, że dla większych rozmiarów problemu użycie nowych sposobów reprezentacji macierzy w zauważalny sposób skraca czas obliczeń.
3
Wykorzystano standard OpenMP, który omawiamy szczegółowo w rozdziale 4.
Tabela 3.5. Czas działania i wydajność algorytmów dla n = 4096
alg. Alg.3 Alg.T
Quad-core Mflops sec. 72800.40 2.51 81660.70 2.24
2x Quad-core Mflops sec. 134151.73 1.36 147904.53 1.23
Tabela 3.6. Czas działania i wydajność algorytmów dla n = 8192
alg. Alg.3 Alg.T
Quad-core Mflops sec. 77349.85 18.95 84852.68 17.27
2x Quad-core Mflops sec. 145749.74 10.05 163312.97 8.97
Tabela 3.7. Czas działania i wydajność algorytmów dla n = 16384
alg. Alg.3 Alg.T
Quad-core Mflops sec. 80094.68 146.43 85876.31 136.57
2x Quad-core Mflops sec. 146194.12 80.19 168920.31 69.40
Tabela 3.8. Czas działania i wydajność algorytmów dla n = 32768
44
3. BLAS: podstawowe podprogramy algebry liniowej
3.4. Praktyczne użycie biblioteki BLAS Biblioteka BLAS została zaprojektowana z myślą o języku Fortran. Nagłówki przykładowych podprogramów z poszczególnych poszczególnych poziomów przedstawia listing 3.1. Na poziomie pierwszym (działania na wektorach) poszczególne operacje są opisane przy pomocy fortranowskich podprogramów (czyli SUBROUTINE) oraz funkcji (czyli FUNCTION). W nazwach pierwszy znak określa typ danych, na których działa operacja (S, D dla obliczeń na liczbach rzeczywistych odpowiednio pojedynczej i podwójnej precyzji oraz C, Z dla obliczeń na liczbach zespolonych pojedynczej i podwójnej precyzji). Wyjątek stanowi operacja I AMAX znajdowania numeru składowej wektora, która jest największa co do modułu. W nazwie, w miejsce znaku „ ”, należy wstawić jedną z liter określających typ składowych wektora. Przykładowo SAXPY oraz DAXPY to podprogramy realizujące operację AXPY. Wektory są opisywane parametrami tablicowymi (przykładowo SX oraz SY w podprogramie SAXPY na listingu 3.1) oraz liczbami całkowitymi, które wskazują co ile danych w pamięci znajdują się kolejne składowe wektora (parametry INCX oraz INCY na listingu 3.1). Na poziomie 2 dochodzą opisy tablic przechowujących macierze, które są przechowywane kolumnami (jak pokazano na rysunku 1.3), stąd parametr LDA określa liczbę wierszy w tablicy przechowującej macierz. Parametr TRANS równy ’T’ lub ’N’ mówi, czy należy zastosować transpozycję macierzy. Parametr UPLO równy ’L’ lub ’U’ określa, czy macierz jest dolnotrójkątna, czy górnotrójkątna. Parametr DIAG równy ’U’ lub ’N’ mówi, czy macierz ma na głównej przekątnej jedynki, czy też elementy różne od jedności. Na poziomie 3 dochodzi parametr SIDE równy ’L’ (left) lub ’R’ (right) oznaczający operację lewostronną lub prawostronną. Listing 3.1. Przykładowe nagłówki w języku Fortran 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Poziom 1 ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗ SUBROUTINE SAXPY(N, SA , SX , INCX , SY , INCY) ∗ . . parametry s k a l a r n e . . REAL SA INTEGER INCX , INCY ,N ∗ .. ∗ . . parametry t a b l i c o w e . . REAL SX( ∗ ) ,SY( ∗ ) ∗ ∗ Wyznacza sy , g d z i e sy := sy+s a ∗ sx ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗ REAL FUNCTION SDOT(N, SX , INCX , SY , INCY) ∗ . . parametry s k a l a r n e . . INTEGER INCX , INCY ,N
.. . . parametry t a b l i c o w e . . REAL SX( ∗ ) ,SY( ∗ )
∗ ∗ Zwraca sx 0 ∗ sy ( tzw . dot p r o d u c t ) ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Poziom 2 ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗ SUBROUTINE SGEMV(TRANS,M, N,ALPHA, A,LDA, X, INCX , BETA, Y, INCY) ∗ . . parametry s k a l a r n e . . REAL ALPHA,BETA INTEGER INCX , INCY ,LDA,M,N CHARACTER TRANS ∗ .. ∗ . . parametry t a b l i c o w e . . REAL A(LDA, ∗ ) ,X( ∗ ) ,Y( ∗ ) ∗ ∗ Wyznacza y , g d z i e y := a l p h a ∗A∗x + b e t a ∗y ∗ lub y := a l p h a ∗A0 ∗x + b e t a ∗y ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ SUBROUTINE STRSV(UPLO,TRANS, DIAG, N, A,LDA, X, INCX) ∗ . . parametry s k a l a r n e . . INTEGER INCX ,LDA,N CHARACTER DIAG,TRANS,UPLO ∗ .. ∗ . . parametry t a b l i c o w e . . REAL A(LDA, ∗ ) ,X( ∗ ) ∗ ∗ Wyznacza x , g d z i e A∗x = b l u b A0 ∗x = b ∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Poziom 3 ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗ SUBROUTINE SGEMM(TRANSA,TRANSB,M, N, K,ALPHA, A,LDA, B, LDB,BETA, C,LDC) ∗ . . parametry t a b l i c o w e . . REAL ALPHA,BETA INTEGER K,LDA, LDB, LDC,M,N CHARACTER TRANSA,TRANSB ∗ .. ∗ . . parametry t a b l i c o w e . . REAL A(LDA, ∗ ) ,B(LDB, ∗ ) ,C(LDC, ∗ ) ∗ ∗ Wyznacza ∗ ∗ C := a l p h a ∗ op ( A ) ∗ op ( B ) + b e t a ∗C, ∗ ∗ g d z i e op ( X ) to op ( X ) = X l u b op ( X ) = X0 ∗ ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗
SUBROUTINE STRSM( SIDE ,UPLO,TRANSA, DIAG,M, N,ALPHA, A,LDA, B,LDB) . . parametry s k a l a r n e . . REAL ALPHA INTEGER LDA, LDB,M,N CHARACTER DIAG, SIDE ,TRANSA,UPLO .. . . parametry t a b l i c o w e . . REAL A(LDA, ∗ ) ,B(LDB, ∗ ) .. Wyznacza X, g d z i e
∗ ∗ ∗ ∗ op ( A ) ∗X = a l p h a ∗B l u b X∗ op ( A ) = a l p h a ∗B ∗ ∗ oraz ∗ ∗ op ( A ) = A or op ( A ) = A0 ∗ ∗ przy czym B:=X ∗ ∗ ∗ ∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗ ∗∗ ∗∗ ∗∗ ∗∗ ∗
Istnieje możliwość łatwego użycia podprogramów BLAS-u z poziomu języka C. Trzeba w takim przypadku przyjąć następujące założenia: — podprogramy subroutine należy traktować jako funkcje void, — w języku Fortran parametry są przekazywane jako wskaźniki, — macierze są przechowywane kolumnami, zatem parametr LDA określa liczbę wierszy w tablicy przechowującej macierz. Listing 3.2 przedstawia odpowiedniki nagłówków z listingu 3.1 dla języka C. Listing 3.2. Przykładowe nagłówki w języku C 1 2
void SAXPY( const i n t ∗n , const f l o a t ∗ alpha , const f l o a t ∗x , const i n t ∗ i n c x , f l o a t ∗y , const i n t ∗ i n c y ) ;
3 4 5
f l o a t SDOT( const i n t ∗n , const f l o a t ∗x , const i n t ∗ i n c x , const f l o a t ∗y , const i n t ∗ i n c y ) ;
6 7 8 9 10
void SGEMV( const const const const
char ∗ t r a n s , const i n t ∗m, const i n t ∗n , f l o a t ∗ alpha , const f l o a t ∗a , i n t ∗ lda , const f l o a t ∗x , const i n t ∗ i n c x , f l o a t ∗ beta , f l o a t ∗y , const i n t ∗ i n c y ) ;
11 12 13 14
void STRSV( const char ∗ uplo , const char ∗ t r a n s , const char ∗ diag , const i n t ∗n , const f l o a t ∗a , const i n t ∗ lda , f l o a t ∗x , const i n t ∗ i n c x ) ;
15 16 17 18
void SGEMM( const char ∗ t r a n s a , const char ∗ t r a n s b , const i n t ∗m, const i n t ∗n , const i n t ∗k , const f l o a t ∗ alpha , const f l o a t ∗a ,
3.4. Praktyczne użycie biblioteki BLAS const i n t ∗ lda , const f l o a t ∗b , const i n t ∗ ldb , const f l o a t ∗ beta , f l o a t ∗ c , const i n t ∗ l d c ) ;
19 20 21 22 23 24 25 26
void STRSM( const const const const const
char ∗ s i d e , const char ∗ uplo , char ∗ t r a n s a , const char ∗ diag , i n t ∗m, const i n t ∗n , const f l o a t ∗ alpha , f l o a t ∗a , const i n t ∗ lda , f l o a t ∗b , int ∗ ldb ) ;
Na listingu 3.3 przedstawiamy przykład użycia podprogramów z biblioteki BLAS (poziom 1 i 2) dla rozwiązywania układów równań liniowych eliminacją Gaussa. Listing 3.3. Rozwiązywanie układów równań liniowych eliminacją Gaussa przy użyciu biblioteki BLAS 1 2 3 4 5 6 7 8 9 10 11 12
void elim_gaussa ( i n t n , double ∗a , i n t lda , double t o l , i n t ∗ i n f o ) { /∗ n − l i c z b a niewiadomych a − m a c i e r z o n w i e r s z a c h i n+1 kolumnach o s t a t n i a kolumna t o prawa s t r o n a uk ł adu lda − l i c z b a wierszy w t a b l i c y t o l − t o l e r a n c j a ( b l i s k a zeru ) i n f o == 0 − o b l i c z o n o r o z w i ą z a n i e != 0 − m a c i e r z o s o b l i w a ∗/ i n t i , j , k , i n c x =1; ∗ i n f o =0; k=0;
13 14
while ( ( k
15
i n t dv=n−k ; // w y z n a c z e n i e w i e r s z a g ł ó wnego i n t p i v=k+IDAMAX(&dv ,&a [ k∗ l d a+k ] ,& i n c x ) −1;
16 17 18
i f ( abs ( a [ k∗ l d a+p i v ] )< t o l ) { // m a c i e r z o s o b l i w a ∗ i n f o=k+1; } else { i f ( k!= p i v ) { // wymiana w i e r s z y " k " i " p i v " i n t n1=n+1; DSWAP(&n1 ,& a [ k ] ,& lda ,& a [ p i v ] ,& l d a ) ; } f o r ( i=k+1; i
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
i f ( abs ( a [ ( n−1)∗ l d a+n −1])< t o l ) // m a c i e r z o s o b l i w a ∗ i n f o=n ;
36 37 38
i f ( ∗ i n f o ==0){ // odwrotna e l i m i n a c j a char u p l o= ’U ’ ; char t r a n s= ’N ’ ; char d i a g= ’N ’ ; DTRSV(&uplo ,& t r a n s ,& diag ,&n , a ,& lda ,& a [ n∗ l d a ] ,& i n c x ) ; }
39 40 41 42 43 44 45
}
3.5. LAPACK Biblioteka LAPACK (ang. Linear Algebra Package) jest zbiorem podprogramów do rozwiązywania układów równań liniowych oraz algebraicznego zagadnienia własnego. Pełny opis znajduje się w książce [3]. Listing 3.4 zamieszczamy przykładowy kod do rozwiązywania układów równań liniowych przy pomocy eliminacji Gaussa. Listing 3.4. Rozwiązywanie układów równań liniowych przy użyciu biblioteki LAPACK 1 2 3
n − l i c z b a niewiadomych l d a − wiodący r o z m i a r t a b l i c y i n f o − o wyniku (==0 − j e s t r o z w i ą z a n i e !=0 − b r a k r o z w i ą z a n i a ) t − do m i e r z e n i a c z a s u a − t a b l i c a − m a c i e r z i prawa s t r o n a x − rozwi ą zanie
14 15 16 17 18 19 20
// a l o k u j e m y pami ę ć na t a b l i c e a i w e k t o r x a=m a l l o c (MAXN∗MAXN∗ s i z e o f ∗ a ) ; x=m a l l o c (MAXN∗ s i z e o f ∗ a ) ; int ∗ i p i v ; i p i v=m a l l o c (MAXN∗ s i z e o f ∗ i p i v ) ; i n t n r h s =1;
21 22 23 24
// generujemy dane wej ś c i o w e ustawdane ( n , a , l d a ) ;
3.5. LAPACK // r o z w i ą z y w a n i e uk ł adu e l i m i n a c j a Gaussa DGESV(&n,& nrhs , a ,& lda , i p i v ,& a [ n∗ l d a ] ,& lda ,& i n f o ) ;
25 26 27
// p r z e t w a r z a n i e wynik ów // . . . . . . . .
28 29 30
}
Biblioteki BLAS i LAPACK są dostępne na większość architektur komputerowych. Istnieje również możliwość skompilowania ich źródeł. Na szczególną uwagę zasługuje biblioteka Atlas (ang. Automatically Tuned Linear Algebra Software [65]), która dobrze wykorzystuje właściwości współczesnych procesorów ogólnego przeznaczenia (CPU).4 Na platformy komputerowe oparte na procesorach Intela ciekawą (komercyjną) propozycję stanowi biblioteka MKL (ang. Math Kernel Library5 ). Zawiera ona między innymi całą bibliotekę BLAS oraz LAPACK. Na rysunku 3.5 podajemy przykładowy plik Makefile, który może posłużyć do kompilacji i łączenia programów wykorzystujących bibliotekę MKL.
Kod źródłowy jest dostępny na stronie http://www.netlib.org/atlas Więcej informacji na stronie http://software.intel.com/en-us/articles/ intel-mkl/ 5
49
50
3. BLAS: podstawowe podprogramy algebry liniowej
3.6. Zadania Poniżej zamieściliśmy kilka zadań do samodzielnego wykonania. Ich celem jest utrwalenie umiejętności posługiwania się biblioteką BLAS. Zadanie 3.1. Napisz program obliczający iloczyn skalarny dwóch wektorów liczb rzeczywistych. Do wyznaczenia iloczynu wykorzystaj funkcję biblioteki BLAS poziomu 1 (DDOT). Zadanie 3.2. Mając dane dwie tablice a i b elementów typu rzeczywistego, napisz program liczący iloczyn skalarny dwóch wektorów x i y utworzonych z elementów tablic a i b w następujący sposób. Wektor x składa się z 30 pierwszych elementów tablicy a o indeksach nieparzystych, a wektor y z 30 elementów tablicy b o indeksach podzielnych przez 3, począwszy od indeksu 30. Zadanie 3.3. Napisz program wykonujący operację AXPY (uogólniona operacja dodawania wektorów) dla dwóch wektorów liczb rzeczywistych x i y. Wykorzystaj funkcję biblioteki BLAS poziomu 1 (DAXPY). Zadanie 3.4. Napisz program, w którym wszystkie elementy jednego wektora oraz co trzeci element począwszy od szóstego drugiego wektora przemnożysz o liczbę 3. Wykorzystaj funkcję biblioteki BLAS poziomu 1 (DSCAL). Zadanie 3.5. Napisz program, w którym utworzysz wektor y zawierający wszystkie elementy wektora x o indeksach nieparzystych. Wykorzystaj funkcję biblioteki BLAS poziomu 1 (DCOPY). Zadanie 3.6. Napisz program, wykonujący operację uogólnionego mnożenia macierzy przez wektor. Wykorzystaj funkcję BLAS poziomu 2 (DGEMV). Zadanie 3.7. Opisz w postaci funkcji, algorytmy wykonujące mnożenie macierzy. Macierze należy pomnożyć za pomocą następujących metod: 1. wykorzystując funkcję biblioteki BLAS poziomu 1 (DDOT), 2. wykorzystując funkcję biblioteki BLAS poziomu 2 (DGEMV), 3. wykorzystując funkcję biblioteki BLAS poziomu 3 (DGEMM).
4. Programowanie w OpenMP OpenMP to standard programowania komputerów z pamięcią wspólną dla języków C/C++ oraz Fortran [6,56]. Umożliwia on zawarcie w programie komputerowym trzech kluczowych aspektów programu równoległego, czyli 1. specyfikacji równoległego wykonywania obliczeń; 2. mechanizmów komunikacji pomiędzy poszczególnymi wątkami; 3. synchronizacji pracy wątków. W standardzie OpenMP realizuje się powyższe aspekty przy użyciu kilku dyrektyw (w językach C oraz C++ są to pragmy, zaś w języku Fortran komentarze specjalne) dla kompilatora oraz niewielkiego zbioru funkcji. Umożliwia to kompilację programu również przy użyciu kompilatorów, które nie wspierają OpenMP, a zatem możliwe jest takie skonstruowanie programu, aby kod działał również na tradycyjnych systemach jednoprocesorowych.
4.1. Model wykonania programu Model wykonania programu w OpenMP jest następujący. Program rozpoczyna się realizacją instrukcji pojedynczego wątku głównego (ang. main thread). Następnie, gdy wystąpi konstrukcja specyfikująca region równoległy, wówczas tworzona jest grupa działających równolegle wątków i jednym z nich jest wątek główny. W przypadku natrafienia przez pewien wątek na kolejny region równoległy, jego wykonanie przebiega sekwencyjnie (chyba, że odpowiednio wyspecyfikowanie zagnieżdżanie wątków). Na końcu regionu równoległego występuje niejawna bariera. Po jej osiągnięciu wątek główny kontynuuje pracę sekwencyjną.
4.2. Ogólna postać dyrektyw Poniżej przedstawiamy ogólny schemat dyrektyw OpenMP dla języków C oraz C++. W książce [6] przedstawiono szczegółowo składnię OpenMP dla języka Fortran. 1 2
#pragma omp dyrektywa k l a u z u l a . . . k l a u z u l a instrukcja
Dyrektywę OpenMP wraz z następującą bezpośrednio po niej instrukcją będziemy nazywać konstrukcją OpenMP. Opcjonalne klauzule specyfikują dodatkowe szczegóły dotyczące danej konstrukcji. Pragmy omp są ignorowane przez kompilatory, które nie wspierają standardu OpenMP. Ukrycie wywołań funkcji OpenMP wymaga użycia dyrektyw warunkowej kompilacji. Umożliwia ona zaakceptowanie kodu przez każdy kompilator. Ilustruje to poniższy przykład.
4.3. Specyfikacja równoległości obliczeń 1 2 3 4
#i f d e f _OPENMP iam=omp_get_thread_num ( ) ; // s p e c y f i c z n e i n s t r u k c j e ... // OpenMP #endif
4.3. Specyfikacja równoległości obliczeń Przedstawimy teraz konstrukcje OpenMP służące do specyfikacji potencjalnej równoległości obliczeń. 4.3.1. Konstrukcja parallel Podstawowa konstrukcja OpenMP jest oparta na dyrektywie parallel oraz następującym bezpośrednio po niej bloku strukturalnym, czyli instrukcją (na ogół złożoną), która ma jedno wejście i jedno wyjście. Ogólna postać tej konstrukcji jest następująca: 1 2 3 4
#pragma omp p a r a l l e l k l a u z u l e { // b l o k s t r u k t u r a l n y ... }
dyrektywie parallel mogą się pojawić następujące klauzule: if(wyrażenie skalarne) num threads(wyrażenie skalarne) private(lista zmiennych) firstprivate(lista zmiennych) shared(lista zmiennych) default(shared albo none) copyin(lista zmiennych) reduction(operator : lista zmiennych) Wykonanie konstrukcji parallel przebiega następująco. Gdy wątek master osiągnie miejsce określone przez dyrektywę parallel, wówczas tworzona jest grupa wątków pod warunkiem, że 1. nie występuje klauzula if, 2. wyrażenie w klauzuli if ma wartość różną od zera. Gdy nie wystąpi sytuacja opisana wyżej (punkty 1, 2), wówczas blok strukturalny jest wykonywany przez wątek główny. W grupie wątków, master staje się wątkiem o numerze 0, a numeracja nie zmienia się w trakcie wykonania. Liczba wątków w grupie zależy od zmiennej środowiskowej OMP NUM THREADS, wartości wyrażenia w klauzuli num threads oraz wywołania poniższej funkcji. W — — — — — — — —
53
54
4. Programowanie w OpenMP 1 2
// u s t a w i e n i e l i c z b y wą t k ów void omp_set_num_threads ( i n t num)
Każdy wątek wykonuje instrukcję opisaną blokiem strukturalnym. Po konstrukcji parallel występuje niejawna bariera. Po zakończeniu wykonywania instrukcji bloku przez wszystkie wątki, dalsze instrukcje wykonuje sekwencyjnie wątek główny. Ilustruje to poniższy przykład. Listing 4.1. Użycie dyrektywy parallel 1 2 3 4 5 6 7 8 9 10 11 12 13
#include <s t d i o . h> #include i n t main ( ) { i n t iam , np ; p r i n t f ( " b e g i n \n" ) ; #pragma omp p a r a l l e l private ( np , iam ) { iam=omp_get_thread_num ( ) ; np=omp_get_num_threads ( ) ; p r i n t f ( " H e l l o ␣ from ␣%d␣ o f ␣%d\n" , iam , np ) ; } p r i n t f ( " end \n" ) ; }
Funkcje wywoływane w liniach 8 i 9 zwracają odpowiednio numer wątku oraz liczbę wszystkich wątków. 4.3.2. Zasięg zmiennych Pozostałe klauzule definiują zasięg zmiennych. Dotyczą one tylko bloku strukturalnego występującego bezpośrednio po dyrektywie. Domyślnie, jeśli zmienna jest widoczna wewnątrz bloku i nie została wyspecyfikowana w jednej z klauzul typu „private”, wówczas jest wspólna dla wszystkich wątków w grupie. Zmienne automatyczne (deklarowane w bloku) są prywatne. W szczególności — private(lista): zmienne na liście są prywatnymi zmiennymi każdego wątku (obiekty są automatycznie alokowane dla każdego wątku), — firstprivate(lista): jak wyżej, ale dodatkowo w każdym wątku zmienne są inicjowane wartościami z wątku głównego, — shared(lista): zmienne z listy są wspólne dla wszystkich wątków w grupie, — default(shared): wszystkie zmienne domyślnie są wspólne (o ile nie znajdują się na żadnej liście typu „private”), — default(none): dla wszystkich zmiennych trzeba określić, czy są wspólne, czy też prywatne,
4.3. Specyfikacja równoległości obliczeń
55
— reduction(operator : lista): dla zmiennych z listy jest wykonywana operacja redukcyjna określona przez operator. Listing 4.2 ilustruje zastosowanie klauzuli reduction do numerycznego wyznaczenia wartości całki ze wzoru Z b p−1 Z xi+1 X f (x)dx = f (x)dx, a
k=0
xi
gdzie xi = a + ih, i = 0, . . . , p, h = (b − a)/p oraz Z xi+1 f (xi ) + f (xi+1 ) f (x)dx ≈ h . 2 xi Listing 4.2. Obliczanie całki 1 2
i n t main ( ) { i n t iam , np ; f l o a t a =0; f l o a t b=1; float s ; #pragma omp p a r a l l e l private ( np , iam ) shared ( a , b ) \ reduction (+: s ) { iam=omp_get_thread_num ( ) ; np=omp_get_num_threads ( ) ; f l o a t xa , xb , h ; h=(b−a ) /np ; xa=a+iam∗h ; xb=xa+h ; s =0.5∗h ∗ ( f ( xa )+f ( xb ) ) ; } p r i n t f ( " Calka=%f \n" , s ) ; }
Dopuszczalnymi operatorami redukcyjnymi są 1
// d o p u s z c z a l n e o p e r a t o r y r e d u k c y j n e + − ∗ & | ^ && | |
Typ zmiennych musi być odpowiedni dla operatora. Zmienne występujące na listach w klauzulach reduction nie mogą być na listach shared ani private.
56
4. Programowanie w OpenMP
4.4. Konstrukcje dzielenia pracy Podamy teraz konstrukcje dzielenia pracy (ang. work-sharing), które znacznie ułatwiają programowanie. Wszystkie należy umieszczać w bloku strukturalnym po parallel. 4.4.1. Konstrukcja for Konstrukcja for umożliwia dzielenie wykonań refrenu pętli for między wątki w grupie, przy czym każdy obrót będzie wykonany tylko raz. Przyjmuje ona następującą postać. 1 2 3 4 5 6 7 8 9
#pragma omp p a r a l l e l . . . { ... #pragma omp f o r . . . . for ( . . . ; . . . ; . . . ) { ... } ... }
Wymaga się, aby pętla for była w postaci „kanonicznej”, co oznacza, że przed jej wykonaniem musi być znana liczba obrotów. Dopuszczalne klauzule to: — private(lista zmiennych) — firstprivate(lista zmiennych) — reduction(operator : lista zmiennych) — lastprivate(lista zmiennych) — nowait — ordered — schedule(rodzaj,rozmiar) Rola pierwszych trzech jest analogiczna do roli w dyrektywie parallel. Klauzula lastprivate działa jak private, ale po zakończeniu wykonywania pętli zmienne mają taką wartość, jak przy sekwencyjnym wykonaniu pętli. Po pętli for jest niejawna bariera, którą można znieść umieszczając klauzulę nowait. Ilustruje to następujący przykład. 1 2 3 4 5 6 7 8
#pragma omp p a r a l l e l shared ( n , . . . ) { int i ; #pragma omp f o r nowait . . . f o r ( i =0; i
4.4. Konstrukcje dzielenia pracy f o r ( i =0; i
9 10 11 12
}
Wątek, który zakończy wykonywanie przydzielonych mu obrotów pierwszej pętli, przejdzie do wykonania jego obrotów drugiej pętli bez oczekiwania na pozostałe wątki w grupie. Klauzula ordered umożliwia realizację wybranej części refrenu pętli for w takim porządku, jakby pętla była wykonywana sekwencyjnie. Wymaga to użycia konstrukcji ordered. Ilustruje to następujący przykład. 1 2 3 4 5 6 7 8 9 10 11 12
i n t iam ; #pragma omp p a r a l l e l private ( iam ) { iam=omp_get_thread_num ( ) ; int i ; #pragma omp f o r ordered f o r ( i =0; i <32; i ++){ . . . // i n s t r u k c j e o b l i c z e n i o w o " i n t e n s y w n e " #pragma omp ordered p r i n t f ( "Wą t e k ␣%d␣ wykonuje ␣%d\n" , iam , i ) ; } }
Klauzula schedule specyfikuje sposób podziału wykonań refrenu pętli między wątki. Decyduje o tym parametr rodzaj. Możliwe są następujące przypadki. — static – gdy przyjmuje postać schedule(static,rozmiar), wówczas pula obrotów jest dzielona na kawałki o wielkości rozmiar, które są cyklicznie przydzielane do wątków; gdy nie poda się rozmiaru, to pula obrotów jest dzielona na mniej więcej równe części; — dynamic – jak wyżej, ale przydział jest dynamiczny; gdy wątek jest wolny, wówczas dostaje kolejny kawałek; pusty rozmiar oznacza wartość 1; — guided – jak dynamic, ale rozmiary kawałków maleją wykładniczo, aż liczba obrotów w kawałku będzie mniejsza niż rozmiar; — runtime – przydział będzie wybrany w czasie wykonania programu na podstawie wartości zmiennej środowiskowej OMP SCHEDULE, co pozwala na użycie wybranego sposobu szeregowania w trakcie wykonania programu, bez konieczności ponownej jego kompilacji. Domyślny rodzaj zależy od implementacji. Dodajmy, że w pętli nie może wystąpić instrukcja break, zmienna sterująca musi być typu całkowitego. Dyrektywy schedule, ordered oraz nowait mogą wystąpić tylko raz. Poniżej zamieszczamy przykład użycia schedule.
57
58
4. Programowanie w OpenMP 1 2 3 4 5 6 7 8 9
i n t iam , i ; #pragma omp p a r a l l e l private ( iam , i ) { iam=omp_get_thread_num ( ) ; #pragma omp f o r schedule ( s t a t i c , 2 ) f o r ( i =0; i <32; i ++){ p r i n t f ( "Wą t e k ␣%d␣ wykonuje ␣%d\n" , iam , i ) ; } }
4.4.2. Konstrukcja sections Konstrukcja sections służy do dzielenia pracy, której nie da się opisać w postaci pętli for. Ogólna postać jest następująca. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
#pragma omp p a r a l l e l . . . . { ... #pragma omp sections . . . . { #pragma omp section { // b l o k s t r u k t u r a l n y 1 ... } #pragma omp section { // b l o k s t r u k t u r a l n y 2 ... } #pragma omp section { // b l o k s t r u k t u r a l n y 3 ... } ... } ... }
Dopuszczalne klauzule to — private(lista zmiennych) — firstprivate(lista zmiennych) — reduction(operator : lista zmiennych) — lastprivate(lista zmiennych) — nowait Ich znaczenie jest takie, jak dla klauzuli for. Podobnie, na koniec jest dodawana domyślna bariera, którą można znieść stosując nowait. Przydział bloków poprzedzonych konstrukcją section odbywa się zawsze dynamicznie.
4.5. Połączone dyrektywy dzielenia pracy 4.4.3. Konstrukcja single Konstrukcja single umieszczona w bloku strukturalnym po parallel powoduje, że tylko jeden wątek wykonuje blok strukturalny. Jej postać jest następująca. 1 2 3 4 5 6 7 8 9
#pragma omp p a r a l l e l . . . . { ... #pragma omp s i n g l e . . . . { ... } ... }
Po konstrukcji single jest umieszczana niejawna bariera. Lista dopuszczalnych klauzul jest następująca. — private(lista zmiennych) — firstprivate(lista zmiennych) — nowait Ich znaczenie jest identyczne jak opisane wcześniej.
4.5. Połączone dyrektywy dzielenia pracy Przedstawimy teraz dyrektywy ułatwiające zrównoleglanie istniejących fragmentów kodu. Stosowane są wtedy, gdy konstrukcja for lub sections jest jedyną częścią bloku strukturalnego po dyrektywie parallel. 4.5.1. Konstrukcja parallel for Postać konstrukcji jest następująca. 1 2 3 4
#pragma omp p a r a l l e l f o r . . . for ( . . . ; . . . ; . . . ) { ... }
Możliwe do zastosowania klauzule są takie jak dla parallel oraz for, z wyjątkiem nowait. Poniżej pokazujemy przypadki jej zastosowania. Niech x, y ∈ IRn oraz α ∈ IR. Poniższy kod realizuje operację aktualizacji wektora (tzw. AXPY) postaci y ← y + αx. Zakładamy, że wektory x, y są reprezentowane w tablicach x[MAX], y[MAX]. 1 2
f l o a t x [MAX] , y [MAX] , a l p h a ; int i , n ;
59
60
4. Programowanie w OpenMP 3 4 5 6 7
#pragma omp p a r a l l e l f o r shared ( n , x , y , a l p h a ) f o r ( i =0; i
Niech teraz x, y ∈ IRn oraz dot ∈ IR. Poniższy kod realizuje operację wyznaczania iloczynu skalarnego (tzw. DOT product) postaci dot ← yT x. Podobnie jak w powyższym przykładzie, wektory x, y są reprezentowane w tablicach jednowymiarowych x[MAX], y[MAX]. 1 2
f l o a t x [MAX] , y [MAX] , dot ; int i , n ;
3 4 5 6 7 8
#pragma omp p a r a l l e l f o r shared ( n , x , y ) \ reduction (+: dot ) f o r ( i =0; i
Niech teraz x ∈ IRn , y ∈ IRm oraz A ∈ IRm×n . Poniższy kod realizuje operację wyznaczania iloczynu macierzy przez wektor postaci y ← y + Ax. Wektory x, y są reprezentowane w tablicach x[MAX], y[MAX], zaś macierz A w tablicy dwuwymiarowej a[MAX][MAX]. 1 2
f l o a t x [MAX] , y [MAX] , a [MAX] [MAX] ; i n t i , n , m;
3 4 5 6 7
#pragma omp p a r a l l e l f o r shared (m, n , x , y , a ) private ( j ) f o r ( i =0; i <m; i ++) f o r ( j =0; i
4.5.2. Konstrukcja parallel sections Ogólna postać konstrukcji jest następująca. 1 2 3 4 5 6 7 8
#pragma omp p a r a l l e l sections . . . . { #pragma omp section { // b l o k s t r u k t u r a l n y 1 ... } #pragma omp section { // b l o k s t r u k t u r a l n y 2
4.6. Konstrukcje zapewniające synchronizację grupy wątków ... } #pragma omp section { // b l o k s t r u k t u r a l n y 3 ... } ...
9 10 11 12 13 14 15 16
}
Możliwe do zastosowania klauzule są takie jak dla parallel oraz sections, z wyjątkiem nowait.
4.6. Konstrukcje zapewniające synchronizację grupy wątków Przedstawimy teraz ważne konstrukcje synchronizacyjne, które mają szczególnie ważne znaczenia dla zapewnienia prawidłowego dostępu do wspólnych zmiennych w pamięci. 4.6.1. Konstrukcja barrier Konstrukcja definiuje jawną barierę następującej postaci. 1 2 3
... #pragma omp barrier ...
Umieszczenie tej dyrektywy powoduje wstrzymanie wątków, które dotrą do bariery aż do czasu, gdy wszystkie wątki osiągną to miejsce w programie. 4.6.2. Konstrukcja master Konstrukcja występuje we wnętrzu bloku strukturalnego po parallel i oznacza, że blok strukturalny jest wykonywany tylko przez wątek główny. Nie ma domyślnej bariery na wejściu i wyjściu. Postać konstrukcji jest następująca. 1 2 3 4 5 6 7 8 9
#pragma omp p a r a l l e l . . . . { ... #pragma omp master { ... } ... }
61
62
4. Programowanie w OpenMP 4.6.3. Konstrukcja critical Konstrukcja występuje we wnętrzu bloku strukturalnego po parallel i oznacza, że blok strukturalny jest wykonywany przez wszystkie wątki w trybie wzajemnego wykluczania, czyli stanowi sekcję krytyczną. Postać konstrukcji jest następująca. 1 2 3 4 5 6 7 8 9
#pragma omp p a r a l l e l . . . . { ... #pragma omp c r i t i c a l { ... } ... }
Możliwa jest również postać z nazwanym regionem krytycznym. 1 2 3 4 5 6 7 8 9
#pragma omp p a r a l l e l . . . . { ... #pragma omp c r i t i c a l ( nazwa ) { ... } ... }
Wątek czeka na wejściu do sekcji krytycznej aż do chwili, gdy żaden inny wątek nie wykonuje sekcji krytycznej (o podanej nazwie). Następujący przykład ilustruje działanie critical. Rozważmy następujący kod sumujący wartości składowych tablicy. 1 2 3 4
#pragma omp p a r a l l e l f o r reduction (+:sum ) f o r ( i =0; i
Równoważny kod bez użycia reduction wymaga zastosowania konstrukcji critical. 1 2 3 4 5 6 7
#pragma omp p a r a l l e l private ( priv_sum ) shared ( sum ) { priv_sum =0; #pragma omp f o r nowait f o r ( i =0; i
4.6. Konstrukcje zapewniające synchronizację grupy wątków 8 9 10 11 12
#pragma omp c r i t i c a l { sum+=priv_sum ; } }
Jako przykład rozważmy problem wyznaczenia wartości maksymalnej wśród składowych tablicy. Prosty algorytm sekwencyjny przyjmie postać. 1 2 3 4
max=a [ 0 ] ; f o r ( i =1; i max) max=a [ i ] ;
Zrównoleglenie wymaga zastosowania sekcji krytycznej. Otrzymamy w ten sposób następujący algorytm, który właściwie będzie działał sekwencyjnie. 1 2 3 4 5 6
max=a [ 0 ] ; #pragma omp p a r a l l e l f o r f o r ( i =1; i max) max=a [ i ] ;
Poniższa wersja działa efektywniej, gdyż porównania z linii numer 4 są wykonywane równolegle. 1 2 3 4 5 6 7 8
max=a [ 0 ] ; #pragma omp p a r a l l e l f o r f o r ( i =1; i max) { #pragma omp c r i t i c a l i f ( a [ i ]>max) max=a [ i ] ; }
W przypadku jednoczesnego wyznaczania minimum i maksimum można użyć nazw sekcji krytycznych. Otrzymamy w ten sposób następujący algorytm. 1 2 3 4 5 6 7 8 9
max=a [ 0 ] ; min=a [ 0 ] ; #pragma omp p a r a l l e l f o r f o r ( i =1; i max) { #pragma omp c r i t i c a l (maximum) i f ( a [ i ]>max) max=a [ i ] ; }
63
64
4. Programowanie w OpenMP i f ( a [ i ]<mim) { #pragma omp c r i t i c a l ( minimum ) i f ( a [ i ]<min ) min=a [ i ] ; }
10 11 12 13 14 15
}
Trzeba jednak zaznaczyć, że problem znalezienia maksimum lepiej rozwiązać algorytmem następującej postaci. 1 2 3 4 5 6 7 8 9 10 11 12
max=a [ 0 ] ; priv_max=a [ 0 ] ; #pragma omp p a r a l l e l private ( priv_max ) { #pragma omp f o r nowait f o r ( i =0; i priv_max ) priv_max=a [ i ] ; #pragma omp c r i t i c a l i f ( priv_max>max) max=priv_max ; }
4.6.4. Konstrukcja atomic W przypadku, gdy w sekcji krytycznej aktualizujemy wartość zmiennej, lepiej jest posłużyć się konstrukcją atomic następującej postaci. 1 2 3 4 5 6 7
#pragma omp p a r a l l e l . . . . { ... #pragma omp atomic zmienna=expr ; ... }
4.6.5. Dyrektywa flush Dyrektywa powoduje uzgodnienie wartości zmiennych wspólnych podanych na liście, albo gdy nie ma listy – wszystkich wspólnych zmiennych. 1 2 3 4 5 6
#pragma omp p a r a l l e l . . . . { ... #pragma omp f l u s h ( l i s t a zmiennych ) ... }
4.7. Biblioteka funkcji OpenMP Uzgodnienie wartości zmiennych następuje automatycznie w następujących sytuacjach: — po barierze (dyrektywa barrier), — na wejściu i wyjściu z sekcji krytycznej (konstrukcja critical), — na wejściu i wyjściu z konstrukcji ordered), — na wyjściu z parallel, for, section oraz single.
4.7. Biblioteka funkcji OpenMP Przedstawimy teraz wybrane (najważniejsze) funkcje zdefiniowane w ramach standardu OpenMP. — void omp set num threads(int num) określa, że liczba wątków w grupie (dla następnych regionów równoległych) ma wynosić num. — int omp get num threads(void) zwraca liczbę wątków w aktualnie realizowanym regionie równoległym. — int omp get thread num(void) zwraca numer danego wątku w aktualnie realizowanym regionie równoległym. — int omp get num procs(void) zwraca liczbę procesorów, które są dostępne dla programu. — int omp in parallel(void) zwraca informację, czy aktualnie jest wykonywany region równoległy. — void omp set nested(int) ustawia pozwolenie lub zabrania na zagnieżdżanie wykonania regionów równoległych (wartość zerową traktuje się jako false, różną od zera jako true). — int omp get nested(void) zwraca informację, czy dozwolone jest zagnieżdżanie wykonania regionów równoległych (wartość zerową traktuje się jako false, różną od zera jako true). Ciekawym mechanizmem oferowanym przez runtime OpenMP jest dynamiczne dopasowywanie liczby wątków do dostępnych zasobów (procesorów) w komputerze. W przypadku gdy jednocześnie wykonuje się wiele programów równoległych, przydzielenie każdemu jednakowej liczby procesorów może prowadzić do degradacji szybkości wykonania programu. W takim przypadku OpenMP dynamicznie dopasuje liczbę wątków wykonujących region równoległy do dostępnych zasobów. Trzeba podkreślić, że w ramach wykonywanego regionu równoległego liczba wątków jest zawsze niezmienna. Mechanizmem tym możemy sterować posługując się wywołaniami następujących funkcji. — void omp set dynamic(int) ustawia pozwolenie lub zabrania na dynamiczne dopasowywanie liczby wątków (wartość zerową traktuje się jako false, różną od zera jako true).
65
66
4. Programowanie w OpenMP — int omp get nested(void) zwraca informację, czy dozwolone jest dynamiczne dopasowywanie liczby wątków (wartość zerową traktuje się jako false, różną od zera jako true). Omówione powyżej funkcjonalności mogą być również ustawione z poziomu zmiennych środowiskowych. — OMP SCHEDULE definiuje sposób szeregowania obrotów pętli w konstrukcji for (na przykład ”dynamic, 16”). — OMP NUM THREADS określa liczbę wątków w grupie. — OMP NESTED pozwala lub zabrania na zagnieżdżanie regionów równoległych (należy ustawiać TRUE lub FALSE). — OMP DYNAMIC pozwala lub zabrania na dynamiczne dopasowywanie liczby wątków (należy ustawiać TRUE lub FALSE). Przy ustawianiu zmiennych środowiskowych należy się posługiwać odpowiednimi poleceniami wykorzystywanej powłoki. Przykładowo dla powłok sh oraz bash przyjmie to postać export OMP_NUM_THREADS=16 zaś dla powłok csh oraz tcsh następującą postać setenv OMP_NUM_THREADS 16 Do mierzenia czasu obliczeń w programach OpenMP możemy wykorzystać funkcję omp get wtime. — double omp get wtime( ) zwraca liczbę sekund jaka upłynęła od pewnego, z góry ustalonego, punktu z przeszłości. Konieczne jest jej dwukrotne wywołanie, co ilustruje poniższy fragment kodu. 1
double s t a r t = omp_get_wtime ( ) ;
2 3
. . . // o b l i c z e n i a , k t ó r y c h c z a s chcemy z m i e r z y ć
4 5
double end = omp_get_wtime ( ) ;
6 7 8 9
p r i n t f ( " s t a r t ␣=␣ %.12 f \n" , s t a r t ) ; p r i n t f ( " end ␣=␣ %.12 f \n" , end ) ; p r i n t f ( " d i f f ␣=␣ %.12 f \n" , end − s t a r t ) ;
Przedstawione w sekcji 4.6 mechanizmy służące synchronizacji wątków mogą się okazać niewystarczające w przypadku bardziej złożonych algorytmów. Wówczas można skorzystać z mechanizmów synchronizacji oferowanych przez zestaw funkcji zdefiniowanych w ramach standardu OpenMP, które wykorzystują pojęcie blokady (ang. lock) – zmiennych typu omp lock t.
4.8. Przykłady — void omp init lock(omp lock t *lock) inicjuje blokadę. — void omp destroy lock(omp lock t *lock) niszczy blokadę zwalniając pamięć zajmowaną przez zmienną. — void omp set lock(omp lock t *lock) wykonuje próbę przejęcia blokady. Jeśli blokada jest wolna, wówczas wątek wywołujący funkcję przejmuje blokadę na własność i kontynuuje działanie. W przypadku, gdy blokada jest w posiadaniu innego wątku, wątek wywołujący oczekuje na zwolnienie blokady. — void omp unset lock(omp lock t *lock) zwalnia blokadę, w wyniku czego inne wątki mogą współzawodniczyć w próbie przejęcia na własność danej blokady. — int omp test lock(omp lock t *lock) testuje i ewentualnie przejmuje blokadę. Jeśli blokada jest dostępna (wolna), wówczas przejmuje blokadę zwracając zero. Gdy blokada jest w posiadaniu innego wątku, wówczas zwracana jest wartość różna od zera. W obu przypadkach wątek kontynuuje pracę. Wykorzystanie blokad ilustruje następujący przykład. 1 2 3
omp_lock_t l c k ; omp_init_lock(& l c k ) ; sum=0;
4 5 6 7
#pragma omp p a r a l l e l private ( priv_sum ) shared ( sum , l c k ) { priv_sum= . . . . . ; // o b l i c z e n i a l o k a l n e
8
omp_set_lock(& l c k ) ; sum+=priv_sum ; omp_unset_lock(& l c k ) ;
9 10 11 12
}
13 14
omp_destroy_lock(& l c k ) ;
4.8. Przykłady Podamy teraz kilka przykładów algorytmów numerycznych, których wykonanie można przyspieszyć łatwo stosując zrównoleglenie przy pomocy dyrektyw OpenMP. Więcej informacji na temat podanych algorytmów numerycznych można znaleźć w książce [24]. 4.8.1. Mnożenie macierzy Rozważmy teraz problem wyznaczenia iloczynu macierzy AB, a ściślej wykonania operacji C ← C + AB, gdzie A ∈ IRm×k , B ∈ IRk×n oraz C ∈
67
68
4. Programowanie w OpenMP IRm×n , przy wykorzystaniu wzoru
cij ← cij +
k X
ail blk ,
i = 1, . . . , m, j = 1, . . . , n.
l=1
Zdefiniowane wyżej obliczenia można wykonać posługując się następującym kodem sekwencyjnym. 1 2 3 4 5
int i , j , l ; f o r ( i =0; i <m; i ++) f o r ( j =0; j
Zrównoleglenie może być zrealizowane „wierszami”, to znaczy zrównoleglona zostanie zewnętrzna pętla. Otrzymamy w ten sposób poniższy kod (listing 4.3). Listing 4.3. Równoległe mnożenie macierzy 1 2 3 4 5 6 7 8
int i , j , l ; #pragma omp p a r a l l e l f o r shared ( a , b , c ) private ( j , l ) \ schedule ( s t a t i c ) f o r ( i =0; i <m; i ++){ f o r ( j =0; j
4.8.2. Metody iteracyjne rozwiązywania układów równań Niech będzie dany układ równań liniowych Ax = b,
(4.1)
gdzie A ∈ IRn×n , x, b ∈ IRn oraz macierz A jest nieosobliwa, przy czym aii 6= 0, i = 1, . . . , n. Niech dalej będą zdefiniowane macierze L=
0 a21 .. .
0 0 .. .
..
.
an1 . . . an,n−1 0
,
0 a12 . . .
U =
0 .. 0
a1n .. .
. an−1,n 0
4.8. Przykłady
69
oraz
a11
0 a22
D=
.. 0
= diag(a11 , . . . , ann )
. ann
takie, że A = L + D + U . Wówczas przybliżenie rozwiązania układu (4.1) może być wyznaczone metodą iteracyjną Jacobiego xk+1 = −D−1 ((L + U )xk − b).
(4.2)
Zauważmy, że wzór (4.2) wykorzystuje operację mnożenia macierzy przez wektor, a zatem nadaje się do łatwego zrównoleglenia. Inną metodę iteracyjną stanowi metoda Gaussa-Seidla określona następującym wzorem xk+1 = −(L + D)−1 ((U xk − b),
(4.3)
która wymaga w każdym kroku rozwiązania układu równań liniowych o macierzy dolnotrójkątnej. Następujące twierdzenie charakteryzuje zbieżność obu wprowadzonych wyżej metod. Twierdzenie 4.1. Niech macierz A ∈ IRn×n będzie macierzą o dominującej głównej przekątnej: X |aii | > |aij |. j6=i
Wówczas metody Jacobiego i Gaussa-Seidla są zbieżne do jednoznacznego rozwiązania układu Ax = b dla dowolnego przybliżenia początkowego x0 . W metodach iteracyjnych (4.2) oraz (4.3) stosuje się powszechnie następujące dwa kryteria stopu (zakończenia postępowania iteracyjnego): — maksymalna względna zmiana składowej przybliżonego rozwiązania nie przekracza pewnego z góry zadanego małego parametru ε: max {|xk+1 − xki |} < ε max {|xki |}, i
1≤i≤n
1≤i≤n
(4.4)
— składowe wektora residualnego rk = b−Axk będą stosunkowo niewielkie, a ściślej max {|rik |} < ε. (4.5) 1≤i≤n
Poniżej (listing 4.4) przedstawiamy równoległą implementację metody Jacobiego z kryterium stopu (4.5). Jednocześnie pozostawiamy Czytelnikowi implementację metody Gaussa-Seidla.
70
4. Programowanie w OpenMP Listing 4.4. Równoległa implementacja metody Jacobiego 1 2 3 4 5 6 7
double a [MAXN] [MAXN] , b [MAXN] , x_old [MAXN] , x_new [MAXN] , r [MAXN] ; r e s =1.0 e +20; e p s =1.0 e −10; #pragma omp p a r a l l e l default ( shared ) private ( i , j , rmax ) { while ( r e s >=e p s ) {
8
#pragma omp f o r schedule ( s t a t i c ) nowait f o r ( i =0; i rmax ) rmax=abs ( r [ i ] ) ; } #pragma omp c r i t i c a l { i f ( r e s
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
}
38 39
}
4.8.3. Równanie przewodnictwa cieplnego Rozważmy następujące równanie różniczkowe (tzw. równanie przewodnictwa cieplnego) ut = uxx ,
a ≤ x ≤ b,
t ≥ 0,
(4.6)
4.8. Przykłady
71
gdzie indeksy oznaczają pochodne cząstkowe. Przyjmijmy następujące warunki brzegowe u(0, x) = g(x), a≤x≤b (4.7) oraz u(t, a) = α,
u(t, b) = β,
t ≥ 0,
(4.8)
gdzie g jest daną funkcją, zaś α, β danymi stałymi. Równanie (4.6) wraz z warunkami (4.7)–(4.8) jest matematycznym modelem temperatury u cienkiego pręta, na którego końcach przyłożono temperatury α i β. Rozwiązanie u(t, x) określa temperaturę w punkcie x i czasie t, przy czym początkowa temperatura w punkcie x jest określona funkcją g(x). Równanie (4.6) może być również uogólnione na więcej wymiarów. W przypadku dwuwymiarowym równanie ut = uxx + uyy
(4.9)
określa temperaturę cienkiego płata o wymiarach 1 × 1, czyli współrzędne x, y spełniają nierówności 0 ≤ x, y ≤ 1. Dodatkowo przyjmujemy stałą temperaturę na brzegach płata u(t, x, y) = g(x, y),
(x, y) na brzegach
(4.10)
oraz zakładamy, że w chwili t = 0 temperatura w punkcie (x, y) jest określona przez funkcję f (x, y), czyli u(0, x, y) = f (x, y).
(4.11)
Podamy teraz proste metody obliczeniowe wyznaczania rozwiązania równań (4.6) i (4.9) wraz z implementacją przy użyciu standardu OpenMP. 4.8.3.1. Rozwiązanie równania 1-D Aby numerycznie wyznaczyć rozwiązanie równania (4.6) przyjmijmy, że rozwiązanie będzie dotyczyć punktów siatki oddalonych od siebie o ∆x oraz ∆t – odpowiednio dla zmiennych x i t. Pochodne cząstkowe zastępujemy ilorazami różnicowymi. Oznaczmy przez um j przybliżenie rozwiązania w punkcie xj = j∆x w chwili tm = m∆t, przyjmując ∆x = 1/(n + 1). Wówczas otrzymamy następujący schemat różnicowy dla równania (4.6) um+1 − um j j ∆t
=
1 m (um − 2um j + uj−1 ), (∆x)2 j+1
(4.12)
lub inaczej m m m um+1 = um j + µ(uj+1 − 2uj + uj−1 ), j
j = 1, . . . , n,
(4.13)
72
4. Programowanie w OpenMP gdzie µ=
∆t . (∆x)2
(4.14)
Warunki brzegowe (4.7) przyjmą postać um 0 = α,
um n+1 = β,
m = 0, 1, . . . ,
zaś warunek początkowy (4.7) sprowadzi się do u0j = g(xj ),
j = 1, . . . , n.
Schemat różnicowy (4.13) jest schematem otwartym albo inaczej jawnym (ang. explicit). Do wyznaczenia wartości um+1 potrzebne są jedynie wartoj ści wyznaczone w poprzednim kroku czasowym, zatem obliczenia przeprowadzane według wzoru (4.13) mogą być łatwo zrównoleglone. Trzeba tutaj koniecznie zaznaczyć, że przy stosowaniu powyższego schematu bardzo istotnym staje się właściwy wybór wielkości kroku czasowego ∆t. Schemat (4.13) będzie stabilny, gdy wielkości ∆t oraz ∆x będą spełniały nierówność 1 ∆t ≤ (∆x)2 . 2
(4.15)
Poniżej przedstawiamy kod programu w OpenMP, który realizuje obliczenia w oparciu o wprowadzony wyżej schemat (4.13). Listing 4.5. Rozwiązanie równania przewodnictwa cieplnego (1-D) 1 2 3
#i n c l u d e <s t d i o . h> #i n c l u d e #d e f i n e MAXN 100002
4 5 6 7 8 9 10 11
double u_old [MAXN] , u_new [MAXN] ; i n t main ( ) { double mu, dt , dx , alpha , beta , time ; i n t j ,m, n ,max_m; n =100000; max_m=10000; alpha =0.0; beta =10.0;
12 13 14
u_old [ 0 ] = a l p h a ; u_new [ 0 ] = a l p h a ; u_old [ n+1]= b e t a ; u_new [ n+1]= b e t a ;
#pragma omp p a r a l l e l default ( shared ) private ( j ,m) {
4.8. Przykłady 22 23 24 25
73
#pragma omp f o r schedule ( s t a t i c ) f o r ( j =1; j<=n ; j ++){ u_old [ j ] = 2 0 . 0 ; }
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
f o r (m=0;m<max_m;m++){ #pragma omp f o r schedule ( s t a t i c ) f o r ( j =1; j<=n ; j ++){ u_new [ j ] =u_old [ j ]+mu∗ ( u_old [ j +1]−2∗u_old [ j ]+ u_old [ j −1]) ; } #pragma omp f o r schedule ( s t a t i c ) f o r ( j =1; j<=n ; j ++){ u_old [ j ]=u_new [ j ] ; } } } // wydanie wynik ów . . . . . . . . }
Przykładowe czasy wykonania programu na komputerze z dwoma procesorami Xeon Quadcore 3.2GHz dla użytych ośmiu, czterech oraz jednego rdzenia wynoszą odpowiednio 0.29, 0.44, 1.63 sekundy. 4.8.3.2. Rozwiązanie równania 2-D W celu wyznaczenia rozwiązania równania (4.9) przyjmijmy, że wewnętrzne punkty siatki są dane przez (xi , yj ) = (ih, jh),
. 1 uyy (xi , yj ) = 2 [u(xi , yj−1 ) − 2u(xi , yj ) + u(xi , yj+1 )], h otrzymujemy schemat obliczeniowy um+1 = um ij + ij
∆t m m m m (u + um i,j−1 + ui+1,j + ui−1,j − 4uij ), h2 i,j+1
(4.16)
dla m = 0, 1, . . ., oraz i, j = 1, . . . , n. Wartość um ij oznacza przybliżenie wartości temperatury w punkcie siatki o współrzędnych (i, j) w m-tym kroku czasowym. Podobnie jak w przypadku równania 1-D określone są warunki brzegowe u0,j = g(0, yj ),
un+1,j = g(1, yj ),
j = 0, 1, . . . , n + 1,
74
4. Programowanie w OpenMP ui,0 = g(xi , 0),
ui,n+1 = g(xi , 1),
i = 0, 1, . . . , n + 1,
oraz warunki początkowe u0ij = fij ,
i, j = 1, . . . , n.
Z uwagi na wymóg stabilności, wielkości ∆t oraz h powinny spełniać nierówność h2 ∆t ≤ . 4 Listing 4.6 przedstawia fragment kodu realizującego schemat iteracyjny (4.16). Listing 4.6. Rozwiązanie równania przewodnictwa cieplnego (2-D) 1 2 3 4
#pragma omp p a r a l l e l default ( shared ) private ( i , j ,m) { f o r (m=0;m<max_m;m++){ #pragma omp f o r schedule ( s t a t i c ) private ( j ) f o r ( i =1; i<=n ; i ++) f o r ( j =1; j<=n ; j ++) u_new [ i ] [ j ]= u_old [ i ] [ j ]+mu∗ ( u_old [ i ] [ j +1]+ u_old [ i ] [ j −1]+u_old [ i + 1 ] [ j ]+ u_old [ i − 1 ] [ j ] −4∗ u_old [ i ] [ j ] ) ;
15
#pragma omp f o r schedule ( s t a t i c ) private ( j ) f o r ( i =1; i<=n ; i ++) f o r ( j =1; j<=n ; j ++) u_old [ i ] [ j ]=u_new [ i ] [ j ] ; }
16 17 18 19 20 21
}
4.9. Zadania Poniżej zamieściliśmy szereg zadań do samodzielnego wykonania. Do ich rozwiązania należy wykorzystać standard OpenMP. Zadanie 4.1. Napisz program wczytujący ze standardowego wejścia liczbę całkowitą n (n ≤ 0), która ma stanowić rozmiar dwóch tablic a i b. Następnie w bloku równoległym zamieść dwie pętle for. Niech w pierwszej pętli wątki w sposób równoległy wypełnią obydwie tablice wartościami,
4.9. Zadania
75
do pierwszej wstawiając wartość swojego identyfikatora, do drugiej całkowitą wartość losową z zakresu < 0; 10). W drugiej pętli wykonaj równoległe dodawanie tych tablic. Wynik zamieść w tablicy a. Do podziału pracy pomiędzy wątki użyj dyrektywy „omp for” oraz szeregowania statycznego z kwantem 5. Po wyjściu z bloku wyświetl obydwie tablice. Zadanie 4.2. Opisz w postaci funkcji algorytm równoległy, zwracający maksimum z wartości bezwzględnych elementów tablicy a, gdzie tablica a oraz jej rozmiar są parametrami tej funkcji. Zadanie 4.3. Napisz program wczytujący ze standardowego wejścia liczbę całkowitą n (n ≤ 0), a następnie n liczb. Program ma wyświetlić na standardowym wyjściu sumę tych liczb. Sumowanie powinno zostać wykonane przez 4 wątki. Jeżeli n nie jest podzielne przez cztery, to dodatkowe elementy sumowane powinny być przez wątek główny. Zadanie 4.4. Opisz w postaci funkcji double sredniaArytm(double a[], int n) algorytm wyznaczający średnią arytmetyczną ze wszystkich elementów tablicy a o rozmiarze n. Wykorzystaj operację redukcji z operatorem „+”. Zadanie 4.5. Opisz w postaci funkcji algorytm równoległy wyznaczający wartość poniższego ciągu, gdzie n jest parametrem tej funkcji. Wykorzystaj operację redukcji z operatorem „-”.
−1 −
1 1 1 − ... − 2 3 n
Zadanie 4.6. Niech funkcje f1, f2, f3, f4 i f5 będą funkcjami logicznymi (np. zwracającymi wartość „prawda” w przypadku gdy wykonały się one pomyślnie oraz „fałsz” gdy ich wykonanie nie powiodło się.) Opisz w postaci funkcji algorytm równoległy, który wykona funkcje od f1 do f5 i zwróci wartość „prawda” gdy wszystkie funkcje wykonają się z powodzeniem lub „fałsz” w przeciwnym wypadku. Algorytm nie powinien wymuszać aby każda funkcja wykonana została przez osobny wątek.
76
4. Programowanie w OpenMP Zadanie 4.7. Opisz w postaci funkcji algorytm równoległy wyznaczający wartość liczby π ze wzoru Wallisa. π=2
∞ Y n=1
(2n)(2n) (2n − 1)(2n + 1)
Zadanie 4.8. Opisz w postaci funkcji algorytm równoległy wyznaczający wartość liczby π metodą Monte Carlo. Jeśli mamy koło oraz kwadrat opisany na tym kole to wartość liczby π można wyznaczyć ze wzoru: P π=4 P We wzorze tym występuje pole koła, do czego potrzebna jest wartość liczby π. Sens metody Monte Carlo polega jednak na tym, że w ogóle nie trzeba wyznaczać pola koła. To co należy zrobić to wylosować odpowiednio dużą liczbę punktów należących do kwadratu i sprawdzić jaka ich część należy również do koła. Stosunek tej części do liczby wszystkich punktów będzie odpowiadał stosunkowi pola koła do pola kwadratu w powyższym wzorze. Zadanie 4.9. Dla dowolnego zadania, w którym wystąpiła redukcja, zmodyfikuj rozwiązanie w taki sposób, aby wykonać operację redukcji bez używania klauzuli reduction. Zadanie 4.10. Opisz w postaci funkcji algorytm wyznaczający wartość poniższej całki metodą prostokątów. Z 1 4 ( )dx 2 0 1+x Zadanie 4.11. Opisz w postaci funkcji double iloczynSkal(double x[], double y[], int n) algorytm wyznaczający iloczyn skalarny dwóch wektorów x i y w n-wymiarowej przestrzeni euklidesowej. Zadanie 4.12. Opisz w postaci funkcji double dlugoscWektora(double x [], int n) algorytm wyznaczający długość wektora x w n-wymiarowej przestrzeni euklidesowej.
4.9. Zadania
77
Zadanie 4.13. Opisz w postaci funkcji void mnozMacierze(double A[], double B[], double C[], int lwierszyA, int lkolumnA, int lkolumnB), algorytm równoległy wykonujący równolegle mnożenie macierzy. Wynik mnożenia macierzy A i B należy zamieścić w macierzy C. Napisz program, w którym przetestujesz działanie funkcji. Przed mnożeniem program powinien zainicjować macierze A i B wartościami. Wykonaj pomiary czasu działania funkcji mnozMacierze dla odpowiednio dużej macierzy i dla różnej liczby wątków. Zadanie 4.14. Opisz w postaci funkcji bool czyRowne(int a [], int b [], int n) algorytm sprawdzający, czy wszystkie odpowiadające sobie elementy tablic a i b o rozmiarze n są równe. Zadanie 4.15. Opisz w postaci funkcji int minIndeks(int a [], int M, int N, int wzor, int &liczba) algorytm równoległy wyznaczający najwcześniejszy indeks wystąpienia wartości wzor w tablicy a wśród składowych a[M]..a[N]. Poprzez parametr wyjściowy liczba należy zwrócić liczbę wszystkich wystąpień wartości wzor. Zadanie 4.16. Podaj przykład zrównoleglonej pętli for, która będzie wykonywała się szybciej z szeregowaniem statycznym z kwantem 1, aniżeli statycznym bez określania kwantu, czyli z podziałem na w przybliżeniu równe, ciągłe grupy kroków pętli dla każdego wątku. Zadanie 4.17. Dodaj do przykładu 4.2 dyrektywy warunkowej kompilacji, tak aby program działał bez OpenMP. Zadanie 4.18. Opisz w postaci funkcji int maxS(int *A[], int m, int n) algorytm wyznaczający wartość max
0≤i≤m−1
n−1 X
(|Aij |),
j=0
gdzie m i n to odpowiednio liczba wierszy i kolumn macierzy A.
78
4. Programowanie w OpenMP Zadanie 4.19. Używając metody trapezów (patrz poniższy wzór) Z a
b
1 1 f (x)dx ≈ T (h) = h[ f0 + f1 + ... + fn−1 + fn ] 2 2
5. Message Passing Interface – podstawy W tym rozdziale wprowadzimy podstawowe informacje na temat Message Passing Interface (MPI), jednego z najstarszych, ale ciągle rozwijanego, a przede wszystkim bardzo popularnego standardu programowania równoległego. Omówimy ogólną koncepcję MPI oraz podstawowe schematy komunikacji między procesami. Dla pełniejszego przestudiowania możliwości MPI odsyłamy Czytelnika do [47, 51, 56].
5.1. Wprowadzenie do MPI Program MPI zakłada działanie kilku równoległych procesów, w szczególności procesów rozproszonych, czyli działających na różnych komputerach, połączonych za pomocą sieci. W praktyce MPI jest najczęściej używany na klastrach komputerów i implementowany jako biblioteka funkcji oraz makr, które możemy wykorzystać pisząc programy w językach C/C++ oraz Fortran. Przykładowe implementacje dla tych języków to MPICH oraz OpenMPI. Oczywiście znajdziemy też wiele implementacji dla innych języków. Naturalnym elementem każdego programu, w skład którego wchodzi kilka równoległych procesów (lub wątków), jest wymiana danych pomiędzy tymi procesami (wątkami). W przypadku wątków OpenMP odbywa się to poprzez współdzieloną pamięć. Jeden wątek zapisuje dane do pamięci, a następnie inne wątki mogą tę daną przeczytać. W przypadku procesów MPI rozwiązanie takie nie jest możliwe, ponieważ nie posiadają one wspólnej pamięci. Komunikacja pomiędzy procesami MPI odbywa się na zasadzie przesyłania komunikatów, stąd nazwa standardu. Poprzez komunikat należy rozumieć zestaw danych stanowiących właściwą treść wiadomości oraz informacje dodatkowe, np. identyfikator komunikatora, w ramach którego odbywa się komunikacja, czy numery procesów komunikujących się ze sobą. Komunikacja może zachodzić pomiędzy dwoma procesami, z których jeden wysyła wiadomość a drugi ją odbiera, wówczas nazywana jest komunikacją typu punkt-punkt, ale może też obejmować więcej niż dwa procesy i wówczas jest określana mianem komunikacji grupowej. Na listingu 5.1 przedstawiono prosty program, od którego zaczniemy omawiać standard MPI. Listing 5.1. Prosty program MPI w języku C - „Witaj świecie!”. 1 2
#include <s t d i o . h> #include "mpi . h"
3 4 5
i n t main ( i n t argc , char ∗∗ argv ) {
5.1. Wprowadzenie do MPI
81
i n t myid ; i n t numprocs ;
6 7 8
// F u n k c j i MPI n i e wywo ł ujemy p r z e d MPI_Init
p r i n t f ( " Witaj ␣ ś w i e c i e ! ␣ " ) ; p r i n t f ( " P r o c e s ␣%d␣ z ␣%d . \ n" , myid , numprocs ) ;
16 17 18
MPI_Finalize ( ) ;
19 20
// . . . a n i po MPI_Finalize
21 22
return 0 ;
23 24
}
Powyższy program skompilować możemy poleceniem: mpicc program.c -o program Aby uruchomić skompilowany program MPI wykorzystujemy polecenie: mpirun -np p ./program gdzie w miejsce p wpisujemy liczbę równoległych procesów MPI dla uruchamianego programu. Wynik programu dla czterech procesów może być następujący: Witaj Witaj Witaj Witaj Witaj
świecie! świecie! świecie! świecie! świecie!
Proces Proces Proces Proces Proces
0 1 3 4 2
z z z z z
5. 5. 5. 5. 5.
Oczywiście jest to tylko przykładowy wynik. Należy pamiętać, że procesy MPI wykonują się równolegle, zatem kolejność wyświetlania przez nie komunikatów na ekran będzie przypadkowa. W powyższym programie znajdziemy kilka elementów stanowiących pewną ogólną strukturę każdego programu MPI. Po pierwsze w każdym programie znaleźć się musi poniższa dyrektywa. #include "mpi.h" W pliku mpi.h zawarte są wszystkie niezbędne definicje, makra i nagłówki funkcji MPI.
82
5. Message Passing Interface – podstawy Następnie, aby móc korzystać z biblioteki MPI, zanim użyta zostanie jakakolwiek inna funkcja z tej biblioteki, musimy wywołać funkcję MPI Init. Funkcja ta jako swoje argumenty przyjmuje wskaźniki do argumentów funkcji main. Na zakończenie programu konieczne jest wywołanie MPI Finalize. Obydwie te funkcje stanowią swego rodzaju klamrę każdego programu MPI. Kolejnymi elementami, które znajdziemy równie często w każdym programie MPI, są funkcje MPI comm rank oraz MPI comm size. Składnia tych funkcji jest następująca1 : int MPI_comm_rank(MPI_comm comm, int *id) MPI Comm comm – [IN] Komunikator. int *id – [OUT] Identyfikator procesu w ramach komunikatora comm. int MPI_comm_size(MPI_comm comm, int *size) MPI Comm comm – [IN] Komunikator. int *size – [OUT] Liczba wszystkich procesów w komunikatorze comm. Pierwszym argumentem obydwu tych funkcji jest komunikator. Komunikator jest to przestrzeń porozumiewania się dla procesów MPI, które dołączyły do tej przestrzeni i dzięki temu mogą się komunikować. Inaczej mówiąc, jest to po prostu zbiór wszystkich procesów, które mogą wysyłać do siebie wzajemne komunikaty. W ramach jednego programu MPI może istnieć więcej niż jeden komunikator, ale dla prostych programów ograniczymy się do komunikatora MPI COMM WORLD, do którego należą wszystkie procesy uruchomione dla danego programu MPI. W drugim argumencie funkcji MPI comm rank zapisany zostanie identyfikator, jaki dany proces otrzymał w ramach komunikatora. Identyfikator procesu MPI jest liczbą od 0 do p−1, gdzie p to rozmiar danego komunikatora. Wartość ta zostanie zapisana w drugim, wyjściowym parametrze funkcji MPI comm size. Wywołanie obydwu tych funkcji daje każdemu z procesów informację na temat własnego otoczenia. W wielu programach wiedza ta będzie niezbędna do właściwego podziału pracy pomiędzy równoległe procesy. Większość funkcji MPI zwraca stałą całkowitą oznaczającą kod błędu. MPI Success oznacza prawidłowe wykonanie funkcji, a pozostałe kody zależą od implementacji MPI. W praktyce jednak bardzo często kody błędu są ignorowane, a funkcje wywoływane tak jak procedury2 . Dlatego też, dla uproszczenia, w podawanych przez nas przykładach zostały one pominięte. W odróżnieniu od wątków OpenMP, procesy programu MPI startują jednocześnie z chwilą startu programu, co można zaobserwować uruchamiając program z listingu 5.2. 1 W całym rozdziale przy opisie będziemy używać oznaczeń [IN] oraz [OUT] dla wskazania parametrów wejściowych i wyjściowych. 2 Procedurą czasem określa się funkcję typu void.
5.1. Wprowadzenie do MPI Listing 5.2. Ilustracja czasu działania procesów MPI. 1 2
#include <s t d i o . h> #include "mpi . h"
3 4 5 6
i n t main ( i n t argc , char ∗∗ argv ) { p r i n t f ( " P r o c e s ␣ wystartowa ł . \ n" ) ;
p r i n t f ( " P r o c e s ␣%d␣ z ␣%d␣ p r a c u j e . \ n" , myid , numprocs ) ;
15 16
MPI_Finalize ( ) ;
17 18
p r i n t f ( " P r o c e s ␣ koń czy ␣ d z i a ł a n i e . \ n" ) ;
19 20
return 0 ;
21 22
}
Wynikiem tego programu dla czterech procesów będzie następujący wydruk: Proces Proces Proces Proces Proces Proces Proces Proces Proces Proces Proces Proces
wystartował. wystartował. wystartował. wystartował. 0 z 4 pracuje. 1 z 4 pracuje. 2 z 4 pracuje. 3 z 4 pracuje. kończy działanie. kończy działanie. kończy działanie. kończy działanie.
Widzimy, że od początku do końca programu działa 4 procesy. Jednak przed MPI Init i po MPI Finalize procesy te nie należą do komunikatora MPI. W praktyce też, przed wywołaniem funkcji MPI Init, nie będziemy zamieszczać nic oprócz definicji zmiennych. Podobnie po MPI Finalize znajdziemy tylko operacje zwalniające dynamicznie przydzieloną pamięć. Dla każdego procesu, oprócz jego identyfikatora, mamy możliwość sprawdzenia, na którym węźle równoległego komputera (klastra komputerów) został on uruchomiony. Posłuży do tego funkcja MPI Get processor name.
83
84
5. Message Passing Interface – podstawy Składnia tej funkcji jest następująca: int MPI_Get_processor_name(char *name, int *resultlen) char *name – [OUT] Nazwa rzeczywistego węzła, na którym działa dany proces MPI. Wymagane jest, aby była to tablica o rozmiarze conajmniej MPI MAX PROCESSOR NAME. int *resultlen – [OUT] Długość tablicy name. Specyfikacja tej funkcji określa, że wartość zapisana w tablicy name powinna jednoznacznie identyfikować komputer, na którym wystartował dany proces. Efekt może być różny w zależności od implementacji MPI. Przykładowo, może to być wynik działania takich funkcji jak: gethostname, uname czy sysinfo. Użycie funkcji MPI Get processor name zaprezentowano na listingu 5.3. Listing 5.3. Działanie funkcji MPI Get processor name 1 2
#include <s t d i o . h> #include "mpi . h"
3 4 5 6 7
i n t main ( i n t argc , char ∗∗ argv ) { i n t myid ; i n t numprocs ;
8
i n t namelen ; char processor_name [MPI_MAX_PROCESSOR_NAME] ;
p r i n t f ( " P r o c e s ␣%d␣ z ␣%d␣ d z i a ł a ␣ na␣ s e r w e r z e ␣%s . \ n" , myid , numprocs , processor_name ) ;
18 19 20
MPI_Finalize ( ) ;
21 22
return 0 ;
23 24
}
Poniżej przedstawiono przykładowy wydruk będący wynikiem powyższego programu. Program wykonany został na klastrze dwóch komputerów pracujących pod systemem operacyjnym Centos. Uruchomiono 4 procesy, pod dwa na każdy węzeł klastra. Nazwy tutor1 oraz tutor2 to wynik systemowego polecenia hostname dla każdego z węzłów.
5.2. Komunikacja typu punkt-punkt Proces Proces Proces Proces
0 1 2 3
z z z z
4 4 4 4
działa działa działa działa
na na na na
serwerze serwerze serwerze serwerze
tutor1. tutor1. tutor2. tutor2.
5.2. Komunikacja typu punkt-punkt Do przesłania wiadomości pomiędzy dwoma procesami można użyć następujących funkcji: MPI Send oraz MPI Recv. Pierwsza z nich służy do wysłania komunikatu, druga do jego odebrania. Ich składnia jest następująca: int MPI_Send( void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm ) void *buf – [IN] Adres początkowy bufora z danymi. Może to być adres pojedynczej zmiennej lub początek tablicy. int count – [IN] Długość bufora buf. Dla pojedynczej zmiennej będzie to wartość 1. MPI Datatype datatype – [IN] Typ pojedynczego elementu bufora. int dest – [IN] Identyfikator procesu, do którego wysyłany jest komunikat. int tag – [IN] Znacznik wiadomości. Używany do rozróżniania wiadomości w przypadku gdy proces wysyła więcej komunikatów do tego samego odbiorcy. MPI Comm comm – [IN] Komunikator. int MPI_Recv( void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status *status ) void *buf – [OUT] Adres początkowy bufora do zapisu odebranych danych. Może to być adres pojedynczej zmiennej lub początek tablicy. int count – [IN] Maksymalna liczba elementów w buforze buf. MPI Datatype datatype - [IN] Typ pojedynczego elementu bufora. int source – [IN] Identyfikator procesu, od którego odbierany jest komunikat. int tag – [IN] Znacznik wiadomości. Używany do rozróżniania wiadomości w przypadku gdy proces odbiera więcej komunikatów od tego samego nadawcy. MPI Comm comm – [IN] Komunikator. MPI Status *status – [OUT] Zmienna, w której zapisywany jest status przesłanej wiadomości.
85
86
5. Message Passing Interface – podstawy Zawartość bufora po stronie nadawcy zostaje przekazana do bufora po stronie odbiorcy. Wielkość przesłanej wiadomości określają kolejne parametry funkcji MPI Send, jest to ciąg count elementów typu datatype. Po stronie odbiorcy specyfikujemy maksymalną liczbę elementów, jaką może pomieścić bufor, oczywiście wiadomość odebrana zostanie również w przypadku gdy tych elementów będzie mniej. Parametr datatype określa typ elementów składowych wiadomości. Może to być jeden spośród predefiniownych typów MPI, których listę dla języka C przedstawiono w tabeli 5.1. Tabela 5.1. Predefiniowane typy MPI dla języka C.
MPI MPI MPI MPI MPI MPI MPI MPI MPI MPI MPI MPI
Datatype CHAR SHORT INT LONG UNSIGNED CHAR UNSIGNED SHORT UNSIGNED UNSIGNED LONG FLOAT DOUBLE LONG DOUBLE
Odpowiednik w języku C signed char signed short int signed int signed long int unsigned char unsigned short int unsigned int unsigned long int float double long double
Składowe wiadomości mogą być również typu złożonego. Mogą to być obiekty struktur bądź klas, możemy też tworzyć typy pochodne od przedstawionych w tabeli 5.1 typów predefiniowanych, o czym więcej w kolejnym rozdziale. Przykład użycia funkcji MPI Send oraz MPI Recv przedstawiono na listingu 5.4. Listing 5.4. Komunikacja typu punkt-punkt, funkcje MPI Send oraz MPI Recv. Przesłanie pojedynczej danej. 1 2
#include <s t d i o . h> #include "mpi . h"
3 4 5 6 7
i n t main ( i n t argc , char ∗∗ argv ) { i n t numprocs , myid ; i n t tag , from , t o ;
MPI_Send(&data , 1 , MPI_DOUBLE, to , tag , MPI_COMM_WORLD) ;
22 23
} e l s e i f ( myid == 3 ) {
24 25 26
from = 0 ; tag = 2010;
27 28 29
MPI_Recv(&data , 1 , MPI_DOUBLE, from , tag , MPI_COMM_WORLD, &s t a t u s ) ;
30 31 32
p r i n t f ( " P r o c e s ␣%d␣ odebra ł : ␣%f \n" , myid , data ) ;
33 34
} else { // Nie r ó b n i c }
35 36 37 38
MPI_Finalize ( ) ;
39 40
return 0 ;
41 42
}
Program ten wymusza dla poprawnego działania uruchomienie czterech procesów MPI. Jakąkolwiek pracę wykonują tylko dwa z nich. Proces numer 0 wysyła wartość pojedynczej zmiennej, proces numer 3 tę wartość odbiera. Wynikiem tego programu dla czterech procesów będzie poniższy wydruk: Proces 3 odebrał: 2.500000
Kolejny przykład (listing 5.5) stanowi niewielką modyfikację poprzedniego. Tutaj również zachodzi komunikacja pomiędzy dwoma procesami. Tym razem proces numer 1 wysyła do procesu numer 3 tablicę danych. Listing 5.5. Komunikacja typu punkt-punkt. Przesłanie tablicy danych. Zmienna status. 1 2
#include <s t d i o . h> #include "mpi . h"
3 4 5
i n t main ( i n t argc , char ∗∗ argv ) {
87
88
5. Message Passing Interface – podstawy i n t numprocs , myid ; i n t count , tag , from , to , i ; i n t r_count , r_source , r_tag ; double data [ 1 0 0 ] ; MPI_Status s t a t u s ;
MPI_Send ( data , count , MPI_DOUBLE, to , tag , MPI_COMM_WORLD) ;
24 25
} e l s e i f ( myid == 3 ) {
26 27 28
count = 1 0 0 ; from = MPI_ANY_SOURCE; t a g = MPI_ANY_TAG;
29 30 31 32
MPI_Recv( data , count , MPI_DOUBLE, from , tag , MPI_COMM_WORLD, &s t a t u s ) ;
33 34 35
MPI_Get_count(& s t a t u s , MPI_DOUBLE, &r_count ) ; r _ s o u r c e= s t a t u s .MPI_SOURCE; r_tag= s t a t u s .MPI_TAG;
36 37 38 39
p r i n t f ( " I n f o r m a c j a ␣ o ␣ z m i e n n e j ␣ s t a t u s \n" ) ; p r i n t f ( " ź r ód ł o ␣ : ␣%d\n" , r _ s o u r c e ) ; p r i n t f ( " z n a c z n i k ␣ : ␣%d\n" , r_tag ) ; p r i n t f ( " l i c z b a ␣ odebranych ␣ e l e m e n t ów␣ : ␣%d\n" , r_count ) ;
40 41 42 43 44
p r i n t f ( " P r o c e s ␣%d␣ odebra ł : ␣ \n" , myid ) ;
45 46
f o r ( i =0; i
47 48 49 50
}
51 52
MPI_Finalize ( ) ;
53 54
return 0 ;
55 56
}
5.2. Komunikacja typu punkt-punkt W przykładzie tym podczas wywołania funkcji MPI Recv nie określamy dokładnie od jakiego procesu ma przyjść komunikat, wstawiając w miejsce zmiennej source stałą MPI ANY SOURCE. Podobnie nie jest precyzowana zmienna tag, a w jej miejscu pojawia się stała MPI ANY TAG. Proces numer 3 jest skłonny tym samym odebrać wiadomość od dowolnego nadawcy z dowolnym znacznikiem. W takim przypadku bardzo pomocna staje się zmienna status, w której po odebraniu komunikatu znajdziemy takie informacje jak nadawca wiadomości, jej znacznik oraz wielkość. MPI Status jest strukturą, pole MPI SOURCE zawiera identyfikator nadawcy a pole MPI TAG znacznik wiadomości. Do określenia liczny elementów składowych wiadomości należy wywołać funkcję MPI Get count. Wynikiem tego programu dla czterech procesów będzie poniższy wydruk: Informacja o zmiennej status: źródło = 0 znacznik = 2010 liczba odebranych elementów = 7 Proces 3 odebrał: 0.000000 1.000000 2.000000 3.000000 4.000000 5.000000 6.000000
W [51] znajdziemy program „Pozdrowienia” – klasyczny przykład ilustrujący komunikację typu punkt-punkt. W całości został on przytoczony na listingu 5.6. Listing 5.6. Program „Pozdrowienia”. 1 2 3
#include <s t d i o . h> #include <s t r i n g . h> #include "mpi . h"
4 5 6 7
i n t main ( i n t argc , char ∗∗ argv ) { i n t myid , numprocs ;
i f ( myid != 0 ) { s p r i n t f ( message , " P o z d r o w i e n i a ␣ od ␣ p r o c e s u ␣%d ! " , myid ) ;
89
90
5. Message Passing Interface – podstawy dest = 0; MPI_Send ( message , s t r l e n ( message ) +1, MPI_CHAR, d e s t , tag , MPI_COMM_WORLD) ;
24 25 26
} else {
27 28 29
f o r ( s o u r c e =1; s o u r c e
30 31
MPI_Recv( message , 1 0 0 , MPI_CHAR, s o u r c e , tag , MPI_COMM_WORLD, &s t a t u s ) ;
32 33 34
p r i n t f ( "%s \n" , message ) ; }
35 36
}
37 38
MPI_Finalize ( ) ;
39 40
return 0 ;
41 42
}
W programie tym proces numer 0 odbiera komunikaty od wszystkich pozostałych procesów. Wszystkie procesy, począwszy od procesu numer 1, przygotowują wiadomość w postaci łańcucha znaków i wysyłają go do procesu numer 0, który odbiera te wiadomości i wyświetla je na ekran. Kolejność odbierania wiadomości jest taka: najpierw od procesu numer 1, potem od procesu numer 2 i tak kolejno. Wynikiem tego programu dla sześciu procesów będzie poniższy wydruk: Pozdrowienia Pozdrowienia Pozdrowienia Pozdrowienia Pozdrowienia
od od od od od
procesu procesu procesu procesu procesu
1! 2! 3! 4! 5!
Algorytm odbierania wiadomości w przykładzie 5.6 jest dobry pod warunkiem, że z jakiegoś powodu zależy nam na odebraniu wiadomości w takiej kolejności. Jeśli natomiast zależy nam na tym, aby program był optymalny, a nie zależy nam na z góry ustalonej kolejności odbierania wiadomości, wówczas w programie należałoby zmodyfikować wywołanie funkcji MPI Recv, jak poniżej. 32 33
MPI_Recv( message , 1 0 0 , MPI_CHAR, MPI_ANY_SOURCE, tag , MPI_COMM_WORLD, &s t a t u s ) ;
Po takiej modyfikacji proces numer 0 nie będzie musiał czekać na któryś z kolejnych procesów w przypadku gdy ten jest jeszcze niegotowy, mimo
5.2. Komunikacja typu punkt-punkt że w tym samym czasie w kolejce do nawiązania komunikacji czekają inne procesy. Przykładowy wynik programu po tej modyfikacji dla sześciu procesów będzie poniższy wydruk: Pozdrowienia Pozdrowienia Pozdrowienia Pozdrowienia Pozdrowienia
od od od od od
procesu procesu procesu procesu procesu
1! 3! 5! 4! 2!
Oczywiście wydruk ten może się różnić, i zapewne będzie, za każdym uruchomieniem programu. Jeżeli procesy potrzebują wymienić się komunikatami nawzajem, wówczas można użyć funkcji MPI Sendrecv, która łączy w sobie funkcjonalności zarówno MPI Send jaki i MPI Recv. Jej składnia wygląda następująco: int MPI_Sendrecv( void *sendbuf, int sendcount, MPI_Datatype sendtype, int dest, int sendtag, void *recvbuf, int recvcount, MPI_Datatype recvtype, int source, int recvtag, MPI_Comm comm, MPI_Status *status ) void *sendbuf – [IN] Adres początkowy bufora z danymi do wysłania. Może to być adres pojedynczej zmiennej lub początek tablicy. int sendcount – [IN] Długość bufora sendbuf. Dla pojedynczej zmiennej będzie to wartość 1. MPI Datatype sendtype – [IN] Typ elementów bufora sendbuf. int dest – [IN] Identyfikator procesu, do którego wysyłany jest komunikat. int sendtag – [IN] Znacznik wiadomości wysyłanej. void *recvbuf – [OUT] Adres początkowy bufora do zapisu odebranych danych. Może to być adres pojedynczej zmiennej lub początek tablicy. int recvcount – [IN] Liczba elementów w buforze recvbuf. MPI Datatype recvtype – [IN] Typ elementów bufora recvbuf. int source – [IN] Identyfikator procesu, od którego odbierany jest komunikat. int recvtag – [IN] Znacznik wiadomości odbieranej. MPI Comm comm – [IN] Komunikator. MPI Status *status – [OUT] Zmienna, w której zapisywany jest status przesłanej wiadomości.
91
92
5. Message Passing Interface – podstawy Funkcja ta nie ogranicza się jedynie do komunikacji pomiędzy dwoma procesami, które wymieniają się wiadomościami, pozwala aby proces wysyłał wiadomość do jednego procesu a odbierał od jeszcze innego. W sumie jednak każdy z procesów, wywołujący MPI Sendrecv, wysyła jedną wiadomość i odbiera jedną wiadomość. Inną odmianą tej funkcji jest MPI Sendrecv replace, której składnia jest następująca: int MPI_Sendrecv_replace( void *buf, int count, MPI_Datatype datatype, int dest, int sendtag, int source, int recvtag, MPI_Comm comm, MPI_Status *status ) void *buf – [IN] Adres początkowy bufora z danymi do wysłania, który jednocześnie jest adresem początkowym bufora do zapisu odebranych danych. Może to być adres pojedynczej zmiennej lub początek tablicy. int count – [IN] Długość bufora buf. Dla pojedynczej zmiennej będzie to wartość 1. MPI Datatype datatype – [IN] Typ pojedynczego elementu bufora buf. int dest – [IN] Identyfikator procesu, do którego wysyłany jest komunikat. int sendtag – [IN] Znacznik wiadomości wysyłanej. int source – [IN] Identyfikator procesu, od którego odbierany jest komunikat. int recvtag – [IN] Znacznik wiadomości odbieranej. MPI Comm comm – [IN] Komunikator. MPI Status *status – [OUT] Zmienna, w której zapisywany jest status przesłanej wiadomości. Różni się ona od MPI Sendrecv tym, że nie wymaga dodatkowego bufora na odebraną wiadomość. W miejsce danych, które zostały wysłane, zapisywane są dane, które zostały odebrane, oczywiście kasując poprzednią zawartość.
5.3. Synchronizacja procesów MPI – funkcja MPI Barrier W programach MPI często będą takie miejsca, w których konieczna będzie synchronizacja procesów. Będziemy wymagać aby wszystkie procesy skończyły pewien etap pracy zanim przejdą do następnej części.
5.3. Synchronizacja procesów MPI – funkcja MPI Barrier Rozważmy pewien przykład (listing 5.7): Listing 5.7. Funkcja MPI Barrier. 1 2 3
#include <s t d i o . h> #include < s t d l i b . h> #include "mpi . h"
4 5 6
void p r i n t A r r a y ( i n t id , i n t ∗ a r r a y , i n t s i z e ) { int i ;
7
p r i n t f ( " ␣%d␣ : ␣ " , i d ) ; f o r ( i =0; i <s i z e ; ++i ) p r i n t f ( " ␣%d␣ " , a r r a y [ i ] ) ; p r i n t f ( " \n" ) ;
8 9 10 11 12
return ;
13 14
}
15 16 17 18 19
i n t main ( i n t argc , char ∗∗ argv ) { i n t myid , numprocs ; int i ;
20
i n t buf1 [ 1 0 ] = { 0 } , buf2 [ 1 0 ] = { 0 } ;
f o r ( i =0; i <10; ++i ) buf2 [ i ] = 10 + myid ;
31 32 33
p r i n t A r r a y ( myid , buf1 , 1 0 ) ;
34 35
p r i n t A r r a y ( myid , buf2 , 1 0 ) ;
36 37
MPI_Finalize ( ) ;
38 39
return 0 ;
40 41
}
Założeniem w tym programie było, aby każdy proces, po tym jak ustawi wartości dwóch tablic, wyświetlił je na ekran. Przykładowym wynikiem działania tego programu jest poniższy wydruk.
Załóżmy jednak, że zależy nam na bardziej przejrzystym wydruku na ekranie. Niech zatem najpierw każdy z procesów wyświetli na ekranie pierwszą tablicę, potem jeden z procesów wyświetli linię rozdzielającą, a potem każdy proces wyświetli drugą tablicę. Gwarancję takiego efektu uzyskać możemy dzięki mechanizmowi bariery, który czytelnik miał już okazję poznać w rozdziale o OpenMP. Barierę w MPI realizujemy poprzez wywołanie funkcji MPI Barrier. Składnia tej funkcji jest następująca. int MPI_Barrier ( MPI_Comm comm ) MPI Comm comm – [IN] Komunikator. Funkcja ta blokuje wszystkie procesy do momentu, aż zostanie wywołana przez każdy z procesów. Jest to takie miejsce w programie, do którego musi dojść najwolniejszy z procesów, zanim wszystkie ruszą dalej. Rozważmy zatem następującą modyfikację kodu z listingu 5.7. 34
p r i n t A r r a y ( myid , buf1 , 1 0 ) ;
35 36
MPI_Barrier (MPI_COMM_WORLD) ;
37 38
i f ( myid==0) p r i n t f ( "−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n" ) ;
Dzieje się tak dlatego, że przeplot procesów może nastąpić w trakcie wykonywania operacji wyświetlania w funkcji printArray. Aby tego uniknąć musielibyśmy wymusić aby wyświetlanie wewnątrz funkcji printArray odbywało się sekwencyjnie, czyli aby jej wywołanie było swego rodzaju sekcją krytyczną. W MPI nie mamy do tego specjalnych mechanizmów i jesteśmy zmuszeni zastosować własne rozwiązania programistyczne. Dokonamy zatem modyfikacji funkcji printArray tak, aby wykluczyć przeplot. Na listingu 5.8 zamieszczono modyfikację programu 5.7. Najważniejszym elementem tej modyfikacji jest usunięcie funkcji printArray i użycie w jej miejsce funkcji safePrintArray. Wewnątrz tej funkcji widzimy pętlę. W każdym obrocie tylko jeden z procesów wyświetla dane na ekran, a pozostałe czekają na barierze. Jednocześnie funkcja ta wymusza, aby procesy wyświetlały swoją tablicę po kolei, począwszy od procesu 0, co ułatwi nam porównywanie wydruków na ekranie. Listing 5.8. Serializacja wyświetlania danych na ekranie. 1 2 3
#include <s t d i o . h> #include < s t d l i b . h> #include "mpi . h"
4 5 6 7 8
void s a f e P r i n t A r r a y ( i n t id , i n t nprocs , i n t ∗ a r r a y , int s i z e ) { int i , n ; f o r ( n=0; n
9 10 11 12 13 14
i f ( n == i d ) { p r i n t f ( " ␣%d␣ : ␣ " , i d ) ; f o r ( i =0; i <s i z e ; ++i ) p r i n t f ( " ␣%d␣ " , a r r a y [ i ] ) ; p r i n t f ( " \n" ) ;
15
i f ( i d==nprocs −1) p r i n t f ( " \n" ) ;
16 17
}
96
5. Message Passing Interface – podstawy 18
MPI_Barrier (MPI_COMM_WORLD) ; }
19 20 21
}
22 23 24 25 26
i n t main ( i n t argc , char ∗∗ argv ) { i n t myid , numprocs ; int i ;
27
i n t buf1 [ 1 0 ] = { 0 } , buf2 [ 1 0 ] = { 0 } ;
f o r ( i =0; i <10; ++i ) buf2 [ i ] = 10 + myid ;
37 38 39
s a f e P r i n t A r r a y ( myid , numprocs , buf1 , 1 0 ) ;
40 41
MPI_Barrier (MPI_COMM_WORLD) ;
42 43
s a f e P r i n t A r r a y ( myid , numprocs , buf2 , 1 0 ) ;
44 45
MPI_Finalize ( ) ;
46 47
return 0 ;
48 49
}
W dalszej części tego rozdziału funkcja safePrintArray będzie często używana.
5.4. Komunikacja grupowa – funkcje MPI Bcast, MPI Reduce, MPI Allreduce Jeśli jakaś dana ma być przesłana z jednego procesu do wszystkich pozostałych, wówczas używanie komunikacji typu punkt-punkt nie jest wydajne, zarówno pod względem zwięzłości kodu, jak i czasu działania takiej operacji, która wiązałaby się z wielokrotnym wywołanie funkcji wysyłającej i odbierającej. W takiej sytuacji należy używać funkcji specjalnie opracowanych do komunikacji grupowej. Do rozesłania pojedynczej danej lub tablicy danych z jednego procesu do wszystkich pozostałych posłuży nam funkcja MPI Bcast.
5.4. Komunikacja grupowa – funkcje MPI Bcast, MPI Reduce, MPI Allreduce 97 Składnia tej funkcji jest następująca: int MPI_Bcast ( void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm ) void *buffer – [IN/OUT] Na procesie root, adres początkowy bufora z danymi. Na pozostałych procesach, adres początkowy bufora gdzie dane mają być zapisane. Może to być adres pojedynczej zmiennej lub początek tablicy. int count – [IN] Długość bufora buffer. Dla pojedynczej zmiennej będzie to wartość 1. MPI Datatype datatype – [IN] Typ pojedynczego elementu bufora. int root – [IN] Identyfikator procesu, od którego rozsyłany jest komunikat. MPI Comm comm – [IN] Komunikator. MPI Bcast rozsyła wiadomość zamieszczoną w tablicy buffer procesu root do wszystkich pozostałych procesów. Na listingu 5.9 przedstawiono przykład użycia funkcji MPI Bcast. Listing 5.9. Funkcja MPI Bcast. i n t myid , numprocs ; int root ;
1 2 3
i n t buf [ 1 0 ] = { 0 } ;
4 5
...
6 7
i f ( myid == 0 ) f o r ( i =0; i <10; ++i ) buf [ i ] = i ;
8 9 10 11
s a f e P r i n t A r r a y ( myid , numprocs , buf , 1 0 ) ;
12 13
root = 0;
14 15
MPI_Bcast ( buf , 1 0 , MPI_INT, r o o t , MPI_COMM_WORLD) ;
16 17
s a f e P r i n t A r r a y ( myid , numprocs , buf , 1 0 ) ;
18
Proces numer 0 wypełnia tablicę wartościami a następnie tablica ta jest rozesłana do wszystkich pozostałych procesów. Wynik działania programu zamieszczono na wydruku poniżej. 0 1 2 3
: : : :
0 0 0 0
1 0 0 0
2 0 0 0
3 0 0 0
4 0 0 0
5 0 0 0
6 0 0 0
7 0 0 0
8 0 0 0
9 0 0 0
98
5. Message Passing Interface – podstawy
0 1 2 3
: : : :
0 0 0 0
1 1 1 1
2 2 2 2
3 3 3 3
4 4 4 4
5 5 5 5
6 6 6 6
7 7 7 7
8 8 8 8
9 9 9 9
Jednym z ważniejszych zastosowań obliczeń równoległych jest wykonanie operacji, której argumentem jest tablica wartości (lub tablice), a jej wynikiem pojedyncza liczba (lub pojedyncza tablica). Praca związana z taką operacją może zostać podzielona pomiędzy procesy. Każdy proces wyznacza wynik częściowy. Następnie wyniki częściowe są scalane (redukowane) do wyniku końcowego. Przykładem może być obliczenie iloczynu skalarnego wektorów, znalezienie wartości minimalnej lub maksymalnej spośród elementów tablicy itp. Operacje redukcji mają duże znaczenie w obliczeniach równoległych, stąd też większość standardów udostępnia specjalne rozwiązania do ich realizacji. W MPI do tego celu stosowana jest funkcja MPI Reduce. Jej składnia jest następująca: int MPI_Reduce ( void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm ) void *sendbuf – [IN] Adres początkowy bufora z danymi do redukcji. Może to być adres pojedynczej zmiennej lub początek tablicy. void *recvbuf – [OUT] Adres początkowy bufora do zapisu redukowanych danych. Może to być adres pojedynczej zmiennej lub początek tablicy. Istotny tylko dla procesu root. int count – [IN] Długość bufora sendbuf. Dla pojedynczej zmiennej będzie to wartość 1. MPI Datatype datatype – [IN] Typ pojedynczego elementu buforów. MPI Op op – [IN] Operator redukcji. int root – [IN] Identyfikator procesu, do którego dane zostaną zredukowane. MPI Comm comm – [IN] Komunikator. Funkcje do komunikacji grupowej charakteryzują się tym, że wywoływane są przez wszystkie procesy, ale niektóre parametry istotne są tylko dla procesu root. Tak jest w przypadku tablicy recvbuf. W wyniku wywołania funkcji MPI Reduce, dane zapisywane są tylko w tablicy recvbuf procesu 0. Nie jest też konieczna alokacja tej tablicy dla pozostałych procesów. Prosty przykład użycia funkcji MPI Reduce przedstawiono na listingu 5.10.
5.4. Komunikacja grupowa – funkcje MPI Bcast, MPI Reduce, MPI Allreduce 99 Listing 5.10. Funkcja MPI Reduce. int int int int
f o r ( i =0; i <10; ++i ) buf [ i ] = random ( ) %10;
10 11 12
s a f e P r i n t A r r a y ( myid , numprocs , buf , 1 0 ) ;
13 14
i f ( myid==0) p r i n t f ( " \n" ) ; MPI_Barrier (MPI_COMM_WORLD) ;
15 16 17
root = 0; MPI_Reduce ( buf , r e d u c e b u f , 1 0 , MPI_INT, MPI_MAX, r o o t , MPI_COMM_WORLD) ;
18 19 20 21
s a f e P r i n t A r r a y ( myid , numprocs , r e d u c e b u f , 1 0 ) ;
22
Każdy z procesów wypełnia własną tablicę buf losowymi danymi. Po wywołaniu funkcji MPI Reduce w tablicy reducebuf procesu 0 znajdą się maksymalne wartości spośród elementów wszystkich tablic o identycznych indeksach. Przykładowe wyniki zamieszczono poniżej. 0 1 2 3
: : : :
3 6 7 4
6 4 5 4
7 3 2 0
5 4 7 0
3 2 9 7
5 3 7 6
6 9 4 2
2 0 6 4
9 9 7 2
1 8 2 0
0 1 2 3
: : : :
7 0 0 0
6 0 0 0
7 0 0 0
7 0 0 0
9 0 0 0
7 0 0 0
9 0 0 0
6 0 0 0
9 0 0 0
8 0 0 0
Pewną odmianą funkcji MPI Reduce jest funkcja MPI Allreduce, która różni się tym, że wyniki są scalane i zamieszczane w pamięci każdego procesu. Składnia funkcji MPI Allreduce jest następująca: int MPI_Allreduce ( void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )
100
5. Message Passing Interface – podstawy void *sendbuf – [IN] Adres początkowy bufora z danymi do wysłania. Może to być adres pojedynczej zmiennej lub początek tablicy. void *recvbuf – [OUT] Adres początkowy bufora do zapisu odebranych danych. Może to być adres pojedynczej zmiennej lub początek tablicy. int count – [IN] Długość bufora sendbuf. Dla pojedynczej zmiennej będzie to wartość 1. MPI Datatype datatype – [IN] Typ pojedynczego elementu buforów. MPI Op op – [IN] Operator redukcji. MPI Comm comm – [IN] Komunikator. Funkcja ta nie posiada parametru root, który w MPI Reduce określał miejsce przesłania wyniku redukcji. Wywołanie funkcji MPI Allreduce dla programu z listingu 5.10 przyjmie następującą postać. MPI_Allreduce ( buf , r e d u c e b u f , 1 0 , MPI_INT, MPI_MAX, MPI_COMM_WORLD) ;
1 2
Zmienią się też wyniki programu. Każdy z procesów posiada taki sam zestaw danych w tablicy reducebuf. 0 1 2 3
: : : :
3 1 9 4
6 8 9 9
7 5 0 7
5 2 0 6
3 8 4 4
5 5 4 7
6 8 6 5
2 1 9 8
9 8 7 7
1 2 2 8
0 1 2 3
: : : :
9 9 9 9
9 9 9 9
7 7 7 7
6 6 6 6
8 8 8 8
7 7 7 7
8 8 8 8
9 9 9 9
9 9 9 9
8 8 8 8
Funkcja MPI Allreduce daje takie same rezultaty jak wywołanie MPI Reduce a następnie rozesłanie wyniku redukcji przy pomocy MPI Bcast. Na listingu 5.11 zamieszczono przykład zastosowania operacji rozsyłania i redukcji dla wyznaczenie poniższej całki metodą trapezów. Z
1
( 0
4 )dx 1 + x2
Listing 5.11. Program MPI – Całkowanie metodą trapezów 1 2 3
#include <s t d i o . h> #include <math . h> #include "mpi . h"
i f ( myid == r o o t ) { p r i n t f ( "Wprowadź ␣ l i c z b ę ␣ p r z e d z i a ł ów␣ ca ł kowania : ␣ " ) ; s c a n f ( "%d" ,&n ) ; }
22 23 24 25 26 27
MPI_Bcast(&n , 1 , MPI_INT, r o o t , MPI_COMM_WORLD) ;
28 29
h =1.0/( double ) n ;
30 31
sum = 0 . 0 ; f o r ( i=myid ; i
32 33 34 35 36 37 38
MPI_Reduce(&sum , &pi , 1 , MPI_DOUBLE, MPI_SUM, r o o t , MPI_COMM_WORLD) ;
39 40 41
i f ( myid == r o o t ) { p i = h∗ p i ; p r i n t f ( " p i =%.14 f \n" , p i ) ; }
42 43 44 45 46
MPI_Finalize ( ) ;
47 48
return 0 ;
49 50
}
Liczona całka daje w wyniku wartość π co możemy zobaczyć na przykładowym wydruku.
Wprowadź liczbę przedziałów całkowania: 8000000 pi=3.14159265358975
102
5. Message Passing Interface – podstawy
5.5. Pomiar czasu wykonywania programów MPI Celem zrównoleglania programów jest uzyskanie przyspieszenia dla nich. Dzięki przyspieszeniu obliczeń pewne problemy mogą być rozwiązywane w krótszym czasie, inne mogą być wykonywane dla większych zestawów danych. Nieodłącznym elementem wykonywania różnego typu symulacji jest pomiar czasu ich działania. W programach MPI pomocna może się zatem okazać funkcja MPI Wtime. Jest to jedna z niewielu funkcji MPI, która nie zwraca kodu błędu. Składnia funkcji MPI Wtime jest następująca: double MPI_Wtime() Zwraca ona czas w sekundach jaki upłynął od pewnej ustalonej daty z przeszłości. Na listingu 5.12 zamieszczono przykład użycia funkcji MPI Wtime do zmierzenia pewnego sztucznie wygenerowanego opóźnienia programu poprzez funkcję sleep. Listing 5.12. Pomiar czasu metodą MPI Wtime. 1 2 3
#include <s t d i o . h> #include < s t d l i b . h> #include "mpi . h"
4 5 6 7
i n t main ( i n t argc , char ∗ argv [ ] ) { double t _ s t a r t , t_stop ;
8
MPI_Init(& argc , &argv ) ;
9 10
t _ s t a r t = MPI_Wtime ( ) ; sleep (10) ; t_stop = MPI_Wtime ( ) ;
11 12 13 14
p r i n t f ( " 10 ␣ sekund ␣u ś p i e n i a ␣ z m i e r z o n e ␣ p r z e z ␣MPI_Wtime : " ) ; p r i n t f ( " ␣ %1.2 f \n" , t_stop−t _ s t a r t ) ;
15 16 17
MPI_Finalize ( ) ;
18 19
return 0 ;
20 21
}
Wynik działania programu: 10 sekund uśpienia zmierzone przez MPI_Wtime: 10.00 10 sekund uśpienia zmierzone przez MPI_Wtime: 10.00 10 sekund uśpienia zmierzone przez MPI_Wtime: 10.00
5.5. Pomiar czasu wykonywania programów MPI Na powyższym przykładzie zmierzony czas był jednakowy dla wszystkich procesów, co jednak nie jest często występującą sytuacją w rzeczywistych problemach. Jeśli każdy proces pracował różną ilość czasu, to czas działania programu lub jego fragmentu będzie równy czasowi najwolniejszego z procesów. Jeden ze sposobów na zmierzenie globalnego czasu przy różnych czasach dla poszczególnych procesów przedstawiono na przykładzie 5.13. Listing 5.13. Pomiar maksymalnego czasu działania programu 1 2 3 4
