Etienne Borde

Mode-based reconfiguration of critical software component architectures

Designing reconfigurable yet critical embedded and complex systems (i.e. systems composed of different subsystems) requires making these systems adaptable while guaranteeing that they operate with respect to predefined safety properties. When it comes to complex systems, component-based software engineering methods provide solutions to master this complexity (ldquodivide to conquerrdquo). In addition, architecture description languages provide solutions to design and analyze critical and reconfigurable embedded systems. In this paper we propose a methodology that combines the benefits of these two approaches by leaning on both AADL and Lightweigth CCM standards. This methodology is materialized through a complete design process and an associated framework, MyCCM-HI, dedicated to designing reconfigurable, critical, and complex embedded systems.

Design Patterns for Rule-Based Refinement of Safety Critical Embedded Systems Models

Safety critical embedded systems must be verified and optimized. Their production process, which includes both automatic code generation and middleware implementation, depends on the the target execution platform and must be adapted accordingly. In such a context, Model Driven Architecture provides several approaches to transform user models into programming code but these solutions lack of flexibility to address simultaneously the three issues of verification, optimization and adaptation. To overcome this limitation, we propose a method to structure the production process with design patterns for model transformations. Our approach allows to adapt the workflow of rule-based refinements according to the user input models, the targeted execution platform, and the analysis performed on intermediate transformed models.

Translating ATL Model Transformations to Algebraic Graph Transformations

Analyzing and reasoning on model transformations has become very relevant for various applications such as ensuring the correctness of transformations. ATL is a model transformation language with rich semantics and a focus on usability, making its analysis not straightforward. Conversely, Algebraic Graph Transformation AGT is an approach with strong theoretical foundations allowing for formal analyses that would be valuable in the context of ATL. In this paper we propose a translation of ATL to the AGT framework in the objective of bringing theoretical analyses of AGT to ATL transformations. We validate our proposal by translating a set of feature-rich ATL transformations to the Henshin AGT framework. We execute the ATL and AGT versions on the same set of models and verify that the result is the same.

Architecture models refinement for fine grain timing analysis of embedded systems

As real-time systems have become more and more complex, architects rely on abstract models of computation in order to design and analyse these systems. In order to ease the production of source code that respects such models of computation, developper can take advantage of code generators and/or middleware. However, when analyzing an abstract model of computation, timing overheads due to generated code or middleware components are not taken into account. Answering this issue is even more problematic in the domain of embedded systems because of the variability of execution platforms. To tackle this problem, we present in this paper a model refinement and timing analysis framework: abstract models of computation are first transformed in more precise models, which include the timing characteristics of the execution platform. These refined models are then used for a more precise timing analysis. The experiment results we present in this paper show that our method can deal with realistic software architecture of real-time systems.

Automatic selection and composition of model transformations alternatives using evolutionary algorithms

The design of software architectures requires to address a number of competing non-functional properties (NFPs): improving one NFP requires to degrade another one. As a consequence, software architects have to come up with several design alternatives, and select architectures answering at best the trade-off between NFPs. In this paper, we propose to (i) formalize design alternatives with model transformations in order to ease the estimation of NFPs (using models analysis techniques); (ii) structure these model transformations to compose and select them (using evolutionary algorithms); and (iii) identify which model transformation alternatives produce the best output models with respect to NFPs. Experiments on a placement problem provide evidence that the approach can successfully explore the design space and find good architectural solutions.

Deterministic implementation of periodic-delayed communications and experimentation in AADL

The design of hard real-time embedded systems has to comply with strong requirements with respect to time determinism and resource consumption. However, interacting tasks may induce pessimism in schedulability analysis or introduce significant overheads in memory usage. In this paper, we restrict the execution and communication models to enforce an efficient and predictable implementation. To ensure determinism, a message sent by an emitting task is delivered at its deadline. We take advantage of a wait-free specialized message queues to provide predictable and efficient implementation. The integration of such mechanisms is assisted by a model driven engineering framework1.

An Automated Approach for Architectural Model Transformations

Software architectures are frequently represented as large models where many competing quality attributes have to be taken into account. In this context, there may be a large number of possible alternative architectural transformations that the architecture designer has to deal with. The complexity and dimensions of the solution space make that finding the most appropriate architecture considering several quality attributes is a challenging and time-consuming task. In this paper, we present a model transformation framework designed to automate the selection and composition of competing architectural model transformations. We also introduce a case study showing that this framework is useful for rapid prototyping through model transformations.

Model-Driven Requirements Engineering for Embedded Systems Development

The development of embedded systems is a complex and challenging task. Part of this complexity originates from limited resources and the need to solve tradeoffs between competing quality properties and goals. Producing a correct design therefore requires a complete and understandable requirements specification. Non-Functional Goals (NFGs) are commonly used to analyze these tradeoffs, while Model-Driven Development has the potential to reduce the design complexity of embedded systems by increasing the abstraction level. In this paper, we extend the Requirements Definition and Analysis Language (RDAL) for goals specification in order to drive a model-driven architecture refinement of embedded systems. Determining the impact of the refinements on Non-Functional Properties (NFPs) and relating these NFPs to design objects are the key aspects of our method. The feasibility of the approach is illustrated through the introduction of a Pacemaker system which needs to deal with several NFPs such as performance, availability, and power consumption.

Formalization of design patterns for security anddependability

In critical systems, failures or attacks based on software misconceptions can have catastrophic consequences. In order to avoid those situations, such systems need security and dependability (S&D) constraints. Usually S&D design patterns shape S&D mechanisms. Security and dependability experts identify S&D mechanisms to reach S&D objectives and manually apply them to the system architecture. Our contribution consists in studying S&D design patterns application. We formalize these S&D design patterns as model transformations, preconditions and postconditions to automate their integration. Finally, we illustrate this process with a Software Defined Radio case study to which we apply the red/black (R/B) architecture security design pattern.

Model driven code generation for critical and adaptative embedded systems

Implementing adaptative systems requires to make the trade off of (i) the adaptation promptness, (ii) the amount of interferences due to adaptation, and (iii) the guarantee of data ows consistency. Furthermore, implementing critical systems requires to respect design constraints that enable to improve its determinism. In this paper, we propose a design methodology that helps to make the adaptation trade off while respecting the critical systems design specificities. We then illustrate the usage of this methodology on an industrial use-case, using a component-based framework that generates the adaptation code. Lastly, we present and discuss the associated experimental results, and show the relative benefits of using the one or the other mode switch protocol.