Ansgar Radermacher

Generating execution infrastructures for component-oriented specifications with a model driven toolchain: a case study for MARTE's GCM and real-time annotations

The development of embedded Systems becomes more and more complex. Model driven engineering can help to manage this complexity by specifying real-time properties in a declarative way and automating the deployment. The UML profile MARTE is a OMG standard that allows to model real-time properties. However, there is no execution infrastructure that supports MARTEs generic component model (GCM) and the application modeling (HLAM). The contribution of the paper is twofold: it presents a proposition of a component model with flexible interaction support that allows to tailor code generation to domain and target requirements. Second, it will show how MARTEs GCM concepts can be implemented by means of the proposed component model. The proposed component model has been largely developed in the context of the French national project Flex-eWare with the intention to unify major components model, notably the CORBA component model (CCM) and Fractal. The paper explains the major elements of this model in detail and shows how specific connector and containers can implement MARTE specifications. We present the tool support that is integrated into a UML modeler and based on model-to-model and model to text transformations.

Designing Fault-Tolerant Component Based Applications with a Model Driven Approach

The requirement for higher reliability and availability of systems is continuously increasing even in domains not traditionally strongly involved in such issues. Solutions are expected to be efficient, flexible, reusable on rapidly evolving hardware and of course at low cost. Model driven approaches can be very helpful for this purpose. In this paper, we propose a study associating model-driven technology and component-based development. This work is illustrated by the realization of a use case from aerospace industry that has fault-tolerance requirements: a launch vehicle. UML based modeling is used to capture application structure and related non-functional requirements thanks to the profiles CCM (CORBA Component Model) and QoS&FT (Quality of Service and Fault Tolerance). The application model is enriched with infrastructure component dedicated to fault-tolerance. From this model we generate CCM descriptor files which in turns are used to build bootcode (static deployment) which instantiates, configures and connects components. Within this process, component replication and FT properties are declaratively specified at model level and are transparent for the component implementation.

An Open Framework for Detailed Hardware Modeling

When interfacing hardware and software design flows, it is a common practice to specify abstracted and understandable models in order to communicate design intends and to study interdependencies affecting design decisions. Modeling languages, such as UML, help to create architectural specifications amenable for reuse, complexity managing, and system refinements. This paper presents a set of extensions to UML that ensure description and conception of hardware through different views and detail levels. At the same time, the proposed extensions offer annotations to analyze and simulate the main extra-functional characteristics of embedded systems, namely, performance, power consumption and memory usage. This work is part of the upcoming OMGs standard for modeling and analysis of real-time and embedded systems (MARTE).

A Model-Driven Framework for the Development of Portable Real-Time Embedded Systems

One pillar of Model-Driven Development for real-time embedded software is the separation of concerns between application model and target platform. This requires definition of model transformations realizing the mapping of the application model onto the target platform. Real-Time and Embedded Systems design means coping with different target platforms and with heterogeneous constraints related to time, synchronization and memory footprint. However, different target platforms have APIs and implementation patterns that vary significantly so that it is necessary to develop several dedicated model transformations in order to achieve portability between them. Although this is one way to achieve portability, we show in this paper that the cost of portability can be reduced by providing domain-independent model transformations while still ensuring performance requirements are satisfied.

Model-Driven Development of Self-Describing Components for Self-Adaptive Distributed Embedded Systems

Todays distributed embedded systems comprise various fields of application. Increasingly they are deployed in complex scenarios and must be able to adapt to changing environments and internal system changes. Such self-adaptive embedded systems pose great advantages in terms of flexibility, resource utilization, energy efficiency and robustness. The realization of these systems require enhanced development methods to incorporate the adaptation in the design. We introduce a novel concept for the model-driven development of self-adaptive embedded systems. The focus of our work is the definition and transfer of the information needed for the adaptation at runtime. This is preserved as so-called self-description of the components. We present our self-x profile, a modeling extension for describing the adaptation, and the respective design flow with built-in transformations. Furthermore, we outline the applicability of our methodology in an automotive use case.

ENHANCING INTERACTION SUPPORT IN THE CORBA COMPONENT MODEL

Even if promising with respect to software complexity management, component-based approaches, like CCM and EJB, have until now fall short in achieving their breakthrough in the real-time and embedded community. Our aim is to adapt one of these approaches - namely the CCM - to the specific needs of this area. In such a process, we have identified several crucial points, among which is interaction management. The current CCM runtime interaction support is actually poor and lacks flexibility. That is the reason why, drawing our inspiration from similar works of the ADLs field, we propose to gather all interaction-related processing in connectors. This paper details the rationale underlying our choice, and outlines all modifications needed to introduce the connector meta-element in the CCM. It also illustrates the relevance of CCM connectors in the scope of a telecommunication use case.

A Fault-tolerance Framework for Distributed Component Systems

The requirement for higher reliability and availability of systems is continuously increasing even in domains not traditionally strongly concerned by such issues. Required solutions are expected to be efficient, flexible, reusable on rapidly evolving hardware and of course at low cost. Combining both model and component seems to be a very promising cocktail for building solutions to this problem. Hence, we will present in this paper an approach using a model as its first structural citizen all along the development process. Our proposal will be illustrated with an application modeled with UML (extended with some of its dedicated profiles). Our approach includes an underlying execution infrastructure/middleware, providing fault-tolerance services. For the component aspect, our framework promotes firstly an infrastructure based on the Component/Container/Connectorparadigm to provide run-time facilities enabling transparent management of fault-tolerance (mainly fault-detection and redundancy mechanisms). For the model-driven point of view, our framework provides tool support for assisting the users to model their applications and to deploy and configure them on computing platforms. In this paper we focus on the run-time support offered by the component framework, specially the replication-aw are interaction mechanism enabling a transparent replication management mechanisms and some additional system components dedicated to fault-detection and replicas management.

Unifying HW Analysis and SoC Design Flows by Bridging Two Key Standards: UML and IP-XACT

In order to save time and improve efficiency, all SoC development processes are separated into many parallel flows. These flows should keep a strong communication to avoid redundancy and incoherency. We distinguish two main trends. One aims at designing and implementing hardware when the other focuses on its functional description that may serve to software architecturing, analysis and allocation. Even if both are newly using UML, no connections have been made to synchronize them. The goal of this work is then to bridge permanently the gap between those two hardware design trends by unifying their corresponding modelbased standards: UML and IP-XACT.

Towards a Model-Driven Engineering approach for developing adaptive real-time embedded systems

Developing real-time embedded systems poses significant challenges to the developers. In such systems, correctness means not only computing the right results but also produce It in a timely way. This implies that response time is as important as producing correct results. Therefore, real-time systems must be built to meet these response times. Several solutions were suggested within the context of Model-Driven Engineering (MDE) to address this problem. However, Real-Time systems may be large, distributed, have long lifetimes and a dynamic environment. On the one hand, such qualities require the use of different software performance and reliability techniques at different levels of granularity and at different time. On the other hand, they involve the integration of new, previously unanticipated services and the update of existing services with the respect of system real-time constraints and without requiring system downtime. These adaptive behaviors amplify more and more the complexity of the development of real-time embedded systems. Existing MDE approach do not handle completely these time-bounded adaptive behaviors. In this position paper, we present the related works around the development of adaptive real-time embedded systems and why we aim to address the issue in MDE approach.

Process and tool support for design patterns with safety requirements

The requirement for higher Security and Dependability (S&D) of systems is continuously increasing, even in domains tradi-tionally not deeply involved in such issues. Nowadays, many practitioners express their worries about current S&D software engineering practices. New recommendations should be considered to ground this discipline on two pillars: solid theory and proven principles. We took the second pillar towards software engineering for embedded system applications, focusing on the problem of integrating S&D by design to foster reuse. In this paper, we propose to combine design patterns and Model Driven Engineering (MDE) techniques for building component-based applications with safety requirements. The resulting modeling framework serves primarily to capture the basic concepts for specifying safety-oriented design patterns, building an S&D pattern system, and maintain safety properties, with existing modeling artifacts, during the engineering process based on the S&D pattern system. As a proof of concept, we are evaluating the feasibility of the framework through the example of the MooN pattern system for building systems having safety requirements: Communication Based Train Control (CBTC).