Nem determinisztikusság és párhuzamosság.

Nem determinisztikusság és párhuzamosság.

A nem determinisztikusság a párhuzamosságban gyökeredzik. Példa: Spar parbegin x:=0 x:=1 x:=2 parend;

Tetszőleges sorrendet eredményezhet a végrehajtás.

Sndet if true x:=0 true x:=1 true x:=2 fi;

A legnagyobb közös osztó megtalálása:

GCD: while xy do if xy then x:= x-y else y:= y-x fi od;

GCD': do x y x:= x-y yx y:= y-x od;

Olvasmányosabb megoldás.

Nem determinisztikus program.

Szintaxis.

1.) Szekvenciális nem determinisztikus program:

S::= skip u t S1;S2 if 1 S1 ... 1 Sn fi

do 1 S1 ... n Sn od;

Speciális esetek:

if then S1 else S2 fi : if S1 ~ Sn fi ;

when do S od : do S od ;

2.) Szekvenciális nem determinisztikus program exit iterációval:

S::= skip u t S1;S2 if S1 ... Sn fi do SB SE exit od;

SB : 1 S1 ... n Sn ;

A nem determinisztikus ciklus szintakszisának induktív definíciója:

Jelölje azt a nem determinisztikus programot, amelyre:

()(M[]()= );

(do 1 S1 ... 1 Sn od)0 = ;

(do 1 S1 ... 1 Sn od)k+1=

if do 1 S1 ... 1 Sn od; (do 1 S1 ... 1 Sn od)k

(~1 . . . ~n) skip

fi;

3.) párhuzamos nem determinisztikus program:

S::= skip u t S1;S2 if 1 S1 ... 1 Sn fi

do 1 S1 ... n Sn od parbegin S1 S2 parend;

Atomic program: S;

A nem determinisztikus kiválasztás

if 1 S1 ... 1 Sn fi utasítás esetén:

Az i Si őrfeltétetles utasítás kiválasztása végrehajtásra:

• Ha valamelyik i értékre igaz, akkor a kiértékelés után Si

végrehajtódik és az if...fi utasítás végrehajtása befejeződik.

• Ha több i értéke is igaz, akkor véletlenszerű kiválasztásra

kerül sor.

• Ha minden i{1, . . ., n} esetén i értéke hamis, akkor az

utasítás végrehajtása hibajelzést eredményez, abortál.

Nem determinisztikus iteráció:

do 1 S1 ... n Sn od

utasítás esetén:

Az i Si őrfeltételes utasítás kiválasztása végrehajtásra:

• Ha valamelyik i értékre igaz, akkor a kiértékelés után Si

végrehajtódik.

• Ha több i értékre is igaz, akkor véletlenszerű kiválasztásra

kerül sor.

• A fenti eljárás mind addig ismétlődik, amíg van olyan i,

amelynek értéke igaz.

• Ha minden i{1, . . ., n} esetén i értéke hamis, akkor a

do ... od utasítás végrehajtása befejeződik.

Szemantika.

Szemantika definiálása állapot átmenetek axiómáival:

i = "true" if 1 S1 ... n Sn fi, Si,; (i=1,...,n).

(i{1,...,n})(i = "false") if 1S1 ... n Sn fi, E,fail;

(E,fail hiba konfiguráció és nincs rákövetkezője!)

i = "true" do 1 S1 ... 1 Sn od,

Si; do 1 S1 ... 1 Sn od,; (i=1,...,n).

(i{1,...,n})(i = "false") do 1 S1 ... 1 Sn od,

E,;

Definíció. Adott S nem determinisztikus program és .Az S nem determinisztikus program kezdeti állapotból elindítvahibás, ha létezik olyan kiszámítása, amely (S',fail) hibakonfigurációban végződik.

Definíció. Adott S nem determinisztikus program és .

• Az S nem determinisztikus program parciális helyességiszemantikája:

M[S]() ={ S, E,};

• Az S nem determinisztikus program teljes helyességiszemantikája:

Mtot[S]() = M[S]() { S divergál kezdeti értékből indítva {fail S hibás kezdeti értékből indítva;

Adott S nem determinisztikus program és esetén: Mtot[S]() vagy véges, vagy tartalmazza virtuális állapotot.

Indoklás a König lemma alapján.

Mtot[if then S1 else S2 fi] = Mtot[if S1 ~ S2 fi];

Mtot[while do S od] = Mtot[do S od];

if then S1 else S2 fi if S1 ~ S2 fi;

while do S od do S od;

Mtot[ if then S fi ] Mtot[ if S fi ];

nincs fail van fail

Transzformáljuk át a párhuzamos programot nem determinisztikus

programmá.

Módszer:

Adva

S parbegin S1 ... Sn parend;

Vezessünk be egy pci integer változót minden Si komponenshez.

Ez a változó modellezi a programszámlálóját az Si végrehajtása

során. Ez a számláló mindenkor az Si komponensen belül

végrehajtandó következő atomi utasításra mutat.

A pozíciók az Si komponensen belül 0,1,...;

Az Si befejezési pontját azonosítsa termi.

Si komponensben az atomi akciók "címeinek" halmaza: POSi

Példa: Pozitív értékű elem gyors keresése az a[1:N] tömbben.

Specifikáció:

(1kN+1(i, 0ik)((a[i]0k N) a[k]0);

FINDPOS i:=1 ; j:=2; oddtop:=N+1; eventop:=N+1;

parbegin S1 S2 parend;

S1 while i min(oddtop,eventop) do

if a(i) 0 then oddtop:= i else i:= i+2 fi;

od;

S2 while j min(oddtop,eventop) do

if a(j) 0 then oddtop:= j else j:= j+2 fi;

od;

Owicki and Gries [1976]

Példa. S parbegin S1S2;

S1 while i min(oddtop,eventop) do 0 if a(i) 0 then oddtop:= i else i:= i+2 fi 1 2 3

od; 4

S2 while j min(oddtop,eventop) do 0 if a(j) 0 then oddtop:= j else j:= j+2 fi 1 2 3

od; 4

term1=4; term2= 4;

POS1 = POS2 = {0,1,2,3,4};

S1 while i min(oddtop,eventop) do

0 if a(i) 0 then oddtop:= i else i:= i+2 fi 1 2 3

od;4

T1: do pc1 := 0 i min(oddtop,eventop) pc1:= 1;

pc1 := 0 ~(i min(oddtop,eventop)) pc1:= 4;

pc1 := 1 a[i] 0 pc1:= 2;

pc1 := 1 ~(a[i] 0 ) pc1:= 3;

pc1 := 2 oddtop:= i; pc1:= 0;

pc1 := 3 i:= i+2; pc1:= 0;

S2 while j min(oddtop,eventop) do

0 if a(j) 0 then oddtop:= j else j:= j+2 fi 1 2 3

od;4

do pc2 := 0 j min(oddtop,eventop) pc2:= 1;

pc1 := 0 ~(j min(oddtop,eventop)) pc2:= 4;

pc1 := 1 a[j] 0 pc2:= 2;

pc1 := 1 ~(a[j] 0 ) pc2:= 3;

pc1 := 2 oddtop:= j; pc2:= 0;

pc1 := 3 j:= j+2; pc2:= 0;

term1= 4; term2= 4;

A nem determinisztikus program:

T1 pc1:= 0; pc2 := 0;

do pc1 := 0 i min(oddtop,eventop) pc1:= 1;

pc1 := 0 ~(i min(oddtop,eventop)) pc1:= 4;

pc1 := 1 a[i] 0 pc1:= 2;

pc1 := 1 ~(a[i] 0 ) pc1:= 3;

pc1 := 2 oddtop:= i; pc1:= 0;

pc1 := 3 i:= i+2; pc1:= 0;

pc2 := 0 j min(oddtop,eventop) pc2:= 1;

pc2 := 0 ~(j min(oddtop,eventop)) pc2:= 4;

pc2 := 1 a[j] 0 pc2:= 2;

pc2 := 1 ~(a[j] 0 ) pc2:= 3;

pc2 := 2 oddtop:= j; pc2:= 0;

pc2 := 3 j:= j+2; pc2:= 0;

od;

M, Mtot; N.

• N[S] monoton: (X Y ) N[S](X) N[S](Y);

• N[S1; S2](X) = N[S2](N[S1](X));

• N[(S1; S2); S3](X) = N[(S1; (S2; S3)](X);

• M[(if 1S1... nSn fi)](X) =

M[(S1)](X[1])... M[(Sn)](X[n]);

• (X ([1])... [n]))

Mtot[(if 1S1... nSn fi)](X) =

Mtot[(S1)](X[1])... Mtot[(Sn)](X[n]);

• M[(do 1S1... nSn od)] =

M [do 1S1... nSn)1] ... M [do 1S1... nSn)];

A segély kiosztásának nem determinisztikus programja.

Adva három csoport: a, b, c, akik között ki kell osztani N darab segélyt.A szeretetszolgálat osztja ki az ajándékot. Véletlenszerű az, hogy asoron következő segélyt melyik csoport kapja, de egymás utánközvetlenül kétszer ugyan az a csoport nem kaphat segélyt.

A csoportok által megkapott segélyek száma legyen mindenkor

xa = count(a,ex);

xb = count(b,ex);

xc = count(c,ex);

Ezek kezdőértéke: xa = xb = xc = 0.

A kiosztható segélyek száma mindenkor: r = N - (xa + xb + xc ).

Így r kezdőértéke: r = N.

A mindenkor utoljára megajándékozott azonosítóját jelölje

f{a,b,c}.

f kezdőértéke: f = a.

A követelmények alapján:

Az a csoport kaphat mindenkor segélyt, amelyik

nem a legutoljára megajándékozott volt és van még segély:

(f a) r 0;

Készítsük el a kiosztás szimulálásának a nem determinisztikus

programját.

kiosztás=

(xa 0; xb 0; xc 0; f a; r N; átad;

átad = do r 0 if

f a (xa,r) (xa+1, r-1); f a f b (xb,r) (xb+1, r-1); f b f c (xc,r) (xc+1, r-1); f c fi

od;

A szemantika definiálásának másik módja a program-stuktúrák

tranzakciós diagramjának megadása.

S: u e;

ST: ({s,t},{(s, "true" (u e), t)}, s, t);

"true" (u e)

s t

S: S1;S2; S1T: (L1,T1, s, r); S2T: (L2,T2, r, t);

Ha L1 L2 = {r}, akkor

ST = S1T; S2T = (L1L2, T1 T2, s, t);

S1T S2Ts r t

S: if then S1 else S2 fi;

({s, t},{(s, (u fS1), t), (s, ~ (u fS2), t)},s,t);

fS1 ~ fS2

s

t

S: if S1 ~ S2 fi;

S1T: (L1,T1,s,t); ~ S2T: (L2,T2,s,t);

Ha L1L2 = {s,t},

Akkor ST = (L1L2, T1T2, s,t).

ST1

ST2

s t

S = while do SB od;

({s, t},{(s, (u fSB), s), (s, ~ skip, t)}, s, t );

~ skip

fSB

s t

S = while do SB od;

S = do SB ~ SE; exit od;

SBT = (LB, TB, s, t);

SET: (LE,TE,s,t);

LBLE = {s};

ST: (LB LE, TBTE, s, t);

SE = skip.

SBT

~ SETs t