Implémentation Ada

Gestion de la mémoire

Put 20

L'affectation de Comptes(σ-modèle)

La sémantique intuitive des comptes ne laisse guère de place à l'affectation (c'est-à-dire la copie de comptes).

Néanmoins les commodités de la programmation peuvent sembler accrues par l'affectation.

Elle permet en particulier de traduire l'évolution d'un même compte.

declare

X : account := open (100) ;

begin

X := put (X, 20) ;

end;

α

Open100

X

β

X

Put 20

L'affectation de Comptes

Elle devient périlleuse dès lors que plusieurs (variables) comptes entrent en jeu.

declare

X : account :=

put (open (100), 20) ;

Y : account :=

get (open (50), 30) ;

begin

Y := get (X, 10) ; end;

α

Open100

X

β

Get 30γ

Open50

Y

δ

Get 10

Y

εβ

Get 10

γ

Put 20

L'affectation de Comptes

Jeter la partie gauche avant affectation ?

declare

X : account :=

put (open (100), 20) ;

begin

X := get (X, 10) ; end;

α

Open100

X

ββ

X

C'est couper la branche sur laquelle on est assis ...

Get 10

γ

Put 20

L'affectation de Comptes

Libérer l'objet pointé quand le pointeur disparaît?

declare

X : account :=

put (open (100), 20) ;

begin

declare

Y : account := X;

begin

X := get (X, 10) ;

end ;

put_line

(natural'image

(balance (X)));

end;

α

Open100

X

β

X

C'est couper la branche sur laquelle on est assis ...

Y

β

Get 10

γ

Put 20

Modifier l'affectation de Comptes L'affectation du pointeur recopie la structure pointée.

declare

X : account :=

put (open (100), 20) ;

begin

declare

Y : account := X;

begin

X := get (X, 10) ;

end ;

put_line

(natural'image

(amount (X, 1)));

end;

α

Open100 Xβ

Plus de partage, plus de résidus ...

Y

Put 20δ

Open100

ε

Put 20ρ

Open100

σ

γ

Get 10

γ

Put 20

Modifier l'affectation de Comptes Un compteur contrôle le partage.

declare

X : account :=

put (open (100), 20) ;

begin

declare

Y : account := X;

begin

X := get (X, 10) ;

end ;

put_line

(natural'image

(amount (X, 1)));

end;

α

Open100 Xβ

Du partage contrôlé, sans résidus ...

Yβ

β

γ1 123

1

21

Naissance, vie et mort d'un compte

declare

X : account;

begin

X

:=

X;

end;

À chaque étape, une procédure est lancée qui peut modifier l'état de la variable …

Par défaut ces procédures ne font … rien

ADJUST FINALIZE AFFECTATION

INITIALIZE(X)

FINALIZE(X)

Si le type est « contrôlé »

Les Comptes (contrôlés) with ada.finalization ; with ada.unchecked_deallocation;package Accounts is type account is private ; function Open (m : natural) return account; function Put (a : account ; m : natural) return account; function Get (a : account ; m : natural) return account; function Operations (a : account) return natural; function Amount (a : account ; n : natural) return natural; function "=" (x, y : account) return boolean; private… type account is new ada.finalization.controlled with ... end Accounts;

En devenant contrôlés, les comptes retrouvent

- l'affectation,

- l 'égalité

Les Comptes (copie) type builder is (Open, Put, Get); type term (selon : builder) is record

case selon is when Open => initial : natural ; when Put | Get => changed : account ;change : natural ;

end case; end record ; type acces is access term ; type account is new ada.finalization.controlled with record controle : acces; end record; procedure initialize (x : in out account); procedure adjust (x : in out account); procedure finalize (x : in out account);

Le type contrôlé n'a d'effet que si les procédures initialize/adjust/finalize sont redéfinies.

Les Comptes (copie) package body Accounts is procedure initialize (x : in out account) is begin null ; end initialize; procedure adjust (x : in out account) is begin if x.controle = null then raise program_error; else x.controle := new term'(x.controle.all) ; end if ; end adjust ; procedure finalize (x : in out account) is procedure finalize is new ada.unchecked_deallocation (term, acces); begin finalize (x.controle); end finalize; ...

Ne rien à faire à l'initialisation, Copier (récursivement) à l'ajustement, Détruire (récursivement) à la finalisation.

Les Comptes (compteur) type builder is (Open, Put, Get); type term (selon : builder) is record

case selon is when Open => initial : natural ; when Put | Get => changed : account ;change : natural ;

end case; end record ; type acces is access term ; type compteur is access positive; type account is new ada.finalization.controlled with record occurrences : compteur ; controle : acces; end record; procedure initialize (x : in out account); procedure adjust (x : in out account); procedure finalize (x : in out account);

Les occurrences sont stockées au bout d'un pointeur pour être partagées..

Les Comptes (compteur) package body Accounts is procedure initialize (x : in out account) is begin x.occurrences := new positive'(1); end initialize; procedure adjust (x : in out account) is begin if x.controle = null then raise program_error; else x.occurrences.all := x.occurrences.all+1 ; end if ; end adjust ; procedure finalize (x : in out account) is procedure finalize is new ada.unchecked_deallocation (term, acces); procedure finalize is new ada.unchecked_deallocation (positive, compteur); begin if x.occurrence.all = 1 then finalize (x.occurrence); finalize (x.controle); end finalize ; else x.occurrences.all := x.occurrences.all+1 ; end if ; end finalize ; ...

accès initial

+ d'accès

- d'accès

De la Spécification FormelleA L’Implémentation Ada

- la spécification algébrique peut se traduire en ADA par un σ-modèle utilisant un terme constitué de constructeurs comme représentation des objets.

- cette traduction implique généralement des pointeurs qui doivent faire l'objet d'un soin particulier pour leur dés-allocation.

- elle n'exclut pas d'autres modèles, plus efficaces, qui partageront la partie publique de la spécification ADA, et dont il faudra prouver qu'ils respectent les axiomes.