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.

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.

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;

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.

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

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;

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.

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.

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).

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.

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.

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 ).

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}].

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.

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 ).

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}].

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;

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;

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.

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;