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ó: qsor, length(q) = N, N 1;

A termelő műveletei:

xa[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,jinteger) 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

xa[i];

wait length(q) N ta;

q add(q,x);ii+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; inin+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

xa[i];

wait in - out N ta;

buffer[in mod N] x; in in+1;ii+1;

od;

consumer:

while j M do

wait in - out 0 ta;

y buffer[out mod N]; out out + 1b[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 ... Sn 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 S1 ... Sn 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 S1 ... Sn parend; 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,1i,knik) [(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;

n3.

A csoportok közötti kölcsönös kizárás.

Adott p() mellett nem létezik olyan

parbegin R1 . . . Rn parend , konfiguráció,

amelyre valamilyen

i {1, . . ., n1} és k { n1+1, . . ., n} esetén

Ri at(EHi in Si) és Rk at(EHk in Sk);

Csoporton belüli közös használat.

Adott p() mellett létezhet olyan

parbegin R1 . . . Rn parend , konfiguráció,

amelyre valamilyen

i, j {1, . . ., n1} esetén

Ri at(EHi in Sk) és Rk at(EHk in Sk).

Végtelen igénylés.

Adott p() mellett nem létezik olyan parbegin R11 . . . Rn1 parend , 1

parbegin R12 . . . Rn2 parend , 2 ...

végtelen végrehajtási sorozat, aholminden parbegin R1i . . . Rni parend , i konfiguráció esetén

(~i{1, . . ., n1}~k{n1+1, . . ., n})

(Rji at(EHj in Sj) és Rk at(EIk in 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 ... Sn parend; 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,1i,knik)

[(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; n3.

A csoportok közötti kölcsönös kizárás.

Nem létezik olyan parbegin R1 . . . Rn parend , konfiguráció,

amelyrevalamilyen i {1, . . ., n1} és k { n1+1, . . ., n} esetén

Ri at(EHi in Si) és Rk at(EHk in Sk).

Csoporton belüli közös használat.

Adott p() mellett létezhet olyan parbegin R1 . . . Rn parend , konfiguráció, amelyre

Ri at(EHi in Si) és Rk at(EHk in Sk), ha i, k {1, . . ., n1}.

Végtelen igénylés.

Adott p() mellett nem létezik olyan parbegin R11 . . . Rn1 parend , 1

parbegin R12 . . . Rn2 parend , 2 ...

végtelen végrehajtási sorozat, ahol minden parbegin R1i . . . Rni parend , i konfiguráció esetén

(~i{1,..., n1}~k{n1+1,..., n})(Rjiat(EHj in Sj)Rkat(EIk in Sk)).

Holtpont-mentesség.

Adott p() mellett a párhuzamos program végrehajtása nemvé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 ... readerm parend;

w 1; rcnt 0; sr 1;

parbegin writer1 ... writern reader1 ... readerm parend;

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

rcntrcnt+1;

if rcnt = 1 then P(w) fi;

V(sr);

Adatbázis lekérdezés;

P(sr);

rcntrcnt-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 azerő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 - afelú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éllyellé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 ... readerm parend;

while "true" doInformáció gyűjtés;who wr;P(w);Adatbázis felújítás;await "true" then ww +1,

who r ta;od;

while "true" do wait who = r tw;

P(sr);rcntrcnt+1;if rcnt = 1 then P(w) fi;V(sr);Adatbázis lekérdezés;P(sr);rcntrcnt-1;if rcnt = 0 then V(w) fi;V(sr);Válasz kiértékelése;

od;