félcsoport (semigroup) = ({s},{ * : s s  s [infix]}. semigroup is a type specification =

1. félcsoport (semigroup) = ({s},{ *: s s s [infix]}. semigroup is a type specification = sorts: s oprs: *: s s s [infix] eqns: m1, m2, m3 s (m1* m2) * m3 = m1* (m2* m3) ; end semigroup;

2. monoid = ({s},{ *: s s s[infix], e:s}. monoid is a type specification = semigroup + oprs: e:s eqns: m s e*m = m m*e = m

3. group = ({s},{ *: s s s[infix], e:s, ( _ ) -1: s s}. group is a type specification = monoid + oprs: ( _ ) -1: s s eqns: m s m*(m -1) = e (m -1)*m = e

4. ring = ({s},{ z: s, * : s s s[infix], + : s s s[infix], - : s  s}. ring is a type specification = semigroup + oprs: z : s, + : s s s[infix], - : s  s eqns: m, m1, m2, m3 s (m1+ m2)+ m3 = m1+ (m2+ m3) m1+ m2= m2+ m1 m + z = m m + (-m) = z (m1+ m2)*m3 = (m1*m3) + (m2*m3)) m1*(m2+ m3) = (m1*m2) + (m1*m3)) end ring;

5. Mátrix. Egyszerűség kedvéért 22-es mátrixot definiálunk. matrix(ring) is a type specification = parameters = ring + exports = type sort : matrix oprs : zero :  matrix unit :  matrix MATRIX: ring ring ring ring  matrix add: matrix matrix  matrix sub: matrix matrix  matrix

6. eqns: a1,a2,a3,a4, b1,b2,b3,b4ring zero = MATRIX(z,z,z,z) unit = MATRIX(e,z,z,e) add(MATRIX(a1,a2,a3,a4), MATRIX(b1,b2,b3,b4)) = MATRIX(a1+b1,a2+b2,a3+b3,a4+b4) sub(MATRIX(a1,a2,a3,a4), MATRIX(b1,b2,b3,b4)) = MATRIX(a1+(-b1),a2+(-b2),a3+(-b3),a4+(-b4)) end matrix;

7. Ismételt paraméter átadás. Példa: Van: int, matrix(ring); string(data); bintree(data); Kellene. bintree(string(matrix(int))); 1. Megoldás: int  matrix(ring) = matrix(int); matrix(int)  string(data) = string(matrix(int)); string(matrix(int))  bintree(data) = bintree(string(matrix(int))); 2. Megoldás: string(data) bintree(data) = bintree(string(data)); matrix(ring) bintree(string(data)) = bintree(string(matrix(ring))); int bintree(string(matrix(ring))) = bintree(string(matrix(int)));

8. Paraméter átadás kompozíciója asszociatív: (f °g) ° h = f ° (g ° h); data bintree(data) h1 param string(param) (3) h2 h2' (1) ring matrix(ring) string(matrix(ring)) h3 h3 (2) int string(matrix(int)) bintree(string(matrix(int))); (Az eredmény független a választott stratégiától!)

9. Cél: megbízható szoftver előállítása. Módszer : absztrakció + modularizáció. Objektum elvű szoftverfejlesztési módszer: Objektum modul, az objektumhoz való szabványos hozzáférhetőséggel. Szinkronizált objektum modul párhuzamos környezetben. nem szinkronizált objektum szinkronizációs mechanizmus request enter exit

10. Az objektumon végzendő operációk fázisai: request enter exit Állapot az objektum létezésének egy feltételnek eleget tevő szakasza. (aktivitást fejt ki, vagy vár egy esemény bekövetkezésére). állapot entry/ event/ exit/ Az objektum állapotához három fázis kötődik: Indulás fázis. (Az entry akció kezdeményezi). Belső tevékenységek fázisa. (Az event akció). Kilépési fázis. (Az exit akció).

11. p.req p.ent[] p.ex : a szinkronizáció követelményeinek megfelelő belépési feltétel. p  pre obj

12. Adattípus specifikációja: eqns: <típus név> is a type specification = parameters = ... ; exports = class sort: oprs: eqns: . . . fs(fc(a)) = h(a)  pre(fs(b)) : b = fc(a); attr(fc(a))  n  fc(a) = "undefined"  pre(fc(a)) : attr(a)  n. sync: ... . Egy specifikációs nyelv a szinkronizációra: elsőrendű predikátum kalkulus nyelve + klózok (operáció, akció, időbeli rendezettség).

13. Individuum változók: közös erőforráson végzendő operációkhoz tartozó akciók. Az akciók szintaktikai formája: operáció neve[végrehajtásának sorszáma](paraméter), ;   {req, ent, ex}; Például: p[i](x).req; Individuumok halmazán értelmezett reláció: akciók közötti időbeli rendezettségi reláció:  Szintaxis: akció akció  bool [infix]. Például : p[i].req  q[j].exit; A reláció tulajdonságai: nem reflexív: ~ (A  B); asszimmetrikus: (A  B)  ~ (B  A); tranzitív: (A  B) ~ (B  C)  (A  C); Szemantika: A  B = ha A műveleti akció megelőzi B műveleti akciót akkor "true" különben "false".

14. Paraméterekre vonatkozó relációk az elsőbbségi relációban. Szintaxis: R(x,y)(f[i](x).ex g[j](y).ent), ahol R(x,y) reláció. Szemantika: R(x,y)(f[i](x).ex g[j](y).ent) = ha az f(x) művelet exit akciója az i. végrehajtás esetén megelőzi a g(y) művelet enter akcióját a j. végrehajtás esetén és a paramétereikre ugyanakkor fennáll az R(x,y)="true" állítás akkor "true" különben "false". Megjegyzés: Az univerzális és az egzisztenciális kvantor: : for all; : for some. implementor absztrakt szinkronizációs specifikáció program követelményeknek való megfelelés ellenőrzése szinkronizációs tulajdonságok bizonyítása függetlenül az operáció algoritmusától

15. Axiómák: (i)( p(i).req  p(i).ent); (i)( p(i).ent  p(i).ex); (i,k; k  0)(p(i).req  p(i+k).req); Erőforráshoz való hozzáférési korlátozások: 1.) Addig az adaton nem végezhető p művelet, amíg nem jött létre: (i)(create.ex  p[i].ent); 2.) Ugyanabból a műveletből egyszerre csak egy dolgozhat az objektumon (kizárólagos használat): (i)(p[i].ex  p[i+1].ent); 3.) Ugyanabból a műveletből egyszerre csak n 1 dolgozhat az objektumon: (i)( h[i].ex  h[i+1].ent);

16. 4.) Különböző műveletekből egyszerre csak egy dolgozhat az objektumon (kölcsönös kizárás): (i,j)( p[i].ex  q[j].ent  q[j].ex  p[i].ent ); 5.) Két különböző művelet esetén q művelet az objektumhoz való hozzáférések számában legfeljebb n-nel haladhatja meg a p hozzáféréseinek számát: (i)( p[i].ex  q[i+n].ent ); Prioritásos korlátozások. 1.) A p operációnak elsőbbsége van a q operációval szemben az erőforráshoz való hozzáférésben (prioritásos belépés): (i,j)( p[i].req  q[j].ent)  p[i].ent  q[j].ent );

17. 2.) A p operációnak elsőbbsége van a q operációval szemben az erőforráshoz való hozzáférésben (prioritásos belépés): (i,j)( p[i].req  q[j].ent)  p[i].ent  q[j].ent ); 3.) A p operációnak elsőbbsége van a q operációval szemben az erőforrás kizárólagos használatában (prioritásos kölcsönös kizárás): (i,j)( p[i].req  q[j].ent)  p[i].ex  q[j].ent ); 4.) Paraméterektől függő prioritásos kölcsönös kizárás : (i,j)( p[i](x).req  q[j](y).ent)  R(x,y)  p[i](x).ex  q[j](y).ent);

18. Beütemezések. 1.) Beütemezés prioritás alapján kölcsönös kizárással: (i,j,k)( q[j].req  p[i].ex  q[j].ent  r[k].req  p[i].ex  r[k].ent  q[j].ex  r[k].ent); 2.) Beütemezés kölcsönös kizárással paramétertől függő prioritás alapján: (i,j,k)((q[j](x).req  p[i].ex  q[j](x).ent  r[k](y).req  p[i].ex  r[k](y).ent)  R(x,y)  q[j](x).ex  r[k](y).ent); Sorrendiségi korlátozás. p[i] operáció után közvetlenül q[j] operáció használja az erőforrást: (~k)( p[i].ex  r[k].ent  q[j].ent);

19. Korlátos buffer szinkronizációs axiómája. syn = for all j; create.ex  deposit[j].ent  deposit [j].ex  remove[j].ent  remove [j].ex deposit[j+n].ent  (szinkronizáció); deposit[j].ex  deposit [j+1].ent  remove[j].ex  remove[j+1].ent; (kizárólagos használat) Adatbázis szinkronizációs axiómája. syn: for all i,j: create.ex writer[i].ent  (write[i].ex  write[i+1].ent)  (writer[i].exreader[j].ent  reader[j].exwriter[i].ent)  (writer[i].reqread[j].ent  writer[i].exreader[j].ent)

20. Példa. Az adatbázis típusának a specifikációja párhuzamos esetre. db(elem) is a class specification = parameters = sorts: elem oprs: : elem exports = class sorts: db oprs: create:  db write: db elem  db read: db  elem eqns: ddb; eelem; read(create) =  read(write(d,e)) = e syn: for all i,j: create writer[i].ent  (write[i].ex  write[i+1].ent  (writer[i].exreader[j].ent  reader[j].exwriter[i].ent)  (writer[i].reqread[j].ent  writer[i].exreader[j].ent) end db;

21. Adva a lista típus specifikációja: listx(elem) is a type specification = sorts : listx, elem oprs : empty :  listx add : elem listx  listx _ . _ : listx listx  listx eqns : /, m  list; e  elem; empty . / = / add(e , /) . m = add(e, / . m ) end listx; Egészítsük ki a specifikációt a szinkronizációs specifikációval.

22. Megoldás. listx(elem) is a type specification = sorts : listx, elem oprs : /, m  listx; e  elem; empty :  listx add : elem listx  listx _ . _ : listx listx  listx eqns : /, m  list; e  elem; empty . / = / add(e , /) . m = add(e, / . m ) syn : (i,j)(empty.ex  _ . _ [j].ent  _ . _ [j].ex  _ . _ [j+1].ent  add[j].ex  add[j+1].ent  (add[i].ex  _ . _ [j].ent  _ . _ [j].ex add[i].ent)) end listx;