Spelling suggestions: "subject:"génération dde pode"" "subject:"génération dde mode""
1 |
Modélisation des systèmes temps-réel répartis embarqués pour la génération automatique d'applications formellement vérifiéesVergnaud, Thomas 12 1900 (has links) (PDF)
La construction d'une application répartie fait en général intervenir une couche logicielle particulière, appelée intergiciel, qui prend en charge la transmission des données entre les différents noeuds de l'application. La conception d'applications pour les systèmes embarqués temps-réel implique la prise en compte de certaines contraintes spécifiques à ce domaine, que ce soit en terme fiabilité ou de dimensions à la fois temporelles et spatiales. Ces contraintes doivent notamment être respectées par l'intergiciel. L'objet de ces travaux est la description des applications temps-réel réparties embarquées en vue de configurer automatiquement l'intergiciel adéquat. L'étude se focalise sur la définition d'un processus de conception permettant d'intégrer les phases de description, de vérification et de génération de l'application complète. Pour cela, nous nous reposons sur le langage de description d'architecture AADL. Nous l'exploitons comme passerelle entre la phase de description de l'architecture applicative, les formalismes de vérification, la génération du code exécutable et la configuration de l'exécutif réparti. Nous montrons comment spécifier un exécutif pour AADL afin de produire automatiquement le code applicatif et l'intergiciel pour une application répartie. Nous montrons également comment exploiter ces spécifications pour produire un réseau de Petri afin d'étudier l'intégrité des flux d'exécution dans l'architecture. Afin de valider notre processus de conception, nous avons conçu et développé Ocarina, un compilateur pour AADL qui utilise l'intergiciel schizophrène PolyORB comme exécutif.
|
2 |
Génération stratégique de code pour la maîtrise des performances de systèmes temps-réel embarqués / Strategic generation of code to master the performances of real-time embedded systemsCadoret, Fabien 26 May 2014 (has links)
Nous nous sommes intéressés aux systèmes embarqués temps-réel critiques (SETRC) qui soulèvent des problématiques de criticité, de respect de contraintes temporelles et de disponibilité des ressources telles que la mémoire. Pour maîtriser la complexité de conception de ces systèmes, l’Ingénierie Dirigée par les Modèles (IDM) propose de les modéliser pour les analyser au regard de leurs exigences et pour générer en partie leur code d’exécution. Cependant ces deux phases doivent s’articuler correctement de sorte que le système généré respecte toujours les propriétés du modèle initialement analysé. Par ailleurs, le générateur de code doit s’adapter à de multiples critères : notamment pour assurer le respect des performances ou bien pour cibler différentes plates-formes d’exécution qui ont leurs propres contraintes et sémantiques d’exécution. Pour réaliser cette adaptation, le processus de développement requiert de faire évoluer les règles de transformation selon ces critères. Son architecture doit également de permettre de sélectionner les composants logiciels répondant à ces critères. Nous répondons à cette problématique en proposant un processus de génération s’appuyant sur l’IDM. Lorsque l’utilisateur a spécifié et validé un modèle de haut niveau, une transformation traduit automatiquement ce modèle en un second modèle détaillé proche du code généré. Pour assurer la conservation des exigences, le modèle détaillé est exprimé dans le même formalisme que le modèle initial de sorte qu’il reste analysable. Cette démarche détermine l’impact de la stratégie du générateur sur les performances du système final et permet au générateur de changer de stratégie, à une étape donnée, pour assurer le respect des contraintes du système. Pour faciliter le développement et la sélection de stratégies alternatives, nous proposons une méthodologie qui s’articule autour d’un formalisme pour l’orchestration des transformations, un ensemble de patrons de transformation (qui factorisent et généralisent les règles de transformation) et une adaptation de composants logiciels selon leur impact sur les performances. Nous avons mis en place ce processus au sein de l’environnement OSATE, pour lequel nous avons développé le framework RAMSES (Refinment of AADL Models for Synthesis of Embedded Systems). Nous l’avons expérimenté sur la génération des communications entre tâches pour lesquelles plusieurs stratégies d’implémentation ont été définies / We focused on real-time embedded critical systems (RTECS) which present different problems: criticality, respect of time constraints and resources availability such as memory. In order to master design complexity of such systems, Model Driven Engineering (MDE) proposes to model it for analysis purposes and to generate, partially or totally, its execution code. However, these two phases must be correctly connected to ensure the generated code is always enforcing all the properties of the model initially analysed. In addition, the code generator must be adapted to several criteria: in particular to ensure respect of performances or to target different execution platforms which have their own execution constraints and semantics. To realize such an adaptation, the development process requires to evolve transformation rules according to these criteria. Its architecture needs also to allow the selection of the generated software components respecting these criteria.We answer such a problem by proposing a generation process based on the MDE. When the user specifies and validates a high-level model, a model transformation translates automatically this model into a detailed model close to the generated code. To ensure the conservation of the requirements, the detailed model is expressed in the same formalism as the initial model so that it remains analysable (by the same tools initially used). This approach determines the impact of the code generation strategy on the performances of the final system and allows the generator to adapt its strategy, in a given stage, to insure the respect of the system constraints. To facilitate the development and the selection of alternative strategies, we propose a methodology which articulates around a formalism for the orchestration of the transformations, a set of transformation patterns (which factorize and generalize the transformation rules) and an adaptation of software components according to their impact on the performances. We set up this process within the environment OSATE, for which we have developed the framework RAMSES (Refinement of AADL Models for Synthesis of Embedded Systems). We have experimented it on the code generation of the communications between tasks for which several strategies of implementation were defined.
|
3 |
Vers une prise en compte fine de la plate-forme cible dans la construction des systèmes temps réel embarqués critiques par ingénierie des modèlesGilles, Olivier 29 April 2010 (has links) (PDF)
Une démarche classique d'ingénierie dirigée par les modèles (IDM) consiste à modéliser un problème, puis à générer le code source associé à partir de ce modèle. Cette approche, qui a été étendue succès aux systèmes temps-réel, réduit signicativement les erreurs. Le modèle développé suit généralement une approche fonctionnelle du problème ; celle-ci est cependant rarement optimale en terme de consommation de ressources. Pour les systèmes temps réel, cette limitation est acceptable : ce n'est plus le cas dans le contexte de systèmes temps-réels embarqués (TRE). Cette thèse propose d'associer l'approche IDM à un processus d'optimisation basé sur le modèle du système, pour pouvoir appliquer cette approche aux systèmes TRE. Pour cela, nous proposons d'utiliser ensemble trois solutions : d'une part, AADL, un langage de modélisation architecturale, qui permet de spécifier la composante non-fonctionnelle de l'application. Ensuite, REAL, un langage d'expression de contrainte, qui permet d'exprimer des contraintes sur le modèle. Finalement, un processus d'optimisation, qui permet de transformer un modèle naïf en modèle répondant aux performances requises, en se basant sur des heuristiques gloutonnes. Nous montrons comment cette approche permet d'automatiser le processus de développement, en limitant le rôle de l'architecte à la traduction des contraintes exprimées par le cahier des charges et à la conception d'un modèle naïf du problème.
|
4 |
Méthodes et outils de génération de code pour les plateformes multi-cœurs fondés sur la représentation de haut niveau des applications et des architecturesElmrabti, A. 08 December 2010 (has links) (PDF)
La complexité des systèmes sur puce s'accentue pour supporter les nouvelles applications dans le domaine des télécommunications et du multimédia. La tendance actuelle des nouvelles architectures matérielles converge vers des plateformes multi-cœurs à plusieurs unités de calcul (processeurs, DSP, IP) interconnectées par un réseau sur puce qui peut être configurable au niveau de ses interfaces réseau. Pour ce genre d'architectures, les environnements de génération de code classiques ne sont plus adaptés. Cette thèse propose un flot de génération de code de configuration pour le déploiement des applications de type flots de données sur les architectures à base d'IPs interconnectés à travers un réseau sur puce configurable. Le flot commence par un modèle de haut niveau de l'application et de l'architecture et propose une méthodologie de partitionnement des ressources. Le processus de génération de code passe par plusieurs étapes modélisées par diverses représentations intermédiaires du système. Le flot a été développé par la suite dans un environnement basé sur le standard IEEE 1685 (IP-XACT). Le flot proposé a été appliqué pour la génération et la validation du code de configuration en vue de déployer une application 3GPP-LTE de télécommunication sur la plateforme Magali. Le flot a ensuite été généralisé pour supporter, en plus de la génération du code de configuration, la génération du code logiciel exécutable par les processeurs.
|
5 |
Understanding retargeting compilation techniques for network processorsLi, Jun January 2003 (has links)
Mémoire numérisé par la Direction des bibliothèques de l'Université de Montréal.
|
6 |
Développement d'applications logicielles sûres de fonctionnement : une approche dirigée par la conception / Development of dependable applications : a design-driven approachEnard, Quentin 06 May 2013 (has links)
Dans de nombreux domaines tels que l’avionique, la médecine ou la domotique, les applications logicielles jouent un rôle de plus en plus important, allant jusqu’à être critique pour leur environnement. Afin de pouvoir faire confiance à ces applications, leur développement est contraint par des exigences de sûreté de fonctionnement. En effet il est nécessaire de démontrer que ces exigences de haut-niveau sont prises en compte tout au long du cycle de développement et que des solutions concrètessont mises en œuvre pour parvenir à les respecter. De telles contraintes rendent le développement d’applications sûres de fonctionnement particulièrement complexe et difficile. Faciliter ce processus appelle à la recherche de nouvelles approches dedéveloppement qui intègrent des concepts de sûreté de fonctionnement et guident les développeurs lors de chacune des étapesnécessaires à la production d’une nouvelle application digne de confiance.Cette thèse propose ainsi de s’appuyer sur une approche dirigée par la conception pour guider le développement des applications sûres de fonctionnement. Cette approche est concrétisée à travers une suite d’outils nommée DiaSuite et offre du support dédié à chaque étape du développement. En particulier, un langage de conception permet de décrire à la fois les aspects fonctionnels et non-fonctionnels des applications en se basant sur un paradigme dédié et en intégrant des concepts de sûreté de fonctionnement tels que le traitement des erreurs. A partir de la description d’une application, du support est généré pour guider les phases d’implémentation et de vérification. En effet, la génération d’un framework de programmation dédié permet de guider l’implémentation tandis que la génération d’un modèle formel permet de guider la vérification statique de l’application et qu’un support de simulation permet de faciliter les tests. Cette approche est évaluée grâce à des cas d’études réalisés dans les domaines de l’avionique et de l’informatique ubiquitaire. / In many domains such as avionics, medecine or home automation, software applications play an increasingly important rolethat can even be critical for their environment. In order to trust these applications, their development is contrained by dependability requirements. Indeed, it is necessary to demonstrate that these high-level requirements are taken into account throughout the development cycle and concrete solutions are implemented to achieve compliance. Such constraints make the development of dependable applications particularly complex and difficult. Easing this process calls for the research of new development approaches that integrate dependability concepts and guide the developers during each step of the development of trustworthy applications.This thesis proposes to leverage a design-driven approach to guide the development of dependable applications. This approachis materialized through a tool-suite called DiaSuite and offers dedicated support for each stage of the development. Inparticular, a design language is used to describe both functional and non-functional applications. This language is based on adedicated paradigm and integrates dependability concepts such as error handling. From the description of an application, development support is generated to guide the implementation and verification stages. Indeed, the generation of a dedicated programming framework allows to guide the implementation while the generation of a formal model allows to guide the static verification and simulation support eases the testing. This approach is evaluated through case studies conducted in the domains of avionics and pervasive computing.
|
7 |
Implementability of distributed systems described with scenarios / Implémentabilité de systèmes distribués décrits à l'aide de scénariosAbdallah, Rouwaida 16 July 2013 (has links)
Les systèmes distribués sont au cœur de nombreuses applications modernes (réseaux sociaux, services web, etc.). Cependant, les développeurs sont confrontés à de nombreux défis dans l’implémentation des systèmes distribués, notamment les comportements erronés à éviter et qui sont causées par la concurrence entre les entités de ce système. La génération automatique de code à partir des exigences des systèmes distribués reste un vieux rêve. Dans cette thèse, nous considérons la génération automatique d'un squelette de code portant sur les interactions entre les différentes entités d'un système distribué. Cela nous permet d'éviter les comportements erronés causés par la concurrence. Ensuite, ce squelette peut être complété par l'ajout et le débogage du code qui décrit les actions locales qui se passent sur chaque entité indépendamment de ses interactions avec les autres entités. / Distributed systems lie at the heart of many modern applications (social networks, web services, etc.). However, developers face many challenges in implementing distributed systems. The major one we focus on is avoiding the erroneous behaviors, that do not appear in the requirements of the distributed system, and that are caused by the concurrency between the entities of this system. The automatic code generation from requirements of distributed systems remains an old dream. In this thesis, we consider the automatic generation of a skeleton of code covering the interactions between the entities of a distributed system. This allows us to avoid the erroneous behaviors caused by the concurrency. Then, in a later step, this skeleton can be completed by adding and debugging the code that describes the local actions happening on each entity independently from its interactions with the other entities. The automatic generation that we consider is from a scenario-based specification that formally describes the interactions within informal requirements of a distributed system. We choose High-level Message Sequence Charts (HMSCs for short) as a scenario-based specification for the many advantages that they present: namely the clear graphical and textual representations, and the formal semantics. The code generation from HMSCs requires an intermediate step, called “Synthesis” which is their transformation into an abstract machine model that describes the local views of the interactions by each entity (A machine representing an entity defines sequences of messages sending and reception). Then, from the abstract machine model, the skeleton’s code generation becomes an easy task. A very intuitive abstract machine model for the synthesis of HMSCs is the Communicating Finite State Machine (CFSMs). However, the synthesis from HMSCs into CFSMs may produce programs with more behaviors than described in the specifications in general. We thus restrict then our specifications to a sub-class of HMSCs named "local HMSC". We show that for any local HMSC, behaviors can be preserved by addition of communication controllers that intercept messages to add stamping information before resending them. We then propose a new technique that we named "localization" to transform an arbitrary HMSC specification into a local HMSC, hence allowing correct synthesis. We show that this transformation can be automated as a constraint optimization problem. The impact of modifications brought to the original specification can be minimized with respect to a cost function. Finally, we have implemented the synthesis and the localization approaches into an existing tool named SOFAT. We have, in addition, implemented to SOFAT the automatic code generation of a Promela code and a JAVA code for REST based web services from HMSCs.
|
8 |
Elementary functions : towards automatically generated, efficient, and vectorizable implementations / Fonctions élémentaires : vers des implémentations vectorisables, efficaces, et automatiquement généréesLassus Saint-Genies, Hugues de 17 May 2018 (has links)
Les fonctions élémentaires sont utilisées dans de nombreux codes de calcul haute performance. Bien que les bibliothèques mathématiques (libm) auxquelles font appel ces codes proposent en général plusieurs variétés d'une même fonction, celles-ci sont figées lors de leur implémentation. Cette caractéristique représente un frein à la performance des programmes qui les utilisent car elles sont conçues pour être polyvalentes au détriment d'optimisations spécifiques. De plus, la duplication de modèles partagés rend la maintenance de ces libms plus difficile et sujette à l'introduction de bugs. Un défi actuel est de proposer des "méta-outils" visant la génération automatique de code performant pour l'évaluation des fonctions élémentaires. Ces outils doivent permettre la réutilisation d'algorithmes efficaces et génériques pour différentes variétés de fonctions ou architectures matérielles. Il devient alors possible de générer des libms optimisées pour des besoins très spécifiques avec du code générateur factorisé, qui facilite sa maintenance. Dans un premier temps, nous proposons un algorithme original permettant de générer des tables sans erreur pour les fonctions trigonométriques et hyperboliques. Puis nous étudions les performances de schémas d'évaluation polynomiale vectorisés, premier pas vers la génération de fonctions vectorisées efficaces. Enfin, nous proposons une méta-implémentation d'un logarithme vectorisé, factorisant la génération de code pour différents formats et architectures. Ces contributions sont compétitives comparées à d'autres solutions, justifiant le développement de tels méta-codes. / Elementary mathematical functions are pervasive in many high performance computing programs. However, although the mathematical libraries (libms), on which these programs rely, generally provide several flavors of the same function, these are fixed at implementation time. Hence this monolithic characteristic of libms is an obstacle for the performance of programs relying on them, because they are designed to be versatile at the expense of specific optimizations. Moreover, the duplication of shared patterns in the source code makes maintaining such code bases more error prone and difficult. A current challenge is to propose "meta-tools" targeting automated high performance code generation for the evaluation of elementary functions. These tools must allow reuse of generic and efficient algorithms for different flavours of functions or hardware architectures. Then, it becomes possible to generate optimized tailored libms with factorized generative code, which eases its maintenance. First, we propose an novel algorithm that allows to generate lookup tables that remove rounding errors for trigonometric and hyperbolic functions. The, we study the performance of vectorized polynomial evaluation schemes, a first step towards the generation of efficient vectorized elementary functions. Finally, we develop a meta-implementation of a vectorized logarithm, which factors code generation for different formats and architectures. Our contributions are shown competitive compared to free or commercial solutions, which is a strong incentive to push for developing this new paradigm.
|
9 |
Configuration et déploiement d'applications temps-réel réparties embarquées à l'aide d'un langage de description d'architectureZalila, Bechir 07 November 2008 (has links) (PDF)
La production de systèmes temps-réel répartis embarqués (TR2E) est une opération lourde en temps et en coût de développement. De plus, les applications temps-réel doivent satisfaire des contraintes dures pour assurer leur bon fonctionnement (respect des échéances temporelles...). L'utilisation des langages de description d'architecture vise à réduire le coût de développement de ces applications. AADL (Architecture Analysis & Design Language) fait partie de cette famille de langages. Il propose la notion de ``composant'' (matériel ou logiciel) dont la sémantique bien définie permet de décrire plusieurs aspects d'un système TR2E. Les différentes contraintes qui doivent être satisfaites sont intégrées dans le modèle AADL sous forme de propriétés. Ce travail de thèse exploite les fonctionnalités offertes par AADL pour spécifier les besoins exacts d'une application AADL afin de la produire automatiquement. En effet, le processus de production que nous proposons (1) génère automatiquement le code pour intégrer les composants applicatifs à la plate-forme d'exécution, (2) génère automatiquement une importante partie des composants intergiciels taillés sur mesure pour l'application et (3) déploie automatiquement les composants applicatifs et intergiciels afin d'obtenir un système fortement dédié à l'application. Notamment, la plate-forme d'exécution supportant les composants AADL est elle même configurée statiquement en fonction des propriétés spécifiées. L'approche adoptée réduit le temps de développement et permet d'obtenir un code personnalisé et analysable. La configuration et le déploiement (souvent séparés du processus de développement) sont désormais automatiques et intégrés à la chaîne de production.
|
10 |
Un modèle de composants hiérarchiques avec protocoles d'interactionPavel, Sebastien 21 October 2008 (has links) (PDF)
L'utilisation et la gestion des composants sont au coeur des nouvelles architectures logicielles. Les composants représentent les briques de bases des logiciels. Les efforts de recherche actuels se concentrent sur l'élaboration de modèles à base de composants qui intègrent des propriétés importantes comme, par exemple, la description et l'intégration des composants avec des comportements explicites (protocoles d'interaction). Ce sont ces descriptions plus complètes que les interfaces classiques (les points d'entrée et de sortie), qui ouvrent la voie vers la correction des assemblages. Comme aboutissement des travaux de cette thèse, nous proposons un modèle de composants qui utilise des Systèmes de Transitions Symboliques (STSs) pour décrire les comportements des composants. Les composants de notre modèle sont des boîtes noires communicant exclusivement par l'intermédiaire de leurs interfaces étendues avec des protocoles d'interaction. Le modèle spécifie aussi les règles de compatibilité, les algorithmes de vérification des assemblages des composants et de la substitution et un langage de description des composants. Nous proposons une implémentation dans le langage Java en suivant une approche générative ou le code Java est généré à partir des descriptions des composants de haut niveau. Le code est donc garanti a être conforme à la spécification.
|
Page generated in 0.123 seconds