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.

Présentation au sujet: "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."— Transcription de la présentation:

1 Implémentation Ada Gestion de la mémoire

2 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; α Open 100 X β X

3 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) ; beginY := get (X, 10) ; end; α Open 100 X β Get 30 γ Open 50 Y δ Get 10 Y εβ

4 Get 10 γ Put 20 L'affectation de Comptes Jeter la partie gauche avant affectation ? declare X : account := put (open (100), 20) ; beginX := get (X, 10) ; end; α Open 100 X ββ X C'est couper la branche sur laquelle on est assis...

5 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; α Open 100 X β X C'est couper la branche sur laquelle on est assis... Y β

6 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; α Open 100 X β Plus de partage, plus de résidus... Y Put 20 δ Open 100 ε Put 20 ρ Open 100 σ γ

7 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; α Open 100 X β Du partage contrôlé, sans résidus... Y β β γ 112 3 1 21

8 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é »

9 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é

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

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

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

13 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

14 De la Spécification Formelle A 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.