Notre proposition consiste à présenter un modèle et une infrastructure d'exécution orienté composant pour le domaine des applications multi-tâches à contraintes temps réel souples et embarquées (nommé Tinap). Nous définissons un modèle de composant reposant sur plusieurs vues : une vue structurelle, placée au centre du cycle de conception, reposant initialement sur le modèle Fractal, une vue dynamique permettant au concepteur, dans une démarche descriptive, de personnaliser l'architecture métier pour définir les aspects de son applicatif liés à la concurrence, et enfin une vue implantation et une vue comportement fournissant respectivement une abstraction de l'implantation interne des composants et de leur comportement à l'égard de leur environnement. De plus, notre proposition est intégrée à un cadre méthodologique dirigé par les modèles. Nous avons également expérimenté le paradigme composant à différents niveaux d'abstraction: pour l'applicatif et pour celui de l'infrastructure d'exécution qui les implante. Enfin, au niveau du système d'exploitation fournissant les services élémentaires nécessaires. Cette démarche est motivée par la volonté d'exploiter notre modèle multi-vues canonique et de l'adapter en fonction des besoins de chaque niveau d'abstraction. Cette expérimentation est menée avec Think, une implantation en C des spécifications Fractal. Nous expérimentons Tinap par deux cas d'étude que nous avons prototypés. En premier lieu, pour concevoir une application d'analyse et de contrôle de flux multimédias par l'intermédiaire de disques vinyles. En second lieu pour expérimenter la mise en oeuvre du modèle d'exécution Accord (une méthodologie de conception pour applications temps-réel). / Our proposal is to present a component-oriented model and execution infrastructure for soft realtime and embedded applications (called Tinap). We define a component model based on several views : a structural view placed at the centre of the design cycle and based initially on the Fractal component model. A dynamic view, allowing the designer, in a descriptive way, to directly customize its functional architecture with concurrency-related aspects. Finally, an implementation and a behavioral view, providing respectively an abstraction of the structure and the behavior of the internal implementations of the components according to the environment. Moreover, our proposal has been incorporated into a model-based approach in order to mitigate the complexities of the design phases. We also experienced the component paradigm at different levels of abstraction: at application level and at execution infrastructure one. The latter implements the high-level concepts provided to the designer. Finally, at the operating system level which provides the services required by the infrastructure. This approach is motivated by the will to exploit our canonical model at these different levels, and to adapt it depending on their needs. This experimentation was conducted with Think, a C implementation of Fractal specifications. We present two case studies prototyped with Tinap. First, an application for DJ's: From a dedicated signal pressed on a vinyl and analysed by the software, the user is able to control various multimedia sources (audio/video). Secondly, for the implementation of the Accord execution model (a design methodology for real-time applications).

Mémoire numérisé par la Direction des bibliothèques de l'Université de Montréal.

Thèse doctorat : Informatique : Rennes 1 : 2006. / Bibliogr. p. 183-194.

Reproduction de : Thèse de doctorat : informatique : Grenoble, INPG : 1987. / Titre provenant de l'écran-titre. Bibliogr. p. 225-242.

Thèse doctorat : Traitement du signal et télécommunications : Rennes 1 : 2008. / Titre provenant de la page du titre du document électronique. Bibliogr. p. 139-143.

Th. doct.--Informatique et réseaux--Paris--ENST, 1995. / Bibliogr. p. 115-125. Résumé en français et en anglais.

Les architectures logicielles ont un rôle important dans le développement de systèmes à logiciel prépondérant afin de permettre la satisfaction tant des exigences fonctionnelles que des exigences extra-fonctionnelles. En particulier, les architectures logicielles dynamiques ont émergé pour faire face aux caractéristiques des systèmes contemporains qui opèrent dans des environnements dynamiques et par conséquent susceptibles de changer en temps d’exécution. Les langages de description architecturale (ADLs) sont utilisés pour représenter les architectures logicielles en produisant des modèles qui peuvent être utilisés pendant la conception ainsi que l’exécution. Cependant, la plupart des ADLs existants sont limités sur plusieurs facettes : (i) ils ne décrivent que les aspects structurels, topologiques de l’architecture ; (ii) ils ne fournissent pas un support adéquat pour représenter les aspects comportementaux de l’architecture ; (iii) ils ne permettent pas de décrire des aspects avancés de la dynamique de l’architecture ; (iv) ils sont limités en ce qui concerne la vérification automatisée des propriétés et des contraintes architecturales ; et (v) ils sont déconnectés du niveau d’implémentation et entraînent souvent des incohérences entre l’architecture et l’implémentation. Pour faire face à ces problèmes, cette thèse propose un framework formel pour les architectures logicielles dynamiques. Ce framework comprend : (i) .-ADL, un langage formel pour décrire des architectures logicielles dynamiques sous les perspectives structurelles et comportementales ; (ii) la spécification des opérations de reconfiguration dynamique programmée ; (iii) la génération automatique de code source à partir des descriptions architecturales ; et (iv) une approche basée sur la vérification statistique pour exprimer et vérifier formellement des propriétés des architectures logicielles dynamiques. Les contributions principales apportées par le framework proposé sont quatre. Premièrement, le langage .-ADL a été doté de primitives de niveau architectural pour décrire des reconfigurations dynamiques programmées. Deuxièmement, les descriptions architecturales dans .-ADL sont transformées vers le code source d’implémentation dans le langage de programmation Go, en contribuant à minimiser les dérives architecturales. Troisièmement, une nouvelle logique appelée DynBLTL est utilisée pour exprimer formellement des propriétés dans les architectures logicielles dynamiques. Quatrièmement, un outil basé sur SMC a été développé pour automatiser la vérification des propriétés architecturales en cherchant à réduire l’effort, les ressources computationnelles, et le temps pour réaliser cette tâche. Dans ce travail, deux systèmes basés sur réseaux de capteurs sans fil sont utilisés pour valider les éléments du framework. / Software architectures play a significant role in the development of software-intensive systems in order to allow satisfying both functional and non-functional requirements. In particular, dynamic software architectures have emerged to address characteristics of the contemporary systems that operate on dynamic environments and consequently subjected to changes at runtime. Architecture description languages (ADLs) are used to represent software architectures, producing models that can be used at design time and/or runtime. However, most existing ADLs have limitations in several facets: (i) they are focused on structural, topological aspects of the architecture; (ii) they do not provide an adequate support for representing behavioral aspects of the architecture; (iii) they do not allow describing advanced aspects regarding the dynamics of the architecture; (iv) they are limited with respect to the automated verification of architectural properties and constraints; and (v) they are disconnected from the implementation level, thus entailing inconsistencies between architecture and implementation. In order to tackle these problems, this thesis proposes formally founded framework for dynamic software architectures. Such a framework comprises: (i) .-ADL, a formal language for describing software architectures under both structural and behavioral viewpoints; (ii) the specification of programmed dynamic reconfiguration operations; (iii) the automated generation of source code from architecture descriptions; and (iv) an approach based on statistical model checking (SMC) to formally express and verify properties in dynamic software architectures. The main contributions brought by the proposed framework are fourfold. First, the .-ADL language was endowed with architectural-level primitives for describing programmed dynamic reconfigurations. Second, architecture descriptions in .-ADL are translated towards implementation source code in the Go programming language, thereby contributing to minimize architectural drifts. Third, a novel logic, called DynBLTL, is used to formally express properties in dynamic software architectures. Fourth, a toolchain relying on SMC was built to automate the verification of architectural properties while striving to reduce effort, computational resources, and time for performing such a task. In this work, two wireless sensor network-based systems are used to validate the framework elements.

.

Les architectures logicielles sont centrales vis-à-vis des processus logiciels de construction des applications. Les langages de description d'architectures (ADLs) représentent la solution la plus adaptée pour définir de telles architectures. Toutefois, les concepts de ces ADLs sont en règle générale figés et leurs utilisations ne répond pas nécessairement aux différentes préoccupations des processus logiciels. De plus, leur aspect syntaxique ne facilite pas la coopération des différents acteurs de processus logiciels. Notre proposition, CODeX, fournit un cadre de travail pour méta-modéliser des ADLs. Ces méta-modèles permettent de définir les concepts liés aux architectures nécessaires à un processus logiciel. Dans le but de structurer les ADLs ainsi définis et de permettre la collaboration des différents acteurs d'un processus logiciel, les méta-modèles sont définis en mettant en œuvre la séparation des préoccupations architecturales d'un processus logiciel. Cette séparation définit l'organisation des différents concepts d'un ADL. Un outillage complément de ce cadre de travail permet de produire automatiquement, sur la base du méta-modèle d'un ADL, l'environnement associé pour la manipulation des architectures logicielles. Ce dernier est architecturé autour d'une représentation réifiée des architectures logicielles. Cette représentation suit la séparation des préoccupations définie dans le méta-modèle et permet d'offrir à chaque acteur d'un processus logiciel une vue dédiée sur l'architecture d'une application.

Les approches basées sur les composants permettent de développer des logiciels en réutilisant des composants existant dans des bibliothèques. La structure d'un tel logiciel produit par assemblage de composants est définie à l'aide d'un langage de description d'architectures (ADL). Les processus de développement sont encore peu adaptés à ce paradigme. Ainsi, les ADL existants ne fournissent pas de véritable support au développement et à l'évolution des architectures logicielles à composants. Cette thèse propose Dedal, un ADL permettant de définir une architecture logicielle à différents niveaux d'abstraction qui correspondent aux étapes du cycle de vie du logiciel : sa spécification, son implémentation et son déploiement. La définition de l'architecture est complétée par un modèle du logiciel à l'exécution. La cohérence entre les différentes définitions d'une architecture doit être assurée : sa définition à un niveau d'abstraction doit être conforme à sa définition à un niveau supérieur. Ce principe permet de contrôler l'évolution d'une architecture, en validant les modifications réalisées à un certain niveau d'abstraction ou en motivant la création d'une nouvelle version pour propager les modifications entre niveaux d'abstraction et rétablir la cohérence. Ces mécanismes préviennent les problèmes d'érosion ou de dérive qui surviennent lors des évolutions entre les différents niveaux de définition des architectures. Un environnement couvrant le cycle de vie complet d'un logiciel à base de composants a été prototypé. Il comporte un atelier, permettant de décrire des architectures avec Dedal, puis un environnement d'exécution, extension des outils Fractal, capable de contrôler l'évolution des architectures déployées. L'évolution à l'exécution est réalisée de façon graduelle, de manière à faire fonctionner et à instrumenter les nouvelles versions pendant une phase de transition, avant de valider définitivement une modification. / Component-based approaches promote software development by reuse of existing components from a repository. The structure of such software is described as an assembly of software components using an architecture description language (ADL). Software development processes often do not comply with this paradigm yet. Consequently, existing ADLs do not fully support component-based software architecture development and evolution. This thesis proposes Dedal, an ADL to describe software architectures at several abstraction levels that correspond to the steps of software lifecycle: its specification, its implementation and its deployment. The architecture definition is completed with a runtime model of the software. Consistency between the various definitions of a given architecture must be maintained: its definition at some abstraction level must conform to its definition at a higher abstraction level. This consistency principle enables to control the evolution of architectures either validating changes performed at an abstraction level or motivating the creation of a new version, to propagate changes from an abstraction level to the other and restore their consistency. These mechanisms prevent from architecture erosion or drift which might occur between two different description levels after evolution. An environment that covers the whole lifecycle of component-based software has been prototyped. It includes a CASE tool that supports the Dedal-based description of architectures and a runtime environment that extends Fractal tools to control the evolution of the deployed software. Runtime evolution is performed gradually in order to have new versions run and instrumented during a transition phase before committing changes.