A prhuzamos programozs nyelvi elemei Legndi Richrd Olivr

A párhuzamos programozás nyelvi elemei Legéndi Richárd Olivér Eötvös Loránd Tudományegyetem richard. legendi@gmail. com 2009. november 12.

Kivonat n n n Bevezetés Alapfogalmak Példák Alapfeladatok, eszközök Párhuzamos nyelvek általános jellemzése Nyelvi lehetőségek: Ada, Java, PVM

Párhuzamosság „Concurrency is hard and boring. Unfortunately, my favoured technique of ignoring it and hoping it will go away doesn't look like it's going to bear fruit. ”

Párhuzamosság n n Több részfeladat egyidejűleg történő végrehajtása Miért? q q q A feladat logikai szerkezete A program több, fizikailag is független eszközön fut Hatékonyság

Hatékonyság – Amdahl’s law n n Vannak folyamatok, amik gyorsíthatók több erőforrással – és vannak, amik nem Egy felső határt ad a gyorsulás mértékére, ha ismert a párhuzamosan végrehajtandó utasítások aránya: P : párhuzamosítható műveletek aránya N : processzorok száma

Hatékonyság – Amdahl’s law n n Ha N ∞, akkor speedup 1 / P Ha egy program 50%-a szekvenciális, akkor maximum 2 x-es gyorsulás várható, a processzorok számától függetlenül P : párhuzamosítható műveletek aránya N : processzorok száma

A párhuzamosság szintjei n n n Utasítások Taskok Folyamatok (processes) Szálak (threads) Viselkedésük alapján lehetnek: q q q Függetlenek Versengők Együttműködők

Modula-2 n n n Korutinok (startprocess()-szel indíthatók) Jeleket küldhetnek (send), fogadhatnak (wait) awaited(): megadja, hogy van-e legalább egy olyan folyamat, amely jelre vár TRANSFER(<p 1>, <p 2>) Megszakítja p 1 processzt, és átadja a vezérlést p 2 -nek Amikor egy folyamat aktív lesz, onnan folytatja, ahol az előző vezérlésnél megállt

SIMULA 67 n n n Korutinok Alárendeltségi viszony a létrehozójával (szülő -gyermek) detach(): a gyermek visszaadja a vezérlést a szülőnek call(): a leválasztott folyamat újraaktiválása resume(X): az X korutin javára lemondás a vezérlésről

Portal n A folyamatoknak különböző állapotai is lehetnek: q q q Aktiválható – megkaphatja a vezérlést Felfüggesztett Várakozó – egy jelre vár

Algol 68 n n n Begin – end közé írt, vesszővel elválasztott utasítások párhuzamosan futtathatók A blokk nem fejeződik be, amíg minden párhuzamos klóz véget nem ér Szinkronizálás: Dijkstra szemaforokkal

Concurrent Eiffel n n Párhuzamosság a separate kulcsszóval Lehet osztály, metódus, függvény is q q n Eljárás esetén nem függesztődik fel Függvény esetén megvárja a hívó az eredményt Külön virtuális processzoron futnak

Modula-3 n n n A folyamatokat szálaknak nevezi A párhuzamosság eszközei: Thread. Fork, Thread. Join Közös memóriaterületen kommunikálhatnak, üzenetekkel – Channel

Ada n n Task-objektumok ábrázolják a folyamatokat Entry pointokkal – más taskokból hívhatók A task törzsében minden entry-hez legalább egy accept tartozik A hívó folyamat a randevú fogadásáig, és az accept végrehajtásáig felfüggesztődik (randevú)

Tényleges párhuzamosság? n n Látszat – pl. single core gépben Egyszerre egy folyamatot hajt végre, de adott időtartam alatt akár többet is Valódi párhuzamosság – pl. többmagos, többprocesszoros gépekben

Alapfeladatok n n 2 alapvető probléma Kommunikáció q n Kommunikációs közeg: socket, signal handler, fájl, osztott memória, etc. Szinkronizáció: q q Folyamatok összehangolása aszinkron – szinkron

Kölcsönös kizárás, szinkronizáció n n Szinkronizáció: olyan folyamat, amellyel meghatározható a folyamatokban szereplő utasítások relatív sorrendje Kölcsönös kizárás: osztott változók biztonságos használatához Kritikus szakasz: program azon része, ahol egy időben csak egyetlen folyamat tartózkodhat Atomi művelet: bármilyen közbeeső állapota nem látható a többi folyamat számára

Miért van rájuk szükség? n n n Közös erőforrások használata X = X + 1 (nem feltétlen 2 művelet) Pl. 32 bites JVM + long, 2 regiszterben van tárolva 2 olvasás + 2 írás

Felmerülő problémák n n n Azon túl, hogy megbízhatóság… Holtpont – kölcsönösen egymásra várakoznak a folyamatok, és egyik sem tud tovább haladni Kiéheztetés – több folyamat azonos erőforrást használ, és valamelyik ritkán fér csak hozzá Versenyhelyzetek – amikor egy számítás helyessége függ a végrehajtó folyamatok sorrendjétől (pl. check-then-act blokkok) A szinkronizációt ezen problémák elkerülésével kell megoldani

Kölcsönös kizárás n n Belépési – kilépési protokollok Több módszer: q q q n Tevékeny várakozás Szemafor Monitor Feltételes kritikus szakasz Nyelvfüggő elemek (pl. Ada védett objektumai) Azonos invariánsban szereplő változókat ugyanazzal a lockkal védeni.

Tevékeny várakozás n n n Amíg a kívánt helyzet elő nem áll, addig a folyamat dinamikusan várakozik Kritikus szakaszok kezelésére szolgál Hátránya: q A folyamat várakozás közben is foglalja a processzoridőt

Szemafor n n n Dijkstra, ’ 68 Szintén kritikus szakaszok védelmére Általános forma: q q n s – szemafor, s >= 0 egész értékkel P(s) – belépési protokoll (passeer) (s > 0) s-Kritikus szakasz V(s) – kilépési protokoll (verhogen) s++ P, S atomi műveletek

Szemafor n n n Bináris szemafor (mutex, lock): s : = 1 Ha s > 1: hány folyamat léphet be egyszerre a kritikus szakaszba Előnye: q n Segítségével hatékony program készíthető Hátránya: q A strukturáltság ellen hat

Miért nem elég a szemafor? n n Cigarette smokers problem (1971, S. S. Patil) 3 erőforrás: Dohány – Papír – Gyufa 3 láncdohányos, mindegyiknek 1 erőforrás végtelen 1 felügyelő q n n Elvesz 2 véletlen szereplőtől 1 -1 nyersanyagot, az asztalra rakja, majd értesíti a harmadikat, hogy készíthet egy cigarettát Mind a 3 alapanyagra szükség van a dohányzáshoz Probléma: megoldani ezt a szituációt, kizárólag egyfajta szinkronizációs primitívvel

Cigarette smokers problem II n Kikötések: q q n Az ágens kód nem változtatható meg Nem használható feltételes utasítás, sem több szemafor Az első érthető, a második kb. minden nem triviális problémát megoldhatatlanná tesz…

Cigarette smokers problem III n Megoldás (ha a 2. feltételt elhagyjuk): q Felügyelő: q i. dohányos: while true { P( T ); i, j választása (nemdet. ) k legyen a 3. dohányos V( A[k] ); } while true { P( A[i] ); cigarettát készít V( T ); dohányzik } A[] = [0, 0, 0] : szemafor tömb T =1 : asztal szemafor (bináris szemaforok)

Monitor n n n A változókat és a rajtuk értelmezett műveleteket úgy zárja egységbe, hogy a monitorhoz tartozó műveletek közül egyidőben csak egy lehet aktív Belső adatszerkezetei kívülről csak a monitor műveletein keresztül érhetők el Feltételes változók, várakozási sorokkal: q q q n c : feltétel wait(c) : a folyamat blokkolódik, és bekerül c várakozási sorába; elindítani más fogja signal(c) : ha van várakozó folyamat, az elsőt elindítja (ha nincs, nem történik semmi) Előnye: q A szemafornál strukturáltabb || nyelvi elem

Monitor a Concurrent Pascalban n Itt a monitor osztott változók egységbe zárása (osztály pedig absztrakt adattípus) Egy osztály folyamathoz vagy monitorhoz köthető A monitor biztosítja az adatok védelmét, a monitor eljárásai pedig egy várakozási sorban állnak – egyszerre csak egy hajtódik végre

Feltételes kritikus szakasz n n Kritikus szakaszban a folyamat a védett változóhoz csak ellenőrzötten férhet hozzá A megadott őrfeltételnek teljesülnie kell, mielőtt a vezérlés belép

Párhuzamos nyelvek általános jellemzése n n A párhuzamos programok végrehajtása nem determinisztikus fő szempont a hatékonyság, biztonság A vezérlésre különböző modellek léteznek: q Ellenőrzésvezérelt (control driven computation) n q Adatvezérlésű (data driven computation) n q Az elindított folyamatok ellenőrzése fork, join, wait típusú parancsokkal történik A folyamatok végrehajtási sorrendje az adatszerkezetektől, és a közöttük lévő összefüggésektől függ. A folyamat végrehajtódik, ha minden adat a rendelkezésre áll Igényvezérlésű (demand driven computation) n A folyamatok akkor hajtódnak végre, amikor ezeket egy másik folyamat kéri

Párhuzamos nyelvek osztályozása n Osztott változókkal rendelkező nyelvek Üzenetküldéssel rendelkező nyelvek Osztott memóriát használó, adatvezérlésű nyelvek OO párhuzamos nyelvek Funkcionális nyelvek Logikai nyelvek n Egy nyelv több kategóriába is eshet n n n

Funkcionális nyelvek n 2 legfontosabb művelet: q n n n Kifejezések egyszerűsítése és kiértékelése Egy függvényhívás egy folyamatnak tekinthető A kiértékelések bizonyos annotációk, kiértékelési szabályok alapján párhuzamosan is történhetnek Pl. Concurrent Clean, Distributed Haskell

Logikai nyelvek n n n Szabályok kiértékelése párhuzamosan is történhet Pl. Concurrent Prolog, Parlog: And/Or párhuzamosság q q Balról jobbra, az And ‘. ’ műveleti jelekkel elválasztott kifejezéseket párhuzamosan értékeli Ha nem sikerül, az Or ‘; ’ utáni műveletekkel próbálkozik Kommunikáció: közös változókon keresztül Szinkronizáció: automatikus

Szekvenciális OO nyelvek n Az alábbi 3 feltétellel: q q q A program futása pontosan 1 objektum létrehozásával indul Ha egy objektum üzenetet küld egy másiknak, akkor megvárja az üzenet feldolgozását Egy objektum csak akkor aktív, ha éppen egy bejövő üzenet feldolgozására egy metódust futtat

Párhuzamos OO nyelvek n Párhuzamosság úgy érhető el, ha valamely feltételt elhagyjuk: q q q Egyszerre több folyamat indul Az üzenetküldő nem várja meg az üzenet fogadását (aszinkron kommunikáció) Az objektumok nem várnak passzívan az érkező üzenetekre

Szálbiztos osztályok tervezése n Ha több folyamat ugyanazt az állapotváltozót használja, szinkronizáció nélkül, az baj. 3 módon javítható: q q q n Ne használják közösen ugyanazt az állapotváltozót, vagy Legyen az állapotváltozó megváltoztathatatlan (immutable), vagy Szinkronizáció használata a változó használatánál Biztonságos osztályok tervezésénél az OO technikák fontosak (enkapszuláció, immutability, az invariánsok tiszta specifikációja)

Szálbiztos osztályok tervezése n n n Egy osztály szálbiztos, ha több szálból, az ütemezésre való tekintet nélkül, valamint a kliens kódban elhelyezett egyéb szinkronizáció nélkül is helyesen viselkedik A biztonságos osztályok enkapszulálják a szükséges szinkronizációt, így a használójának nem kell róla gondoskodnia Az állapot nélküli osztályok mindig biztonságosak

Szálbiztos osztályok tervezése n Egy objektum immutable, ha: q q q n Az állapota nem változtatható meg a létrehozása után Minden adattagja immutable Helyesen lett létrehozva Az immutable osztályok mindig biztonságosak

Ada 95 n n n Taskok, egymástól független virtuális processzorokon Kommunikáció: a szinkronizációs pontokon, randevú keretein belül, a hívó és hívott között Nyelvi elemek: q q entry, accept – taskok közötti kommunikáció leírásához delay t – időzítés, felfüggeszt legalább t mp-re select – kommunikációs típusok megadása abort – végrehajtás megszüntetése

Taskok definiálása task Hello is -- specifikacio entry msg( s : String : = ”Hello World”); end Hello; task body Hello is -- torzs begin accept msg(s : String : = ”Hello World”) do put_line(s); end msg; end Hello;

Task objektumok n n n Minden task objektum, így van típusa is Az ugyanolyan típusú taskok ugyanazt az utasítássorozatot hajtják végre, önállóan Limited típus (értékadás, =, /= nem használható rájuk) q q n n művelethalmaza az attribútumaira korlátozódik az objektumok értéke állandó a futás során Lehet diszkrimináns része is A tasktörzsben definiált objektumokra a kölcsönös kizárás automatikusan biztosított

Taskok indítása, végrehajtása n n n Indításuk az objektumot bevezető deklarációs rész feldolgozása után, az 1. utasítás végrehajtása előtt történik Ha hiba történik, komplett állapotba kerül, és a taskot tartalmazó programegységben Tasking_Error lép fel Egy befejezett taskot nem lehet újra elindítani

Belépési pontok n n n Kommunikáció: a belépési pontokon keresztül, közvetlenül a paramétereken keresztül Minden entry-hez legalább egy accept Ha egy task meghívja egy másik belépési pontját: q q q n és az válaszol rá, akkor randevú jön létre; különben vár rá ha több task is hívta, akkor várakozási sor (FIFO) Egy task saját belépési pontjának hívása holtpontot eredményez!

Select n Lehetővé teszi, hogy egy adott task többféle hívást várjon és fogadjon task body Select. Task is begin loop select accept F 1(…) do … end F 1; or accept F 2(…) do … end F 2; end select; end loop; end Select. Task

Feltételes hívásfogadás n n n n A select alternatívákat feltételekhez köthetjük when <feltétel> => <utasítás> Egy ág nyitott, ha nincs feltétele, vagy teljesül Különben zárt A feltételek a select elején, 1 x értékelődnek ki Ha minden ág zárt Programming_Error Lehet else ág: ha egyik belépésipont-hívást sem lehet kiszolgálni

Randevúk n Különféle randevúk is megoldhatók a select, accept, delay használatával: q q q szelektív hívás szelektív fogadás feltételes hívás időhöz kötött hívás etc.

Java n n Szálakkal dolgozik 2 lehetőség van a létrehozásukra: q 1. Thread: osztály, származtatással start()/stop()/run()/etc. new Thread() { public void run() { System. out. println(”Thread”); } }. start();

Java q 2. Runnable: interfész, implementálással (nincs többszörös öröklődés, pl. Appletekhez) Egyetlen előírt metódus: run() new Thread(new Runnable() { public void run() { System. out. println(”Thread”); } }). start();

Szálak attribútumai, műveletei n n n Megszakítás: interrupt() Lehet démon szál is: set. Daemon(true) Csak akkor áll meg, ha a többi, nem démon szál is megállt már Szinkronizáció: join() Prioritással is rendelkezhetnek (1 -10) Round-Robin módszerrel ütemeződnek ***

A yield()/wait(0) szemantikája n n n „… a Thread osztály yield() eljárásának hatására a hívó szál a futási sor végére kerül. ” (539. o. ) DE! Ezek szemantikája nem definiált a JLS szerint. A JVM implementációk nop utasításként, ütemezési javaslatnak is kezelhetik. http: //java. sun. com/docs/books/jls/third_edition/html/ memory. html#17. 9 Java yield(), wait(0) =/= Unix rendszerek hasonló utasításával Habár a Sun JVM így implementálta…

Thread. Group n n n A szálak csoportokba szervezhetők (egyszerre egyben lehetnek, ez nem változtatható meg) Csoportosan kezelhetők (leállítás, megszakítás, etc. ) Csoportok újabb csoportokat tartalmazhatnak hierarchikus szerkezet

Szinkronizálás n n Monitorokkal, szinkronizációs burkokkal A monitorok újrahívhatók synchronized =/= static synchronized Ezen kívül: wait(), notify. All() Időhöz is köthetők

Volatile n n Akkor használjuk, ha egyszerűsíti a kódot. Ha már gondolkozni kell, hogy miért is lehet ott volatile… Használható, ha: q q q n Egy változó új értéke nem függ a régitől, vagy egyetlen szál módosíthatja csak; A változó nem szerepel invariánsban egyéb más állapotváltozókkal; és Egyéb okból nem szükséges lockolás a változó módosításához. Tipikusan shutdown hookoknál: volatile boolean run = true; while (run) { … }

JDK 6. 0 n n java. util. concurrent. atomic java. util. concurrent. lock Változatos, hatékony eszközök: q q Barrier, Semaphor, Future. Task, … Adatszerkezetek: Concurrent. Hash. Map, Blocking. Queue, … Lockok, pl. Reentrant. Lock Atomi változók: Atomic. Long, Atomic. Reference, …

Paralell Virtual Machine (PVM) n n Hálózatba kapcsolt számítógépeket egyetlen nagy, || virtuális számítógépként kezelése 2 részből áll: q q n n Démon: a rendszerbe kapcsolt számítógépeken fut 1 -1 példány, a virtuális gép működtetése a feladata Programkönyvtár: folyamatindítás és kezelés A folyamatok üzenetküldéssel kommunikálhatnak Minden folyamatnak egyedi azonosító (tid)

PVM C API n n n #include <pvm 3. h> pvm_mytid: megadja a folyamat azonosítóját pvm_exit: a folyamat kilép a rendszerből (működhet tovább, de PVM hívásokat nem hajthat végre) pvm_spawn: új folyamat indítása pvm_kill: folyamat leállítása pvm_pstat: információ minden futó folyamatról

Kommunikáció n n n Üzenetküldéseken keresztül 1 folyamatnak 1 aktív küldő vagy fogadó tárja lehet pvm_mkbuf: új tár létrehozása pvm_initsend: törli az aktuális tárat, és újat hoz létre Üzenetküldés: be-, ill. kicsomagolással q q Becsomagolás: pvm_pk[byte, short, str, …] Kicsomagolás: pvm_upk[byte, short, str, …]

Kommunikáció II n Üzenet küldése: q q n pvm_send: egy folyamatnak pvm_mcast: több folyamatnak (egyenértékű a pvm_send többszöri hívásával) Üzenet fogadása: q q pvm_recv: meghatározható, hogy kitől, milyen típusú adatot (akárkitől akármit). Az üzenet megérkeztéig blokkolódik a folyamat pvm_probe: lekérdezhető, hogy van-e a paraméterezésnek megfelelő üzenet

Folyamatok n n n pvm_joingroup, pvm_lvgroup: A folyamatok csoportba szervezhetők pvm_broadcast: csoporüzenet küldésére pvm_barrier: Több folyamat szinkronizációja

Források n n n Programozási nyelvek, Nyékyné Gaizler Judit et al. , Kiskapu, 2003. Java Concurrency in Practice, Brian Goetz et al. , Addison-Wesley Professional, 2006. Az ADA 95 programozási nyelv, Nyékyné Gaizler Judit et al. , ELTE Eötvös Kiadó, 2003. Ada Wikibook http: //en. wikibooks. org/wiki/Ada_Programming The Java Language Specification, 3 rd ed. , 2005 http: //java. sun. com/docs/books/jls

Párhuzamosság más szinten n n SISD / MISD / SIMD / MIMD Kép-, és jelfeldolgozás (AMD lib): http: //framewave. sourceforge. net/

Kérdések ?

Ami kimaradt… n n n Hyper-threading, superscalar architektúrák. NET környezet Google Go?

Köszönöm a figyelmet! Legéndi Richárd Olivér Eötvös Loránd Tudományegyetem, Informatikai Kar Programozási Nyelvek és Fordítóprogramok Tanszék richard. legendi@gmail. com