Adva S parbegin S 1 Sn parend Prhuzamos

Adva S parbegin S 1 . . . Sn parend; Párhuzamos programszerkezet két vagy több olyan folyamatot tartalmaz, amelyek egymással közös változó segítségével kommunikálnak. Folyamat a végrehajtás alatt lévő program. Kommunikáció azt jelenti, hogy a közös változó értékét párhuzamosan futó folyamatok kiolvassák, illetve felülírják. Közös változó: olyan változó, amelyhez egynél több folyamat is hozzáférhet. Lokális változó: olyan változó, amelyhez csak egy folyamat férhet hozzá.

A párhuzamosan történő végrehajtás követelményei: 1. Követelmény (A közös változóhoz való hozzáférés követelményei). A hozzáférés a közös változóhoz: a változó értékének kiolvasása vagy felülírása. A közös változókhoz való hozzáférések atomi operációnak tekintendők. 2. Követelmény (A végrehajtás követelményei). A végrehajtás sebessége minden, de nem fejeződött folyamat esetén pozitív és tetszőleges, ( kivéve, ha a közös változóhoz való hozzáférésre vár). Ekkor azonban a hozzáférés kellő idő után garantált és a végrehajtás folytatódhat. Az atomi műveletek (közös változóhoz való hozzáférések) lineárisan sorba rendezettek, de a sorrend véletlenszerű.

A közös változókhoz való hozzáférések lineárisan sorba rendezettek. • • • Megvárakoztatás. (blokkolt állapot). Követelmény, garantált a hozzáférés minden folyamat számára. (holtpont mentesség állapota). Folyamatok végrehajtási sebessége pozitív érték, kivéve, ha a közös erőforrásra várnak. (fair követelmény). Reynold féle kritérium: Ha az 1. , 2. követelmények teljesülnek, a párhuzamos komponensek végrehajtása során érvényes a program állapotára vonatkozóan a nem determinisztikus egymás utáni atomi végrehajtás a logikai kiértékelés és a felülírás, (feltéve, hogy a logikai kiértékelés és felülírás közös változót tartalmaz).

Atomi (primitív) művelet, utasítás végrehajtása: - meg nem szakítható végrehajtás, - aszinkron módon. Atomi műveletek: - Egy bool kifejezés kiértékelése. - Egy változó értékének a kiolvasása. - Értékadás egy változónak. Atomi utasítás. Egy olyan S program szakasz, amelyet atomivá teszünk, amelyet ciklust, vagy atomi utasítást nem tartalmaz. Jelölés: S ;

Közös változóval rendelkező determinisztikus párhuzamos program szintaxisa: S : : = skip | y t | S 1; S 2 | if then S 1 else S 2 fi | while do S 1 od | parbegin S 1 S 2 parend ; atomi program: S ; Más jelölés: while do S 1 od : do S 1 od; Szemantika. S, E, S , E, M[ S ]({p}) = M[S]({p})

Lemma. A közös változóval rendelkező párhuzamos program blokkolás-mentes. T. i. : Minden S, konfigurációnak S E és esetén van rákövetkezője a reláció szerint. Lemma. Minden S párhuzamos program esetén a S, konfigurációnak véges számú rákövetkezője van a reláció mellett. Következik: A szintaktikai axiómákhoz, szabályokhoz rendelt tranzakciók relációinak definícióiból.

Lemma. Adott S és kezdő állapot. Mtot[S]( ) vagy véges számú állapotot tartalmaz, vagy csak a virtuális állapotot. A bizonyítás a fákra vonatkozó König lemma [1927] adaptációjával mutatható ki. Ezt Knuth D. E. végezte el 1968 -ban.

Programhelyesség bizonyításnál feltesszük: Bool kifejezés, értékadás, skip, atomi régió, kiértékelődik ill. végrehajtódik atomi akcióként: • Meg nem szakíthatók; • Egymás után hajtódnak végre, de a végrehajtás sorrendje nincs meghatározva. A konvencionális hardver ezt nem garantálja. Garancia: Általában a kritikus hivatkozások atomi kezelését garantálja, kizárólagos írási vagy olvasási atomi hozzáférést garantál az egyszerű, vagy indexes változók esetében. y f(x, y) : y f(x, y)

Példa: S parbegin x y y x parend; Feltevéssel: x y esetén két atomi művelet van: y kiolvasása és az x értékének felülírása a kiolvasott értékkel. Legyen x=1; y=2; Lehetséges eredmények: x=y=2; x=y=1; x=2 és y=1. A parallel modellünk jelentése nem azonos a hagyományos hardware által nyújtott megoldással. Minden komponens program szoftver-akkumulátorok bevezetésével áttranszformálható egy olyan vele ekvivalens párhuzamos programmá, ahol minden atomi akció egy hozzáférést jelent a közös változóhoz. S' parbegin AC 1 y; x AC 1 AC 2 x; y AC 2 parend; A párhuzamosság atomi egységére vonatkozó x y szemantikai meghatározásunk az egyszerű kezelés célját szolgálja a helyességbizonyításnál.

Ha az < s > ahol s egy közös változó, akkor ez azonos a hagyományos hardver által nyújtott lehetőséggel. A párhuzamos program helyesség bizonyítását leegyszerűsíti a virtuális <S > atomi definíciónk. • Minél kisebb egységre vonatkozik az atomi definíciónk annál inkább megfelel a valóságos végrehajtásnak. • Minél nagyobb egységre vonatkozik az atomi definíciónk annál inkább megkönnyíti a program helyességének a bizonyítását.

Párhuzamos program szinkronizációval. A feltételes atomi utasítás szintaxisa: b S ; Dijkstra - féle jelölés: await b then S ta; Speciális esetek: await "true" then S ta; await b then skip ta; await b then ta; wait b tw; A Dijkstra - féle atomi szemafor utasítások: P(s): s s-1; if s 0 then állj be az s-hez rendelt várakozó sorba fi; V(s): s s+1; if s 0 then induljon el egy folyamat az s-hez rendelt várakozó sorból fi;

A Dijkstra féle szemafor utasítások egyszerű implementációja: P(s) : await s 0 then s s-1 ta; V(s) : await "true" then s s+1 ta; Egy pontos implementáció: P(s) : await "true" then begin s s-1; if s 0 then V[j] "false" fi; await V[j] then ta end ta; V(s) : await "true" then begin s s+1; if s 0 then begin válassz egy olyan i-t, amelyre V[i] = "false"; V[i] "true" end fi end ta;

Szemantika. Az őrfeltételes atomi utasítás jelentése: (b) = "true" S, E, b S , E, (b) = "true" S, E, await b then S ta, E, A holtpont állapot informális definíciója. Az S párhuzamos program holtpont állapotba jutott, ha • a program végrehajtása nem fejeződött be és • annak minden olyan komponense, amely nem fejeződött be, blokkolt állapotban van.

Párhuzamos program szinkronizációval. Szintaxis. S : : = b y f(x, y) S 1; S 2 if b then S 1 else S 2 fi while b do S od parbegin S 1 S 2 parend; Feltételes meg nem szakítható (atomi) utasítás: b S ; amely nem tartalmazhat iterációt, vagy másik atomi utasítást. parbegin S 1 . . . Sn parend; Más jelölései: cobegin S 1 . . . Sn coend; [ S 1 S 2 ];

Lemma. A párhuzamos program végrehajtása során, a állapotban, a p( ) állítás mellett, az await b then S ta utasításnál blokkolt állapotba kerül, ha p( ) ~b = "true". Definíció. Adva az S párhuzamos program, és annak egy állapota a p( ) = "true" mellett. Az S, konfigurációt holtpontnak nevezzük, ha 1. 1. ~(S E); 1. 2. S, S', ' tranzakció nem létezik. A holtpont virtuális állapot jele: . Az S program a állapotból holtpontra juthat, ha létezik olyan kiszámítás, amely holtpont konfigurációban végződik.

Az S program holtpontmentes, (p mellett) ha nem létezik olyan állapot p( ) = "true" mellett, amelynél S holtpontra juthat. Az S párhuzamos program szemantikája. Parciális helyességi szemantikája kiindulási állapot mellett: M[S]( ) = { S, E, }. Gyenge teljes helyességi szemantikája kiindulási állapot mellett: Mwtot[S] ( ) = M[S]( ) { S divergál kezdő állapotból}. Teljes helyességi szemantikája kiindulási állapot mellett: Mtot[S] ( ) = Mwtot[S] ( ) { S holtpontba jut kezdő állapotból}. ( , , fail virtuális állapotok).

Példa. Kölcsönös kizárás: Probléma: Adva egy erőforrás, amelyet "n" folyamat használ feladatainak megoldása során, ahol 0 n. Követelmények: Kölcsönös kizárás. Az erőforrást egy adott időpontban legfeljebb csak egy folyamat használhatja. Blokkolás mentesség. A párhuzamos folyamatok futását a szinkronizáció ne függessze fel végtelen hosszú időre. Erőforráshoz való hozzáférhetőség. Minden egyes folyamat, ha használni akarja az erőforrást, akkor véges időn belül használhassa azt.

A követelmények formális megfogalmazása. S: inicializálás; parbegin S 1 . . . Sn parend; Si: while "true" do NKi ; EIi ; EHi ; EFi ; od ; ahol: ( i, k, 1 i, k n i k) [( var(NKi) var(EHi))] [( var(EIk) var(EFk))] = { }; (az elkészítés és erőforrás használatának változói különböznek az igénylés és a felszabadítás változóitól) Feltevés: NKi és EHi nem tartalmaz őrfeltételes utasítást.

Definíció. a. ) Kölcsönös kizárás: Az S végrehajtása során nem létezik olyan parbegin R 1 . . . Rn parend, konfiguráció, ahol valamilyen j, k {1, . . . , n}, i j esetén Rj at(EHj in Sj) ; Rk at(EHk in Sk), b. ) Blokkolás-mentesség: Nincs olyan végrehajtás : S, T, amely holtpont konfigurációban végződik. Triviális megoldás: Sj: while "true" do NKj; EHj ; od;

A kölcsönös kizárás Dijkstra féle megoldása: out bool; S: out T; parbegin S 1 . . . Sn parend; A folyamatok szerkezete: Si: P : passeren; V: vrijgeven; while "true" do NKi; P(out); EHi; V(out); od; P(out) await out then out F ta; V(out) out T; Szemaforral: s k; k 0; P(s) await s 0 then s s-1 ta;

Párhuzamos nem determinisztikus program szinkronizációval. Szintaxis. Nem determinisztikus kiválasztás: if b 1 S 1 . . . bn Sn if Nem determinisztikus iteráció: do b 1 S 1 . . . bn Sn od Kilépéses nem determinisztikus iteráció: do SB SE; exit od SB : b 1 S 1 . . . bn Sn ; S : : = b y f(x, y) S 1; S 2 if b 1 S 1 . . . bn Sn if do b 1 S 1 . . . bn Sn od do SB SE; exit od parbegin S 1 S 2 parend;