Frédéric Boulanger

Exploring Multi-Paradigm Modeling Techniques

Multi-Paradigm Modeling (MPM) addresses the necessity of using multiple modeling paradigms when designing complex systems. Because of its multidisciplinary nature, the MPM field involves research teams with technical backgrounds as different as control science, model checking, modeling language engineering or system-on-chip development. In this paper, we propose to explore the MPM domain through a survey of existing techniques from different horizons. Since the heterogeneity of models is at the heart of MPM, we first identify the sources of this heterogeneity and introduce the problems it raises. Then we show how the different existing techniques address these problems.

A formal abstract framework for modelling and testing complex software systems

The contribution of this paper is twofold: first, it defines a unified framework for modelling abstract components, as well as a formalization of integration rules to combine their behaviour. This is based on a coalgebraic definition of components, which is a categorical representation allowing the unification of a large family of formalisms for specifying state-based systems. Second, it studies compositional conformance testing i.e. checking whether an implementation made of correct interacting components combined with integration operators conforms to its specification.

Extending the Standard Execution Model of UML for Real-Time Systems

The ongoing OMG standard on the “Semantics of a Foundational Subset for Executable UML Models” identifies a subset of UML (called fUML, for Foundational UML), for which it defines a general-purpose execution model. This execution model therefore captures an executable semantics for fUML, providing an unambiguous basis for various kinds of model-based exploitations (model transformation, code generation, analysis, simulation, debugging etc.). This kind of facility is of great interest for the domain of real time systems, where analysis of system behavior is very sensible. One may therefore wonder if the general-purpose execution model of fUML can be used to reflect execution semantics concerns of real-time systems (e.g., concurrency, synchronization, and scheduling.). It would practically mean that it is possible to leverage on this precise semantic foundation (and all the work that its definition implied) to capture the precise execution semantics of real-time systems. In this paper, we show that this approach is not directly feasible, because of the way concurrency and asynchronous communications are actually handled in the fUML execution model. However, we show that introducing support for these aspects is technically feasible and reasonable in terms of effort and we propose lightweight modifications of the Execution model to illustrate our purpose.

A Generic Execution Framework for Models of Computation

The model driven engineering approach has had an important impact on the methods used for the conception of systems. However, some important difficult points remain in this domain. In this paper, we focus on problems related to the heterogeneity of the computation models (and therefore of the modeling techniques) used for the different aspects of a system and to the validation and the execution of a model. We present here a language for describing computation models, coupled with a generic execution platform where different computation models as well as their composition can be interpreted. Our goal is to be able to describe precisely the semantics of the computation models underlying domain specific languages, and to allow the interpretation of these models within our platform. This provides for a non ambiguous definition of the behavior of heterogeneous models of a system, which is essential for validation, simulation and code generation

Bridging the Chasm between Executable Metamodeling and Models of Computation

The complete and executable definition of a Domain Specific Language (DSL) includes the specification of two essential facets: a model of the domain-specific concepts with actions and their semantics; and a scheduling model that orchestrates the actions of a domain-specific model. Metamodels can capture the former facet, while Models of Computation (MoCs) capture the latter facet. Unfortunately, theories and tools for metamodeling and MoCs have evolved independently, creating a cultural and technical chasm between the two communities. Consequently, there is currently no framework to explicitly model and compose both facets of a DSL. This paper introduces a new framework to combine a metamodel and a MoC in a modular fashion. This allows (i) the complete and executable definition of a DSL, (ii) the reuse of a given MoC for different domain-specific metamodels, and (iii) the use of different MoCs for a given metamodel, to account for variants of a DSL.

A model of domain-polymorph component for heterogeneous system design

Heterogeneous systems mix different technical domains such as signal processing, analog and digital electronics, software, telecommunication protocols, etc. Heterogeneous systems are composed of subsystems that are designed using different models of computation (MoC). These MoCs are the laws that govern the interactions of the components of a subsystem. The design of heterogeneous systems includes the design of each part of the system according to its specific MoC, and the connection of the parts in order to build the model representing the system. Indeed, this model allows the MoCs that govern different parts of system to coexist and interact. To be able to use a component which is specified according to a given MoC, under other, different MoCs, we can use either a hierarchical or a non-hierarchical approach, or we can build domain-specific components (DSC). However, these solutions present several disadvantages. This paper presents a new model of component, called domain-polymorph component (DPC). Such a component is atomic and is able to execute its core behavior, specified under a given MoC, under different host MoCs. This approach is not a competitor to the approaches above but is complementary.

Semantic adaptation using CCSL clock constraints

When different parts of a system depend on different technical domains, the best suitable paradigm for modeling each part may differ. In this paper, we focus on the semantic adaptation between parts of a model which use different modeling paradigms in the context of model composition. We show how CCSL, a language for defining constraints and relations on clocks, can be used to define this semantic adaptation in a formal and modular way.

An approach for domain-polymorph component design

Heterogeneous modelling and design tools allow the design of software systems using several computation models. The designed system is built by assembling components that obey a computation model. The internal behavior of a component is specified either in some programming language or by assembling sub-components that obey a possibly different computation model. When the same behavior is used in several computation models, it must be implemented in as many components as there are models, or, if the design platform supports it, it may be implemented as a generic component. Model-specific components require the recoding of the same core behavior several times, and generic components may not take model-specific features into account. In this paper, we introduce the notion of domain-polymorph component. Such a component is able to adapt a core behavior to the semantics of several computation models. The core behavior is implemented only once and is automatically adapted to the semantics of different computation models. Domain-polymorph components can be chosen by a system designer and integrated in a computation model: they will benefit from an appropriate execution environment and their semantics will be adapted to the host model. The designer will have the choice for several parameters of the adaptation. Contrary to generic components, such components adapt their behavior to the host model instead of letting the host model interpret their generic behavior. We also present an implementation of the concept of domain-polymorph component in the Ptolemy II framework.

Testing of Component-Based Systems

In this paper, we pursue our works on generic modeling and testing of component-based systems. Here, we extend our conformance testing theory to the testing of component-based systems. We first show that testing a global system can be done by testing its components thanks to the projection of global behaviors onto local ones. Secondly, based on our projection techniques, we define a framework to build adequate test purposes automatically for testing components in the context of the global system where they are plugged in. The basic idea is to identify from any trace try of the global system, the trace of any component involved in tr. Those projected traces can be then seen as test cases that should be tested on individual components.

Testing of abstract components

In this paper, we present a conformance testing theory for Barbosas abstract components. We do so by defining a trace model for components from causal transfer functions which operate on data flows at discrete instants. This allows us to define a test selection strategy based on test purposes which are defined as subtrees of the execution tree built from the component traces. Moreover, we show in this paper that Barbosas definition of components is abstract enough to subsume a large family of state-based formalisms such as Mealy machines, Labeled Transition Systems and Input/Output Labeled Transition Systems. Hence, the conformance theory presented here is a generalization of the standard theories defined for different state-based formalisms and is a key step toward a theory of the test of heterogeneous systems.