Bechir Zalila

From the prototype to the final embedded system using the Ocarina AADL tool suite

Building distributed deal-time embedded systems requires a stringent methodology, from early requirement capture to full implementation. However, there is a strong link between the requirements and the final implementation (e.g., scheduling and resource dimensioning). Therefore, a rapid prototyping process based on automation of tedious and error-prone tasks (analysis and code generation) is required to speed up the development cycle. In this article, we show how the AADL (Architecture Analysis and Design Language), which appeared in late 2004, helps solve these issues thanks to a dedicated tool suite. We then detail the prototyping process and its current implementation: Ocarina.

Ocarina: An Environment for AADL Models Analysis and Automatic Code Generation for High Integrity Applications

Developing safety-critical distributed applications is a difficult challenge. A failure may cause important damages as loss of human life or missions failure. Such distributed applications must be designed and built with rigor. Reducing the tedious and error-prone development steps is required; we claim that automatic code generation is a natural solution. In order to ease the process of verification and certification, the user can use modeling languages to describe application critical aspects. In this paper we introduce the use of AST as a modeling language for Distributed Real-time Embedded (DRE) systems. Then we present our tool-suite ocarina which allows automatic code generation from AST models. Finally, we present a comparison between ocarina and traditional approaches.

Towards a model-based approach for reconfigurable DRE systems

This paper defines a model-based approach, which treats the reconfiguration issues for Distributed Real time Embedded (DRE) systems at a high level of abstraction. We aim at specifying reconfigurable DRE systems using a characterization approach. To treat the reconfiguration requirements, we propose a meta-model and a UML profile as implementation of this meta-model. This leads to a simple way to model reconfigurable systems thanks to UML tools, our RCA4RTES meta-model and profile, and the MARTE profile and library.

Generating distributed high integrity applications from their architectural description

High-Integrity distributed applications are used in many critical domains. They must be designed and built with a great deal of vigor, as a failure could mean loss of life. Thus, it is preferable that a significant part of their code be generated automatically from a model that describes their critical aspects. Automatic code generation eases the process of certification as well. In this paper we introduce the use of AADL as a modeling language for HI distributed systems. Then we present our Ravenscar Profile compliant Ada code generation rules from AADL models. Finally, we present our Ravenscar Profile compliant middleware, PolyORB-HI and the extension of the code generation rules for HI distributed applications.

AO4AADL: Aspect oriented extension for AADL

Managing embedded system complexity and scalability is one of the most important problems in software development. To better address this problem, it is very recommended to have an abstraction level high enough to model such systems. Architectural description languages (ADLs) intend to model complex systems and manage their structure at a high abstraction level. Traditional ADLs do not normally provide appropriate formalisms to separate any kind of crosscutting concerns. This frequently results in poor descriptions of the software architectures and a tedious adaptation to constantly changing user requirements and specifications. AOSD (Aspect Oriented Software Development) deals with these problems by considering crosscutting concerns in software development. The effectiveness of considering an aspect-oriented architectural design appears when aspect concepts are taken into account early in the software’s life-cycle.In this paper, we propose a new aspect language called AO4AADL that adequately manipulates aspect oriented concepts at architecture level in order to master complexity and ensure scalability. The abstract nature of our proposed language allows the generation of aspect code for several programming languages and platforms.

A Middleware for Reconfigurable Distributed Real-Time Embedded Systems

Managing reconfigurable Distributed Real-time Embedded (DRE) systems is a tedious task due to the substantially increasing complexity of these systems and the difficulty to preserve their real-time aspect. In order to resolve this increasing complexity, we propose to develop a new middleware, called RCES4RTES (Reconfigurable Computing Execution Support for Real-Time Embedded Systems), allowing the dynamic reconfiguration of component-based DRE systems. This middleware provides a set of functions ensuring dynamic reconfiguration as well as monitoring and coherence of such systems using a small memory footprint and respecting real-time constraints.

Development of reconfigurable distributed embedded systems with a model-driven approach

In this paper, we propose a model‐driven approach allowing to build reconfigurable distributed real‐time embedded (DRE) systems. The constant growth of the complexity and the required autonomy of embedded software systems management give the dynamic reconfiguration a big importance. New challenges to apply the dynamic reconfiguration at model level as well as runtime support level are required. In this direction, the development of reconfigurable DRE systems according to traditional processes is not applicable. New methods are required to build and to supply reconfigurable embedded software architectures. In this context, we propose an model‐driven engineering based approach that enables to design reconfigurable DRE systems with execution framework support. This approach leads the designer to specify step by step his/her system from a model to another one more refined until the targeted model is reached. This targeted model is related to a specific platform leading to the generation of the most part of the system implementation. We also develop a new middleware that supports reconfigurable DRE systems. Copyright

Architecture Exploration of Real-Time Systems Based on Multi-objective Optimization

This article deals with real-time embedded system design and verification. Real-time embedded systems are frequently designed according to multi-tasking architectures that have timing constraints to meet. The design of real-time embedded systems expressed as a set of tasks raises a major challenge since designers have to decide how functions of the system must be assigned to tasks. Assigning each function to a different task will result in a high number of tasks, and then in higher preemption overhead. In contrast, mapping many functions on a limited number of tasks leads to a less flexible design which is more expensive to change when the functions of the system evolve. This article presents a method based on an optimization technique to investigate the assignment of functions to tasks. We propose a multi-objective evolution strategy formulation which both minimizes the number of preemptions and maximizes task laxities. Our method allows designers to explore the search space of all possible function to task assignments and to find good tradeoffs between the two optimization objectives among schedulable solutions. After explaining our mapping approach, we present a set of experiments which demonstrates its effectiveness for different system sizes.

Fault Tolerance for Distributed Real Time Dynamically Reconfigurable Systems from Modeling to Implementation

The development of computer systems is extremely complex due to real-time, distribution and dynamism requirements. For this reason, whatever the taken precautions, the occurrence of faults is sometimes unavoidable. In this context, we notice the need of techniques ensuring the dependability of realtime distributed dynamically reconfigurable systems. We focus on fault-tolerance, that means avoiding service failures in the presence of faults. In this paper, we have defined a development process for modeling and generating fault tolerance code using aspect oriented programming. First, we integrate fault tolerance elements since the modeling step of a system in order to take advantage of features of analysis, proof and verification possible at this stage using AADL and its annex Error Model Annex. Second, we extend an aspect oriented language and adapt it to respect real-time requirements. Finally, we define a code generation process for both functional preoccupations and crosscutting ones like fault tolerance.

Automatic framework generation for hard real-time applications

The communication and tasking infrastructure of a real-time application makes up a significant portion of any modern embedded control system. Traditionally, the tasking and communication constructs are provided by a full-fledged real-time operating system. We present an approach to automatically generate a robust framework for an application from its architectural description. This framework sits atop a Ravenscar-compliant runtime as opposed to a standard real-time operating system. We also present an extension of our approach to support code generation for high-integrity distributed applications.