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;

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

Mátrix.

Egyszerűség kedvéért 22-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,b4ring

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

requestenterexit

Az objektumon végzendő operációk fázisai:

requestenterexit

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

állapotentry/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: <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).

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].exreader[j].ent reader[j].exwriter[i].ent) (writer[i].reqread[j].ent writer[i].exreader[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: ddb; eelem; 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].exreader[j].ent reader[j].exwriter[i].ent) (writer[i].reqread[j].ent writer[i].exreader[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;