Thomas Leveque

Supporting incremental synchronization in hybrid multi-view modelling

Multi-view modelling is a widely accepted technique to reduce the complexity in the development of modern software systems. It allows developers to focus on a narrowed portion of the specification dealing with a selected aspect of the problem. However, multi-view modelling support discloses a number of issues mainly due to consistency management, expressiveness, and customization needs. A possible solution to alleviate those problems is to adopt a hybrid solution for multi-view modelling based on an arbitrary number of custom views defined on top of an underlying modelling language. In this way it is possible to benefit from the consistency by-construction granted by well-formed views while at the same time providing malleable perspectives through which the system under development can be specified. In this respect, this paper presents an approach for supporting synchronization mechanism based on model differences in hybrid multi-view modelling. Model differences allow to focus only on the manipulations operated by the user in a particular view, and to propagate them to the other views in a incremental way thus reducing the overhead of a complete recomputation of modified models.

A hybrid approach for multi view modeling

Multi-view modeling is a widely accepted technique to reduce the complexity in the development of modern software systems. It allows developers to focus on a narrowed portion of the specification dealing with a selected aspect of the problem. However, multi-view modeling support discloses a number of issues: on the one hand consistency management very often has to cope with semantics interconnections between the different concerns. On the other hand, providing a predefined set of views usually results as too restrictive because of expressiveness and customization needs. This paper proposes a hybrid solution for multi-view modeling based on an arbitrary number of custom views defined on top of an underlying modeling language. The aim is to benefit from the consistency by-construction granted by well-defined views while at the same time providing malleable perspectives through which the system under development can be specified.

Evolution management of extra-functional properties in component-based embedded systems

As software complexity increases in embedded systems domain, component-based development becomes increasingly attractive. A main challenge in this approach is however to analyze the systems extra-functional properties (such as timing properties, or resource requirements), an important step in a development of embedded systems. Analysis of such properties are computational and time consuming, and often difficult. For this reason reuse of the results of the analysis is as important as the reuse of the component itself, especially in case of modifications of the context in which the component is used. This paper presents concepts and mechanisms that allow to automatically discover whether a property value is still valid when related components evolve: a value context language is proposed to formally define the validity conditions and identify possible threats.

Flexible Semantic-Preserving Flattening of Hierarchical Component Models

Hierarchical component models allow to better manage system design complexity compared to flat component models. However, many analysis techniques lack support for dealing with hierarchical models. This paper presents a general approach to use existing analysis on hierarchical component systems by means of a flattening transformation. The transformation can be partially applied, which provides a possibility for tradeoffs between analysis scalability, result precision and reusability concerns. The general approach has been implemented and evaluated in the context of ProCom, a hierarchical component model for real-time embedded systems. As a result, the paper describes a flattening transformation which preserves the ProCom operational semantics and presents the related optimizations.

Hierarchical Composition of Parametric WCET in a Component Based Approach

Worst Case Execution Time (WCET) computation is crucial to the overall timing analysis of real-time embedded systems. Facing the ever increasing complexity of such systems, techniques dedicated to WCET analysis can take advantage of Component Based Software Engineering (CBSE) by decomposing a difficult problem into smaller pieces, easier to analyse. To achieve this objective, the corresponding analysis results have to be composed to provide timing guarantees on the whole system. In this paper, we express the WCET of a component as a formula, allowing to represent its different computational modes. We then propose a Model Driven Engineering (MDE) approach that derives parametric WCET for composite components from parametric WCET of their subcomponents. This approach gives more accurate WCET estimates than naaive additive compositional analysis by taking into account usage context of components. However, analysis scalability concerns lead us to consider a trade-off between precision and scalability. This trade-off can be specified in the model. The composition of WCET estimations is automated and produces the parametric WCET expression of the composite component under analysis. This approach has been integrated in PRIDE.

PRIDE - An Environment for Component-Based Development of Distributed Real-Time Embedded Systems

Settling down the software architecture for embedded system is a complex and time consuming task. Specific concerns that are generally issued from implementation details must be captured in the software architecture and assessed to ensure system correctness. The matter is further complicated by the inherent complexity and heterogeneity of the targeted systems, platforms and concerns. In addition, tools capable of conjointly catering for the complete design-verification deployment cycle, extra-functional properties and reuse are currently lacking. To address this, we have developed Pride, an integrated development environment for component-based development of embedded systems. Pride is based on an architecture relying on components with well-defined semantics that serve as the central development entity, and as means to support and aggregate various analysis and verification techniques throughout the development -- from early specification to synthesis and deployment. Pride also provides generic support for integrating extra-functional properties into architectural definitions.

On the concurrent versioning of metamodels and models: challenges and possible solutions

Model-Driven Engineering aims at shifting the focus of software development from coding to modelling in order to reduce the complexity of realizing nowadays applications. In this respect, models are expected to evolve due to refinements, improvements, bug fixes, and so forth. Because of the same reasons, also modelling languages (i.e. metamodels) are expected to be changed, even though at a different speed if compared to models. The relevant corpus of research grown up in the latest years and dealing with both these problems considers them as separate events; however, in normal practice not all the models are migrated instantaneously due to a metamodel adaptation, rather the co-adaptation is required when commits are attempted from a local workspace to the model repository, which can demand for different management policies. This paper illustrates the challenges arising in coping with concurrent metamodel and model versioning. In particular, it details a set of desired behaviours among which the user would usually select the appropriate management for the scenario into consideration together with entailed problems. Moreover, the work proposes corresponding solutions and discusses open issues.

Modeling Security Aspects in Distributed Real-Time Component-Based Embedded Systems

Model Driven Engineering (MDE) and Component Based Software Development (CBSD) are promising approaches to deal with the increasing complexity of Distributed Real-Time Critical Embedded Systems. On one hand, the functionality complexity of embedded systems is rapidly growing. On the other hand, extra-functional properties (EFP) must be taken into account and resource consumption must be optimized due to limited resources. However, EFP are not independent and impact each other. This paper introduces concepts and mechanisms that allow to model security specifications and derive automatically the corresponding security implementations by transforming the original component model into a secured one taking into account sensitive data flow in the system. The resulted architecture ensures security requirements by construction and is expressed in the original meta model, therefore, it enables using the same timing analysis and synthesis as with the original component model.

A Solution for Concurrent Versioning of Metamodels and Models.

Model-Driven Engineering has been widely recognised as a powerful paradigm for shifting the focus of software development from codingto modelling in order to cope with the rising complexity of modern systems. Models become the main artefacts in the development process and therefore undergo evolutions performed in different ways until the final implementation is produced. Moreover, modelling languages are expectedto evolve too and such evolutions have to be taken into account when dealing with model versioning. Since consistency between models and related metamodels is one of the pillars on which model-driven engineering relies, evolution of models and metamodels cannot be considered as independentevents in a model versioning system.This article exploits model comparison and merging mechanisms toprovide a solution to the issues related to model versioning when considering metamodel and model manipulations as concurrent and even misaligned. A scenario-based description of the challenges arising from versioning of models is given and a running example is exploited to demonstrate the proposed solutions.

Refining extra-functional property values in hierarchical component models

It is nowadays widely accepted that extra-functional properties (EFPs) are as important as functional properties for system correctness, especially when considering systems such as safety-critical embedded systems. The criticality and resource-constrained nature of these systems necessitate to be able to predict tight and accurate extra-functional property values all along the development, from early estimations to measurements. By using a hierarchical component model that allows implementing components as an assembly of subcomponent instances, the same component can be instantiated in several assemblies, i.e. in different usage contexts. Many EFP values are sensitive to the usage context and knowing information about the enclosing assembly enables refining the values of the properties on the subcomponents. Such refinement is usually not supported and the consistency between refined values and the original ones not ensured. This paper presents the concepts and mechanisms to support EFP refinement in hierarchical component models with explicit property inheritance and refinement policies which formally define consistency constraints between refined value and the original one. These policies are interpreted and ensured for all actors and in all workspaces. The paper also describes the related experiments performed on the ProCom component model.