La simulation informatique est un outil incontournable dans les sciences exp��rimentales. La puissance de calcul croissante des ordinateurs associ��e au parall��lisme et aux avanc��es dans la mod��lisation math��matique des ph��nom��nes physiques permet de r��aliser virtuellement des exp��riences de plus en plus complexes. De plus, l'��mergence de la programmation GPU a consid��rablement accru la qualit�� et la rapidit�� de l'affichage. Ceci a permis de d��mocratiser la visualisation sous forme graphique des r��sultats de simulation. La visualisation scientifique peut ��tre passive : l'utilisateur peut suivre l'��volution de la simulation ou bien observer ses r��sultats apr��s que le calcul soit termin��. Elle peut aussi ��tre interactive lorsque le chercheur peut agir sur la simulation alors qu'elle se d��roule. Cr��er de telles applications complexes n'est cependant pas �� la port��e de tout scientifique non informaticien. La programmation par composants est, depuis des ann��es, mise en avant comme une solution �� ce probl��me. Elle consiste �� construire des applications en interconnectant des programmes ex��cutant des t��ches ��l��mentaires. Ce m��moire pr��sente un mod��le de composants et une m��thode de composition d'applications de visualisation scientifique interactive. Elle s'int��resse, en particulier, �� la conciliation de deux contraintes majeures dans la coordination de ces applications : la performance et la coh��rence.

La simulation informatique est un outil incontournable dans les sciences expérimentales. La puissance de calcul croissante des ordinateurs associée au parallélisme et aux avancées dans la modélisation mathématique des phénomènes physiques permet de réaliser virtuellement des expériences de plus en plus complexes. De plus, l'émergence de la programmation GPU a considérablement accru la qualité et la rapidité de l'affichage. Ceci a permis de démocratiser la visualisation sous forme graphique des résultats de simulation. La visualisation scientifique peut être passive : l'utilisateur peut suivre l'évolution de la simulation ou bien observer ses résultats après que le calcul soit terminé. Elle peut aussi être interactive lorsque le chercheur peut agir sur la simulation alors qu'elle se déroule. Créer de telles applications complexes n'est cependant pas à la portée de tout scientifique non informaticien. La programmation par composants est, depuis des années, mise en avant comme une solution à ce problème. Elle consiste à construire des applications en interconnectant des programmes exécutant des tâches élémentaires. Ce mémoire présente un modèle de composants et une méthode de composition d'applications de visualisation scientifique interactive. Elle s'intéresse, en particulier, à la conciliation de deux contraintes majeures dans la coordination de ces applications : la performance et la cohérence.

Depuis la fin des années 1990, le développement des terminaux nomades et des réseaux sans fil s'est considérablement accéléré. Cela a provoqué l'apparition de nouvelles applications, très largement réparties, et offrant de nouveaux services, aussi bien aux usagers (applications de commerce électronique, télévision interactive, applications de proximité), qu'aux entreprises (développement du commerce B2B).<br /><br /> Avec l'apparition de ces nouvelles applications, les services techniques, qui prennent en charge un certain nombre de contraintes systèmes, ont également dû évoluer. Nos travaux ont principalement porté sur l'étude de mécanismes permettant de concevoir des services techniques adaptés à ces nouvelles applications. Cela a été réalisé en trois phases :<br />− Dans un premier temps, nous avons étudié la possibilité d'utiliser le modèle de programmation par composants, pour réaliser un service de gestion de transactions distribuées offrant la possibilité d'utiliser le modèle de transactions emboîtées ouvertes (ce modèle transactionnel étant très intéressant dans le cadre des applications de commerce B2B).<br />− Puis, nous avons généralisé le mécanisme de réalisation des services techniques en utilisant le modèle à composants, de manière à pouvoir facilement faire évoluer ces services aux travers de différentes "personnalités". Dans le cadre de ce travail, nous avons également proposé une architecture permettant de choisir la bonne personnalité du service technique, en fonction des besoins applicatifs, et des contraintes de l'environnement d'exécution.<br />− Enfin, nous avons proposé un service de requêtes dépendantes de la localisation de l'utilisateur, pour applications de proximité. Ce service, utilisant une localisation approchée d'un utilisateur, propose de retrouver des informations, dans un environnement dynamique formé de plusieurs terminaux nomades, capables de capacité de communication.

La simulation informatique est un outil incontournable dans les sciences expérimentales. La puissance de calcul croissante des ordinateurs associée au parallélisme et aux avancées dans la modélisation mathématique des phénomènes physiques permet de réaliser virtuellement des expériences de plus en plus complexes. De plus, l'émergence de la programmation GPU a considérablement accru la qualité et la rapidité de l'affichage. Ceci a permis de démocratiser la visualisation sous forme graphique des résultats de simulation. La visualisation scientifique peut être passive : l'utilisateur peut suivre l'évolution de la simulation ou bien observer ses résultats après que le calcul soit terminé. Elle peut aussi être interactive lorsque le chercheur peut agir sur la simulation alors qu'elle se déroule. Créer de telles applications complexes n'est cependant pas à la portée de tout scientifique non informaticien. La programmation par composants est, depuis des années, mise en avant comme une solution à ce problème. Elle consiste à construire des applications en interconnectant des programmes exécutant des tâches élémentaires. Ce mémoire présente un modèle de composants et une méthode de composition d'applications de visualisation scientifique interactive. Elle s'intéresse, en particulier, à la conciliation de deux contraintes majeures dans la coordination de ces applications : la performance et la cohérence. / Computer simulation is an essential tool in experimental sciences. The increasing computing power, parallelism and the advances in the mathematical modeling of physical phenomena allow to virtually run always more complex experiments. In addition, the rise of GPU programming has greatly increased the quality and performance of display. This has allowed to spread the graphical visualization of simulation results. Scientific visualization can be passive: the user can only follow the simulation's progress or observe its results when it is done. It can also be interactive in which case the researcher can act on the simulation while it is running. Creating such complex applications can, however, be tedious for non-computer-scientists. Component-based development is, for years, highlighted as a solution to this problem. It consists in building applications by interconnecting small programs completing elementary tasks. This thesis presents a component model and a method for composing interactive scientific visualization applications. It particularly focuses on the balance between two major constraints of these applications: performance and coherence.

L'objectif de cette thèse est de faciliter la conception et le déploiement d'applications distribuées sur la Grille, en utilisant une approche orientée composants. Les problématiques du calcul sur grilles abordées dans notre proposition sont : la complexité de conception, le déploiement, la flexibilité et la performance. Nous proposons et justifions un modèle de composants et son implantation. Le modèle proposé repose sur le modèle de composants Fractal et sur le modèle des objets actifs. Il bénéficie d'une part, de la structure hiérarchique et de la définition précise du modèle Fractal, et d'autre part, de l'identification des composants comme activités configurables. Nous proposons un modèle de déploiement et nous spécifions un ensemble de primitives pour les communications collectives, grâce à la définition d'interfaces collectives. Les interfaces collectives permettent de gérer la distribution des données, le parallélisme et la synchronisation des invocations.<br />Nous avons développé une implantation du modèle proposé avec l'intergiciel de grille ProActive. Le framework de composants bénéficie ainsi des fonctionnalités sous-jacentes offertes par l'intergiciel ProActive. Nous démontrons la capacité de passage à l'échelle et l'efficacité de notre framework en déployant sur plusieurs centaines de machines des applications intensives en termes de calcul et de communications. Nous mettons à profit les interfaces collectives pour développer une application SPMD à base de composants, dont nous évaluons les performances.

Les logiciels récents sont de plus en plus complexes en terme de leur développement et gestions associés. Pour adresser cette complexité, un approche fondé sur les composant a vu le jour qui vise une meilleure ingénierie des logiciels. En particulier, une approche à composants structure les logiciels comme un assemblage dynamique des composants qui doivent être déployés et gérés à l'exécution, en continu. Pour ce deploiement et cette gestion, nous avons adopté une approche fondée sur une architecture logicielle explicite de composants. Cette approche, communément appelée " gestion basée sur l'architecture ", a évolué de premières solutions ad-hoc vers des infrastructures génériques fondées sur des modèles de composants réflexifs. Une de ces infrastructures est la plateforme JADE. JADE vise à gérer autonomiquement des systèmes distribués complexes. Basé sur un modèle de composants réflexifs, JADE capture l'architecture logicielle complète des systèmes distribués, incluant non seulement les applications distribuées hébergées mais aussi les systèmes distribués qui les hébergent". En particulier, cette architecture réifie en continue certains aspects de l'exécution des systèmes distribués, tels que les défaillances de nœuds ou les caractéristiques de performance. Utilisant cette architecture réifiée, les gestionnaires autonomes observent et réagissent selon les changements de conditions. Chaque réaction de gestionnaires automatiques a pour but de planifier une reconfiguration de l'architecture en réponse à un changement des conditions d'exécution. Par exemple, un gestionnaire d'auto-réparation observant la défaillance d'un nœud aurait pour but de reconstruire, sur un autre nœud, la partie perdue du système distribué. Un gestionnaire d'auto-protection observerait une intrusion et planifierait la reconfiguration du système distribué pour isoler les composants compromis. Un gestionnaire d'auto-optimisation pourrait observer une disponibilité en baisse d'un serveur répliqué et planifier d'augmenter cette réplication cardinale des composants serveurs. Au coeur de cette gestion autonomique fournie par JADE se trouve le déploiement des composants. En effet, la plupart des reconfigurations de l'architecture de systèmes distribués s'appuient sur l'aptitude à instancier des composants sur des nœuds distants. Plus précisément, une fois que les gestionnaires autonomes ont générés un plan de reconfiguration du système distribué, l'exécution effective du plan est automatiquement distribuée, essentiellement par création et suppression de composants ainsi que leur édition de liens. La création et la suppression de composants requièrent une gestion locale des composants sur chaque nœud du système distribué. Cette gestion locale nécessite une infrastructure distribuée pour trouver, installer, charger et supprimer les composants. Le travail présenté dans cette thèse est le socle de JADE, fournissant les capacités de déploiement avancé dans un environnement distribué. En particulier, nous avons traité ce défi via une conception récursive où l'implémentation de composants a été modélisée par des composants. Cette approche fournie un déploiement uniforme qui suit les principes basés sur l'architecture. En particulier, nous pouvons déployer non seulement des composants d'applications mais aussi des composants " middleware ". De plus, au-delà du déploiement de composants normaux, nous pouvons également déployer des logiciels " legacy " qui sont gérés uniformément par JADE. En plus de fournir le socle du déploiement de JADE, ce travail a montré que le modèle de composant réflexif utilisé par JADE (appelé FRACTAL) a besoin d'être étendu pour capter les implémentations et leur spécificité. Bien que conçu spécifiquement pour FRACTAL et JADE, ces extensions présetent une applicabilité bien plus large, elles s'appliquent en effet à la plupart des modèles de composant courant. En effet, la plupart de ces modèles se focalisent sur l'assemblage fonctionnel de composants et ne proposent rien ou peu sur le déploiement des composants. Ce travail a également montré que l'architecture autonomique basée sur l'architecture a des besoins dynamiques spécifiques en terme de déploiement qui rend difficile la ré-utilisation de plateformes existantes pour la gestion dynamique de composants, tels que OSGI. Sur la base d'OSGi, cette thèse a expérimenté plusieurs conceptions et prototypes qui ont été utilisé avec succès, mais dont ultimement les limites sont apparues. Ces limites sont liées à une tension fondamentale entre les conceptions architecturales de JADE et OSGI. Une nouvelle conception et un nouveau prototype ont montré la faisabilité de supporter notre FRACTAL étendu sur la plateforme JAVA, servant de fondation à la gestion autonomique de systèmes distribués complexes fondée sur l'architecture.

L'utilisation d'AOP pour modéliser les préoccupations transverses ou non modulaire de CBSE assure une meilleure modularité et réutilisabilité des composants. Dans ce cadre, nous proposons une approche générique pour modéliser les aspects dans les modèles à composants. Nous modélisons un aspect par un wrapper sur une vue de système. Une vue décrit une configuration adéquate du système où tous les composants dans l'intérêt d'un aspect sont encapsulés dans le même composite. Pour la définition des vues, nous définissons un langage déclaratif VIL. Nous illustrons comment les vues sont mises en œuvre dans des modèles à composants (ex., Fractal), et nous fournissons un modèle formel pour l'analyse des interférences d'aspects. Les composants et les aspects sont modélisés par des automates et Uppaal est utilisé pour détecter les interférences. Pour la résolution d'interférences, nous fournissons un ensemble d'opérateurs de composition. Notre approche est illustrée par un exemple : l'accès wifi dans un aéroport. / Using AOP to model non-modular concerns in CBSE ensures better modularity and reusability of components. In this thesis, we provide a model independent approach for modeling aspects in component models. In the approach we model aspects as wrappers on views of component systems. A view describes an adequate component system configuration where all the components of interest of an aspect are encapsulated in the same composite.For declarative definition of views, we provide a declarative language VIL. We illustrate how views are implemented in component models(e.g., Fractal). We provide a formal framework for aspect interferences analysis. In the framework component systems and aspects are modeled as automata and Uppaal model checker is used for the detection of aspect interferences. For interferences resolution, we provide a set of composition operators as templates to be instantiated for any two arbitrary aspects. Our approach is illustrated with an airport wireless access example.

Cette thèse s'inscrit dans le domaine de l'intelligence ambiante et de l'interaction homme-machine. Elle a pour thème la génération d'interfaces homme-machine adaptées au contexte d'interaction dans les environnements ambiants. Les travaux de recherche présentés traitent des problèmes rencontrés lors de la conception d'IHM dans l'ambiant et notamment de la réutilisation de techniques d'interaction multimodales et multi-périphériques. Ce travail se divise en trois phases. La première est une étude des problématiques de l'IHM spécifiques à l'Ambiant et des architectures logicielles adaptées à ce cadre théorique. Cette étude permet d'établir les limites des approches actuelles et de proposer, dans la seconde phase, une nouvelle approche pour la conception d'IHM ambiante appelée DAME. Cette approche repose sur l'association automatique de composants logiciels qui construisent dynamiquement une IHM. Nous proposons deux modèles complémentaires qui permettent de décrire les caractéristiques ergonomiques et architecturales des composants. La conception de ces derniers est guidée par une architecture logicielle composée de plusieurs couches qui permet d'identifier les différents niveaux d'abstraction réutilisables d'un langage d'interaction. Un troisième modèle, appelé modèle comportemental, permet de spécifier des recommandations quant à l'instanciation de ces composants. Nous proposons un algorithme permettant de générer des IHM adaptées au contexte et d'évaluer la qualité de celles-ci par rapport aux recommandations du modèle comportemental. Dans la troisième phase, nous avons implémenté une plateforme réalisant la vision soutenue par DAME. Cette implémentation est confrontée aux utilisateurs finaux dans une expérience de validation qualitative. De ces travaux ressortent des résultats encourageants, ouvrant la discussion sur de nouvelles perspectives de recherche dans le cadre de l'IHM en informatique ambiante.

Les plates-formes MPSoC permettent de satisfaire les contraintes de performance, de flexibilité et de consommation énergétique requises par les systèmes embarqués émergents. Elles intègrent un nombre important de processeurs, des blocs de mémoire et des périphériques, hiérarchiquement organisés par un réseau d'interconnexion. Le développement du logiciel est réputé difficile, notamment dû à la gestion d'un grand nombre d'entités (tâches/threads/processus). L'exécution concurrente de ces entités permet d'exploiter efficacement l'architecture mais complexifie le processus de mise au point et notamment l'analyse des erreurs. D'une part, les exécutions peuvent être non-déterministes notamment dû à la concurrence, c'est à dire qu'elles peuvent se dérouler d'une manière différente à chaque reprise. En conséquence, il n'est pas garanti qu'une erreur se produirait durant la phase de mise au point. D'autre part, la complexité de l'architecture et de l'exécution peut rendre trop important le nombre d'éléments à analyser afin d'identifier une erreur. Il pourrait donc être difficile de se focaliser sur des éléments potentiellement fautifs. Un des défis majeurs du développement logiciel MPSoC est donc de réduire le temps de la mise au point. Dans cette thèse, nous proposons une méthodologie de mise au point qui aide le développeur à identifier les erreurs dans le logiciel MPSoC. Notre premier objectif est de déboguer une même exécution plusieurs fois afin d'analyser des sources potentielles de l'erreur jusqu'à son identification. Nous avons donc identifié les sources de non-déterminisme MPSoC et proposé des mécanismes de ré-exécution déterministe les plus adaptés. Notre deuxième objectif vise à minimiser les ressources pour reproduire une exécution afin de satisfaire la contrainte MPSoC de maîtrise de l'intrusion. Nous avons donc utilisé des mécanismes efficaces de ré-exécution déterministe et considéré qu'une partie du comportement non-déterministe. Le troisième objectif est de permettre le passage à l'échelle, c'est à dire de déboguer des exécutions caractérisées par un nombre d'éléments de plus en plus croissant. Nous avons donc proposé une méthode qui permet de circonscrire et de déboguer qu'une partie de l'exécution. De plus, cette méthode s'applique aux différents types d'architectures et d'applications MPSoC. / MPSoC platforms provide high performance, low power consumption and flexi-bility required by the emerging embedded systems. They incorporate many proces-sing units, memory blocs and peripherals, hierarchically organized by interconnec-tion network. The software development is known to be difficult, namely due to themanagement of multiple entities (tasks/threads/processes). The concurrent execu-tion of these entities allows to exploit efficiently the architecture but complicatesthe refinement process of the software and especially the debugging activity. Onthe one hand, the executions of the software can be non-deterministic, namely dueto the concurrency, i.e. they perform differently each time. Consequently, thereis no guaranties that an error will occur during the debugging activity. On theother hand, the complexity of the architecture and the execution can increase theelements to be analyzed in the debugging process. As a result, it can be difficultto concentrate on the potentially faulty elements. Therefore, one of the most im-portant challenges in the development process of MPSoC software is to reduce thetime of the refinement process.In this thesis, we propose a new methodology to refine the MPSoC softwarewhich helps the developers to do the debugging activity. Our first objective is tobe able to debug the same execution several times in order to analyze potentialsources of the error. To do so, we identified the sources of non-determinism in theMPSoC software executions and propose the most appropriate methods to recordand replay them. Our second objective is to reduce the execution overhead requi-red by the record mechanisms to limit the intrusiveness which is an importantMPSoC constraint. To accomplish this objective, we consider a part of the non-deterministic behaviour and selected efficient record-replay methods. The thirdobjective is to provide a scalable solution, i.e. to be able to debug more and morecomplex executions, characterized by an increasing number of elements. Therefore,we propose a partial replay method which allows to isolate and debug a fraction ofthe execution elements. Moreover, this method applies to different types of archi-tectures and applications MPSoC.

Cette thèse s’inscrit dans le domaine de l’intelligence ambiante et de l’interaction homme-machine. Elle a pour thème la génération d’interfaces homme-machine adaptées au contexte d’interaction dans les environnements ambiants. Les travaux de recherche présentés traitent des problèmes rencontrés lors de la conception d’IHM dans l'ambiant et notamment de la réutilisation de techniques d’interaction multimodales et multi-périphériques. Ce travail se divise en trois phases. La première est une étude des problématiques de l’IHM spécifiques à l’Ambiant et des architectures logicielles adaptées à ce cadre théorique. Cette étude permet d’établir les limites des approches actuelles et de proposer, dans la seconde phase, une nouvelle approche pour la conception d’IHM ambiante appelée DAME. Cette approche repose sur l’association automatique de composants logiciels qui construisent dynamiquement une IHM. Nous proposons deux modèles complémentaires qui permettent de décrire les caractéristiques ergonomiques et architecturales des composants. La conception de ces derniers est guidée par une architecture logicielle composée de plusieurs couches qui permet d’identifier les différents niveaux d’abstraction réutilisables d’un langage d’interaction. Un troisième modèle, appelé modèle comportemental, permet de spécifier des recommandations quant à l’instanciation de ces composants. Nous proposons un algorithme permettant de générer des IHM adaptées au contexte et d’évaluer la qualité de celles-ci par rapport aux recommandations du modèle comportemental. Dans la troisième phase, nous avons implémenté une plateforme réalisant la vision soutenue par DAME. Cette implémentation est confrontée aux utilisateurs finaux dans une expérience de validation qualitative. De ces travaux ressortent des résultats encourageants, ouvrant la discussion sur de nouvelles perspectives de recherche dans le cadre de l’IHM en informatique ambiante. / This thesis deals with ambient intelligence and the design of Human-Computer Interaction (HCI). It studies the automatic generation of user interfaces that are adapted to the interaction context in ambient environments. This problem raises design issues that are specific to ambient HCI, particularly in the reuse of multimodal and multidevice interaction techniques. The present work falls into three parts. The first part is an analysis of state-of-the-art software architectures designed to solve those issues. This analysis outlines the limits of current approaches and enables us to propose, in the second part, a new approach for the design of ambient HCI called DAME. This approach relies on the automatic and dynamic association of software components that build a user interface. We propose and define two complementary models that allow the description of ergonomic and architectural properties of the software components. The design of such components is organized in a layered architecture that identifies reusable levels of abstraction of an interaction language. A third model, called behavioural model, allows the specification of recommendations about the runtime instantiation of components. We propose an algorithm that allows the generation of context-adapted user interfaces and the evaluation of their quality according to the recommendations issued from the behavioural model. In the third part, we detail our implementation of a platform that implements the DAME approach. This implementation is used in a qualitative experiment that involves end-users. Encouraging preliminary results have been obtained and open new perspectives on multi-devices and multimodal HCI in ambient computing.