1 / 20

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,

Download Presentation

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

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


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

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

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

  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, ..., n1. n1  2. • Legyenek a B csoport azonosítói rendre n1+1, n1+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 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).

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

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

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

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

  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 writer1 ...  writern  reader1  ...  readermparend;

  18. 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;

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

More Related