Semantics and Execution of Domain Specific Models

In this paper we present a two-level approach to extend the abstract syntax of models with concrete semantics. First, a light-weight execution interface for iteratable models with a generic user interface allows the tool smith to provide arbitrary execution and visualization engine implementations for his or her Domain Specific Modeling Language (DSML). We discuss how the common execution manager runtime allows co-simulations of different model types and engine implementations to provide a flexible framework in the diverse DSML scenery. Second, as a concrete but nevertheless generic implementation of a simulation engine for behavior models, we present semantic model specifications and a runtime interfacing to the Ptolemy II tool suite. As a project in the area of model simulation, the latter provides a mature sophisticated and formally grounded backbone for model execution. We present our approach as an open source Eclipse integration to be an extension to the Eclipse modeling projects. After introducing basic concepts, the paper explains how simulations are currently being integrated into the framework and presents some illustrative case studies also covering UML approaches

Executing Domain-Specific Models in Eclipse: KLEPTO - KIELER leveraging Ptolemy

We present a two-level approach to extend the abstract syntax of domain-specific models with concrete semantics in order to execute such models. First, a light-weight execution infrastructure for executable models with a generic user interface allows the tool smith to provide arbitrary execution and visualisation engine implementations for a Domain-Specific Language (DSL). Second, as a concrete but nevertheless generic implementation of a simulation engine for behaviour models, we present semantic model specifications and a runtime interfacing to the Ptolemy II tool suite as a formally founded backbone for model execution. We present our approach as an open source extension to Eclipse modelling projects

Prototyping the Semantics of a DSL using ASF+SDF: Link to Formal Verification of DSL Models

A formal definition of the semantics of a domain-specific language (DSL) is a key prerequisite for the verification of the correctness of models specified using such a DSL and of transformations applied to these models. For this reason, we implemented a prototype of the semantics of a DSL for the specification of systems consisting of concurrent, communicating objects. Using this prototype, models specified in the DSL can be transformed to labeled transition systems (LTS). This approach of transforming models to LTSs allows us to apply existing tools for visualization and verification to models with little or no further effort. The prototype is implemented using the ASF+SDF Meta-Environment, an IDE for the algebraic specification language ASF+SDF, which offers efficient execution of the transformation as well as the ability to read models and produce LTSs without any additional pre or post processing.Comment: In Proceedings AMMSE 2011, arXiv:1106.596

A Design Pattern for Executable DSML

Model executability is now a key concern in model-driven engineering, mainly to support early validation and verification (V&V). Some approaches have allowed to weave executability into metamodels, defining executable domain-specific modeling languages (DSML). Then, model validation may be achieved by direct interpretation of the conforming models. Other approaches address model executability by model compilation, allowing to reuse the virtual machines or V&V tools existing in the target domain. Nevertheless, systematic methods are not available to help the language designer in the definition of such an execution semantics and related support tools. For instance, simulators are mostly hand-crafted in a tool specific manner for each DSML. In this paper, we propose to reify the elements commonly used to support execution in a DSML. We infer a design pattern (called Executable DSML pattern) providing a general reusable solution for the expression of the executability concerns in DSML. It favors flexibility and improves reusability in the definition of semantics-based tools for DSML. We illustrate how this pattern can be applied to V&V and models at runtime, and give insights on the development of generic and generative tools for model animators

Weaving Concurrency in eXecutable Domain-Specific Modeling Languages

International audienceThe emergence of modern concurrent systems (e.g., Cyber-Physical Systems or the Internet of Things) and highly-parallel platforms (e.g., many-core, GPGPU pipelines, and distributed platforms) calls for Domain-Specific Modeling Languages (DSMLs) where concurrency is of paramount importance. Such DSMLs are intended to propose constructs with rich concurrency semantics, which allow system designers to precisely define and analyze system behaviors. However , specifying and implementing the execution semantics of such DSMLs can be a difficult, costly and error-prone task. Most of the time the concurrency model remains implicit and ad-hoc, embedded in the underlying execution environment. The lack of an explicit concurrency model prevents: the precise definition, the variation and the complete understanding of the semantics of the DSML, the effective usage of concurrency-aware analysis techniques, and the exploitation of the concurrency model during the system refinement (e.g., during its allocation on a specific platform). In this paper, we introduce a concurrent executable metamodeling approach, which supports a modular definition of the execution semantics , including the concurrency model, the semantic rules, and a well-defined and expressive communication protocol between them. Our approach comes with a dedicated metalanguage to specify the communication protocol, and with an execution environment to simulate executable models. We illustrate and validate our approach with an implementation of fUML, and discuss the modularity and applicability of our approach

An Approach of Domain Polymorph Component Design

International audienceHeterogeneous 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

A Design Pattern to Build Executable DSMLs and associated V&V tools

International audienceModel executability is now a key concern in model-driven engineering, mainly to support early validation and verification (V&V). Some approaches allow to weave executability into metamodels, defining executable domain-specific modeling languages (DSMLs). Model validation can then be achieved by simulation and graphical animation through direct interpretation of the conforming models. Other approaches address model executability by model compilation, allowing to reuse the virtual machines or V\&V tools existing in the target domain. Nevertheless, systematic methods are currently not available to help the language designer in the definition of such an execution semantics and related tools. For instance, simulators are mostly hand-crafted in a tool specific manner for each DSML. In this paper, we propose to reify the elements commonly used to support state-based execution in a DSML. We infer a design pattern (called Executable DSML pattern) providing a general reusable solution for the expression of the executability concerns in DSMLs. It favors flexibility and improves reusability in the definition of semantics-based tools for DSMLs. We illustrate how this pattern can be applied to ease the development of V&V tools

Service Semantics Classification: an Approach Towards Modular Service Ontology

Since service systems are becoming increasingly complex in emerging technology, business, legal and economics environments, service abstractions are necessary to master this complexity. However, the term ‘service’ means different things to different people in different disciplines, which implies that any attempt to define general purpose service abstractions must address the disambiguation of the term. Service ontologies and service knowledge management efforts mainly aim at elucidating service semantics. Each discipline has multiple biased service-related concepts, so that in order to build comprehensive multi-disciplinary service models, the service-related concepts of the involved disciplines have to be integrated and structured in a consistent way. We claim that this requires a modular approach in which general purpose service semantics can be further extended or specialised with domain-specific concepts. Service-related and domain-specific concepts can be integrated and structured in many different ways. This paper proposes a semantics classification scheme based on service aspects that are essential for a services ecosystem