Termelő-fogyaszt. fogyasztó modell

Méret: px

Mutatás kezdődik a ... oldaltól:

Download "Termelő-fogyaszt. fogyasztó modell"

Ede Papp
7 évvel ezelőtt
Látták:

1 Termelő-fogyaszt 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.

2 Termelő-fogyaszt fogyasztó modell 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.

3 Termelő-fogyaszt fogyasztó modell 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;

4 Termelő-fogyaszt fogyasztó modell Producer Consumer while i < M do x a[i]; wait length(q) < N ta; q add(q,x) ; i i + 1; while j < M do wait length(q) > 0 ta; (y,q) (read(q), rem(q)) ; b[j] y; j j + 1; A kölcsönös kizárások teljesülnek.

5 Termelő-fogyaszt fogyasztó modell Megvalósítás 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;

6 Termelő-fogyaszt fogyasztó modell producer consumer while i < M do x a[i]; wait in - out < N ta; buffer[in mod N] x; in in + 1 ; i i + 1; while j < M do wait in - out > 0 ta; y buffer[out mod N]; out out + 1 b[j] y; j j + 1;

7 Közös s erőforr forrás-használat problémái 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.

8 Kiéheztet heztetés s (starvation), monopolizálás Adott egy S : parbegin S 1... S n parend párhuzamos rendszer. 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. 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. erőforrást használók; erőforrásra várakozók; lefutottak.

9 Kiéheztet 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. Kiéheztetés-mentes vezérlés A folyamatok legalább két diszjunkt csoportot alkotnak 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.

10 Kiéheztet heztetés-mentes szinkronizáci ció A rendszer formális megfogalmazása végtelenített rendszer esetén S: inicializálás; parbegin S 1... S n parend; n 3. S i Folyamatok szerkezete while B do NK i : Nem kritikus szakasz; EI i : Erőforrás igénylése; EH i : Erőforrás használata; EF i : Erőforrás felszabadítása; ahol i, k, 1 i, k n i 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.

11 Kiéheztet heztetés-mentesség g feltételei 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 ).

12 Kiéheztet heztetés- és s holtpont-mentess mentesség 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,..., n 1 } Végtelen igénylés Adott p(σ) mellett nem létezik olyan < parbegin R R n1 parend, σ 1 > < parbegin R R n2 parend, σ 2 >... végtelen végrehajtási sorozat, ahol minden < parbegin R 1 i... 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}]

13 Holtpont-mentess mentesség g feltételei telei Végtelen igénylés Adott p(σ) mellett nem létezik olyan < parbegin R R n1 parend, σ 1 > < parbegin R R n2 parend, σ 2 >... végtelen végrehajtási sorozat, ahol minden < parbegin R 1 i... R ni parend, σ i > konfiguráció esetén ~ i { 1,..., n 1 } ~ k { n 1 +1,..., n} : Holtpont-mentesség R i at(eh i in S i ) és R k at(ei k in S k ) Adott p(σ) mellett a párhuzamos program végrehajtása nem végződik holtpont állapotban: M(S)[{p}].

14 Holtpont-mentess mentesség g feltételei telei S: inicializálás; parbegin S 1... S n parend; n 3. S i Folyamatok szerkezete while B do NK i : Nem kritikus szakasz; EI i : EH i : EF i : Erőforrás igénylése; Erőforrás használata; ahol i, k, 1 i, k n i k -re: Erőforrás felszabadítása; [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.

15 Példa Feladat 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. Megoldás 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. 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 w 1; rcnt 0; sr 1; parbegin writer 1... writer n reader 1... reader m parend;

16 Példa w 1; rcnt 0; sr 1; parbegin writer 1... writer n reader 1... reader m parend; writer i while "true" do Információ gyűjtés; P(w); Adatbázis felújítás; V(w); reader k while "true" do P(sr); rcnt rcnt+1; if rcnt = 1 then P(w) fi; V(sr); Adatbázis lekérdezés; P(sr); rcnt rcnt - 1; if rcnt = 0 then V(w) fi; V(sr); Válasz kiértékelése;

17 Példa Követelmények A reader és a writer folyamatnak is legyen esélye hozzáférni 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. Szemafor: who { w, r }, kezdőértéke: w

18 Ha felújító folyamat használni akarja az adatbázist, akkor újabb lekérdező folyamat már ne férhessen az adatbázishoz. Megoldás 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 "true" do Információ gyűjtés; who w; P(w); Adatbázis felújítás; await "true" then V(w) who r ta; while "true" do wait who = r tw; P(sr); rcnt rcnt + 1; if rcnt = 1 then P(w) fi; V(sr); Adatbázis lekérdezés; P(sr); rcnt rcnt - 1; if rcnt = 0 then V(w) fi; V(sr); Válasz kiértékelése;

Hasonló dokumentumok

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,