Dans les domaines critiques tels que l’avionique, le ferroviaire ou encore l’automobile, il faut, afin de pouvoir certifier un système, démontrer qu’il réalise la fonction pour laquelle il a été conçu, selon des exigences temporelles spécifiées. En effet, un rendu temporel trop long peut rendre des données erronées, et ainsi mettre en danger la sûreté des personnes. Aujourd’hui, la plupart des approches proposent d’assurer ces exigences de Qualité de service au niveau des couches basses, e.g., au travers d’une bande passante déterministe, d’allocation statique d’intervalles de temps, et d’un ordonnancement prédéfini. Ces contraintes assurent que les applications ne peuvent dépasser le temps d’exécution alloué ; les applications récupèrent de ce fait des exigences qui sont découplées de leur fonctionnalité. En revanche, il faut aussi pouvoir certifier des exigences temporelles spécifiques à une application. De là, les garanties au niveau des couches basses ne sont plus suffisantes. Il faudrait pouvoir prendre en compte ces exigences dès la phase de conception des applications. Aujourd’hui, la plupart des approches existant dans ce domaine se concentrent sur le support de QoS à des phases isolées du processus de développement logiciel, empêchant la traçabilité des exigences. Cette thèse propose une approche dirigée par la conception pour supporter les exigences de QoS tout au long du processus de développement logiciel, intégrée dans une méthodologie outillée, appelée DiaSuite. L’extension de QoS enrichit le langage de conception DiaSpec avec la capacité d’instancier les exigences de QoS sur les composants logiciels. Un support de surveillance à l’exécution de ces exigences temporelles est ensuite généré, directement à partir de la spécification. Cette thèse intègre uniformément les concepts temporels avec les concepts de gestion d’erreurs, au travers de la méthodologie DiaSuite, afin de proposer une couche de supervision qui puisse effectuer une reconfiguration applicative, dans le cas de violation de contrat de QoS. Les contributions de cette thèse sont évaluées au regard du respect des critères de cohérence et de conformité, illustrés au travers d’une étude de cas dans le domaine avionique. / In critical domains such as avionics, railways or automotive, to certify a system, it is required to demonstrate that it achieves its function, with respect to specified timing requirements. Indeed, longer-than-predicted function computing can make data erroneous, leading potentially to endanger people lives. Today, most approaches propose to ensure these Quality of Service requirements at platform level, e.g., through deterministic bandwidth, static time slots allocation and predefined scheduling. These constraints ensure applications can’t overpass allocated time slots; applications are then fed with requirements decoupled to their functionality. However, it shall be possible to certify timing requirements, dedicated to an application. Hence, guarantees at platform-level are not sufficient anymore. It should be possible to take into account these requirements from the stage of application design. Today, most of existing approaches in this domain, focus on supporting QoS at individual stages of the software development process, preventing requirements traceability. This thesis proposes a design-driven approach to supporting QoS throughout software development process, integrated in a tool-based methodology, namely DiaSuite. The QoS extension enriches the DiaSpec design language, with the capability to instantiate QoS requirements onto software components. A runtime execution support to monitoring these timing requirements, is then generated, directly from the specification. This thesis uniformly integrates timing concepts with error ones, around DiaSuite methodology, to propose a supervision layer that could lead to application reconfiguration in case of QoS contract violation. Contributions of this thesis are evaluated through respect of coherence and conformance critera, illustrated through a case study in avionics.

Dans le domaine des plates-formes ouvertes, l’utilisation des cadriciels (frameworks) enrichis par des déclarations pour exprimer les permissions de l’application est de plus en plus répandue. Ceci est une réaction logique au fait qu’il y a une explosion d’adoption des appareils embarqués et mobiles. Leur omniprésence dans notre vie quotidienne engendre des craintes liées à la sécurité et à la vie privée, car l’usager partage de plus en plus ses données et ressources privées avec des tiers qui développent des applications auxquelles on n’a pas de raison de faire confiance. Malheureusement, la manière dont ces langages de spécification ainsi que ces cadres d’applications sont développés est généralement assez ad hoc et repose sur un domaine d’application et un langage de programmation fixes. De plus, ces cadriciels ne sont pas assez restrictifs pour régler le problème de la fuite de données privées et ne donnent souvent pas non plus assez d’informations à l’usager sur le comportement attendu de l’application. Cette thèse présente une méthodologie généraliste pour développer des cadriciels dirigés par des déclarations, qui cible un spectre large de langages de programmation. Nous montrons comment des langages de déclaration expressifs permettent de spécifier avec modularité les droits d’accès aux ressources ainsi que le flux de contrôle d’une telle application. Ces langages peuvent ensuite être compilés en un cadriciel garantissant à l’usager final le respect de ces permissions. Par rapport aux cadriciels existants, notre méthodologie permet de guider la personne qui développe des applications à partir des spécifications ainsi que d’informer l’usager final sur l’usage des ressources sensibles. Contrairement aux travaux existants, la méthodologie présentée dans cette thèse ne repose par sur un langage de programmation particulier. Nous montrons comment mettre en oeuvre de tels cadriciels dans un spectre de langages : des langages avec typage statique ou dynamique, et suivant le paradigme objet ou fonctionnel. L’efficacité de l’approche est montrée à travers des prototypes dans le domaine des applications mobiles dans deux langages très différents, à savoir Java et Racket, ce qui montre la généralité de notre approche. / In the domain of open platforms, it has become common to use application programming frameworks extended with declarations that express permissions of applications. This is a natural reaction to ever more widespread adoption of mobile and pervasive computing devices. Their wide adoption raises privacy and safety concerns for users, as a result of the increasing number of sensitive resources a user is sharing with non-certified third-party application developers. However, the approach to designing these declaration languages and the frameworks that enforce their requirements is often ad hoc, and limited to a specific combination of application domain and programming language. Moreover, most widely used frameworks fail to address serious privacy leaks, and, crucially, do not provide the user with insight into application behaviour. This dissertation presents a generalised methodology for developing declaration-driven frameworks in a wide spectrum of host programming languages. We show that rich declaration languages, which express modularity, resource permissions and application control flow, can be compiled into frameworks that provide strong guarantees to end users. Compared to other declaration-driven frameworks, our methodology provides guidance to the application developer based on the specifications, and clear insight to the end user regarding the use of their private resources. Contrary to previous work, the methodology we propose does not depend on a specific host language, or even on a specific programming paradigm. We demonstrate how to implement declaration-driven frameworks in languages with static type systems, completely dynamic languages, object-oriented languages, or functional languages. The efficacy of our approach is shown through prototypes in the domain of mobile computing, implemented in two widely differing host programming languages, demonstrating the generality of our approach.

Notre environnement est de plus en plus peuplé de grandes quantités d’objets intelligents. Certains surveillent des places de stationnement disponibles, d’autres analysent les conditions matérielles dans les bâtiments ou détectent des niveaux de pollution dangereux dans les villes. Les quantités massives de capteurs et d’actionneurs constituent des infrastructures de grande envergure qui s’étendent sur des terrains de stationnement entiers, des campus comprenant plusieurs bâtiments ou des champs agricoles. Le développement d’applications pour de telles infrastructures reste difficile, malgré des déploiement réussis dans un certain nombre de domaines. Une connaissance considérable des spécificités matériel / réseau de l’infrastructure de capteurs est requise de la part du développeur. Pour remédier à ce problème, des méthodologies et des outils de développement logiciel permettant de relever le niveau d’abstraction doivent être introduits pour que des développeurs non spécialisés puissent programmer les applications. Cette thèse présente une méthodologie dirigée par la conception pour le développement d’applications orchestrant des quantités massives d’objets communicants. La méthodologie est basée sur un langage de conception dédié, nommé DiaSwarm qui fournit des constructions déclaratives de haut niveau permettant aux développeurs de traiter des masses d’objets en phase de conception, avant de programmer l’application. La programmation générative est utilisée pour produire des cadres de programmation spécifiques à la conception pour guider et soutenir le développement d’applications dans ce domaine. La méthodologie intègre le traitement parallèle de grandes quantités de données collectées à partir de masses de capteurs. Nous introduisons un langage de déclarations permettant de générer des cadres de programmation basés sur le modèle de programmation MapReduce. En outre, nous étudions comment la conception peut être utilisée pour rendre explicites les ressources requises par les applications ainsi que leur utilisation. Pour faire correspondre les exigences de l’application à une infrastructure de capteurs cible, nous considérons les déclarations de conception à différents stades du cycle de vie des applications. Le passage à l’échelle de cette approche est évaluée dans une expérience qui montre comment les cadres de programmation générés s’appuyant sur le modèle de programmation MapReduce sont utilisés pour le traitement efficace de grands ensembles de données de relevés des capteurs. Nous examinons l’efficacité de l’approche proposée pour relever les principaux défis du génie logiciel dans ce domaine en mettant en oeuvre des scénarios d’application qui nous sont fournis par des partenaires industriels. Nous avons sollicité des programmeurs professionnels pour évaluer l’utilisabilité de notre approche et présenter des données quantitatives et qualitatives de l’expérience. / Our environment is increasingly populated with large amounts of smart objects. Some monitor free parking spaces, others analyze material conditions in buildings or detect unsafe pollution levels in cities. The massive amounts of sensing and actuation devices constitute large-scale infrastructures that span over entire parking lots, campuses of buildings or agricultural fields. Despite being successfully deployed in a number of domains, the development of applications for such infrastructures remains challenging. Considerable knowledge about the hardware/network specificities of the sensor infrastructure is required on the part of the developer. To address this problem, software development methodologies and tools raising the level of abstraction need to be introduced to allow non-expert developers program applications. This dissertation presents a design-driven methodology for the development of applications orchestrating massive amounts of networked objects. The methodology is based on a domain-specific design language, named DiaSwarm that provides high-level, declarative constructs allowing developers to deal with masses of objects at design time, prior to programming the application. Generative programming is used to produce design-specific programming frameworks to guide and support the development of applications in this domain. The methodology integrates the parallel processing of large-amounts of data collected from masses of sensors. We introduce specific language declarations resulting in the generation of programming frameworks based on the MapReduce programming model. We furthermore investigate how design can be used to make explicit the resources required by applications as well as their usage. To match the application requirements to a target sensor infrastructure, we consider design declarations at different stages of the application lifecycle. The scalability of this approach is evaluated in an experiment, which shows how the generated programming frameworks relying on the MapReduce programming model are used for the efficient processing of large datasets of sensor readings. We examine the effectiveness of the proposed approach in dealing with key software engineering challenges in this domain by implementing application scenarios provided to us by industrial partners. We solicited professional programmers to evaluate the usability of our approach and present quantitative and qualitative data from the experiment.

Statische Codemetriken sind wichtige Indikatoren für die Qualität eines Softwaresystems. Sie beleuchten dabei unterschiedliche Aspekte eines Softwaresystems. Deshalb ist es notwendig, mehrere Codemetriken zu nutzen, um die Qualität eines Softwaresystems in seiner Gesamtheit bewerten zu können. Wünschenswert wäre zudem eine Darstellung, die die Struktur des Gesamtsystems und die Bewertung einzelner Elemente eines Softwaresystems in einer Darstellung kombiniert. Die Arbeit untersucht deshalb, welche Metaphern geeignet sind, um eine solche Darstellung zu ermöglichen. Ein zweites Ziel der Arbeit war es, eine solche Visualisierung automatisch erzeugen zu können. Dafür wurde ein Generator entwickelt, der diese Anforderung erfüllt. Zur Konzeption dieses Generators kamen Techniken aus der generativen Softwareentwicklung zum Einsatz. Bei der Umsetzung des Generators wurde auf Techniken aus der modellgetriebenen Softwareentwicklung zurückgegriffen, vor allem auf Techniken aus dem openArchitectureWare-Framework. Der Generator kann in Eclipse eingebunden werden und ist in der Lage, aus einem Java-Projekt die Struktur und die Metrikwerte automatisch zu extrahieren. Diese Werte werden daraufhin in ein dreidimensionales Modell überführt, das auf dem offenen Extensible 3D Standard basiert. Der Generator ermöglichte zudem die Evaluierung zweier unterschiedlicher Metaphern, die im Rahmen der Arbeit durchgeführt wurde.

Les architectures parallèles sont aujourd'hui présentes dans tous les systèmes informatiques, allant des smartphones aux supercalculateurs en passant par les ordinateurs de bureau. Programmer efficacement ces architectures en fonction des applications requiert un effort pluridisciplinaire portant sur les langages dédiés (Domain Specific Languages - DSL), les techniques de génération de code et d'optimisation, et les algorithmes numériques propres aux applications. Dans cette thèse, nous présentons une méthode de programmation haut niveau prenant en compte les caractéristiques des architectures hétérogènes et les propriétés existantes des matrices pour produire un solveur générique d'algèbre linéaire dense. Notre modèle de programmation supporte les transferts explicites et implicites entre un processeur (CPU) et un processeur graphique qui peut être généraliste (GPU) ou intégré (IGP). Dans la mesure où les GPU sont devenus un outil important pour le calcul haute performance, il est essentiel d'intégrer leur usage dans les plateformes de calcul. Une architecture récente telle que l'IGP requiert des connaissances supplémentaires pour pouvoir être programmée efficacement. Notre méthodologie a pour but de simplifier le développement sur ces architectures parallèles en utilisant des outils de programmation haut niveau. À titre d'exemple, nous avons développé un solveur de moindres carrés en précision mixte basé sur les équations semi-normales qui n'existait pas dans les bibliothèques actuelles. Nous avons par la suite étendu nos travaux à un modèle de programmation multi-étape ("multi-stage") pour résoudre les problèmes d'interopérabilité entre les modèles de programmation CPU et GPU. Nous utilisons cette technique pour générer automatiquement du code pour accélérateur à partir d'un code effectuant des opérations point par point ou utilisant des squelettes algorithmiques. L'approche multi-étape nous assure que le typage du code généré est valide. Nous avons ensuite montré que notre méthode est applicable à d'autres architectures et algorithmes. Les routines développées ont été intégrées dans une bibliothèque de calcul appelée NT2.Enfin, nous montrons comment la programmation haut niveau peut être appliquée à des calculs groupés et des contractions de tenseurs. Tout d'abord, nous expliquons comment concevoir un modèle de container en utilisant des techniques de programmation basées sur le C++ moderne (C++-14). Ensuite, nous avons implémenté un produit de matrices optimisé pour des matrices de petites tailles en utilisant des instructions SIMD. Pour ce faire, nous avons pris en compte les multiples problèmes liés au calcul groupé ainsi que les problèmes de localité mémoire et de vectorisation. En combinant la programmation haut niveau avec des techniques avancées de programmation parallèle, nous montrons qu'il est possible d'obtenir de meilleures performances que celles des bibliothèques numériques actuelles. / Parallelism in today's computer architectures is ubiquitous whether it be in supercomputers, workstations or on portable devices such as smartphones. Exploiting efficiently these systems for a specific application requires a multidisciplinary effort that concerns Domain Specific Languages (DSL), code generation and optimization techniques and application-specific numerical algorithms. In this PhD thesis, we present a method of high level programming that takes into account the features of heterogenous architectures and the properties of matrices to build a generic dense linear algebra solver. Our programming model supports both implicit or explicit data transfers to and from General-Purpose Graphics Processing Units (GPGPU) and Integrated Graphic Processors (IGPs). As GPUs have become an asset in high performance computing, incorporating their use in general solvers is an important issue. Recent architectures such as IGPs also require further knowledge to program them efficiently. Our methodology aims at simplifying the development on parallel architectures through the use of high level programming techniques. As an example, we developed a least-squares solver based on semi-normal equations in mixed precision that cannot be found in current libraries. This solver achieves similar performance as other mixed-precision algorithms. We extend our approach to a new multistage programming model that alleviates the interoperability problems between the CPU and GPU programming models. Our multistage approach is used to automatically generate GPU code for CPU-based element-wise expressions and parallel skeletons while allowing for type-safe program generation. We illustrate that this work can be applied to recent architectures and algorithms. The resulting code has been incorporated into a C++ library called NT2. Finally, we investigate how to apply high level programming techniques to batched computations and tensor contractions. We start by explaining how to design a simple data container using modern C++14 programming techniques. Then, we study the issues around batched computations, memory locality and code vectorization to implement a highly optimized matrix-matrix product for small sizes using SIMD instructions. By combining a high level programming approach and advanced parallel programming techniques, we show that we can outperform state of the art numerical libraries.

Statische Codemetriken sind wichtige Indikatoren für die Qualität eines Softwaresystems. Sie beleuchten dabei unterschiedliche Aspekte eines Softwaresystems. Deshalb ist es notwendig, mehrere Codemetriken zu nutzen, um die Qualität eines Softwaresystems in seiner Gesamtheit bewerten zu können. Wünschenswert wäre zudem eine Darstellung, die die Struktur des Gesamtsystems und die Bewertung einzelner Elemente eines Softwaresystems in einer Darstellung kombiniert. Die Arbeit untersucht deshalb, welche Metaphern geeignet sind, um eine solche Darstellung zu ermöglichen. Ein zweites Ziel der Arbeit war es, eine solche Visualisierung automatisch erzeugen zu können. Dafür wurde ein Generator entwickelt, der diese Anforderung erfüllt. Zur Konzeption dieses Generators kamen Techniken aus der generativen Softwareentwicklung zum Einsatz. Bei der Umsetzung des Generators wurde auf Techniken aus der modellgetriebenen Softwareentwicklung zurückgegriffen, vor allem auf Techniken aus dem openArchitectureWare-Framework. Der Generator kann in Eclipse eingebunden werden und ist in der Lage, aus einem Java-Projekt die Struktur und die Metrikwerte automatisch zu extrahieren. Diese Werte werden daraufhin in ein dreidimensionales Modell überführt, das auf dem offenen Extensible 3D Standard basiert. Der Generator ermöglichte zudem die Evaluierung zweier unterschiedlicher Metaphern, die im Rahmen der Arbeit durchgeführt wurde.

Frames sind parametrisierte Elemente zur Erzeugung von Programmen in einer beliebigen Zielprogrammiersprache. Ihre Handhabung ist einfach und schnell zu erlernen. Allerdings findet bei Verwendung von Frames eine “Verunreinigung” des Programmcodes, der als Basis für die Generatorentwicklung dient, mit Befehlen der Generatorsprache statt. Dies erschwert die Weiterverwendung der gewohnten Entwicklungsumgebung für die Zielprogrammiersprache. Eine eventuelle Weiterentwicklung der Programmbasis muss anschließend in Form von Frames erfolgen. Im Rahmen dieser Arbeit erfolgt die Beschreibung noninvasiver Frames, bei denen Informationen zur Position der Frames getrennt vom Programmcode aufbewahrt werden. Ihre Vermischung erfolgt in einem separaten Schritt zur Darstellung oder zur eigentlichen Codeerzeugung. Der Prozess der Generatorentwicklung auf der Basis noninvasiver Frames passt sich gut in die Prozesse von Merkmal-orientierter (FOSD) und Generativer Softwareentwicklung (GSE) ein, weil noninvasive Frames die automatisierte Prüfung aller mit dem Generator erzeugbaren Programme hinsichtlich Syntax und bestimmter semantischer Eigenschaften unterstützen und die Generierung durch Auswahl der gewünschten Programmeigenschaften ermöglichen. Die Machbarkeit der Entwicklung von Softwaregeneratoren mit noninvasiven Frames wird anhand zweier Fallstudien demonstriert.

A reutilização de software busca aumentar a qualidade e produtividade no desenvolvimento de software, evitando a duplicação do esforço e reaproveitando o máximo possível das experiências de projetos passados. Apesar de simples, esta idéia não é facilmente colocada em prática, principalmente de maneira sistemática e controlada. Técnicas de engenharia de domínio e linhas de produtos de software buscam facilitar esta tarefa, porém ainda existem outros fatores que dificultam a adoção da prática da reutilização. Entre estes, destacam-se os problemas inerentes ao desenvolvimento de software da maneira como é conduzido atualmente, baseado em código-fonte. Estes problemas têm suas origens na crescente demanda por software cada vez mais complexo e afetam negativamente a capacidade de reutilizar software. O desenvolvimento orientado a modelos surge como uma alternativa atraente neste cenário, elevando a importância de modelos dentro do ciclo de vida do software, incorporando-os como parte integrante do produto final por meio de técnicas de modelagem e geração de código. Com isto, parte da complexidade do software fica escondida dentro dos geradores, protegendo os desenvolvedores, reduzindo a incidência de erros, aumentando a produtividade, qualidade, interoperabilidade e manutenibilidade dos artefatos produzidos. Nesta dissertação defende-se a tese de que o desenvolvimento orientado a modelos pode efetivamente aumentar e/ou melhorar a reutilização de software, e que para isso ela deve ser tratada de forma consistente dentro de um processo de engenharia de domínio. Para demonstrar esta tese, é apresentada uma abordagem orientada a modelos para reutilização de software, com atividades que guiam o desenvolvedor durante a análise, projeto e implementação do domínio. São também apresentados os resultados de uma avaliação envolvendo três estudos empíricos, realizados em ambiente acadêmico e industrial, que buscou determinar a viabilidade da abordagem e os benefícios que podem ser alcançados com a combinação de técnicas do desenvolvimento orientado a modelos e da reutilização de software. Os resultados mostram que a abordagem pode trazer diferentes benefícios para organizações de software, incluindo aumento da quantidade e qualidade da reutilização, e reduzindo a complexidade de desenvolvimento e configuração de produtos / Software reuse aims at increasing quality and productivity in software development, avoiding effort duplication and reusing all past experiences possible. Although it is a simple idea, it is not easy to put reuse in practice, especially in a systematic and controlled way. Domain engineering and software product lines techniques try to make this task easier, but there are many other factors that difficult the reuse adoption. Among these factors are the problems that are inherent to software development in the way it is conducted today, based on source code. These problems arise from the growing demand for increasingly complex software, negatively affecting the ability to reuse. Model-driven development is an attractive alternative in this scenario, leveraging the importance of models in the software life cycle, incorporating them as part of the final product through modeling and code generation techniques. As a result, part of the software complexity becomes hidden inside the generators, shielding the developers, reducing errors, increasing the productivity, quality, interoperability and maintainability of the produced assets. In this dissertation is presented the thesis that model-driven development can effectively increase and/or improve software reuse, and that to achieve this goal it must be treated in a consistent way inside a domain engineering process. To demonstrate this thesis, a model-driven software reuse approach is presented, with activities that guide the developer during domain analysis, design and implementation. The results of an evaluation involving three empirical studies are also presented. The studies were performed in both academic and industrial environments, and aimed at determining the viability of the approach and the benefits that can be achieved with the combination of model-driven development and software reuse techniques. The results showed that the approach can bring different benefits to software organizations, such as software reuse quantity and quality improvements, and complexity reduction in product development and configuration tasks

Made available in DSpace on 2014-12-17T15:47:57Z (GMT). No. of bitstreams: 1 MarioSST_DISSERT.pdf: 2743049 bytes, checksum: da23e766aa49e7926f3ad6450145c626 (MD5) Previous issue date: 2011-02-17 / Conselho Nacional de Desenvolvimento Cient?fico e Tecnol?gico / Product derivation tools are responsible for automating the development process of software product lines. The configuration knowledge, which is responsible for mapping the problem space to the solution space, plays a fundamental role on product derivation approaches. Each product derivation approach adopts different strategies and techniques to manage the existing variabilities in code assets. There is a lack of empirical studies to analyze these different approaches. This dissertation has the aim of comparing systematically automatic product derivation approaches through of the development of two different empirical studies. The studies are analyzed under two perspectives: (i) qualitative that analyzes the characteristics of approaches using specific criteria; and (ii) quantitative that quantifies specific properties of product derivation artifacts produced for the different approaches. A set of criteria and metrics are also being proposed with the aim of providing support to the qualitative and quantitative analysis. Two software product lines from the web and mobile application domains are targets of our study / Abordagens de deriva??o de produto s?o respons?veis por automatizar o processo de engenharia de aplica??o de linhas de produto de software. O conhecimento de configura??o, que ? respons?vel por relacionar o espa?o do problema com o espa?o da solu??o, desempenha um papel fundamental nas abordagens de deriva??o de produto. Cada ferramenta adota estrat?gias e t?cnicas diferentes para gerenciar o processo de deriva??o de produto e h? uma car?ncia de estudos experimentais para avaliar as diferentes abordagens. Esta disserta??o de mestrado tem como objetivo comparar sistematicamente abordagens de deriva??o autom?tica de produtos, atrav?s do desenvolvimento de estudos emp?ricos. Os estudos s?o desenvolvidos sob duas perspectivas: (i) qualitativa atrav?s da an?lise de caracter?sticas das ferramentas; e (ii) quantitativa atrav?s da quantifica??o de propriedades espec?ficas de artefatos de deriva??o produzidos para as ferramentas. Um conjunto de crit?rios e m?tricas tamb?m ? proposto com o objetivo de oferecer suporte para as an?lises qualitativas e quantitativas. Duas linhas de produto, uma para o dom?nio de sistemas web e outra para o contexto de aplica??es de dispositivos m?veis, s?o alvos do nosso estudo

Les simulateurs industriels deviennent de plus en plus complexes car ils doivent intégrer de façon performante des modèles physiques complets et des méthodes de discrétisation évoluées. Leur mise au point nécessite de gérer de manière efficace la complexité des modèles physiques sous-jacents, la complexité des méthodes numériques utilisées, la complexité des services numériques de bas niveau nécessaires pour tirer parti des architectures matérielle modernes et la complexité liée aux langages informatiques. Une réponse partielle au problème est aujourd'hui fournie par des plate-formes qui proposent des outils avancés pour gérer de façon transparente la complexité liée au parallélisme. Cependant elles ne gèrent que la complexité du matériel et les services numériques de bas niveau comme l'algèbre linéaire. Dans le contexte des méthodes Éléments Finis (EF), l'existence d'un cadre mathématique unifié a permis d'envisager des outils qui permettent d'aborder aussi la complexité issue des méthodes numériques et celle liée aux problèmes physiques, citons, par exemple, les projets Freefem++, Getdp, Getfem++, Sundance, Feel++ et Fenics. Le travail de thèse a consisté à étendre cette approche aux méthodes d'ordre bas pour des systèmes d'EDPs, méthodes qui souffraient jusqu'à maintenant d'une absence d'un cadre suffisamment général permettant son extension à des problèmes différents. Des travaux récents ont résolue cette difficulté, par l'introduction d'une nouvelle classe de méthodes d'ordre bas inspirée par les éléments finis non conformes. Cette formulation permet d'exprimer dans un cadre unifié les schémas VF multi-points et les méthodes DFM/VFMH. Ce nouveau cadre a permis la mise au point d'un langage spécifique DSEL en C++ qui permet de développer des applications avec un haut niveau d'abstraction, cachant la complexité des méthodes numériques et des services bas niveau garanties de haute performances. La syntaxe et les techniques utilisées sont inspirée par celles de Feel++. Le DSEL a été développé à partir de la plate-forme Arcane, et embarqué dans le C++. Les techniques de DSEL permettent de représenter un problème et sa méthode de résolution avec une expression, parsée à la compilation pour générer un programme, et évaluée à l'exécution pour construire un système linéaire que l'on peut résoudre pour trouver la solution du problème. Nous avons mis au point notre DSEL à l'aide d'outils standard issus de la bibliothèque Boost puis l'avons validé sur divers problèmes académiques non triviaux tels que des problèmes de diffusion hétérogène et le problème de Stokes. Dans un deuxième temps, dans le cadre du projet ANR HAMM (Hybrid Architecture and Multiscale Methods), nous avons validé notre approche en complexifiant le type de méthodes abordées et le type d'architecture matérielle cible pour nos programmes. Nous avons étendu le formalisme mathématique sur lequel nous nous basons pour pouvoir écrire des méthodes multi-échelle puis nous avons enrichi notre DSEL pour pouvoir implémenter de telles méthodes. Afin de pouvoir tirer partie de façon transparente des performances de ressources issues d'architectures hybrides proposant des cartes graphiques de type GPGPU, nous avons mis au point une couche abstraite proposant un modèle de programmation unifié qui permet d'accéder à différents niveaux de parallélisme plus ou moins fin en fonction des spécificités de l'architecture matérielle cible. Nous avons validé cette approche en évaluant les performances de cas tests utilisant des méthodes multi-échelle sur des configurations variés de machines hétérogènes. Pour finir nous avons implémenté des applications variées de type diffusion-advection-réaction, de Navier-Stokes incompressible et de type réservoir. Nous avons validé la flexibilité de notre approche et la capacité qu'elle offre à appréhender des problèmes variés puis avons étudié les performances des diverses implémentations. / Industrial simulation software has to manage : the complexity of the underlying physical models, usually expressed in terms of a PDE system completed with algebraic closure laws, the complexity of numerical methods used to solve the PDE systems, and finally the complexity of the low level computer science services required to have efficient software on modern hardware. Nowadays, this complexity management becomes a key issue for the development of scientific software. Some frameworks already offer a number of advanced tools to deal with the complexity related to parallelism in a transparent way. However, all these frameworks often provide only partial answers to the problem as they only deal with hardware complexity and low level numerical complexity like linear algebra. High level complexity related to discretization methods and physical models lack tools to help physicists to develop complex applications. New paradigms for scientific software must be developed to help them to seamlessly handle the different levels of complexity so that they can focus on their specific domain. Generative programming, component engineering and domain-specific languages (either DSL or DSEL) are key technologies to make the development of complex applications easier to physicists, hiding the complexity of numerical methods and low level computer science services. These paradigms allow to write code with a high level expressive language and take advantage of the efficiency of generated code for low level services close to hardware specificities. In the domain of numerical algorithms to solve partial differential equations, their application has been up to now limited to Finite Element (FE) methods, for which a unified mathematical framework has been existing for a long time. Such kinds of DSL have been developed for finite element or Galerkin methods in projects like Freefem++, Getdp, Getfem++, Sundance, Feel++ and Fenics. A new consistent unified mathematical frame has recently emerged and allows a unified description of a large family of lowest-order methods. This framework allows then, as in FE methods, the design of a high level language inspired from the mathematical notation, that could help physicists to implement their application writing the mathematical formulation at a high level. We propose to develop a language based on that frame, embedded in the C++ language. Our work relies on a mathematical framework that enables us to describe a wide family of lowest order methods including multiscale methods based on lowest order methods. We propose a DSEL developed on top of Arcane platform, based on the concepts presented in the unified mathematical frame and on the Feel++ DSEL. The DSEL is implemented with the Boost.Proto library by Niebler, a powerful framework to build a DSEL in C++. We have proposed an extension of the computational framework to multiscale methods and focus on the capability of our approach to handle complex methods.Our approach is extended to the runtime system layer providing an abstract layer that enable our DSEL to generate efficient code for heterogeneous architectures. We validate the design of this layer by benchmarking multiscale methods. This method provides a great amount of independent computations and is therefore the kind of algorithms that can take advantage efficiently of new hybrid hardware technology. Finally we benchmark various complex applications and study the performance results of their implementations with our DSEL.