Gestion des interférences

Les interactions logicielles [128] sont des notions parentées aux aspects. Afin de montrer les limi-tations des approches classiques par aspects, nous introduisons de nouveaux concepts tels que : les points d’exécution d’entrée/sortie d’un greffon. Le point d’exécution d’entrée (PEE) d’un greffon constitue le point d’entrée d’un assemblage de composants constituant son greffon. Nous n’en dé-nombrons qu’un seul. Nous définissons les points d’exécution de sortie (PES) d’un greffon comme étant les appels à des services extérieurs au greffon. L’inversion de contrôle n’est effectuée que sur un PEE et le contrôle des PES demeure interne au greffon. Les mécanismes de coordination sont regroupés en deux catégories : arbitrage (subsomption, événements discrets, décision baysien, apprentissage, réseau d’activation) et fusion (logique floue, schémas moteur).

Le problème de superposition appelé aussi interaction d’aspect se décline dans plusieurs disciplines. Dans le domaine des composants logiciels, nous nous intéressons au problème de l’appli-cation simultanée de plusieurs assemblages de composants. Donnons un exemple dans le domaine d’étude des machines parallèles, le problème de superposition se résume par exemple à celui du modèle d’accès simultané à une case mémoire [129].

2.5.3.1 EAOP : Généralisation de la notion de point de coupe

Les premiers travaux de Douence [130] offre trois contributions originales à la détection et la ré-solution de conflits. D’abord, il offre un cadre formel d’expression des points de coupe. Ensuite, il définit deux propriétés générales d’indépendance : l’indépendance forte (points de coupe disjoints entre aspects) et l’indépendance par rapport à un programme (points de coupe disjoints utilisés par le programme). Il fournit l’analyse statique de ces propriétés. Enfin, il propose deux types de com-mandes de résolution de conflits : d’abord, la composition explicite des greffons au même point de

10. se dit de la description programmatique d’une fonctionnalité qui est dispersée dans un programme structuré et qui est partagée par plusieurs encapsulations

jonction (a. séquence, b. sélection d’un unique aspect, c. séquence arbitraire décidée par l’analyseur et le contrôle de la visibilité des aspects entre eux par encapsulation d’aspects.

Avec EAOP, Douence définit une machine à état fini et des priorités pour gérer la superposition des schémas [130]. La plupart des formalisations de la programmation par aspects (calculs mini-maux, sémantiques) prennent en compte des langages d’aspects généraux sur lesquels il est difficile de raisonner. Dans la thèse [131], une approche formelle est adoptée. Les aspects peuvent être en effet vus comme des propriétés sur les traces d’exécution du programme. Son approche a l’avantage de permettre de raisonner à la fois sur l’application de base et sur les aspects. Sa formalisation repose sur les automates pour représenter l’application de base et les aspects. Le tissage est défini comme une composition d’automates et peut être vu comme une restriction du comportement de l’application selon la propriété. Dit autrement, l’aspect spécifie l’ensemble des traces d’exécution autorisées. Ce cadre pour la programmation par aspects a été appliqué à différents domaines dont l’ordonnancement de programmes parallèles.

Les aspects dans ce modèle sont régulatifs : ils ne changent pas les variables de l’application de base et peuvent seulement sélectionner ou couper une trace d’exécution de l’application. C’est une catégorie d’aspects qui garantit que les propriétés, par exemple, de sûreté de l’application de base et les invariants sur les états sont préservés dans l’application tissée. Cette catégorie d’aspects garantit aussi que si le programme tissé termine normalement alors il retourne les mêmes résultats que le programme de base. Cette approche a aussi l’avantage que les interactions entre les aspects sont maîtrisées comme le tissage est associatif et commutatif. Il est possible de construire un aspect représentant les autres aspects en les combinant par produit et de le tisser de la même manière.

Cette approche prend en entrée un programme et un aspect, et produit automatiquement un programme tissé respectant l’aspect. La composition se fait automatiquement par produit des au-tomates. Par exemple, le premier automate permet de reconnaître les mots ddacabc et abcabc. Le second automate permet de reconnaître les mots ccab et abcabc. Le produit des deux automates permet de reconnaître uniquement le mot abcabc parmi les mots ci-dessus. Ces travaux sont appli-cables en effet pour une catégorie spécifique des aspects. Il ne permet cependant pas de traiter les aspects dans leur généralité.

EAOP offre trois contributions originales à la détection des conflits. D’abord, il définit l’aspect en termes de ticks provenant de l’exécution de l’application. Ensuite, il propose des points de coupe rattachés à des séquences de ticks avec ou sans sauvegarde d’un état. Enfin, il associe une action à la détection d’un point de coupe.

2.5.3.2 ISL : interactions en environnement distribué, compilé et typé

Dans un modèle orienté objet, les interactions logicielles [30] modélisent les interactions entre ap-pels de méthodes entre différents modules d’un programme logiciel. ISL (sigle signifiant Interaction Specification Language – langage de spécifications d’interactions) est un langage de spécification d’interactions entre des objets logiciels. Il a été développé en 2001 par Berger au laboratoire I3S et permet de fusionner des spécifications écrites dans ce langage afin de modifier la structure de programmes orientés objet. Un appel de méthode est la transmission d’un flot de contrôle entre objets accompagnée d’un passage par paramètre de données. Cette étude sur les interactions

logiciellesconcerne l’ajout de nouvelles fonctionnalités en terme de réécriture de réception

d’ap-pel de méthodes. Ces ajouts s’effectuent au cours de l’exécution de l’application, par conséquent, lors de l’ajout de nouvelles fonctionnalités, de manière sûre. L’étude de la sûreté de l’application lors de l’ajout de ces fonctionnalités a été réalisée dans [132] consistant à vérifier que les modifications se font en respectant l’état de l’application. Nous ne traitons pas de la sécurité des interactions dans cette thèse, mais nous étudions les mécanismes permettant de reconfigurer un plus large spectre d’applications au cours de leur exécution en recherchant les mécanismes essentiels de la reconfigu-ration dynamique.

En résumé, l’objectif général du travail de Berger était de faciliter “l’adaptabilité dynamique des codes” pour des applications logicielles complexes telles que les frameworks et les applications réparties. L’adaptabilité dynamique consiste à ajouter et enlever dynamiquement des contrôles dans le but d’accomplir une adaptation fonctionnelle. En prenant l’exemple typique de l’agenda, nous pouvons associer l’adaptation fonctionnelle à l’exemple de l’ajout de la fonctionnalité d’authen-tification à la communication entre deux agendas différents. La solution traditionnelle consiste à analyser le problème et mettre en œuvre une solution à travers l’utilisation de design patterns, de méta-programmation, d’AOP (Event service, RelationShip Service, DII, Interceptors, Bus reflexif). Les interactions se retrouvent enfouies dans le code de l’application. Ainsi, la solution de L. Berger consiste à faire émerger dans des fichiers extérieurs au code ces interactions. Il propose la mise en place d’un langage de spécification d’interactions (ISL) pour cette occasion. Ainsi pour reprendre l’exemple de l’agenda, deux interactions peuvent être définies pour les deux agendas de la manière suivante :

agenda1.addRendezVous(rdv) −>

call; if rdv.concerne(P) then agenta2.addRendezVous(rdv) endif

Figure 2.6 – Agenda

Cette première interaction spécifie qu’au lieu d’effectuer le comportement originel de la méthode add de l’objet Ag1, nous effectuons plutôt séquentiellement l’action d’ajouter un rendez-vous Ardv sur un certain agenda Ag1 et puis celle de vérifier si le rendez-vous (Ardv) concerne bien la personne (P) et si tel est le cas, alors le rendez-vous est également ajouté à l’agenda Ag2.

agenda.addRendezVous(rdv) −> if controleur.accept() then call endif agenda.setPasswd() −> key.setPasswd()

Figure 2.7 – Agenda avec mot de passe

Dans l’exemple précédent, nous retrouvons deux règles d’interaction. La première règle signifie que le comportement de la méthode add de l’objet agenda est réécrit de la manière suivante : si le contrôleur d’accès C l’accepte, alors nous ajoutons le rendez-vous (Ardv) dans l’agenda. La deuxième règle redéfinit le comportement de la méthode setPasswd de l’objet Agenda en spécifiant d’appeler plutôt cette même méthode sur l’objet Key. Ces règles d’interactions sont regroupées dans un schéma d’interaction qui a l’allure suivante :

Interaction teamDiary2Diary(Diary TD, Diary D, Person P) { TD.addRendezVous(RDV aMeeting) −>

call ; if aMeeting.concern(P) then try { D.addRendezVous(aMeeting) }

catch NotFree { TD.removeRendezVous(aMeeting) } end if,

D.addRendezVous(RDV aMeeting) −> call || if not TD.contains(aMeeting) then

TD.notify(aMeeting) end if

}

ISL offre six contributions originales. D’abord, il définit un langage spécifique pour décrire les interactions c’est-à-dire les relations entre les entités logicielles. Ensuite, il définit la notion de schémas d’interaction qui sont des descriptions des comportements réactifs d’un ensemble d’interactions et les interactions sont dissociées des classes et des objets. Ensuite, il permet la modification des interactions à l’exécution de l’application. Ensuite, il définit la notion de dépôt de schémas d’interactions. Enfin, il permet l’envoi dynamique de messages pour des environnements compilés et fortement typés. Enfin, il conserve la sémantique par combinaison des comportements réactifs indépendants. C’est la fusion comportementale.

2.5.4 Autres approches

Dans les sections précédentes, nous avons présenté les modèles pour l’adaptation logicielle propo-sant des apports différents en termes d’architecture. Cette section présente les spécificités d’autres modèles méritant d’être soulignées.

Plates-formes

Bockish [133] offre une contribution originale à l’approche aspect. Il permet (1) la construction d’un méta modèle (ensemble de concepts) existant à l’exécution de l’application, (2) de conserver la notion d’aspect et (3) l’application des optimisations déjà existantes mais statiques lors du tissage d’aspects pendant l’exécution de l’application.

Ubayashi [134] offre une contribution originale à l’approche aspect en séparant l’interface d’un aspect (weaving interface) de l’implémentation d’un aspect afin de simplifier la composition des aspects sans se soucier de son implémentation.

Les travaux autour de Caesar [135] proposent une approche en découplant l’interface de l’implé-mentation des aspects. Un aspect devient un composant que l’on assemble. D’autres travaux comme ceux sur FuseJ [136] et Hyper/J [137] proposent une unification naturelle d’aspect et de composant. Ils l’appellent approche symétrique. Plusieurs travaux proposent l’application de l’AOP mais sans prendre en compte la décomposition dominante avec les composants [138, 135]. Enfin, certains proposent de conserver une trace de l’abstraction des aspects en intégrant deux intructions sup-plémentaires à l’exécution : l’association et la dissociation de pattern de point de jonction (ex : bytecode) dans Nu [139]. D’autres proposent un métamodèle comme Reflex [140] pour structurer l’adaptation par aspect.

COOL et RIDL ont été proposés dans l’article de Lopes et al. [141]. Dans ce travail, une application distribuée est constituée d’un ensemble d’objets distribués et concurrents qui communiquent par des appels à leurs méthodes partagées. Ces deux langages d’aspect dédiés facilitent le développe-ment des systèmes distribués en séparant le code de base de l’application, qui est décrit dans un langage restreint sans instruction pour gérer les préoccupations transverses liées au cadre distribué. Le langage COOL permet au programmeur d’exprimer la coordination entre les différents processus en spécifiant les contraintes pour appeler les méthodes partagées. Ce langage permet de spécifier les exclusions entre les différents appels de méthodes avec les deux constructions dédiées self-exclusif et mut-exclusif. Le langage RIDL fournit les moyens de paramétrer pour chaque méthode la ma-nière dont les données (arguments des méthodes) sont effectivement transmises (par copie ou par référence). Par comparaison, le langage Java permet de définir pour chaque classe comment les at-tributs sont effectivement transmis (référence ou copie) ; il est possible d’avoir une spécification par méthode, mais de manière transverse et ad hoc (en décrivant plusieurs classes héritées fictives, et en spécifiant pour chacune de ces classes la façon de la transmettre, puis en forçant le type de l’ob-jet). Chaque méthode inclue dans l’ensemble “selfexclusif” ne peut pas être exécutée par plusieurs processus en même temps. Les méthodes appartenant au même ensemble “mutexclusif” ne peuvent pas être exécutées en concurrence. Ce langage permet aussi de décrire des conditions qui bloquent

l’entrée dans une méthode tant qu’elles ne sont pas respectées. Ces conditions sont spécifiées par la construction require et reposent sur des variables qui définissent l’état de synchronisation de l’objet. Les évolutions de l’état de synchronisation sont uniquement possible en entrée ou en sortie d’une méthode, et sont décrites par les constructions on entry et on exit. Une autre difficulté dans les programmes distribues réside dans la transmission des paramètres lors d’un appel de méthode. Les solutions triviales de transmettre la référence de l’objet ou une copie complète de l’objet sont inefficaces.

Nous pouvons citer le langage unifié pour l’adaptation et l’AOP/DAJ [142] : c’est une exten-sion d’AspectJ afin d’intégrer les concepts de Demeter (diagramme de classes, stratégie, visiteur) pour enrichir les mécanismes d’adaptation logicielle. Enfin, Lämmel [143] propose d’améliorer la programmation générique en apportant une modélisation par stratégies qui sépare deux préoccu-pations de l’application : les données et le contrôle qu’il regroupe dans deux ensembles d’aspects disjoints.

Gestion des interférences

Au niveau de la gestion des interférences, les travaux de Moreira [144] reposent sur un modèle orienté préoccupation. Ensuite, la détection de conflit direct entre aspects est effectuée par Tessier [145]. Enfin, d’autres proposent l’ajout d’annotations d’aspect pour la détection de conflits [146]. Zambrano [147] travaille sur les interférences entre les aspects qui ne sont pas d’ordre syntaxique. Il donne les exemples tels que la minimisation de l’utilisation de la mémoire par rapport à l’optimisa-tion de la batterie. En effet, il n’y a aucun point de joncl’optimisa-tion en commun entre ces aspects mais ils sont quand même en conflit. Il appelle cela des conflits de comportement inconsistant, faisant ainsi écho à la taxonomie de Tessier et al. [145]. Ce que l’on retient c’est la manière dont Zambrano pose des étiquettes sous la forme de méta-données sur un aspect. Cela permet d’abstraire l’étiquette de l’aspect. Il offre ainsi deux contributions originales à la détection de conflits. D’abord, il permet l’étiquetage sous la forme d’ajout de métadonnées aux aspect. Ensuite, il définit un coordinateur qui scrute des ressources et active ou désactive des aspects selon les informations indiquées par les étiquettes.

2.5.5 Synthèse et conclusion

Bockish [133] propose la construction d’un méta modèle de l’application en conservant la notion d’aspect à l’exécution. Des optimisations lors du tissage d’aspects peut alors se faire pendant l’exé-cution de l’application. FAC [122] définit un aspect encapsulé dans un composant logiciel et un ordre d’exécution des greffons au niveau de chaque point de jonction. Ensuite, il rend possible l’extraction des préoccupations transverses. Enfin, la sûreté de l’intégration des aspects par le contrôle des as-pects agissant sur un point de jonction par une interface particulière de tissage peut être mise en place. Safran ajoute deux sous-systèmes au modèle à composants : un langage de script pour re-configurer l’application, un toolkit pour observer le contexte de l’application. Ensuite, il propose un contrôleur d’adaptation connectant ces deux entités paramétrables par des règles ECA (événements détectés par WildCat et les actions entreprises par FScript). Ubayashi offre une contribution origi-nale permettant la séparation de l’interface d’un aspect (weaving interface) et de l’implémentation d’un aspect afin de simplifier la composition des aspects sans se soucier de son implémentation.

Au niveau de la détection de conflit, EAOP définit l’aspect en termes de ticks provenant de l’exécution de l’application. Il associe une action à la détection d’un point de coupe. ISL définit un langage spécifique pour décrire les interactions (relations entre les entités logicielles). Ensuite, il définit la notion de schémas d’interaction (description des comportements réactifs d’un ensemble d’interactions) et les interactions sont dissociées des classes et des objets. Ensuite, il permet la modification des interactions à l’exécution de l’application. Ensuite, il définit la notion de dépôt de schémas d’interactions. Enfin, il permet l’envoi dynamique de messages pour des environnements compilés et fortement typés. Enfin, il conserve la sémantique par combinaison des comportements réactifs indépendants. C’est la fusion comportementale. Zambrano permet l’étiquetage sous la forme

d’ajout de métadonnées aux aspects et définit un coordinateur qui scrute des ressources et active ou désactive des aspects selon les informations indiquées par les étiquettes.

Nous allons, dans le chapitre suivant, faire une synthèse de toutes les approches que nous avons vues dans cet état de l’art pour en dégager les problématiques non résolues sur lesquelles s’appuie notre travail.

Chapitre 3

Synthèse générale et objectifs

Sommaire

3.1 Les contraintes de l’IAm . . . 68 3.1.1 Grande diversité des dispositifs . . . 69 3.1.2 Un espace ambiant intrinsèquement réactif . . . 70 3.2 Besoins en adaptation logicielle . . . 71 3.2.1 L’adaptation et l’IAm . . . 71 3.2.2 De l’adaptabilité à l’adaptativité . . . 72 3.3 Synthèse et critique de l’existant . . . 74 3.3.1 Principes de la littérature . . . 74 Synthèse . . . 74 Problèmes liés à l’IAm . . . 75 3.3.2 Principes de notre approche . . . 75 Prise en compte des dispositifs blackbox . . . 75 Communication événementielle . . . 75 Modularité transverse à son paroxysme . . . 75 3.4 Notre approche . . . 76 3.4.1 Modèle de service composite . . . 76 3.4.2 Modèle de composant . . . 76 3.4.3 Modèle d’adaptativité transverse . . . 77

Dans notre environnement quotidien, nous voyons émerger des environnements constellés de dispositifs : capteurs, actionneurs, services. Ces dispositifs sont à priori indépendants, mais pourtant connectés les uns aux autres. On les qualifie parfois d’intelligents, car ils peuvent être impliqués dans des cas d’utilisations multiples : assistance, contrôle à distance des équipements, gestion du confort par le réglage automatique du chauffage en fonction de la température ambiante. Cette nouvelle façon de combiner les dispositifs et les applications a donné naissance à l’intelligence

ambiante(page 11).

Le chapitre 2 explique les raisons pour lesquelles l’intelligence ambiante implique une technique de programmation différente de celles utilisées en informatique classique. En effet, les applications qui vont être exécutées à un instant donné vont être dynamiquement construites. Ensuite, les dispositifs physiques utilisés pour une application donnée peuvent être de nature différente, tout en fournissant une fonctionnalité équivalente. Enfin, le fait que tous ces systèmes doivent pouvoir fonctionner en situation réelle impose des contraintes sur l’économie d’énergie, la longévité des systèmes, etc, et justifie les configurations diverses autour d’une application principale.

La recherche en informatique ambiante a donc pour objectif de faciliter la mise en œuvre de tels systèmes et de fournir un modèle d’adaptation logicielle en prenant en compte ses contraintes.

3.1 Les contraintes de l’IAm

Nous dressons dans cette section un récapitulatif des différents enjeux en informatique ambiante. Un système informatique ambiant évolue dans un espace ambiant constitué d’une infrastructure de dispositifs et de l’environnement physique comprenant les utilisateurs, les objets de la vie de tous les jours, etc. Cet espace ambiant est caractérisé par deux grandes notions [148] : l’hétérogénéité des dispositifs et la variation permanente de l’infrastructure de dispositifs.

Figure 3.1 – Architecture des systèmes IAm

Hétérogénéité des dispositifs : Les utilisateurs interagissent avec les applications Internet

à travers une variété de dispositifs dont les caractéristiques et les performances ont pu passer à l’échelle. Entre un PC très performant, un téléphone mobile et un PDA, les variations de la bande passante, la puissance de calcul local, les dimensions de l’écran, la capacité à afficher des couleurs sont extrêmement différents. Il était difficile de prévoir qu’un serveur puisse offrir un niveau d’accès aussi large et adapté à chaque client. Toutefois, imposer un format uniforme pour tous les clients

serait restreindre leurs fonctionnalités en les ramenant à un niveau commun (écrans textuels, noir et blanc, etc.).

Composants blackbox : Les anciennes applications (patrimoniales), par exemple, ne peuvent

être utilisées qu’à travers leur interface spécifique et ne peuvent pas être modifiées. Dans plusieurs cas, le coût de la conception et de la réécriture d’une application patrimoniale est onéreux et ces applications ont besoin d’être intégrées sans modification.

Dynamiques propres à l’espace ambiant : L’application en informatique ambiante s’adapte

aux variations permanentes de l’espace ambiant. Deux caractéristiques peuvent être déduites de