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

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

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

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, m 1, m 2, m 3  s (m 1 + m 2 )+ m 3 = m 1 + (m 2 + m 3 ) m 1 + m 2 = m 2 + m 1 m + z = m m + (-m) = z (m 1 + m 2 )*m 3 = (m 1 *m 3 ) + (m 2 *m 3 )) m 1 *(m 2 + m 3 ) = (m 1 *m 2 ) + (m 1 *m 3 )) end ring;

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

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;

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)));

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!)

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

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ó).

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

Adattípus specifikációja: eqns: is a type specification = parameters =... ; exports = class sort: oprs: eqns:. f s (f c (a)) = h(a)  pre(f s (b)) : b = f c (a); attr(f c (a))  n  f c (a) = "undefined"  pre(f c (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).

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".

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

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);

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 );

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);

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);

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)

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;

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.

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;