implémentation ada gestion de la mémoire. put 20 l'affectation de comptes (σ-modèle) la...
TRANSCRIPT
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.