Párhuzamos és Grid rendszerek. Áttekintés. Szálak. Eddig általános eszközöket láttunk, melyek

Hasonló dokumentumok
Párhuzamos és Grid rendszerek

Nagyteljesítményű párhuzamos feldolgozás (3. ea)

Szálak. Grid és OO labor (1. labor) Párhuzamos programozás szálakkal OpenMP, UPC. pthread példa/2. pthread példa. pthread_mutex.

Párhuzamos és Grid rendszerek

Programozás alapjai C nyelv 4. gyakorlat. Mit tudunk már? Feltételes operátor (?:) Típus fogalma char, int, float, double

Bevezetés a párhuzamos programozási koncepciókba

Mit tudunk már? Programozás alapjai C nyelv 4. gyakorlat. Legnagyobb elem keresése. Feltételes operátor (?:) Legnagyobb elem keresése (3)

Programozás alapjai C nyelv 10. gyakorlat. Standard függvények. Union

Programozás C nyelven FELÜLNÉZETBŐL elhullatott MORZSÁK. Sapientia EMTE

main int main(int argc, char* argv[]) { return 0; } main return 0; (int argc, char* argv[]) main int int int main main main

Párhuzamos és Grid rendszerek

Párhuzamos és Grid rendszerek. Flynn-féle architektúra modell. ClearSpeed gyorsító kártya. 2006: Tokyo Institute of Technology's

Függvények. Programozás alapjai C nyelv 7. gyakorlat. LNKO függvény. Függvények(2) LNKO függvény (2) LNKO függvény (3)

Programozás alapjai C nyelv 7. gyakorlat. Függvények. Függvények(2)

C programozás. 6 óra Függvények, függvényszerű makrók, globális és

Programozás II. 2. Dr. Iványi Péter

Programozás 6. Dr. Iványi Péter

Párhuzamos és Grid rendszerek

Párhuzamos és Grid rendszerek. Összefogalás. Jellemző szupersz.gép típusok. Párhuzamos architektúrák. Párh. prog. fejlesztési módszerek

Összefogalás. Párhuzamos és Grid rendszerek. Párhuzamos gépek osztályai. Jellemző szupersz.gép típusok. Flynn-féle architektúra modell

A C programozási nyelv V. Struktúra Dinamikus memóriakezelés

Flynn-féle architektúra modell. Párhuzamos és Grid rendszerek (8. ea) egy vektorprocesszor. Belső felépítés. ClearSpeed gyorsító kártya MTAP

Párhuzamos és Grid rendszerek

Függvény pointer. Feladat: Egy tömbben soroljunk fel függvényeket, és hívjuk meg valahányszor.

Programozás I. 5. Előadás: Függvények

OOP #14 (referencia-elv)

Programozás I. gyakorlat

Függvények. Programozás I. Hatwágner F. Miklós november 16. Széchenyi István Egyetem, Gy r

Pénzügyi algoritmusok

Vezérlési szerkezetek

Grafikus kártyák, mint olcsó szuperszámítógépek - I.

OpenCL - The open standard for parallel programming of heterogeneous systems

Járműfedélzeti rendszerek II. 3. előadás Dr. Bécsi Tamás

1.1. A forrásprogramok felépítése Nevek és kulcsszavak Alapvető típusok. C programozás 3

Programozás alapjai II. (7. ea) C++ Speciális adatszerkezetek. Tömbök. Kiegészítő anyag: speciális adatszerkezetek

Live free() or die() Az openmosix cluster szoftver

Párhuzamos és Grid rendszerek

Speciális adatszerkezetek. Programozás alapjai II. (8. ea) C++ Tömbök. Tömbök/2. N dimenziós tömb. Nagyméretű ritka tömbök

Programozás C++ -ban 2007/4

Programozás alapjai II. (7. ea) C++

Alprogramok, paraméterátadás

Programozás C- és Matlab nyelven C programozás kurzus BMEKOKAM603 Függvények. Dr. Bécsi Tamás 6. Előadás

Bevezetés a programozásba I 10. gyakorlat. C++: alprogramok deklarációja és paraméterátadása

Dinamikus csatolású függvénykönyvtár készítése és használata Plugin-szerű betöltés Egyszeű C++ osztályok készítése

C programozási nyelv Pointerek, tömbök, pointer aritmetika

Magas szintű optimalizálás

tétel: különböző típusú adatokat csoportosít, ezeket egyetlen adatként kezeli, de hozzáférhetünk az elemeihez is

Programozás alapjai C nyelv 8. gyakorlat. Mutatók és címek (ism.) Indirekció (ism)

Szenzorhálózatok programfejlesztési kérdései. Orosz György

C programozási nyelv

Pénzügyi algoritmusok

Programozás C és C++ -ban

Mechatronika és mikroszámítógépek 2017/2018 I. félév. Bevezetés a C nyelvbe

Memóriagazdálkodás. Kódgenerálás. Kódoptimalizálás

Kivételkezelés a C++ nyelvben Bevezetés

Programozás alapjai 9.Gy: Struktúra 2.

Párhuzamos és Grid rendszerek. Parallel programozás áttekintése. Történelmi áttekintés

Programozás alapjai C nyelv 5. gyakorlat. Írjunk ki fordítva! Írjunk ki fordítva! (3)

Konkurens TCP Szerver

Programozás alapjai gyakorlat. 2. gyakorlat C alapok

Párhuzamos programok futásának kiértékelése Scalasca profiler segítségével

Programozás C++ -ban 2007/1

Párhuzamos programozás

Kivételek, kivételkezelés a C++ nyelvben

A verem (stack) A verem egy olyan struktúra, aminek a tetejéről kivehetünk egy (vagy sorban több) elemet. A verem felhasználása

Programozás I gyakorlat. 10. Stringek, mutatók

Programozás C++ -ban

Tartalom DCOM. Történeti áttekintés. Történeti áttekintés. Történeti áttekintés. Történeti áttekintés

ISA szimulátor objektum-orientált modell (C++)

Operációs rendszerek. Az NT folyamatok kezelése

Az MTA Cloud a tudományos alkalmazások támogatására. Kacsuk Péter MTA SZTAKI

Processzusok (Processes), Szálak (Threads), Kommunikáció (IPC, Inter-Process Communication)

Bevezetés a C++ programozási nyelvbe

Programozási nyelvek Java

Dr. Schuster György október 14.

Országzászlók (2015. május 27., Sz14)

Java programozási nyelv 4. rész Osztályok II.

Programozás 5. Dr. Iványi Péter

Programozas 1. Strukturak, mutatok

C++ programozási nyelv Konstruktorok-destruktorok

Programozás II. 4. Dr. Iványi Péter

Mintavételes szabályozás mikrovezérlő segítségével

A C programozási nyelv I. Bevezetés

Kereső algoritmusok a diszkrét optimalizálás problémájához

A programozás alapjai

Programozás 1. Dr. Iványi Péter

Hozzáférés a HPC-hez, kezdő lépések (előadás és demó)

A szemantikus elemzés helye. A szemantikus elemzés feladatai. A szemantikus elemzés feladatai. Deklarációk és láthatósági szabályok

Az UPPAAL egyes modellezési lehetőségeinek összefoglalása. Majzik István BME Méréstechnika és Információs Rendszerek Tanszék

Szkriptnyelvek. 1. UNIX shell

Bevezetés a programozásba Előadás: Objektumszintű és osztályszintű elemek, hibakezelés

A programozás alapjai 1 Rekurzió

Kereső algoritmusok a diszkrét optimalizálás problémájához

A PROGAMOZÁS ALAPJAI 1. Függvény mint függvény paramétere. Függvény mint függvény paramétere. Függvény mint függvény paramétere

egy szisztolikus példa

1. Bevezetés szeptember 9. BME Fizika Intézet. Szám. szim. labor ea. Tőke Csaba. Tudnivalók. feladat. Tematika. Moodle Házi feladatok

Java-ról Kotlinra. Ekler Péter AutSoft BME AUT. AutSoft

Programozás alapjai. (GKxB_INTM023) Dr. Hatwágner F. Miklós október 11. Széchenyi István Egyetem, Gy r

Programozás alapjai II. (1. ea) C++

Programozás alapjai II. (1. ea) C++

Átírás:

Párhuzamos és Grid rendszerek (7. ea) szálak, openmp Szeberényi Imre BME IIT <szebi@iit.bme.hu> M Ű E G Y E T E M 1 7 8 2 Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 1 - Áttekintés Eddig általános eszközöket láttunk, melyek SMP és Cluster környezetben is használhatók. SMP/NUMA környezet egyre gyakoribb a hétköznapokban: többmagos, többszálas processzorok 2, 4, 6, 8, mag Újabb architektúrák, ClearSpeed, GPGPU Újabb programozási modellek (CL, CUDA) Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 2 - Szálak A processzek memóriaterületei egymástól teljesen elkülönítettek. A szálak olyan processzek, melyeknek csak a stack területe különül el. Így lényegesen gyorsabban lehet váltani közöttük, valamint könnyebben is kommunikálnak egymással. pthread_create(), pthread_join(), pthread_exit() pthread_mutex_..., pthread_cond_... Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 3 -

pthread példa #include <stdio.h> thread-et megvalósító #include <pthread.h> függvény void* do_loop(void *id) int i, j; thread egyedi adata float f = 0; char me = *(char *)id; for (i=0; i<10; i++) for (j=0; j<5000000; j++) f++; printf("thread_%c: %d\n", me, i); pthread_exit(null); Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 4 - pthread példa/2 int main(int argc, char* argv[]) pthread_t thread_a, thread_b; thread leírója char a='a', b='b', c='c'; pthread_create(&thread_a, NULL, do_loop, &a); pthread_create(&thread_b, NULL, do_loop, &b); do_loop(&c); egyedi printf("ide nem jut!\n"); paraméter return 0; megvalósító függvény Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 5 - mutex: Kölcsönös kizárás pthtread_mutex_init pthtread_ mutex_destroy pthtread_ mutex_lock pthtread_ mutex_trylock pthtread_ mutex_unlock Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 6 -

pthread_mutex pthread_mutex_t mutex_cnt; pthread_mutex_init(&mutex_cnt, NULL); pthread_mutex_lock(&mutex_cnt); // kritikus régió pthread_mutex_unlock(&mutex_cnt); Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 7 - condition: pthtread_ cond_init Feltétel változó pthtread_ cond_destroy pthtread_ cond_wait pthtread_ cond_timedwait pthtread_ cond_signal pthtread_ cond_broadcast Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 8 - pthread_cond pthread_mutex_t mutex_cnt; pthread_cond_t cond_cnt; pthread_mutex_init(&mutex_cnt, NULL); pthread_cond_init(&cond_cnt, NULL); // egyik szál pthread_mutex_lock(&mutex_cnt); // kritikus régió, várni kell valamire pthread_cond_wait(&cond_cnt, &mutex_cnt); pthread_mutex_unlock(&mutex_cnt); Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 9 -

pthread_cond (2) // másik szál pthread_mutex_lock(&mutex_cnt); // a várt esemény bekövetkezett pthread_cond_signal(&cond_cnt); pthread_mutex_unlock(&mutex_cnt); Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 10 - OpenMP motiváció Szálakkal történő párhuzamosítás macerás: OS függő API-k: Windows: CreateThread UNIX: pthread_create Még egy vektor elemeinek összeadásához is sok ismeret kell: Kölcsönös kizárás (mutex) Külön soros és párhuzamos kód keletkezik Nehéz a skálázhatóság megoldása Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 11 - OpenMP Nyelvi kiterjesztés A programozó a funkcionalitásra koncentrálhat. A párhuzamosítás csak lehetőség. Shared memóriás párhuzamosítás Ipari szabvány 1997: 1.0 2011: 3.1 2013: 4.0 jelenleg draft http://openmp.org/mp-documents/openmp3.1-ccard.pdf Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 12 -

Végrehajtási modell Master thread FORK JOIN FORK JOIN Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 13 - Shared memoria modell A szálak változókon keresztül kommunikálnak. A megosztás nyelvi szinten definiált Versenyhelyzet kialakulhat Szinkronizációs eszközök Megosztás minimalizálása Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 14 - Szintaxis #pragma omp construct [clause [clause] ] Egy blokkra vonatkozik (egy belépés, egy kilépés) OpenMP konstrukciók: Parallel régiók megadása Munka elosztás (work sharing) Adatelérés szabályozása Szinkronizáció Runtime függvények Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 15 -

Paralell régiók double D[1000] = 1, 2, 3, 4 ; #pragma omp parallel shared private int i; double sum = 0; for (i=0; i<1000; i++) sum += D[i]; printf( Thread %d computes %f\n, omp_get_thread_num(), sum); // annyiszor fut, ahány thread van. //OMP_NUM_THREADS Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 16 - Work sharing #pragma omp sections Hosszú futási #pragma omp section idejű valami a = computation_1(); #pragma omp section b = computation_2(); c = a + b; Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 17 - Kézi párhuzamosítás for (int i=0; i<n; i++) a[i]=b[i]+c[i]; #pragma omp parallel int id = omp_get_thread_num(); int nthr = omp_get_num_threads(); int istart = id*n/nthr, iend = (id+1)*n/nthr; for (int i=istart; i<iend; i++) a[i]=b[i]+c[i]; Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 18 -

Automatikus párhuzamosítás #pragma omp parallel #pragma omp for schedule(static) for (int i=0; i<n; i++) a[i]=b[i]+c[i]; Csak egyszerű for ciklus lehet: 1 db int ciklusváltozó, cmp. op: <, >, <=, > Növelés/csökkentés: ++, --, értékadó op. Ciklusfüggetlen init, last, növelés Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 19 - Párhuzamos for problémai Load balancing Egyes részek futási ideje lehet, hogy nem azonos A futási idők eltérése csak ritkán becsülhetők előre Dinamikus szétosztás kellene Granualitás A szálak létrehozása, szinkronizálása akkor is idő, ha ezt eldugja a fordító. Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 20 - Ütemezés schedule(static [, chunksize]) Statikus kiosztás Default: azonos darabok Round-robin (több darab, mint thread esetén) schedule(dynamic [, chunksize]) Dinamikus kiosztás Default chunksize = 1 schedule(guided [, chunksize]) Dinamikus, exponenciálisan csökken Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 21 -

Granularitás #pragma omp parallel if (expression) Párhuzamosítás a feltétellel vezérelhető #pragma omp num_threads (expression) A szálak száma módosítható Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 22 - Adatok elérése Osztott változók - globális változók int sum = 0; #pragma omp parallel for for (int i=0; i<n; i++) sum += i; Privát Párh. blokk auto változói Függvények auto változói Explicit privát deklaráció esetén Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 23 - Tárolási attribútumok megadása private: Privát példány keletkezik, de nem másolódik le az eredeti adat Ugyanaz, mintha között lenne firstprivate: Kezdő érték lemásolódik lastprivate: Legutolsó érték visszamásolódik threadprivate: Perzisztens a párh. részek között (globális) Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 24 -

Tárolási attribútumok pl. int i; #pragma omp parallel for private(i) for (i=0; i<n; i++) int idx=1; int x = 10; #pragma omp parallel for firsprivate(x) \ for (i=0; i<n; i++) if (data[i]==x) idx = i; lastprivate(idx) Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 25 - Tárolási attribútumok pl./2 int data[100]; #pragma omp threadprivate(data) #pragma omp parallel for copyin(data) for (int i=0; i<n; i++) data[i]++; Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 26 - Redukció int sum = 0; #pragma omp parallel for reduction(+: sum) for (int i =0; i<n; j++) sum = sum+a[i]*b[i]; Csak skalár Másolat készül, a végén elvégzi a műveletet x op expr x++, ++x, x--, --x, op nem lehet túlterhelt Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 27 -

Szinkronizációs mechanizmusok Single/Master execution #pragma omp single #pragma omp master Critical sections, Atomic updates #pragma omp critical [name] #pragma omp atomic update_statement Csak skalár, a redukciónál megismert formában. Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 28 - Ordered Szinkronizációs mech./2 #pragma omp ordered int vec[100]; #pragma omp parallel for ordered for (int i=0; i<100; i++) vec[i] = 2 * vec[i] + i; #pragma omp ordered printf( vec[i] = %d\n, vec[i]); Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 29 - Barriers Szinkronizációs mech./3 #pragma omp barrier Nowait #pragma omp sections nowait Flush #pragma omp flush (list) Reduction Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 30 -

Kontroll funkciók omp_set_dynamic(int)/ omp_get_dynamic() omp_set_num_threads(int)/ omp_get_num_threads() OMP_NUM_THREADS env. omp_get_num_procs() omp_get_thread_num() omp_set_nested(int)/omp_get_nested() omp_in_parallel() omp_get_wtime() omp_init_lock(), omp_destroy_lock(), omp_set_lock(), omp_unset_lock(), omp_test_lock() Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 31 - Példa: integrálás double integ(double low, double high, long n) int num_pes = -1; double w, pew, sum = 0; int penum; // private double sump, l, h; // private #pragma omp parallel default (none) \ shared(low, high, n, num_pes, w, pew) \ private(penum, sump, l, h) \ reduction(+:sum) // Paralel régió kezdete if (num_pes < 0) num_pes = omp_get_num_threads(); penum = omp_get_thread_num(); // private Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 32 - Példa: integrálás /2 w = (high - low) / n; // shared pew = (high - low) / num_pes; // shared l = pew * penum + low; // private h = l + pew; // private sump = 0.0; l += w / 2.0; while (l < h) sump += fx(l); l += w; sum += sump; // Paralel régió vége return sum * w; // gcc -fopenmp prog.c -lgomp Párhuzamos és Grid rendszerek BME-IIT Sz.I. 2013.03.25. - 33 -