Gé n é r icit é e n AD A. Pa q u e t a g e g é n é r iq u e ( 1 /2 )

Transcription

1 Gé n é r icit é e n AD A La notion de sous-programme permet la réutilisation de code Les paquetages et la POO permettent de réutiliser du code de façon robuste en masquant une partie de celui-ci par excapsulation ADA permet déjà le paramétrage des types via les discriminants Il peut également être intéressant de factoriser un morceau de code qui peut être appliqué à différents types (non parents) par exemple une procédure de calcul du maximum de deux nombres est la même pour les entiers et les réels, on voudrait ne l'écrire qu'une fois ADA introduit également le paramétrage des sous-programmes et paquetages une unité de programme générique est définie à partir de types génériques l'utilisation d'une unité générique nécessite son instanciation par un type non générique 1 Pa q u e t a g e g é n é r iq u e ( 1 /2 ) Un paquetage générique est déclaré avec le mot-clé generic un paquetage peut être déclaré générique sans pour autant avoir de paramètre générique (utile dans le cas d'un paquetage qui hérite d'un paquetage générique) si le paquetage possède des paramètres génériques, ceux-ci sont déclarés avant le début du paquetage et peuvent être des variables, des types ou des sous-programmes non génériques generic_package_declaration ::= generic_formal_part package_specification; generic_formal_part ::= generic {generic_formal_parameter_declaration use_clause} generic_formal_parameter_declaration ::= formal_object_declaration formal_type_declaration formal_subprogram_declaration formal_package_declaration Le corps d'un paquetage générique est identique à celui d'un non générique. 2

2 Pa q u e t a g e g é n é r iq u e ( 2 /2 ) generic type Element_Data is (<>); package Paquetage_Liste is private type Liste is limited private; liste_vide : constant Liste; procedure init(l : out Liste); procedure affiche(l : in Liste); procedure addelement(l : in out Liste; i : in Element_Data); procedure removeelement(l : in out Liste; i : in Element_Data); type Element; type Liste is access all Element; type Element is record suivant:liste; valeur:element_data; end record; liste_vide : constant Liste := null; procedure coucou; end Paquetage_Liste; 3 In st a n cia t ion d 'u n p a q u e t a g e g é n é r iq u e Un paquetage générique est instancié en précisant des valeurs pour les paramètres génériques with Paquetage_Liste; procedure Test is package Paquetage_Liste_Integer is new Paquetage_Liste(Integer); use Paquetage_Liste_Integer; l : Liste; init(l); addelement(l,1);addelement(l,2);addelement(l,3); addelement(l,4);addelement(l,5); affiche(l); addelement(l,6); affiche(l); end; 4

3 Pa r a m è t r e s d e p a q u e t a g e g é n é r iq u e ( 1 /4 ) Les paramètres génériques peuvent être des valeurs : des constantes (déclarées en mode in) des variables partagées entre le paquetage générique et l'unité de programme qui l'utilise (en mode in out) Exemple : le paquetage Paquetage_Liste peut être paramétré par une constante qui représente la longueur maximum d'une liste generic type Element_Data is (<>); LONGUEUR_MAX : in Natural := 100; package Paquetage_Liste is 5 Pa r a m è t r e s d e p a q u e t a g e g é n é r iq u e ( 2 /4 ) Les paramètres génériques peuvent être des types : type T is (<>); définit T comme désignant tout quel type discret types discrets : types entiers : entier types réels flottants : tout type réel flottant types réels fixes : type réel fixe définit T comme désignant tout type définit T comme désignant définit T comme désignant tout types tableaux : type T is array(type_indice) of Type_Element; comme désignant tout type de tableau respectant le type d'indice et d'élément données définit T types pointeurs : type T is access Type; définit T comme désignant tout type de pointeur sur le type donné (qui peut être générique!) types indéterminé : type type T is range <>; type T is digits <>; type T is delta <>; type T is private; définit T comme désignant tout 6

4 Pa r a m è t r e s d e p a q u e t a g e g é n é r iq u e ( 3 /4 ) Les paramètres génériques peuvent être des sous-programmes : Il est possible de préciser le sous-programme par défaut : formal_subprogram_declaration ::= formal_concrete_subprogram_declaration formal_abstract_subprogram_declaration formal_concrete_subprogram_declaration ::= with subprogram_specification [ is subprogram_default ] ; formal_abstract_subprogram_declaration ::= with subprogram_specification is abstract [ subprogram_default ] ; subprogram_default ::= name <> null <> indique que le sous-programme par défaut est celui de même signature présent obligatoirement là où le paquetage est instancié le nom du sous-programme par défaut peut être indiqué 7 Pa r a m è t r e s d e p a q u e t a g e g é n é r iq u e ( 4 /4 ) Exemple : une liste peut être implémentée avec : différentes procédures d'ajout (en tête ou en queue) différentes procédures de tri package Paquetage_Liste is generic type Element_Data is (<>); with procedure addelement(l : in out Liste; i : in Element_Data); with procedure tri(l : in out Liste) is <>; type Liste is limited private; liste_vide : constant Liste; procedure init(l : out Liste); procedure affiche(l : in Liste); procedure removeelement(l : in out Liste; i : in Element_Data); private 8

5 Poin t e u r su r so u s-p r og r a m m e Il est possible de définir des types pointeurs sur des sousprogrammes dont on donne la signature pt_fonct(5.4); -- type pointeur sur toute procedure sans paramètre type Pointe_Procedure is access procedure; -- type pointeur sur toute fonction ayant la signature indiquée type Pointe_Fonction is access function(j : Float) return Integer; L'appel du sous-programme pointé se fait en spécifiant les paramètres passés au sous-programme (ou pt.all s'il n'y a pas de paramètre). -- la fonction round(f : Float) return Integer doit être définie pt_fonc : Pointe_Fonction := round'access; De tels pointeurs peuvent être utilisés pour rendre "génériques" d'autres sous-programmes. 9 D ir e ct iv e s d e com p ila t io n ADA définit des directives de compilation introduites par le motclé pragma. Exemples : CONTROLLED : sur un pointeur, indique que le ramasse-miette ne doit pas s'occuper de ce pointeur, la désallocation doit être effectuée par appel à la méthode UNCHEKED_DEALLOCATION qui est une méthode générique devant au préalable être instanciée ELABORATE : sur un paquetage, oblige l'éditeur de lien à construire le corps du paquetage avant les spécifications des paquetages qui utilise le premier INLINE : sur un sous-programme, oblige le compilateur à remplacer les appels au sous-programme par le code du sous-programme. type pt_int is access Integer; pragma CONTROLLED(pt_Int); procedure free_pt_int is new UNCHECKED_DEALLOCATION(Integer,pt_Int); pi : pt_int; free_pt_int(pi); 10

6 Pr og r a m m a t ion n on sé q u e n t ie lle e n A D A ADA permet de gérer des programmes séquentiels qui s'exécutent en pseudo-parallèlisme : les tâches Ces tâches sont des instances d'un type particulier, le type task qui est à la fois un processus (une suite d'instructions) et un controleur de processus (thread of control). L'ordonnancement des processus en ADA est pseudo-parallèle une file de tâches permet de donner successivement la main aux différentes tâches ADA propose des mécanismes de synchronisation entre tâches delay : permet d'interrompre une tâche pendant une certaine durée et lance donc l'exécution de la tâche suivante mécanisme de rendez-vous : une tâche peut en attendre une autre avant de poursuivre son exécution 11 Un type tâche comporte : Ty p e Tâ ch e une spécification qui précise son nom et éventuellement des entrées permettant la synchronisation un corps qui précise le processus géré par la tâche task type Ecrivain is end Ecrivain; task body Ecrivain is s : String(1..6); i : Integer := 0; put("donner un texte à écrire : "); get(s); new_line; while i < 100 loop put("ecriture : ");put(s);new_line; i := i + 1; end loop; put("l'écrivain est mort, paix à son âme!"); end Ecrivain; t : Ecrivain; -- la tâche est créée et démarre dès qu'elle a la main 12

7 In st a n ce d e t â ch e Une tâche est une instance d'un type tâche. Une tâche peut être déclarée directement par sa spécification et son corps, ce qui correspond à la déclaration d'un type tâche anonyme Langage task ADA Ecrivain; task body Ecrivain is s : String(1..6); i : Integer := 0; put("donner un texte à écrire : "); get(s); new_line; while i < 100 loop put("ecriture : ");put(s);new_line; i := i + 1; end loop; put("l'écrivain est mort, paix à son âme!"); end Ecrivain; -- la tâche a été créée lors de sa déclaration -- et démarre dès qu'elle a la main 13 D e la y Un premier mécanisme de gestion d'une tâche consiste à suspendre son exécution durant une certaine durée. Pendant cette durée, la tâche est retirée de la file des tâches. task Ecrivain; task body Ecrivain is s : String(1..6); i : Integer := 0; put("donner un texte à écrire : "); get(s); new_line; while i < 100 loop put("ecriture : ");put(s);new_line; delay 0.5; i := i + 1; end loop; put("l'écrivain est mort, paix à son âme!"); end Ecrivain; -- la tâche a été créée lors de sa déclaration -- et démarre dès qu'elle a la main 14

8 Sy n ch r on isa t io n ( 1 /3 ) La synchronisation est possible entre deux tâches en utilisant le mécanisme du rendez-vous : une tâche déclare une entrée (entry) et dans son corps, place un ou plusieurs points de rendez-vous (accept) qui peuvent contenir du code task Ecrivain1 is entry rdv; end Ecrivain1; task body Ecrivain1 is accept rdv; while i < 10 loop end loop; accept rdv do put("rdv"); end rdv; put("l'écrivain 1 est mort, paix à son âme!"); end Ecrivain1; 15 Sy n ch r on isa t io n ( 2 /3 ) Une autre tâche peut donner rendez-vous à la première au point de rendez-vous en plaçant un autre point dans son corps task Ecrivain2; les deux tâches ne pourront franchir le point que lorsque toutes les deux l'auront atteint task body Ecrivain2 is s : String(1..6); i : Integer := 0; while i < 10 loop put("je suis l'écrivain 2");new_line; i := i + 1; end loop; Ecrivain1.rdv; put("l'écrivain 2 est mort, paix à son âme!"); Ecrivain1.rdv; end Ecrivain2; Plusieurs tâches peuvent donner rendez-vous à celle qui a déclaré l'entrée : une file d'attente des acceptations est créée et le point n'est franchi que lorsque la file est vide 16

9 Sy n ch r on isa t io n ( 3 /3 ) 17 Com m u n ica t ion e n t r e t â ch e s ( 1 /2 ) Les tâches peuvent communiquer via les rendez-vous : les entrées peuvent avoir des paramètres transmis lors de l'appel du point d'entrée, récupérés par l'instruction accept Les tâches peuvent partager des variables sur lesquelles un accès en exclusion mutuelle peut être installé par l'utilisation du pragma SHARED(nom_variable) De nombreux autres mécanismes sont implémentés pour la programmation temps-réel (priorités des tâches, contrôle synchrone ou asynchrone des tâches, ) 18

10 Com m u n ica t ion e n t r e t â ch e s ( 2 /2 ) task Ecrivain1 is entry rdv(i : Integer); end Ecrivain1; task Ecrivain2; task body Ecrivain1 is accept rdv(i : Integer) do put("rdv ");put(i);new_line; end; put("l'écrivain 1 est mort, paix à son âme!"); end Ecrivain1; task body Ecrivain2 is Ecrivain1.rdv(35); end Ecrivain2; 19 Co n clu sion ADA est vraiment un chouette langage, robuste, intégrant la plupart des "bonnes idées" de programmation ADA est adapté au développement de tous types de logiciels et mériterait d'être davantage utilisé dans l'industrie où son usage croit régulièrement mais lentement 20