L'automatisation de la génération des artefacts textuels à partir des modèles est une étape critique dans l'Ingénierie Dirigée par les Modèles (IDM). C'est une transformation de modèles utile pour générer le code source, sérialiser les modèles dans de stockages persistents, générer les rapports ou encore la documentation. Parmi les différents paradigmes de transformation de modèle-au-texte, la génération de code basée sur les templates (TBCG) est la plus utilisée en IDM. La TBCG est une technique de génération qui produit du code à partir des spécifications de haut niveau appelées templates. Compte tenu de la diversité des outils et des approches, il est nécessaire de classifier et de comparer les techniques de TBCG existantes afin d'apporter un soutien approprié aux développeurs. L'objectif de ce mémoire est de mieux comprendre les caractéristiques des techniques de TBCG, identifier les tendances dans la recherche, et éxaminer l'importance du rôle de l'IDM par rapport à cette approche. J'évalue également l'expressivité, la performance et la mise à l'échelle des outils associés selon une série de modèles. Je propose une étude systématique de cartographie de la littérature qui décrit une intéressante vue d'ensemble de la TBCG et une étude comparitive des outils de la TBCG pour mieux guider les dévloppeurs dans leur choix. Cette étude montre que les outils basés sur les modèles offrent plus d'expressivité tandis que les outils basés sur le code sont les plus performants. Enfin, Xtend2 offre le meilleur compromis entre l'expressivité et la performance. / A critical step in model-driven engineering (MDE) is the automatic synthesis of a textual artifact from models. This is a very useful model transformation to generate application code, to serialize the model in persistent storage, generate documentation or reports. Among the various model-to-text transformation paradigms, Template-Based Code Generation (TBCG) is the most popular in MDE. TBCG is a synthesis technique that produces code from high-level specifications, called templates. It is a popular technique in MDE given that they both emphasize abstraction and automation. Given the diversity of tools and approaches, it is necessary to classify and compare existing TBCG techniques to provide appropriate support to developers. The goal of this thesis is to better understand the characteristics of TBCG techniques, identify research trends, and assess the importance of the role of MDE in this code synthesis approach. We also evaluate the expressiveness, performance and scalability of the associated tools based on a range of models that implement critical patterns. To this end, we conduct a systematic mapping study of the literature that paints an interesting overview of TBCG and a comparative study on TBCG tools to better guide developers in their choices. This study shows that model-based tools offer more expressiveness whereas code-based tools performed much faster. Xtend2 offers the best compromise between the expressiveness and the performance.

Práce se zaobírá problematikou implementace součtového datového typu v jazyce C++. Nejprve navrhuje vlastní abstrakce pro manipulaci s posloupnostmi hodnot a typů, které následně umožňují vyjadřovat komplexní operace deklarativně. V průběhu implementace jsou prezentovány návrhové vzory obvyklé pro oblast metaprogramování. Implementace přichází s rozhodnutími odlišnými od referenční implementace. Pro manipulaci se součtovým typem jsou představeny dvě šablony funkce, lišící se sémantikou. Užití součtového typu je ukázano na příkladu konečného stavového automatu.

With the expansion of the Internet communication and related availability of increasing number of services built on different technologies, distributed systems represent a solution to integrate these network services and provide them to users in a coherent form. The .NET Framework which provides an environment for application development in a highly distributed environment of Internet and intranet can be used to achieve this goal. This PhD thesis deals with access to shared resources in the context of distributed systems using the .NET platform. The first part of the work is devoted to describing the basic principles of distributed systems and .NET platform techniques, which can be used for implementation of the principles. For the purposes of request processing having asynchronous nature not only in distributed systems a universal interface for the description of asynchronous operations was designed and implemented. The interface extends standard asynchronous techniques on the .NET platform. In order to address the issue of access to shared resources model was designed based on the principles of object-oriented programming, along with basic algorithm to avoid deadlock in the case of use resources by multiple processes (threads) simultaneously. This extendable model has been successfully implemented and its functionality verified in basic scenarios of access to shared resources. After the definition of resources and their dependencies the implemented model allows working with resources as with any other objects on .NET platform. The synchronization processes proceed transparently in background.

Model-Based Software Engineering (MBSE) a été proposé comme une méthodologie prometteuse de développement de logiciels pour surmonter les limites de la méthodologie traditionnelle basée sur la programmation pour faire face à la complexité des systèmes embarqués. MBSE favorise l’utilisation de langages de modélisation pour décrire les systèmes d’une manière abstraite et fournit des moyens pour générer automatiquement de différents artefacts de développement, p.ex. code et documentation, à partir de modèles. Le développement d’un système complexe implique souvent de multiples intervenants qui utilisent différents outils pour modifier les artefacts de développement, le modèle et le code en particulier dans cette thèse. Les modifications apportées aux artefacts évoquent le problème de cohérence qui nécessite un processus de synchronisation pour propager les modifications apportées dans l’un artefact aux autres artefacts. Dans cette étude, le problème de la synchronisation des modèles d’architecture basés sur les éléments UML composite structure (UML-CS) et UML state machine (UML-SM) du langage de l’Unified Modeling Language (UML), et le code orienté objet est présenté. UML-CSs sont utilisés pour décrire l’architecture du logiciel basée sur les composants et UML-SMs pour les comportements discrets liés aux événements des systèmes réactifs. Le premier défi est de permettre une collaboration entre les architectes de logiciels et les programmeurs produisant de modèle et de code, en utilisant différents outils. Il soulève le problème de synchronisation où il existe de modifications simultanées des artefacts. En fait, il existe un écart de perception entre les langages à base de diagramme (langages de modélisation) et les langages textuels (langages de programmation). D’une part, les programmeurs préfèrent souvent utiliser la combinaison familière d’un langage de programmation et d’un environnement de développement intégré. D’autre part, les architectes logiciels, travaillant à des niveaux d’abstraction plus élevés, favorisent l’utilisation des modèles et préfèrent donc les langages à base de diagramme pour décrire l’architecture du système. Le deuxième défi est qu’il existe un écart d’abstraction significatif entre les éléments du modèle et les éléments du code: les éléments UML-CS et UML-SM sont au niveau d’abstraction plus élevé que les éléments du code. L’écart rend la difficulté pour les approches de synchronisation actuelles car il n’y a pas de façon facile de réflecter les modifications du code au modèle. Cette thèse propose une approche automatisée de synchronisation composée de deux principales contributions corrélées. Pour aborder le premier défi, on propose un patron méthodologique générique de synchronisation entre modèle et code. Il consiste en des définitions des fonctionnalités nécessaires et plusieurs processus qui synchronisent le modèle et le code en fonction de plusieurs scénarios définis où les développeurs utilisent différents outils pour modifier le modèle et le code. Cette contribution est indépendante de UML-CSs et UML-SMs. La deuxième contribution traite du deuxième défi et est basée sur les résultats de la première contribution. Dans la deuxième contribution, un mapping bidirectionnel est présentée pour réduire l’écart d’abstraction entre le modèle et le code. Le mapping est un ensemble de correspondances entre les éléments de modèle et ceux de code. Il est utilisé comme entrée principale du patron méthodologique générique de synchronisation entre modèle et code. Plus important, l’utilisation du mapping fournit les fonctionnalités définies dans la première contribution et facilite la synchronisation des éléments de UML-CS et UML-SM et du code. L’approche est évaluée au moyen de multiples simulations et d’une étude de cas. / Model-Based Software Engineering (MBSE) has been proposed as a promising software development methodology to overcome limitations of traditional programming-based methodology in dealing with the complexity of embedded systems. MBSE promotes the use of modeling languages for describing systems in an abstract way and provides means for automatically generating different development artifacts, e.g. code and documentation, from models. The development of a complex system often involves multiple stakeholders who use different tools to modify the development artifacts, model and code in particular in this thesis. Artifact modifications must be kept consistent: a synchronization process needs to propagate modifications made in one artifact to the other artifacts. In this study, the problem of synchronizing Unified Modeling Language (UML)-based architecture models, specified by UML composite structure (UML-CS) and UML state machine (UML-SM) elements, and object-oriented code is presented. UML-CSs are used for describing the component-based software architecture and UML-SMs for discrete event-driven behaviors of reactive systems. The first challenge is to enable a collaboration between software architects and programmers producing model and code by using different tools. This raises the synchronization problem of concurrent artifact modifications. In fact, there is a perception gap between diagram-based languages (modeling languages) and text-based languages (programming languages). On the one hand, programmers often prefer to use the more familiar combination of a programming language and an Integrated Development Environment. On the other hand, software architects, working at higher levels of abstraction, tend to favor the use of models, and therefore prefer diagram-based languages for describing the architecture of the system. The second challenge is that there is a significant abstraction gap between the model elements and the code elements: UML-CS andUML-SM elements are at higher level of abstraction than code elements. The gap makes current synchronization approaches hard to be applied since there is no easy way to reflect modifications in code back to model. This thesis proposes an automated synchronization approach that is composed of two main correlated contributions. To address the first challenge, a generic model-code synchronization methodological pattern is proposed. It consists of definitions of necessary functionalities and multiple processes that synchronize model and code based on several defined scenarios where the developers use different tools to modify model and code. This contribution is independent of UML-CSs and UML-SMs. The second contribution deals with the second challenge and is based on the results from the first contribution. In the second contribution, a bidirectional mapping is presented for reducing the abstraction gap between model and code. The mapping is a set of correspondences between model elements and code elements. It is used as main input of the generic model-code synchronization methodological pattern. More importantly, the usage of the mapping provides the functionalities defined in the first contribution and eases the synchronization of UML-CS and UML-SM elements and code. The approach is evaluated by means of multiple simulations and a case study.

Technological advances drive hardware to ever smaller feature sizes, causing devices to become more vulnerable to transient faults. Applications can be protected against faults by adding error detection and recovery measures in software. This is popularly achieved by applying automatic program transformations. However, transformations applied to program representations at abstraction levels higher than machine instructions are fundamentally incapable of protecting against vulnerabilities that are introduced during compilation. In particular, a large proportion of a program’s memory accesses are introduced by the compiler backend. This report presents a backend that protects these accesses against faults in the memory system. It is demonstrated that the presented backend can detect all single bit flips in memory that would be missed by an error detection scheme that operates on the LLVM intermediate representation of programs. The presented compiler backend is obtained by modifying the LLVM backend for the x86 architecture. On a subset of SPEC CINT2006 the runtime overhead incurred by the backend modifications amounts to 1.50x for the 32-bit processor architecture i386, and 1.13x for the 64-bit architecture x86_64. To achieve comprehensive detection of memory faults, the modified backend implements an adjusted calling convention that leaves library function calls transparent and intact.

OPTIMUS MOTUS (R) ist ein grafischer Editor, um komplexe Bewegungsabläufe zu modellieren, zu optimieren, zu testen und schließlich als Funktionsbausteine für die SPS-Welt zu exportieren. So können SPS-Bewegungsprogramme erheblich schneller entwickelt und geändert werden als bei manueller Programmentwicklung. Die aus der Kurventechnik bekannte Bewegungsqualität kommt damit auch bei Servoantrieben zum Tragen. Das Debugging entfällt, weil die Quelltexte maschinell erzeugt werden.

Many modern neural simulators focus on the simulation of networks of spiking neurons on parallel hardware. Another important framework in computational neuroscience, rate-coded neural networks, is mostly difficult or impossible to implement using these simulators. We present here the ANNarchy (Artificial Neural Networks architect) neural simulator, which allows to easily define and simulate rate-coded and spiking networks, as well as combinations of both. The interface in Python has been designed to be close to the PyNN interface, while the definition of neuron and synapse models can be specified using an equation-oriented mathematical description similar to the Brian neural simulator. This information is used to generate C++ code that will efficiently perform the simulation on the chosen parallel hardware (multi-core system or graphical processing unit). Several numerical methods are available to transform ordinary differential equations into an efficient C++code. We compare the parallel performance of the simulator to existing solutions.

The thesis aims to develop a method for extending the language platform Storm with a Java frontend.The project was conducted using an Action Research methodology and highlights triumphs andchallenges. Despite the significant overhead related to note generation and problem statementformulation, this methodology proved beneficial in identifying problems and providing the framework tosolve them. The first research question (RQ.1) evaluates to what extent the language platform Storm is suitable forimplementing the object oriented language Java. Using Storm, only a BNF and a specification for three-address code instructions are needed. Despite encountering difficulties during the implementation, theplatform offers tools that allow comprehensive customization of the new language's intended behaviorand functionality. The second research question (RQ.2) explores a suitable method for implementing a new language inStorm. It is suggested to first implement a foundational structure comprising of statements, blocks,scope handling and variable declarations. From this foundation, new functionalities can be graduallyintroduced and tested by connecting them to the appropriate location in the structure. When allfunctionality is added and tested a refactoring step can take place to modify the BNF if needed.

Vehicles on the road today are complex multi-node computer networks. Security has always been a critical issue in the automotive computing industry. It is becoming even more crucial with the advent of autonomous vehicles and driver assistant technology. There is potential for attackers to control vehicles maliciously. Traditionally Original Equipment Manufacturers have relied on physical security and a firewall to secure vehicles but with network connected and autonomous capable vehicles this is not enough. The concept of defence in depth is required. This means not trusting that internal traffic inside the firewall is benign. Each node in the vehicles network should be able to verify the authenticity and validity of communications it receives from other nodes. Implementation of the crypto-graphic systems for doing this is error prone. Therefore a key issue in the thesis is reducing the attack surface by developing these checks in the autonomous vehicle stack in a scalable way so the programmer does not have to be aware of this security layer on a day-to-day basis nor re-implement it for each node in these heterogeneous systems. Although message integrity and authenticity verification have been studied and implemented in many fields, the area of heterogeneous autonomous systems present unique research challenges. There are tight performance constraints due to the real time requirements for vehicle control systems and data publishing rates. It is an open question if this approach can achieve performance within the bounds required for a reliable autonomous vehicle. Additionally the security benefit of scalably automatically generating the message integrity verification code across all of the nodes in a heterogeneous system would help the field quantify the defect reduction and security benefit of this kind of code generation on complex software systems. / Dagens fordon på vägarna är komplexa datanät med flera noder. Säkerheten har alltid varit en viktig fråga inom bilindustrin. Det blir ännu viktigare i och med tillkomsten av autonoma fordon och förarassistentteknik. Det finns en potential för angripare att styra fordon på ett illvilligt sätt. Traditionellt har tillverkare av originalutrustning förlitat sig på fysisk säkerhet och en brandvägg för att säkra fordonen, men med nätverksanslutna och autonoma fordon räcker detta inte längre. Begreppet försvar på djupet är nödvändigt. Detta innebär att man inte kan lita på att den interna trafiken innanför brandväggen är godartad. Varje nod i fordonets nätverk bör kunna kontrollera äktheten och giltigheten hos den kommunikation som den tar emot från andra noder. Genomförandet av kryptografiska system för att göra detta är felkänsligt. En viktig fråga i avhandlingen är därför att minska angreppsytan genom att utveckla dessa kontroller i det autonoma fordonet på ett skalbart sätt så att programmeraren inte behöver vara medveten om detta säkerhetslager dagligen eller implementera det på nytt för varje nod i dessa heterogena system. Även om meddelandeintegritet och äkthetskontroll har studerats och genomförts inom många områden, innebär området heterogena autonoma system unika forskningsutmaningar. Det finns snäva prestandabegränsningar på grund av realtidskraven för fordonskontrollsystem och datapubliceringshastigheter. Det är en öppen fråga om detta tillvägagångssätt kan uppnå prestanda inom de gränser som krävs för ett tillförlitligt autonomt fordon. Dessutom skulle säkerhetsfördelarna med en skalbar automatisk generering av koden för verifiering av meddelandets integritet över alla noder i ett heterogent system hjälpa fältet att kvantifiera felminskningen och säkerhetsfördelarna med denna typ av kodgenerering i komplexa programvarusystem.

No description available.