6. Közös változóval rendelkező párhuzamos program, Közös változó,

6. Közös változóval rendelkező párhuzamos program, Közös változó, Reynold kritérium. Atomi művelet, atomi utasítás. szintaxis, szemantika, tulajdonságok. Szinkronizációs párhuzamos program, szintaxis, szemantika, tulajdonságok. P(s), V(s) utasítások: kölcsönös kizárás megoldása. Termelő fogyasztó modell. Megállapodás. Formális meghatározás. Absztrakt megoldás. Realizáció. Erőforrás közös használatának problémája. Kiéheztetés, monopolizálás. Kiéheztetés mentes vezérlés szinkronizációs problémája. Példa: adatbázis modell.(két kapus megoldás) 6.1. Közös változóval rendelkező párhuzamos program, Közös változó, Reynold kritérium. 6.1. Definíció (Közös változóval rendelkező párhuzamos program): Párhuzamos programszerkezet két vagy több olyan folyamatot tartalmaz, amelyek egymással közös változó segítségével kommunikálnak. Folyamat a végrehajtás alatt lévő program. Kommunikáció azt jelenti, hogy a közös változó értékét párhuzamosan futó folyamatok kiolvassák, illetve felülírják. Adva S parbegin S 1... S n parend; 6.2. Definíció (Közös változó): Közös változó: olyan változó, amelyhez egynél több folyamat is hozzáférhet. Lokális változó: olyan változó, amelyhez csak egy folyamat férhet hozzá. A párhuzamosan történő végrehajtás követelményei: 1. Követelmény: A közös változóhoz való hozzáférés követelményei: A hozzáférés a közös változóhoz: a változó értékének kiolvasása vagy felülírása. A közös változókhoz való hozzáférések atomi operációnak tekintendők. 2. Követelmény (A végrehajtás követelményei): A végrehajtás sebessége minden, de nem fejeződött folyamat esetén pozitív és tetszőleges, ( kivéve, ha a közös változóhoz való hozzáférésre vár). Ekkor azonban 1

a hozzáférés kellő idő után garantált és a végrehajtás folytatódhat. Az atomi műveletek (közös változóhoz való hozzáférések) lineárisan sorba rendezettek, de a sorrend véletlenszerű. A közös változókhoz való hozzáférések lineárisan sorba rendezettek: Megvárakoztatás. (blokkolt állapot). Garantált a hozzáférés minden folyamat számára. (holtpont mentesség állapota). Folyamatok végrehajtási sebessége pozitív érték, kivéve, ha a közös erőforrásra várnak. (fair követelmény). 6.3. Definíció (Reynold-féle kritérium): Ha az 1., 2. követelmények teljesülnek, a párhuzamos komponensek végrehajtása során érvényes a program állapotára vonatkozóan a nem determinisztikus egymás utáni atomi végrehajtás a logikai kiértékelés és a felülírás (feltéve, hogy a logikai kiértékelés és felülírás közös változót tartalmaz). 6.2. Atomi művelet, atomi utasítás. Szintaxis, szemantika, tulajdonságok. 6.4. Definíció (Atomi művelet, atomi utasítás): Atomi (primitív) művelet, utasítás végrehajtása: meg nem szakítható végrehajtás, és aszinkron módon. Atomi műveletek: Egy bool kifejezés kiértékelése. Egy változó értékének a kiolvasása. Értékadás egy változónak. 6.5. Definíció (Atomi utasítás): Egy olyan S program szakasz, amelyet atomivá teszünk, amelyet ciklust, vagy atomi utasítást nem tartalmaz. Jelölés: <S>; 2

6.6. Definíció (Közös változóval rendelkező determinisztikus párhuzamos program szintaxisa): S 1 od parbegin S 1 S2 parend; S::= skip y t S 1 ;S2 if α then S 1 else S2 fi while α do 6.7. Definíció (Atomi program): <S>; 6.8. Definíció (Más jelölés): while α do S 1 od: do α S 1 od; 6.9. Definíció (Szemantika): < S, σ > < E, τ > << S >, σ > < E, τ > (1) M[< S >](p) = M[S](p) (2) Tulajdonságok: 6.10. Lemma: A közös változóval rendelkező párhuzamos program blokkolásmentes. Ugyanis, minden < S, σ > konfigurációnak S E és σ Σ esetén van rákövetkezője a reláció szerint. 6.11. Lemma: Minden S párhuzamos program és σ Σ esetén a < S, σ > konfigurációnak véges számú rákövetkezője van a reláció mellett. (Következik a szintaktikai axiómákhoz, szabályokhoz rendelt tranzakciók relációinak definícióiból.) 6.12. Lemma: Adott S és σ Σ kezdő állapot. M tot [S](σ) vagy véges számú állapotot tartalmaz, vagy csak a virtuális állapotot. A bizonyítás a fákra vonatkozó König lemma [1927] adaptációjával mutatható ki. Ezt Knuth D. E. végezte el 1968-ban. Programhelyesség bizonyításánál feltesszük: Bool kifejezés, értékadás, skip, atomi régió mindegyike atomi akció, azaz Meg nem szakíthatók, vagy Egymás után hajtódnak végre, de a végrehajtás sorrendje nincs meghatározva. Egy hagyományos hardver ezt nem garantálja. Garancia: Általában a kritikus hivatkozások atomi kezelését garantálja, kizárólagos írási vagy olvasási atomi hozzáférést garantál az egyszerű, vagy indexes változók esetében. y f(x,y): < y f(x,y) > Atomi utasítások: A párhuzamos program helyesség bizonyítását leegyszerűsíti a virtuális <S> atomi definíció. Minél kisebb egységre vonatkozik az atomi definíciónk annál inkább megfelel a valóságos végrehajtásnak. 3

Minél nagyobb egységre vonatkozik az atomi definíciónk annál inkább megkönnyíti a program helyességének a bizonyítását. 6.13. Példa: S parbegin x y y x parend; x y esetén atomi műveletek: y kiolvasása, x értékének felülírása. x = 1; y = 2; esetén lehetséges eredmények: x = y = 2; x = y = 1; x = 2 és y = 1. A parallel modell jelentése nem azonos a hagyományos hardware által nyújtott megoldással. Minden komponens program szoftver-akkumulátorok bevezetésével áttranszformálható egy olyan vele ekvivalens párhuzamos programmá, ahol minden atomi akció egy hozzáférést jelent a közös változóhoz: S parbegin AC1 y; x AC1 AC2 x; y AC2 parend; A párhuzamosság atomi egységére vonatkozó < x y > szemantikai meghatározás az egyszerű kezelés célját szolgálja a helyességbizonyításnál. A párhuzamos program helyesség bizonyítását leegyszerűsíti a virtuális <S> atomi definíció. Minél kisebb egységre vonatkozik az atomi definíciónk annál inkább megfelel a valóságos végrehajtásnak. Minél nagyobb egységre vonatkozik az atomi definíciónk annál inkább megkönnyíti a program helyességének a bizonyítását. 6.3. Szinkronizációs párhuzamos program, szintaxis, szemantika, tulajdonságok. Párhuzamos program szinkronizációval: A feltételes atomi utasítás szintaxisa: < b S >; 6.14. Definíció: Dijkstra - féle jelölés await b then S ta; Speciális esetek await "true" then S ta; await b then skip ta; await b then ta; wait b tw; 4

A Dijkstra - féle atomi szemafor utasítások: P(s): s s -1; if s < 0 then állj be az s-hez rendelt várakozó sorba fi; V(s): s s+1; if s 0 then induljon el egy folyamat az s-hez rendelt várakozó sorból fi; Egyszerűimplementáció: P ( s ) : a w a i t s > 0 then s < s 1 t a ; V( s ) : a w a i t " t r u e " then s < s +1 t a ; Egy pontos implementáció: D i j k s t r a f é l e s z e m a f o r u t a s í t á s o k P ( s ) : a w a i t " t r u e " then b e g i n s < s 1; i f s < 0 then V[ j ] < " f a l s e " f i ; end t a ; a w a i t V[ j ] then t a V( s ) : a w a i t " t r u e " then b e g i n s < s +1; i f s >= 0 then b e g i n v á l a s s z i t, a h o l V[ i ] = " f a l s e " ; V[ i ] < " t r u e " end f i end t a ; Szemantika: 6.15. Definíció (Az őrfeltételes atomi utasítás jelentése): σ(b) = true < S, σ > < E, τ > << b S >, σ > < E, τ > (3) σ(b) = true < S, σ > < E, τ > < await.b.then.s.ta, σ > < E, τ > (4) 6.16. Definíció (Holtpont állapot informális definíciója): Az S párhuzamos program holtpont állapotba jutott, ha a program végrehajtása nem fejeződött be és annak minden olyan komponense, amely nem fejeződött be, blokkolt állapotban van. 5

6.17. Definíció (Szintaxis): S::= <b y f(x,y)> S 1 ; S2 if b then S 1 else S2 fi while b do S od parbegin S 1 S2 parend; Feltételes meg nem szakítható (atomi) utasítás: <b S>; amely nem tartalmazhat iterációt, vagy másik atomi utasítást. Jelölés: parbegin S 1... S n parend; Más jelölések: cobegin S 1... S n coend; [ S 1 S 2 ]; 6.18. Lemma: A párhuzamos program végrehajtása során, a σ állapotban, a p(σ) állítás mellett, az await b then S ta utasítás n ál blokkolt állapotba kerül, ha p(σ) b = "true". 6.19. Definíció: Legyen S párhuzamos program és annak egy σ állapotára p(σ) = "true". Az <S, σ> konfigurációt holtpontnak nevezzük, ha (S E); <S, σ> <S, σ > tranzakció nem létezik. A holtpont virtuális állapot jele:. Az S program a σ állapotból holtpontra juthat, ha létezik olyan kiszámítás, amely holtpont konfigurációban végződik. Az S program holtpontmentes, (p mellett) ha nem létezik olyan σ állapot p(σ) = "true" mellett, amelynél S holtpontra juthat. Az S párhuzamos program szemantikája: Parciális helyességi szemantikája σ kiindulási állapot mellett: M[S](σ) = { τ < S, σ >. < E, τ > } Gyenge teljes helyességi szemantikája σ kiindulási állapot mellett: M wtot [S] (σ) = M[S](σ) { S divergál σ kezdő állapotból } Teljes helyességi szemantikája σ kiindulási állapot mellett: M tot [S] (σ) = M wtot [S] (σ) { S holtpontba jut σ kezdő állapotból } (,, fail Σ virtuális állapotok) 6.4. P(s), V(s) utasítások: kölcsönös kizárás megoldása. 6.20. Definíció (Probléma): Adott egy erőforrás, amelyet n > 0 db folyamat használ feladatainak megoldása során. Követelmények Kölcsönös kizárás Az erőforrást egy adott időpontban legfeljebb csak egy folyamat használhatja. 6

Blokkolás mentesség A párhuzamos folyamatok futását a szinkronizáció ne függessze fel végtelen hosszú időre. Erőforráshoz való hozzáférhetőség Minden egyes folyamat, ha használni akarja az erőforrást, akkor véges időn belül használhassa azt. A követelmények formális megfogalmazása S: inicializálás; parbegin S 1... S n parend; ahol i, k, 1 i, k n i k esetén [( var(nk i ) var(eh i ))] [( var(ei k ) var(ef k ))] = { } (az előkészítés és erőforrás használatának változói különböznek az igénylés és a felszabadítás változóitól) Feltevés NK i és EH i nem tartalmaz őrfeltételes utasítást. Elnevezések NK Nem közös változókat használó programrész EI Erőforrás igénylés EH Erőforrást használó programrész EF Erőforrás felszabadítása Kölcsönös kizárás, blokkolás-mentesség: 6.21. Definíció (Kölcsönös kizárás): Az S végrehajtása során nem létezik olyan < parbegin R1... Rn parend, σ > konfiguráció, hogy valamely j, k {1,..., n}, j k esetén R j at(eh j in S j ); R k at(eh k in S k ) 6.22. Definíció (Blokkolás-mentesség): Nincs olyan végrehajtás σ Σ: <S, σ> *<T, > amely holtpont konfigurációban végződik. 6.23. Definíció (Dijkstra féle kölcsönös kizárás): out bool; S: out True; parbegin S 1... S n parend; P: passeren V: vrijgeven Szemaforral: s k; k > 0; P(out) await out then out False ta; V(out) out True; P(s) await s > 0 then s s - 1 ta; 7

6.5. Termelő fogyasztó modell. Megállapodás. Formális meghatározás. Absztrakt megoldás. Realizáció. Termelő-fogyasztó modell - A probléma absztrakt megfogalmazása: Adott egy N 1 kapacitású közös tároló. Adott a folyamatok két csoportja, amelyek a tárolót használják. n 1 termelőfolyamat, m 1 fogyasztó folyamat. A termelő a tároló használatakor egy-egy terméket helyez el a tárolóban. A fogyasztó a tároló használatakor egy-egy terméket vesz ki a tárolóból. Termelő és fogyasztó közötti sorrendiség: A fogyasztó ugyan abban a sorrendben veszi ki a termékeket a tárolóból, amilyen sorrendben a termelő azt lehelyezte. Termelőfolyamatok közötti kölcsönös kizárás: A termelőfolyamatok közül egyszerre csak egy folyamat használhatja a tárolót. Fogyasztó folyamatok közötti kölcsönös kizárás: A fogyasztó folyamatok közül egyszerre szintén csak egy folyamat használhatja a tárolót. Termelők és a fogyasztók közötti termék esetében példányonkénti kölcsönös kizárás: Ugyanazt a termék példányt a termelőnem helyezheti el, a fogyasztó pedig nem veheti ki egyszerre. A megállapodás formális megfogalmazása Tároló: q sor, length(q) = N, N 1 Termelőműveletei: x a[i]; <q add(q,x)>; i = 0,..., M - 1 Fogyasztó műveletei: <(q,y) (rem(q), read(q))}; b[j] y; j = 0,..., M - 1 A sorrendiségi követelmények teljesülnek! i 0; j 0; { ( i, j integer) q queue 0 length(q) N ( a[0, M -1], b[0, M -1] vector) M 1 N 1 } parbegin producer consumer parend; producer: while i < M do x < a [ i ] ; wait l e n g t h ( q ) < N t a ; <q < add ( q, x ) > ; i < i + 1 ; 8

Consumer: while j < M do wait l e n g t h ( q ) > 0 t a ; <(y, q ) < ( read ( q ), rem ( q ) ) > ; b [ j ] < y ; j < j + 1 ; A kölcsönös kizárások teljesülnek. Megvalósítás - Realizáció: q buffer[0...n-1] ciklikus elhelyezéssel mod(n) Behelyezésnél az index: in Kiemelésnél az index: out Előfeltétel: M 1 N 1 Inicializálás: i 0; j 0; in 0; out 0; S program: parbegin producer consumer parend; {( k, 0 k < M)(a[k] = b[k])}; wait length(q) < N ta: wait in - out < N ta; q add(q,x): buffer[in mod N] x; in in + 1; wait length(q) > 0 ta: wait in - out > 0 ta; (y,q) (read(q), rem(q)); y buffer[out mod N]; out out + 1; producer: while i < M do x < a [ i ] ; wait i n o u t < N t a ; < b u f f e r [ i n mod N] < x ; i n < i n + 1 >; i < i + 1 ; consumer: while j < M do wait i n o u t > 0 t a ; < y < b u f f e r [ o u t mod N ] ; o u t < o u t + 1> b [ j ] < y ; j < j + 1 ; 9

6.6. Erőforrás közös használatának problémája. Kiéheztetés, monopolizálás. 6.24. Definíció (Informális leírás): Adott egy S: parbegin S 1... S n parend párhuzamos rendszer és egy e erőforrás. Az e erőforrás felhasználási módjai A folyamatok egy csoportjának tagjai csak kizárólagosan használhatják az erőforrást. A folyamatok egy másik csoportjának tagjai egyidejűleg akárhányan is használhatják az erőforrást. A két csoport tagjai vegyesen nem használhatják az erőforrást. Probléma Erőforrás monopolizálása, Kiéheztetés Kiéheztetés, monopolizálás: Adott egy S: parbegin S 1... S n parend párhuzamos rendszer. 6.25. Definíció (Informális definíció: Kiéheztetés): a párhuzamos program végrehajtása nem fejeződik be, mert a folyamatok egy csoportja monopolizálja a párhuzamos rendszer közös erőforrását. 6.26. Definíció (Informális definíció: Erőforrás monopolizálása): a párhuzamosan futó folyamatok között mindig van legalább egy olyan folyamat, amely lekötve tartja az erőforrást, miközben a velük párhuzamos folyamatok nem üres csoportjának tagjai folyamatosan várakoznak az erőforrásra. Lehetséges állapotok: : erőforrást használók; erőforrásra várakozók; lefutottak. 6.7. Kiéheztetés mentes vezérlés szinkronizációs problémája. Példa: adatbázis modell.(két kapus megoldás.) 6.27. Definíció (Kiéheztetés-mentesség): Adott egy erőforrás, n 3 folyamat, amelyek az erőforrást használják, és egy párhuzamos rendszer p(σ) előfeltétele. A folyamatok legalább két diszjunkt csoportot alkotnak: 10

Csoportok között teljesül a kölcsönös kizárás: Egy adott időpontban különbözőcsoporthoz tartozó folyamatok az erőforrást nem használhatják. Csoporton belüli közös használat: Létezik legalább egy olyan csoport, amelyben a folyamatok egy adott időpontban többen is használhatják az erőforrást. Kiéheztetés-mentesség: Ne fordulhasson előaz, hogy az egyik csoportbeli folyamatok végtelen hosszú ideig várnak az erőforrásra, a másik csoport folyamatai közül mindig van legalább egy olyan, amely lekötve tartja azt. A rendszer formális megfogalmazása végtelenített rendszer esetén: S: inicializálás; parbegin S 1... S n parend; n 3. ahol i, k, 1 i, k n i neq k -ra: [ változó (NK i ) változó (EH i ) ] [ változó(ei k ) változó(ef k ) ] = { } Feltevés: NK i és EH i nem tartalmaz megvárakoztató utasítást. S i Folyamatok szerkezete: while B do NKi : Nem k r i t i k u s s z a k a s z ; E I i : E r ő f o r r á s i g é n y l é s e ; EHi : E r ő f o r r á s h a s z n á l a t a ; EFi : E r ő f o r r á s f e l s z a b a d í t á s a ; Kiéheztetés-mentesség feltételei, Holtpont-mentesség feltételei: Formális megfogalmazás: Legyen adott a párhuzamos rendszer p(σ) előfeltétellel egy, a folyamatok által közösen használt erőforrás. A folyamatok két csoportot alkotnak. Legyenek az A csoport folyamatainak azonosítói: 1, 2,..., n 1 n 1 2. Legyenek a B csoport azonosítói: n 1 +1, n 1 +2,..., n; n 3. A csoportok közötti kölcsönös kizárás: Nem létezik olyan < parbegin R 1... R n parend, σ> konfiguráció, amelyre valamilyen i { 1,..., n 1 } és k { n 1 +1,..., n } esetén R i at(eh i in S i ) és R k at(eh k in S k ). 11

Csoporton belüli közös használat: Adott p(σ) mellett létezhet olyan < parbegin R 1... R n parend, σ> konfiguráció, amelyre R i at(eh i in S i ) és R k at(eh k in S k ), ha i, k? 1,..., n1 Végtelen igénylés: Adott p(σ) mellett nem létezik olyan < parbegin R 11... R n1 parend, σ 1 > < parbegin R 12... R n2 parend, σ 2 >... végtelen végrehajtási sorozat, ahol minden < parbegin R 1i... R ni parend, σ i > konfiguráció esetén ( i {1,..., n 1 } k {n 1 +1,..., n})( R ji at (EH j in S j ) R k at(ei k in S k )) Holtpont-mentesség: Adott p(σ) mellett a párhuzamos program végrehajtása nem végződik holtpont állapotban: / M(S)[p] Példa: Adatbázis modell: Készítsük el az adatbázis egy absztrakt modelljét a következő specifikáció alapján, majd végezzük el a modell tulajdonságainak elemzését a kiéheztetés-mentesség szempontjából. Legyen n > 0 felújító és m > 1 lekérdezőfolyamat. A felújító folyamatok egymással, valamint a lekérdezőfolyamatokkal is kölcsönös kizárásban vannak az adatbázis használatakor. A lekérdezőfolyamatok egyszerre többen használhatják az adatbázist. Megoldás: A lekérdezőfolyamatok számolják, hogy hányan használják az adatbázist egyidejűleg. Számláló: rcnt, kezdőértéke: 0, (számláláshoz kölcsönös kizárás kell) Szemafor: sr, kezdőértéke: 1 Kölcsönös kizárás szemaforja: w Példa: w 1; rcnt 0; sr 1; parbegin writer 1... writer n reader 1... reader m parend; writer i : while " t r u e " do 12

I n f o r m á c i ó g y ű j t é s ; P (w ) ; A d a t b á z i s f e l ú j í t á s ; V(w ) ; reader k while " t r u e " do P ( s r ) ; r c n t $ \ l e f t a r r o w $ r c n t +1; i f r c n t = 1 then P (w) f i ; V( s r ) ; A d a t b á z i s l e k é r d e z é s ; P ( s r ) ; r c n t $ \ l e f t a r r o w $ r c n t 1 ; i f r c n t = 0 then V(w) f i ; V( s r ) ; V á l a s z k i é r t é k e l é s e ; Követelmények: A reader és a writer folyamatnak is legyen esélye hozzáfér n i az adatbázishoz. A writer folyamatok ne monopolizálhassák az adatbázist. A reader folyamatok ne monopolizálhassák az adatbázist. Megoldás: A writer folyamatok továbbra is egy kapun keresztül léphetnek be az erőforráshoz, ahova akadály nélkül eljuthatnak, de belépéskor lezárják a külsőkaput a reader folyamatok előtt. A reader két kapun keresztül léphet be az erőforráshoz. A külsőkaput a writer nyitja ki a reader előtt a felújítás befejeztekor, amikor megkezdi az erőforrás elengedését. A belsőkapu közös, ezért a writer és a reader egyforma eséllyel léphet be az erőforráshoz. 13

Ha felújító folyamat használni akarja az adatbázist, akkor újabb lekérdezőfolyamat már ne férhessen az adatbázishoz. Szemafor: who w, r, kezdőértéke: w w 1; sr 1; rcnt 0; r 1; who w; parbegin writer 1... writer n reader 1... reader m parend; while " t r u e " do I n f o r m á c i ó g y ű j t é s ; who $ \ l e f t a r r o w $ w; P (w ) ; A d a t b á z i s f e l ú j í t á s ; a w a i t " t r u e " then V(w) who $ \ l e f t a r r o w $ r t a ; while " t r u e " do wait who = r tw ; P ( s r ) ; r c n t < r c n t + 1 ; i f r c n t = 1 then P (w) f i ; V( s r ) ; A d a t b á z i s l e k é r d e z é s ; P ( s r ) ; r c n t < r c n t 1 ; i f r c n t = 0 then V(w) f i ; V( s r ) ; V á l a s z k i é r t é k e l é s e ; 14