Jérôme Hugues

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.

PolyORB: A Schizophrenic Middleware to Build Versatile Reliable Distributed Applications

The development of real-time distributed applications requires middleware providing both reliability and performance. Middleware must be adaptable to meet application requirements and integrate legacy components. Current middleware provides only partial solutions to these issues. Moreover, they newer address all of them. Thus, a new generation of middleware is required. We have introduced the schizophrenic middleware concept as an integrated solution to build versatile reliable distributed applications. PolyORB, our implementation of schizophrenic middleware, supports various distribution models: CORBA (Common Object Request Broker Architecture), SOAP (Simple Object Access Protocol), DSA (Ada 95 Distributed System Annex), Message Passing (an adaptation of Java Message Service to Ada 95) and Web Server paradigm (close to what AWS offers). In this paper, we describe the implementation of PolyORB and provide a summary of our experience regarding the issues mentioned above.

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.

On the Formal Verification of Middleware Behavioral Properties

Distribution middleware is often integrated as a COTS, providing distribution facilities for critical, embedded or large-scale applications. So far, typical middleware does not come with a complete analysis of their behavioral properties. In this paper, we present our work on middleware modeling and the verification of its behavioral properties; the study is applied to our middleware architecture: PolyORB. Then we present the tools and techniques deployed to actually verify the behavioral properties of our model: Petri nets, temporal logic and advanced algorithms to reduce the size of the state space. Finally, we detail some properties we verify and assess our methodology.

Expressing and Enforcing User-Defined Constraints of AADL Models

The Architecture Analysis and Design Language AADL allows one to model complete systems, but also to define specific extensions through property sets and library of models. Yet, it does not define an explicit mechanism to enforce some semantics or consistency checks to ensure property sets are correctly used. In this paper, we present REAL (Requirements and Enforcements Analysis Language) as an integrated solution to this issue. REAL is defined as an AADL annex language. It adds the possibility to express constraints as theorems based on set theory to enforce implicit semantics of property sets or AADL models. We illustrate the use of the language on case studies we developed with industrial partners.

Adapting Models to Model Checkers, A Case Study : Analysing AADL Using Time or Colored Petri Nets

The verification of High-Integrity Real-Time systems combines heterogeneous concerns: preserving timing con- straints, ensuring behavioral invariants, or specific execu- tion patterns. Furthermore, each concern requires specific verification techniques; and combining all these techniques require automation to preserve semantics and consistency.Model-based approaches focus on the definition of rep- resentation of a system, and its transformation to equivalent representation for further processing, including verification and are thus good candidates to support such automation.In this paper, we show there is a strong requirement to automatically map high-level models to abstractions that are dedicated to specific analysis techniques taking full ad- vantage of tools. We discuss this requirement on a case study: validating some aspects of AADL models using both coloured and time Petri Nets.

From AADL Architectural Models to Petri Nets: Checking Model Viability

Modeling of Distributed Real-Time Embedded (DRE) systems allows one toevaluate models behavior or schedulability. However, assessing that a DREsystem’s behavior is correct in the causal domain is a challenge: one need toelaborate a mathematical abstraction suitable for checking properties likeabsence of deadlock or safety conditions (i.e. an invariant remains all overthe execution).In this paper, we propose a global approach to building Petri Nets models froman architecture described using AADL. We consider the semantics of interactingentities de- ¿ned by AADL, and show how to build corresponding Petri Netsmodels. Based on a case study, we show how the veri- ¿cation process could beautomated and parameterized.

Ada 2005 code patterns for metamodel-based code generation

In this paper we discuss the issues we have explored, as part of the ASSERT project, in the definition and implementation of Ada coding patterns for the support of the automated code generation stage of a comprehensive approach to model-driven development for high-integrity systems.

Contributions to middleware architectures to prototype distribution infrastructures

Distributed applications require specific middleware support for semantics and run-time constraints for a wide range of hardware or software configurations. However, their full specifications and existing implementations show they share functional notions and run-time mechanisms. Thus, distribution infrastructures could be prototyped from a given set of middleware components. Generic middleware proposes patterns to describe distribution models; configurable middleware constructs to abide to run-time constraints. We have introduced the schizophrenic middleware concept as a comprehensive solution to rapidly implement different distribution models. PolyORB, our implementation of a schizophrenic middleware, supports CORBA, SOAP, and the Ada 95 Distributed System Annex and Message Oriented Middleware distribution models. In this paper, we describe existing generic and configurable middleware; we introduce PolyORBs key concepts and design; then we compare our platform design to existing generic and configurable middleware, and discuss their respective use to prototype specific distribution models.

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.