Előadást letölteni
Az előadás letöltése folymat van. Kérjük, várjon
KiadtaErika Barnané Megváltozta több, mint 10 éve
1
Termelő-fogysztó modell. A probléma absztrakt megfogalmazása: informális leírás. Adott egy N elemű közösen használt tároló, N 1. Adott a folyamatoknak két csoportja, amelyek a tárolót használják. Az első csoportba n 1 folyamat tartozik, amelyeket termelőknek, A másik csoportba m 1 folyamat tartozik, amelyeket fogyasztóknak nevezzük. A termelő a tároló használata során egy-egy terméket helyez el a tárolókban. A fogyasztó a tároló használata során egy-egy terméket vesz ki a tárolóból.
2
Megállapodás. A termelő és a 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. A 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. A 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. A 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 le, a fogyasztó nem veheti ki egyszerre.
3
A megállapodás formális megfogalmazása. A tároló: q sor, length(q) = N, N 1; A termelő műveletei: x a[i]; q add(q,x) ; i = 0,...,M. A fogyasztó műveletei: (q,y) (rem(q), read(q)) ; b[j] y; j = 0,...M-1. A sorrendiségi követelmények teljesülnek! PC: 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
producer: while i M do x a[i]; wait length(q) N ta; q add(q,x) ; i i+1; od; consumer: while j M do wait length(q) 0 ta; (y,q) (read(q), rem(q)) ; b[j] y; j j+1; od; A kölcsönös kizárások teljesülnek.
5
Realizáció. q: buffer[0:N -1]; ciklikus elhelyezéssel mod(N). Behelyezésnél az index: in; Kiemelésnél az index: out; { M 1 N 1 } i 0; j 0; in 0; out 0; 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
producer: while i M do x a[i]; wait in - out N ta; buffer[in mod N] x; in in+1 ; i i+1; od; consumer: while j M do wait in - out 0 ta; y buffer[out mod N]; out out + 1 b[j] y; j j+1; od;
7
Erőforrás közös használatának problémaköre: Informális leírás. Adva S : parbegin S 1 ... S n parend párhuzamos rendszer. Az e erőforrás. Az e erőforrás felhasználási módjai: A folyamatok egy csoportjának tagjai csak kizárólagosan hsaználhatják az erőforrást. A folyamatok egy másik csoportjának tagjai egyidejűleg akár há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és (starvation), monopolizálás. Adva S : parbegin S 1 ... S n parend párhuzamos rendszer. Kiéheztetés informális definíciója: a párhuzamos program végrehajtása nem fejeződik be, a folyamatok egy csoportja monopolizálhatja a párhuzamos rendszer közös erőforrását. Az erőforrás monopolizálásának informális definíciója: 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
A kiéheztetés-mentes szinkronizáció problémája. Adva egy erőforrás; n 3 folyamat, amelyek az erőforrást használják; Adott a párhuzamos rendszer p( ) előfeltétele. A 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 folyamtok 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
A rendszer formális megfogalmazása végtelenített rendszerre: S: inicializálás; parbegin S 1 ... S n parend; n 3. A folyamatok szerkezete: S i :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; od; ahol ( i,k,1 i,k n i k) [(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
A kiéheztetés-mentesség feltételeinek formális megfogalmazása. Legyen adott a párhuzamos rendszer p( ) előfeltétellel. Adott egy, a folyamatok által közösen használt erőforrás. A folyamatok két csoportot alkotnak. Legyen az A csoportba tartozó folyamatok azonosítója rendre 1, 2,..., n 1. n 1 2. Legyenek a B csoport azonosítói rendre n 1 +1, n 1 +2,..., n; n 3.
12
A csoportok közötti kölcsönös kizárás. Adott p( ) mellett 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 ); Csoporton belüli közös használat. Adott p( ) mellett létezhet olyan parbegin R 1 ... R n parend, konfiguráció, amelyre valamilyen i, j {1,..., n1} esetén R i at(EH i in S k ) és R k at(EH k in S k ).
13
Végtelen igénylés. Adott p( ) mellett nem létezik olyan parbegin R 1 1 ... R n 1 parend, 1 parbegin R 1 2 ... R n 2 parend, 2 ... végtelen végrehajtási sorozat, ahol minden parbegin R 1 i ... R n i parend, i konfiguráció esetén (~ i {1,..., n 1 } ~ k {n 1 +1,..., n}) (R j i at(EH j in S j ) és 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}].
14
S: inicializálás; parbegin S 1 ... S n parend; n 3. S i : 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; od; ahol ( i,k,1 i,k n i k) [(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
A kiéheztetés-mentesség feltételeinek formális megfogalmazása. 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. Legyen az A csoportba tartozó folyamatok azonosítója rendre 1, 2,..., n 1. n 1 2. Legyenek a B csoport azonosítói rendre 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 ).
16
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 1 1 ... R n 1 parend, 1 parbegin R 1 2 ... R n 2 parend, 2 ... végtelen végrehajtási sorozat, ahol minden parbegin R 1 i ... R n i 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}].
17
Feladat. Készítsük el az adatbázis egy absztrakt modelljét a következő szavakban megadott 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. a.) Legyen n 0 db. felújító és m 1 db. lekérdező folyamat. A felújító folyamatok egymást kölcsönösen kizárják az adatbázis használatából. b.) A felújító folyamat és lekérdező folyamat egymást kölcsönösen kizárják az adatbázis használatából. c.) A lekérdező folyamatok közül tetszőleges számú folyamat használhatja egyidejűleg 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; w 1; rcnt 0; sr 1; parbegin writer 1 ... writer n reader 1 ... reader m parend;
18
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); od; 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; od;
19
1.) Mind a reader, mind a writer folyamatnak legyen meg az esélye az adatbázishoz való hozzáféréshez. 2.) Ne álljon elő azonban az a helyzet, hogy a writer folyamatok monopolizálhassák az adatbázis használatát. 3.) Ne álljon elő az a helyzet sem, hogy a reader folyamatok monopolizálhassák az adatbázis használatát. Megoldás: A writer folyamatok továbbra is egy kapun keresztül léphetnek be az erőforráshoz. Ide 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 writer, akkor nyitja ki a reader előtt, amikor - a felújítást befejezte és megkezdi erőfforás elengedését. A belső kapu viszont közös é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.
20
Ha felújító folyamat használni akarja az adatbázist, akkor újabb lekérdező folyamat ne férhessen már hozzá. Megoldás: Szemafor: who {wr,r}, kezdőértéke: wr. w 1; sr 1; rcnt 0; r 1; who wr; parbegin writer 1 ... writer n reader 1 ... reader m parend; while "true" do Információ gyűjtés; who wr; P(w); Adatbázis felújítás; await "true" then w w +1, who r ta; od; 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; od;
Hasonló előadás
© 2024 SlidePlayer.hu Inc.
All rights reserved.