Fabrice Kordon

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.

An introduction to rapid system prototyping

The implementation and maintenance of industrial applications have continuously become more and more difficult. In this context, one problem is the evaluation of complex systems. The IEEE defines prototyping as a development approach promoting the implementation of a pilot version of the intended product. This approach is a potential solution to the early evaluation of a system. It can also be used to avoid the shift between the description/specification of a system and its implementation. This brief introduction to the special section on rapid system prototyping illustrates a current picture of prototyping.

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.

Rapid Prototyping of Intrusion Detection Systems

Designing security softwares that evolve as quickly as threats is a truthful challenge. In addition, current software becomes increasingly more complex and difficult to handle even for security experts. Intrusion Detection Softwares (IDS) represent a solution that can alleviate these concerns. This paper proposes a framework to automatically build an effective online IDS which can check if the programs expected behavior is respected during the execution. The proposed framework extracts relevant information from the programs source code to build a dedicated IDS. We use the GCC compiler to produce the structure of our behaviors model and ensure the IDS is correct. Thanks to Petri nets, our framework allows program offline monitoring and simplifies the online monitoring development.Building Distributed Real-Time Embedded systems requires a stringent methodology, from early requirements capture to full implementation. However, there is a strong link between the requirements and the final implementation (e.g. scheduling, resource dimensioning). Therefore, a rapid prototyping process based on automation of tedious and error-prone tasks (analysis, code generation) is required to speed up the development cycle. In this article, we show how the AADL (Architecture, Analysis and Description Language), appeared late 2005, helps solving these issues thanks to a dedicated tool-suite. We then detail the prototyping process and its current implementation: Ocarina.

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.

Validate, simulate, and implement ARINC653 systems using the AADL

Safety-critical systems are widely used in different domains and lead to an increasing complexity. Such systems rely on specific services such space and time isolation as in the ARINC653 avionics standard. Their criticality requires a carefully driven design based on an appropriate development process and dedicated tools to detect and avoid problems as early as possible. Model Driven Engineering (MDE) approaches are now considered as valuable approach for building safety-critical systems. The Architecture Analysis and Design Language (AADL) proposes a component-based language suitable to operate MDE that fits with safety-critical systems needs. This paper presents an approach for the modeling, verification and implementation of ARINC653 systems using AADL. It details a modeling approach exploiting the new features of AADL version 2 for the design of ARINC653 architectures. It also proposes modeling patterns to represent other safety mechanisms such as the use of Ravenscar for critical applications. This approach is fully backed by tools with Ocarina (AADL toolsuite), POK (AADL/ARINC653 runtime) and Cheddar (scheduling verification). Thus, it assists system engineers to simulate and validate non functional requirements such as scheduling or resources dimensioning.

New features in CPN-AMI 3: focusing on the analysis of complex distributed systems

Due to the state-space size explosion problem, behavioral analysis techniques are difficult to scale up to industrial size problems. Our group couples research on analysis tools with an introspection on modeling and software engineering techniques. CPN-AMI is an integrated development and analysis environment dedicated to Petri nets. The numerous services it offers are built by a homogeneous integration of tools developed internally, and third-party tools from partner universities. These tools include state of the art algorithms and data-structures. This third major release offers better support for modeling and analysis of very large systems

PNML framework: an extendable reference implementation of the petri net markup language

The International Standard on Petri nets, ISO/IEC 15909, provides a formal semantics and syntax to enable model interchange and industrial dissemination. Part 2 defines a concrete interchange format as an XML-based language: PNML. This language is bound to evolve together with future developments of the standard. This paper presents PNML Framework, a companion implementation of the standard. It provides developers of Petri net tools with a convenient and fast way to implement support of PNML documents. It abstracts away from any XML explicit manipulation and ensures compliance with the standard by using APIs.

Hierarchical Set Decision Diagrams and Regular Models

This paper presents algorithms and data structures that exploit a compositional and hierarchical specification to enable more efficient symbolic model-checking. We encode the state space and transition relation using hierarchical Set Decision Diagrams (SDD) [9].In SDD, arcs of the structure are labeled with sets, themselves stored as SDD. To exploit the hierarchy of SDD, a structured model representation is needed. We thus introduce a formalism integrating a simple notion of type and instance . Complex composite behaviors are obtained using a synchronization mechanism borrowed from process calculi. Using this relatively general framework, we investigate how to capture similarities in regular and concurrent models. Experimental results are presented, showing that this approach can outperform in time and memory previous work in this area.

Reliable Software Technologies – Ada Europe 2007

Real-Time Utilities for Ada 2005.- Handling Temporal Faults in Ada 2005.- Implementation of New Ada 2005 Real-Time Services in MaRTE OS and GNAT.- Enhancing Dependability of Component-Based Systems.- On Detecting Double Literal Faults in Boolean Expressions.- Static Detection of Livelocks in Ada Multitasking Programs.- Towards the Testing of Power-Aware Software Applications for Wireless Sensor Networks.- An Intermediate Representation Approach to Reducing Test Suites for Retargeted Compilers.- Correctness by Construction for High-Integrity Real-Time Systems: A Metamodel-Driven Approach.- A Metamodel-Driven Process Featuring Advanced Model-Based Timing Analysis.- ArchMDE Approach for the Development of Embedded Real Time Systems.- Generating Distributed High Integrity Applications from Their Architectural Description.- Automatic Ada Code Generation Using a Model-Driven Engineering Approach.- Towards User-Level Extensibility of an Ada Library: An Experiment with Cheddar.- Modelling Remote Concurrency with Ada.- Design and Performance of a Generic Consensus Component for Critical Distributed Applications.- Sancta: An Ada 2005 General-Purpose Architecture for Mobile Robotics Research.- Incorporating Precise Garbage Collection in an Ada Compiler.