Termelő-fogysztó modell. A probléma absztrakt megfogalmazása: informális leírás.

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 S1 ...  Snparend 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 S1 ...  Snparend 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 S1 ...  Snparend; n  3. A folyamatok szerkezete: Si: while B do NKi: Nem kritikus szakasz; EIi: Erőforrás igénylése; EHi: Erőforrás használata; EFi: Erőforrás felszabadítása; od; ahol (i,k,1i,knik) [(változó (NKi)  változó (EHi))]  [(változó(EIk)  változó(EFk))] = { }; Feltevés: NKi és EHi 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, ..., n1. n1  2. • Legyenek a B csoport azonosítói rendre n1+1, n1+2, . . . , n; • n3.

A csoportok közötti kölcsönös kizárás. Adott p() mellett nem létezik olyan  parbegin R1  . . .  Rnparend ,   konfiguráció, amelyre valamilyen i {1, . . ., n1} és k { n1+1, . . ., n} esetén Ri  at(EHiin Si) és Rk  at(EHkin Sk); Csoporton belüli közös használat. Adott p() mellett létezhet olyan  parbegin R1  . . .  Rnparend ,   konfiguráció, amelyre valamilyen i, j {1, . . ., n1} esetén Ri  at(EHiin Sk) és Rk at(EHkin Sk).

Végtelen igénylés. Adott p() mellett nem létezik olyan  parbegin R11  . . .  Rn1parend , 1    parbegin R12  . . .  Rn2parend , 2   ... végtelen végrehajtási sorozat, ahol minden  parbegin R1i  . . .  Rniparend , i konfiguráció esetén (~i{1, . . ., n1}~k{n1+1, . . ., n}) (Rji at(EHjin Sj) és Rk  at(EIkin Sk)). 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 S1 ...  Snparend; n  3. Si: while B do NKi: Nem kritikus szakasz; EIi: Erőforrás igénylése; EHi: Erőforrás használata; EFi: Erőforrás felszabadítása; od; ahol (i,k,1i,knik) [(változó(NKi)változó(EHi))]  [(változó(EIk)változó(EFk))] = { }; Feltevés: NKi és EHi 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, ..., n1. n1 2. • Legyenek a B csoport azonosítói rendre n1+1,n1+2,. . .,n; n3. A csoportok közötti kölcsönös kizárás. Nem létezik olyan  parbegin R1  . . .  Rnparend ,  konfiguráció, amelyre valamilyen i {1, . . ., n1} és k { n1+1, . . ., n} esetén Ri  at(EHiin Si) és Rk at(EHkin Sk).

Csoporton belüli közös használat. Adott p() mellett létezhet olyan  parbegin R1  . . .  Rnparend ,  konfiguráció, amelyre Ri  at(EHiin Si) és Rk  at(EHkin Sk), ha i, k {1, . . ., n1}. Végtelen igénylés. Adott p() mellett nem létezik olyan  parbegin R11  . . .  Rn1parend , 1   parbegin R12  . . .  Rn2parend , 2  ... végtelen végrehajtási sorozat, ahol minden  parbegin R1i  . . .  Rniparend , i konfiguráció esetén (~i{1,..., n1}~k{n1+1,..., n})(Rjiat(EHjin Sj)Rkat(EIkin Sk)). 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 writer1 ...  writern  reader1  ...  readermparend;

w 1; rcnt 0; sr 1; parbegin writer1 ...  writern  reader1  ...  readermparend; writeri: while "true" do Információ gyűjtés; P(w); Adatbázis felújítás; V(w); od; readerk: 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 writer1  ...  writern  reader1  ...  readermparend; 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  rta; od; while "true" do waitwho = rtw; 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;

Termelő-fogysztó modell. A probléma absztrakt megfogalmazása: informális leírás.