REAL reprend les concepts des langages d'interrogation et de recherche largement utili- sés dans les bases de données (SQL...). Empruntant la plupart de ses notions à la théorie des ensembles et à la grammaire AADL, il est d'accès aisé à tout développeur ayant des notions élémentaires de mathématiques.
L'élément de base du langage est le theorem, qui est la plus petite unité logicielle qui puisse être exécutée indépendamment.
5.2.1 Types de bases et ensembles pré-dé nis
Pour pouvoir interroger le modèle sur lequel les contraintes sont dé nies, REAL utilise des ensembles pré-dé nis correspondant aux catégories de composant AADL : thread, process,
data, bus, etc. Certains éléments AADL qui ne sont pas des composants sont également présents dans les ensembles, tels que les ots d'exécution et les connexions. Ces ensembles pré-dé nis contiendront tous les composants de la catégorie correspondante instanciée dans le modèle AADL. Le paramétrage du théorème permet également de dé nir des ensembles ne contenant que les instances d'un composant particulier (cf.5.2.5).
Si certaines requètes portent sur les ensembles eux-même (c'est-à-dire sur leur cardinalité), la plupart vont véri er des propriétés sur leurs ensembles, éventuellement en les associant dans des fonctions de type somme, maximum, produit, etc. Pour pouvoir accéder aux propriétés des éléments AADL, on peut appliquer la fonction get_property_value sur l'ensemble ciblé, qui va retourner la valeur de chaque élément de l'ensemble sous la forme d'une liste.
Un autre ensemble particulier est l'ensemble local_set. Son contenu varie selon la façon dont le théorème REAL a été appelé (cf. 5.3). Son contenu est nommé le domaine du théorème. Au nombre des valeurs qui peuvent être supportées (donc retournées par get_property_value), nous avons tous les types de bases (booléens, entiers, réels, chaines de caractère), mais également les couples et les listes. Les autres types valides dans la seconde version de AADL, tels que les tableaux et les records, ne sont pas supportés dans la version actuelle de REAL.
5.2.2 Theorem et dé nition de la portée
Le theorem doit être véri é sur tous les élements d'un ensemble particulier, nommé range set. La veri cation expression va spéci er une formule qui doit être véri ée pour l'élément courant du range set, accessible à chaque itération grâce à la range variable, associée au range set lors de sa déclaration.
theorem r m a _ s c h e d u l a b i l i t y foreach p i n Processor_Set do
Listing 5.1 Déclaration d'ensemble de portée
Dans le listing 5.1, la range variable est nommé p, et le range set qui lui est lié vaut Processor_Set, lequel est l'ensemble canonique contenant toutes les instances de processeurs présentes dans le modèle AADL.
5.2.3 Construction des ensembles et variables
Ensembles intermédiaires
L'ensemble des ensembles accessibles par le range set et les ensembles pré-dé nis sont li- mités. Pour pouvoir décrire des ensembles plus ns, REAL permet de dé nir des ensembles intermédiaires, formés à partir d'un sur-ensemble de façon similaire aux jointures SQL : dans l'ensemble intermédiaire nal se trouveront tous les éléments des sur-ensembles véri ant une ex- pression donnée. Cette expression peut contenir les mêmes fonctions élémentaires que l'expression de véri cation.
Formellement, une dé nition d'ensemble est décrite par :
S := {x in E | f(x)}, où x est la variable associée successivement à chaque élément du sur- ensemble E, lui-même dé ni par une expression sur les ensembles, et pouvant faire référence à tous les ensembles dé nis précédement dans le théorème ainsi qu'aux ensembles pré-dé nis. '|'
5.2. Structure de REAL est l'abbréviation pour tel que, et f(x) une expression à valeur booléenne. x sera compris dans l'ensemble S si et seulement si f est vraie pour la valeur x.
L'expression f peut contenir un type particulier de fonction, nommées fonctions prédicats, qui servent à exprimer une relation hiérarchique entre deux éléments du modèle AADL, comme par exemple la relation A est sous-composant de B ou encore A est connecté à B. Les fonctions prédicats permettent de retrouver les informations contenues dans la hiérarchisation du modèle.
theorem r m a _ s c h e d u l a b i l i t y foreach p i n Processor_Set do
S1 := { pr i n Process_Set | ( is_bound_to ( pr , p ) ) } ;
S2 := { th i n Thread_Set | ( is_subcomponent_of ( th , S1 ) ) } ;
Listing 5.2 Déclaration d'un ensemble intermédiaire
Dans le listing 5.2, nous dé nissons un ensemble nommé S1, dé ni comme contenant les éléments du sur-ensemble formé par Process_Set qui véri ent le prédicat is_bound_to avec l'élément de portée courant. L'ensemble S1 contiendra donc après construction les instances de processus référencés par la propriété standard AADL actual_processor_binding dont la valeur sera l'élément courant de l'ensemble de portée. Dit plus simplement, tous les processus s'éxécutant sur ce processeur.
Nous dé nissons également un second ensemble S2 qui est dé ni sur le sur-ensemble Thread_Set, comme contenant les éléments véri ant le prédicat is_subcomponent_of avec l'en- semble S1 c'est-à-dire l'ensemble des instances de threads étant un sous-composant de au moins une des instances de processus présentes dans S1.
Dé nitions de variables
Pour simpli er les expressions et limiter le nombre de calculs, il est possible de dé nir des variables (d'un type supporté par REAL) de la même manière que l'on dé nit des ensembles.
Il existe deux manières de dé nir des variables : soit en leur associant une expression (dont le type de retour va dé nir le type de la variable), soit en leur associant un sous-théorème (cf.
5.2.5).
La portée d'une variable, comme d'un ensemble intermédiaire, est normalement limitée au théorème courant, à l'exclusion de la partie précédant sa déclaration. Cependant, une variable peut être déclarée comme global, auquel cas sa portée s'étend aux sous-théorèmes appelés par le théorème courant.
theorem r m a _ s c h e d u l a b i l i t y foreach p i n Processor_Set do
var s t r _ p e r i o d i c := " p e r i o d i c " ; g l o b a l var max_same_period := 1 ;
Listing 5.3 Déclaration d'une variable
Dans le listing 5.3, nous dé nissons une variable str_periodic qui contient une chaine de caractères égale à "periodic". Nous dé nissons ensuite une variable globale max_period_equals, à valeur (implicitement) entière, et égale à 1. Dans ce dernier cas, la variable pourra être référencée dans les sous-théorèmes appelés par le théorème rma_schedulability.
5.2.4 Expressions paramétrées
Les expressions paramétrées permettent de dé nir une expression à appliquer à tous les élé- ments d'un ensemble. Une expression paramétrés va donc indiquer un élément, une variable locale qui contiendra l'élément courant de l'ensemble, et une expression. Cette dernière peut elle-même contenir une expression paramétrée. Selon le type de retour de l'expression, l'expres- sion paramétrée retournera une liste de ce type. Le listing 5.4, qui calcule le maximum des périodes des threads de chaque process multiplié par 2 et divisé par 500, et de leur propriété compute_execution_time, est un exemple d'une telle expression. On remarquera que, dans l'exemple donné, l'expression la plus imbriquée ne dépend pas de l'expression qui la contient. Il est possible que ce soit le cas.
theorem v a r i a b l e s _ i m b r i c a t e d _ i t e r a t i v e _ e x p r e s s i o n s foreach e i n Processor_Set do
Proc_Set ( e ) := {x i n Process_Set | Is_Bound_To ( x , e ) } ;
Threads := {x i n Thread_Set | Is_Subcomponent_Of ( x , Proc_Set ) } ; var y := Max ( Expr ( Threads , t ,
( ( 2 ∗ Max ( Expr ( Threads , p , ( Get_Property_Value ( p , " P e r i o d " ) ) ) ) / 500) + L a s t ( Get_Property_Value ( t , "Compute_Execution_Time " ) ) ) ) ) ; check ( y = 7 . 0 ) ; end v a r i a b l e s _ i m b r i c a t e d _ i t e r a t i v e _ e x p r e s s i o n s ;
Listing 5.4 Expressions paramétrées imbriquées
5.2.5 Appel de sous-théorèmes
Sous-théorèmes et variables
Le calcul de certaines variables ne peut parfois pas être fait avec une simple expression, parce qu'il fait référence à des éléments qui ne peuvent, par exemple, être atteints par les ensembles intermédiaires du théorème courant. Dans ce cas, il est nécessaire d'appeler un sous-théorème grâce au mot-clef compute. Ce théorème peut être paramétré par :
le domaine ;
jusqu'à 10 variables prédé nies (de argv0 à argv9).
Si un domaine n'est pas spéci é, le sous-théorème héritera du domaine du théorème appelant.
theorem r m a _ s c h e d u l a b i l i t y foreach p i n Processor_Set do
S1 := { pr i n Process_Set | ( is_bound_to ( pr , p ) ) } ; S2 := { th i n Thread_Set | ( is_subcomponent_of ( th , S1 ) } ;
S2P := { th i n S1 | ( p r o p e r t y ( th , " d i s p a t c h _ p r o t o c o l ") = " p e r i o d i c " ) } ; var threads_with_same_period := compute same_period ( S2P ) ;
5.2. Structure de REAL
Listing 5.5 Déclaration d'une variable avec sous-théorème
Dans le listing5.5, nous dé nissons une variable threads_with_same_period grâce à l'exé- cution d'un sous-théorème same_period (dé ni en 5.7). Nous lui assignons un domaine spéci- que, ici égal à S2P , un sous-ensemble de S1 (cf5.2) contenant uniquement les threads pério- diques. Dans le cas présent, nous n'avons pas besoin d'assigner de variables en paramètre. Sous-théorèmes requis
Un théorème REAL peut devoir véri er la validité de certaines contraintes pour pouvoir lui-même être véri é. Cette approche permet de rendre les expressions modulaires et facilement réutilisables. Il est possible dans REAL de spéci er une liste de théorèmes (nécessairement boo- léens) à véri er, grâce au mot-clef require. Dans le cas des théorèmes adressés par ce mot-clef, il n'est pas possible pour la version actuelle de REAL d'assigner des paramètres.
5.2.6 Expression de véri cation
L'expression de véri cation teste une expression sur les ensembles et variables dé nies dans le théorème, et ce pour chaque range element. Cette expression peut concerner soit les ensembles eux-mêmes, soit leurs éléments, soit les diérentes valeurs dé nies dans les variables ou calculées à partir d'expressions élémentaires.
On distingue essentiellement trois types de fonctions dans l'expression de véri cation : les fonctions ensemblistes, s'appliquant à des ensembles ou des éléments (eg. cardinal,
get_property_value, is_property_exists, etc.) ;
les fonctions élémentaires, s'appliquant sur des types élémentaires (listes y compris) (eg. sum, max, size, etc.) ;
les fonctions d'agrégat, s'appliquant sur l'ensemble des valeurs calculées pour tous les élé- ments du range set (eg. mmax, msum).
Les fonctions d'agrégats permettent de calculer une valeur sur tous les éléments d'un en- semble, et sont obligatoirement utilisées pour obtenir des résultats non-booléens à un théorème. Typiquement, un théorème appelé grâce au mot-clef compute d'une déclaration de variable de- vra comporter une fonction d'agrégat, tandis qu'un sous-théorème appelé avec require n'en comportera pas. theorem r m a _ s c h e d u l a b i l i t y foreach p i n Processor_Set do S1 := { pr i n Process_Set | ( is_bound_to ( pr , p ) ) } ; S2 := { th i n Thread_Set | ( is_subcomponent_of ( th , S1 ) } ; var s t r _ p e r i o d i c := " p e r i o d i c " ; g l o b a l var max_same_period := 1 ; S2P := { th i n S2 | ( p r o p e r t y ( th , " d i s p a t c h _ p r o t o c o l ") = s t r _ p e r i o d i c ) } ; S2S := { th i n S2 | ( p r o p e r t y ( th , " d i s p a t c h _ p r o t o c o l ") = " s p o r a d i c " ) } ; var threads_with_same_period := compute same_period ( S2P ) ;
( ( threads_with_same_period <= max_same_period ) and ( ( C a r d i n a l ( S2P ) + C a r d i n a l ( S2S ) ) = C a r d i n a l ( S2 ) ) ) ) ; end r m a _ s c h e d u l a b i l i t y ;
Listing 5.6 Expression de véri cation
Le listing 5.6 véri e pour chaque élément de portée (ie. pour chaque processeur instancié) que :
si le protocole d'ordonnancement est RMA alors : chaque thread périodique a une période unique ; un thread est soit périodique, soit sporadique.
Ce théorème terminant par check, il ne retournera qu'une valeur booléenne.
Pour mettre en ÷uvre ce théorème, nous avons fait appel au sous-théorème présenté dans le listing 5.7, et dont l'appel a déjà été présenté en5.5. On notera que ce sous-théorème utilise son domaine (Local_Set) comme ensemble de portée, et pour chaque élément, cherche les threads du domaine ayant la même période. Le théorème retournant une valeur (entière), nous avons dû utiliser la fonction d'agrégat Mmax, qui va retourner la valeur maximale des valeurs calculées par l'expression de véri cation pour chaque valeur successive de la variable de portée.
theorem same_period foreach e i n Local_Set do var p e r i o d := p r o p e r t y ( e , " p e r i o d " ) ; S := { t i n Local_Set | ( p r o p e r t y ( t , " p e r i o d ") = p e r i o d ) } ; r e t u r n (mmax ( c a r d i n a l ( S ) ) ) ; end same_period ;
Listing 5.7 Théorème avec retour