Adva S  parbegin S 1 ...  S n 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: 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. 1. 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ű. 2.

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. M tot [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 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 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 ...  S n parend; Más jelölései: cobegin S 1 ...  S n 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: M wtot [S] (  ) = M[S](  )  {  S divergál  kezdő állapotból}. Teljes helyességi szemantikája  kiindulási állapot mellett: M tot [S] (  ) = M wtot [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 ...  S n parend; S i : while "true" do NK i ; EI i ; EH i ; EF i ; od ; ahol: (  i,k,1  i,k  n  i  k) [( var(NK i )  var(EH i ))]  [( var(EI k )  var(EF k ))] = { }; (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: NK i és EH i 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 ...  R n parend,   konfiguráció, ahol valamilyen j,k  {1,..., n}, i  j esetén R j  at(EH j in S j ) ; R k  at(EH k in S k ), b.) Blokkolás-mentesség: Nincs olyan végrehajtás  :  S,    T,  amely holtpont konfigurációban végződik. Triviális megoldás: S j : while "true" do NK j ;  EH j  ; od;

A kölcsönös kizárás Dijkstra féle megoldása: out  bool; S: out  T; parbegin S 1 ...  S n parend; A folyamatok szerkezete: S i : while "true" do NK i ; P(out); EH i ; V(out); od; P : passeren; V: vrijgeven; Szemaforral: s  k; k  0; P(out)  await out then out  F ta; V(out)  out  T; 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 ...  b n  S n if Nem determinisztikus iteráció: do b 1  S 1 ...  b n  S n od Kilépéses nem determinisztikus iteráció: do S B  S E ; exit od S B : b 1  S 1 ...  b n  S n ; S ::=  b  y  f(x,y)   S 1 ; S 2  if b 1  S 1 ...  b n  S n if  do b 1  S 1 ...  b n  S n od  do S B  S E ; exit od  parbegin S 1  S 2 parend;