Osztott rendszer: (kommunikáció csatornán keresztül). Osztott rendszer informális definíciója. • Egymástól elkülönülten létező program-komponensek egy halmaza. • A komponensek egymástól függetlenül dolgoznak saját erőforrásukkal. • A komponensek időről időre egymásnak üzeneteket küldenek a közös feladat megoldása érdekében. Osztott programrendszer végrehajtása. • Párhuzamosan futó folyamatoknak egy halmaza. • Minden egyes folyamat rendelkezik saját változókkal. • A különböző folyamatokhoz tartozó változók halmazai diszjunktak. • A folyamatok egymással üzenetek révén kommunikálnak.

Osztott programrendszer. Párhuzamosan futó folyamatok halmaza. üzenetek folyamat 1 lokális változók folyamat 2 lokális változók folyamat n lokális változók

Üzenet formában történő kommunikáció: Szinkron kommunikáció. Aszinkron kommunikáció. Kommunikáció csatornán keresztül. A kommunikációs csatorna nem irányított. A kommunikációs csatornának nincsen típusa. Nem determinisztikus iteráció általános formája: S :: = S 0 ; do g 1  S 1 ...  g j  S j ...  g n  S n od; n  0; g j : őrfeltétel általános formája; S j, i = 0,...,n : nem determinisztikus programok; S 0 : inicializáció; S i : tartalmazhat további iterációkat is.

A kommunikációs csatorna i/o utasításai. Input utasítás. Szintaxis. C?x; C  csat, csat csatornák halmaza; x egyszerű változó. Jelentés: Annak a kívánságnak a kifejezése, hogy az utasítást kiadó programban az x változó egy értéket fogadjon a C csatornán keresztül, és ha ez teljesül akkor x változó felveszi az értéket. Output utasítás. Szintaxis. C!e; C  csat, csat csatornák halmaza; e: a C!e utasítást kiadó programnak lokális változóival képezett aritmetikai kifejezés, Jelentés: Annak a kívánságnak a kifejezése, hogy az utasítást kiadó program az e kifejezés értékét elküldje a C csatornán keresztül.

Az őrfeltételes utasítás általánosítása: Őrfeltétellel ellátott input csatornautasítás. Szintaxis. b;C?x; ill. b;C!e, ahol b egy logikai kifejezés. Jelentés. Az i/o csatorna utasítás kiegészül egy tesztelési függvénnyel, amely folyamatosan vizsgálja, hogy lehetséges-e a kommunikáció a C csatornán keresztül. • Amíg ez nem következik be, a b kifejezés kiértékelése "false" értéket eredményez, • Ha bekövetkezik, akkor pedig "true" értéket eredményez. Jelölések: A "true";C?e ill "true"; C!e rövid jelölése: C?e ;C!e. var(S): (összes változó + csatorna nevek). chanel(S): csatornanevek S-ben.

A b 1 ;C?u input utasítás és a b 2 ;C!e output utasítás egymáshoz illeszthető: • azonos csatornára hivatkoznak; • az e kifejezés típusa és az u változó típusa azonos; • mind b 1 és b 2 őrfeltételek kiértékelése igaz értéket szolgáltat. Az  1 :C?u,  2 : C!e, illesztés eredménye: E(  1,  2 )  E(  2,  1 )  u  e; A kommunikáció jelentése C csatornán keresztül a b 1 ;C?u, b 2 ;C!e egymáshoz illeszthető utasítás (kérés) pár esetén: Várakozás. (Mindkét kérés teljesítésének várnia kell, amíg a másik nem jelenik meg). Egyidejűség. (Mindkét kérés végrehajtása egyszerre történik meg). Értékadás. (A kommunikáció eredménye az, hogy az u  e értékadás megtörténik).

Definíciók: 1. Az osztott rendszer S 1 és S 2 folyamatai diszjunktak, ha change(S 1 )  var(S 2 ) = var(S 1 )  change(S 2 ) = { }; 2. Az S i és S j (i  j) folyamatokat a C csatorna összeköti, ha C  channel(S i )  channel(S j ). 3. A S 1,...,S n folyamatok pontról pontra összekötöttek, ha (  i,j,k)(1  i  j  k  n)(channel(S i )  channel(S j )  channel(S k )  { }); Osztott program: parbegin S 1 ...  S n parend; ahol S 1,..., S n folyamatok páronként diszjunktak; Bármely 1  i  j  k  n esetén az S i, S j, S k folyamatok pontról pontra összekötöttek. S végrehajtása befejeződik, ha mindegyik S j befejeződik.

Párhuzamos program. Objektum elvű program. Osztott program. Komponens elvű programfejlesztés. C. B. Jones: A pre/post specifikációkat tehát minden sc komponens esetén egészítsük ki a "megbízhatósági/garancia" (rely/garantee) előírással is: { p, r } sc { g, q } Előfeltétel: p; Utófeltétel: q; Megbízhatósági feltétel: r; Garancia feltétel: g; Előfeltétel. p:  ; Utófeltétel: q:  ; Megbízhatósági feltétel: r:  ; Garancia feltétel: g:  ; Probléma: A programfejlesztés alávetése a szekvencializációs szabályoknak!

Modellalkotás. Warmer J., Kleppe A.: The Object Constraint Language - Precise Modelling with UML UML 1990-es évek vége. A probléma megoldásának modelljei. + korlátozások Forgatókönyv (scenario) elkészítésekor rögzítsük a komponensekre vonatkozó megállapodásokat: contracts, scenario, prototype; Probléma megoldás számítógépes hálózaton keresztül: A problémát ágensek oldják meg: összehangolt akciókkal, kívánják a közös célt elérni.

Ágens: felhasználó, program, rendszer, stb. Akció: tevékenységek végrehajtása. (Gomb megnyomása, üzenet, algoritmus végrehajtása, stb.) Cél: ( rendszer kívánt állapotának elérése egy jövőbeli időpontban.) Összehangolás: (kontraktus alapján). Kontraktus, megállapodás: (dokumentum, specifikáció, program szövege.) Probléma: Adott a kontraktus, és az ágensek egy halmaza. Kérdés egy adott célt képesek-e elérni az ágensek az adott kontraktussal.

Program: mint kontraktus a felhasználó és a számítógép között. • Bach feldolgozás: választás a számítógépé, (belső beépített nem determinisztikus választás). Dijkstra: abort = {false} user : (Ha végrehajtódott, jelzi, hogy a felhasználó megsértette a megállapodást. A számítógép felhatalmazást kapott a további részt akár hibás végrehajtásra is). • Interaktív program: A felhasználónak van választási lehetősége a végrehajtásnál. (Alternatívák közül választhat). A számítógép belső döntéseket hozó mechanizmus szerint dolgozik. Példa: S = S 1 ; S 2 ; a  felhasználó; b  számítógép. S 1 = (x : = x + 1  a x: = x + 2 ); S 2 = (x : = x - 1  b x: = x - 2 );

S = S 1 ; S 2 ; a  felhasználó; b  számítógép. S 1 = (x : = x + 1  a x: = x + 2 ); S 2 = (x : = x - 1  b x: = x - 2 ); a bb x:= x+1x:= x+2 x:= x-1x:= x-2x:= x-1x:= x-2 x=0x= -1x=1x=0 A felhasználó választása attól függ, hogy mit akar elérni: x  0; vagy x  0.

Legyen  az ágensek egy összessége. Jelölje A az ágensek egy halmazát. Egy-egy ágens a,b,c  A. Action system. Ágens rendszer = (A, S, I ct, Q), ahol A : a rendszer ágenseinek véges halmaza. S : S 0 ; do b 1  S 1  a...  a b n  S n  a S E ; exit; od; és S 0, S 1,..., S n ; nem determinisztikus programok. S 0 : a rendszer indulása előtt elvégzendő feladatok végrehajtására szolgáló program (iniciálás). I ct : a kontraktust rögzítő invariáns. a  A; ágens, amely a megfelelő komponens kiválasztásáért felelős. Q : az ágens rendszer végrehajtása során elérendő célállítás.

Példa. A kecske, farkas, káposzta átszállítása a folyón. Kontraktus: A farkas a kecskével csak akkor lehet együtt, ha a hajós is ott van: (fa = ke  ha = fa) A kecske a káposztával csak akkor lehet együtt, ha a hajós is ott van: (ke = ká  ha = ke) A kontraktus invariánsa: lct: (fa = ke  ha = fa)  (ke = ká  ha = ke)  (  n  {fa, ke, ká, ha})(n  bool); Kiindulási állapot: (ha = F  fa = F  ke = F  ká = F); Elérendő cél állapot: Q: (ha = T  fa = T  ke = T  ká = T); Egy ágens van: a hajós.

A program: átkelés = ha := F; fa := F; ke := F; ká := F; do ha = fa  (ha, fa) := (  ha,  fa);  a ha = ke  (ha, ke) := (  ha,  ke);  a ha = ká  (ha, ká) := (  ha,  ká);  a ha =  ha;  a skip; exit od; a: hajós;

Példa. Raktár szimulációja. Adva egy raktár, amely háromféle darab-áru raktározására szolgál. Az áru féleségek legyenek: A, B, C. A raktár kapacitása: N. - A raktárba B és C áru vegyesen tárolható. - Vegyesen tárolható A és C áru is. - A és B áru azonban nem tárolható vegyesen a raktárban. - Nem determinisztikus módon érkeznek és távoznak a szállítmányok a raktárból. Készítsük el a raktározás helyes működésének szimulációját. Egy adott áruból a raktárban lévő darabszám: n A = cont(A,ent) - count(A,.ex). n B = cont(B,ent) - count(B,.ex). n C = cont(C,ent) - count(C,.ex).

A kontraktus megfogalmazása: A raktárban B és C áru vegyesen tárolható, ha nincs a raktárban A áru : N  n B + n C  0  n A = 0; A raktárban A és C áru vegyesen tárolható, ha nincs a raktárban B áru : N  n A + n C  0  n B = 0; A komponensek közötti megállapodást tehát a következő invariáns rögzíti: Ict(N, n A, n B, n C ) : ((N  n  0  n A = 0)  (N  n  0  n B = 0))  (n = n A + n B + n C ).

raktár = (n A  0; n B  0; n C  0; n  N; raktároz; raktároz = do beszállít  a elszállít  a skip; exit od; a,b,c  A', ágenshalmaz beszállít = if (N  n  0  n B = 0)  (  binsert(R, A); (n A,n)  ( n A +1, n+1)  )  b (N  n  0  n A = 0)  (  binsert(R, B); (n B,n)  ( n B +1, n+1)  )  b (N  n  0)  (  binsert(R, C); (n C,n)  ( n C +1, n+1)  ) fi; elszállít = if n A  0  (  bdelete(R, A); (n A,n)  ( n A -1, n-1)  )  c n B  0  (  bdelete(R, B); (n B,n)  ( n B -1, n-1)  )  c n C  0  (  bdelete(R, C); (n C,n)  ( n C -1, n-1)  ) fi;

Fairness. (Fair tulajdonság). S 1  jel:= "false"; do ~ jel  következő sor nyomtatása  ~ jel  jel:= "true" od; Az első sor nyomtatás; A második sor leállítás. A nem determinisztikus program szemantikája nem garantálja, hogy a második sor megkapja a vezérlést. A fenti program: nem fair program! Gyenge fair követelmény: A do od ciklusban minden olyan őrfeltételes utasítás, amely valamely időponttól folyamatosan készen áll a végrehajtásra, annak végtelen sokszor aktiválódni kell. Az első komponens ilyen feltétel esetén nem aktiválódhatott volna kizárólagosan, ha a második komponens kész a végrehajtásra.

S 2  jel:= "false"; lap := "false"; i := 0; do ~ jel  következő sor nyomtatása; i := (i+1) mod 30; lap := (i=0)  ~ jel  lap  jel:= "true" od; Most is az első tud aktiválódni először. 30 nyomtatás után a második komponens indulásának feltétele folyamatosan teljesül. Ezért a második végrehajtásra kerül. Ezután azonban egyik komponens belépési feltétele sem teljesül. Az iteráció befejeződik. Ezt az esetet szokták erős fair (strong fairness) tulajdonságnak nevezni.

Vizsgálatunk tárgya egyszintű nem determinisztikus program volt: S 0 ; do  1  S 1 ...   n  S n od; S 0, S 1,..., S n determinisztikus komponensek. A fair nem determinisztikus szemantika definíciója S egyszintű nem determinisztikus program esetén: Adott  ; M fair [S](  ) ={  |  S,    *  E,  };  {  |  S divergálhat  kezdő állapotból egy fair kiszámítás esetén}  {fail |S hibás eredményre juthat  kezdő állapotból}

Vizsgálatunk tárgya egyszintű nem determinisztikus program: S 0 ; do  1  S 1 ...   n  S n od; S 0, S 1,..., S n determinisztikus komponensek. A fair nem determinisztikus szemantika definíciója S egyszintű nem determinisztikus program esetén: Adott  ; M fair [S](  ) ={  |  S,    *  E,  };  {  |  S divergálhat  kezdő állapotból egy fair kiszámítás esetén};  {fail |S hibás eredményre juthat  kezdő állapotból}; M tot [S](  ) és M fair [S](  ) közötti különbség: