Search

The complexity of cyber–physical systems (CPSs) is commonly addressed through complex workflows, involving models in a plethora of different formalisms, each with their own methods, techniques, and tools. Some workflow patterns, combined with particular types of formalisms and operations on models in these formalisms, are used successfully in engineering practice. To identify and reuse them, we refer to these combinations of workflow and formalism patterns as modelling paradigms. This paper proposes a unifying (Descriptive) Framework to describe these paradigms, as well as their combinations. This work is set in the context of Multi-Paradigm Modelling (MPM), which is based on the principle to model every part and aspect of a system explicitly, at the most appropriate level(s) of abstraction, using the most appropriate modelling formalism(s) and workflows. The purpose of the Descriptive Framework presented in this paper is to serve as a basis to reason about these formalisms, workflows, and their combinations. One crucial part of the framework is the ability to capture the structural essence of a paradigm through the concept of a paradigmatic structure. This is illustrated informally by means of two example paradigms commonly used in CPS: Discrete Event Dynamic Systems and Synchronous Data Flow. The presented framework also identifies the need to establish whether a paradigm candidate follows, or qualifies as, a (given) paradigm. To illustrate the ability of the framework to support combining paradigms, the paper shows examples of both workflow and formalism combinations. The presented framework is intended as a basis for characterisation and classification of paradigms, as a starting point for a rigorous formalisation of the framework (allowing formal analyses), and as a foundation for MPM tool development. [ABSTRACT FROM AUTHOR]

Model transformations are essential elements of model-driven engineering (MDE) solutions, as they enable the automatic manipulation of models. MDE promotes the creation of domain-specific metamodels, but without proper reuse mechanisms, model transformations need to be developed from scratch for each new metamodel. In this paper, our goal is to understand whether transformation reuse across metamodels is needed by the community, evaluate its current state, identify practical needs and propose promising lines for further research. For this purpose, we first report on a survey to understand the reuse approaches used currently in practice and the needs of the community. Then, we propose a classification of reuse techniques based on a feature model and compare a sample of specific approaches—model types, concepts, a-posteriori typing, multilevel modeling, typing requirement models, facet-oriented modeling, mapping operators, constraint-based model types, and design patterns for model transformations—based on this feature model and a common example. We discuss strengths and weaknesses of each approach, provide a reading grid used to compare their features, compare with community needs, identify gaps in current transformation reuse approaches in relation to these needs and propose future research directions. [ABSTRACT FROM AUTHOR]

To develop complex systems and tackle their inherent complexity, (executable) modelling takes a prominent role in the development cycle. But whereas good tool support exists for programming, tools for executable modelling have not yet reached the same level of functionality and maturity. In particular, live programming is seeing increasing support in programming tools, allowing users to dynamically change the source code of a running application. This significantly reduces the edit–compile–debug cycle and grants the ability to gauge the effect of code changes instantly, aiding in debugging and code comprehension in general. In the modelling domain, however, live modelling only has limited support for a few formalisms. In this paper, we propose a Multi-Paradigm Modelling approach to add liveness to modelling languages in a generic way, which is reusable across multiple formalisms. Live programming concepts and techniques are transposed to (domain-specific) executable modelling languages, clearly distinguishing between generic and language-specific concepts. To evaluate our approach, live modelling is implemented for three modelling languages, for which the implementation of liveness substantially differs. For all three cases, the exact same structured process was used to enable live modelling, which only required a "sanitization" operation to be defined. [ABSTRACT FROM AUTHOR]

A notion of hierarchical scope is commonplace in many programmatic systems. In the context of model, and in particular graph transformation, the use of scope can present two advantages: first, more natural expression of transformation application locality, and second, reduction in the number of match candidates, promising performance improvements. Previous work on scope, however, has focused on applying it to rule hierarchies, which reduces the number of matches performed, but not necessarily the cost of finding a single match. In this paper we define and explore a hierarchical scope formalism applied to the input graph, with associated modifications to the transformation rule definition. We then experimentally evaluate the benefits and challenges of our scoped model transformations in the state-of-the-art graph rewriting tool GrGen and our research-oriented, meta-modeling and rule-based model transformation tool AToMPM. We use a non-trivial “fire spreading” simulation transformation taken from distributed simulation community and a mutual exclusion transformation benchmark to demonstrate that integration of scope results in an elegant, intuitive, and efficient way of solving model transformation problems. [ABSTRACT FROM AUTHOR]

A large number of model transformation languages and tools have emerged since the early 2000s. A transformation engineer is thus left with too many choices for the language he use to perform a specific transformation task. Furthermore, it is currently not possible to combine or reuse transformations implemented in different languages. We therefore propose T-Core, a framework where primitive transformation constructs can be combined to define and encapsulate reusable model transformation idioms. In this context, the transformation engineer is free to use existing transformation building blocks from an extensible library or define his own transformation units. The proposed primitive transformation operators are the result of deconstructing different existing transformation languages. Reconstructing these languages offers a common basis to compare their expressiveness, provides a framework for inter-operating them, and allows the transformation engineer to design transformations with the most appropriate constructs for the task at hand. [ABSTRACT FROM AUTHOR]

Improving simulation performance using activity tracking has attracted attention in the modeling field in recent years. The reference to activity has been successfully used to predict and promote the simulation performance. Tracking activity, however, uses only the inherent performance information contained in the models. To extend activity prediction in modeling, we propose the activity enhanced modeling with an activity meta-model at the meta-level. The meta-model provides a set of interfaces to model activity in a specific domain. The activity model transformation in subsequence is devised to deal with the simulation difference due to the heterogeneous activity model. Finally, the resource-aware simulation framework is implemented to integrate the activity models in activity-based simulation. The case study shows the improvement brought on by activity-based simulation using discrete event system specification (DEVS). [ABSTRACT FROM AUTHOR]

We introduce the MoTif (Modular Timed graph transformation) language, which allows one to elegantly model complex control structures for programmed graph transformation. These include modular construction, parallel composition, and a temporal dimension in addition to the usual transformation control structures. The first part of this contribution formally introduces MoTif and its semantics is based on the Discrete EVent system Specification (DEVS) formalism which allows for highly modular, hierarchical modelling of timed, reactive systems. In MoTif, graphs are embedded in events and individual transformation rules are embedded in atomic DEVS models. A side effect of the use of DEVS is the introduction of an explicit notion of time. This allows one to model a time-advance for every rule as well as to interrupt (pre-empt) rule execution. In the second part, we design a case study to show how the explicit notion of time allows for the simulation-based design of reactive systems such as modern computer games. We use the well-known game of PacMan as an example and model its dynamics in MoTif. This also allows the modelling of player behaviour, incorporating data about human players' behaviour, and reaction times. Thus, a model of both player and game is obtained which can be used to evaluate, through simulation, the playability of a game design. We propose a playability performance measure and change the value of some parameters of the PacMan game. For each variant of the game thus obtained, simulation yields a value for the quality of the game. This allows us to choose an 'optimal' (from a playability point of view) game configuration. The user model is subsequently replaced by a visual interface to a real player, and the game model is executed using a real-time DEVS simulator. [ABSTRACT FROM AUTHOR]

Decision modeling is an essential part of the combat system effectiveness simulation (CoSES), which needs to cope with the cognitive quality, diversity, flexibility, and higher abstraction of decision making. In this paper, a multi-paradigm decision modeling framework is proposed to support decision modeling at three levels of abstraction based on domain-specific modeling (DSM). This framework designs a domain-specific modeling language (DSML) for decision modeling to raise the abstraction level of modeling, transforms the domain-specific models to formalism-based models to enable formal analysis and early verification and validation, and implements the semantics of the DSML based on a Python scripts framework which incorporates the decision model into the whole simulation system. The case study shows that the proposed approach incorporates domain expertise and facilitates domain modeler's participation in CoSES to formulate the problem using DSML in the problem domain, and enables formal analysis and automatic implementation of the decision model in the solution domain. [ABSTRACT FROM AUTHOR]

Domain-specific modelling reduces the gap between problem domain and solution domain. It supports modelling using constructs familiar to experts of a specific domain. Domain-specific models (DSms) are (semi)automatically transformed to various lower-level artifacts, including configuration files, documentation and executable programs. Although various aspects of model-driven development have been investigated, such as model versioning, debugging and transformation, relatively not much attention has been paid to formalise how artifacts are synthesised from DSms. State-of-the-art approaches rely on ad hoc coded generators that essentially use modelling tool APIs to programmatically iterate through internal representations of DSm entities to produce target-platform artifacts. In this work, we propose a more structured approach to artifact generation, where layered model transformations are used to modularly isolate, compile and re-combine various concerns within DSms, while maintaining traceability links between corresponding constructs at different levels of abstraction. We study and demonstrate how our approach simplifies addressing non-functional requirements (e.g., timing and resource utilisation constraints) of modern embedded systems. This is achieved through the modular synthesis of performance models from DSms. We illustrate our work by means of the synthesis of fully functional Google Android applications, performance predictions, simulations and performance measurement facilities from DSms of mobile phone applications. [ABSTRACT FROM AUTHOR]

Designers of complex real-time systems need to address dependability requirements early on in the development process. This paper presents a model-based approach that allows developers to analyse the dependability of use cases and to discover more reliable and safe ways of designing the interactions of the system with the environment. The hardware design and the dependability of the hardware to be used also needs to be considered. We use a probabilistic extension of statecharts to formally model the interaction requirements defined in the use cases. The model is then evaluated analytically based on the success and failure probabilities of events. The analysis may lead to further refinement of the use cases by introducing detection and recovery measures to ensure dependable system interaction. A visual modelling environment for our extended statecharts formalism supporting automatic probability analysis has been implemented in AToM3, A Tool for Multi-formalism and Meta-Modelling. Our approach is illustrated with an elevator control system case study. [ABSTRACT FROM AUTHOR]

Complex real-time system design needs to address dependability requirements, such as safety, reliability, and security. We introduce a modelling and simulation based approach which allows for the analysis and prediction of dependability constraints. Dependability can be improved by making use of fault tolerance techniques. The de-facto example, in the real-time system literature, of a pump control system in a mining environment is used to demonstrate our model-based approach. In particular, the system is modelled using the Discrete EVent system Specification (DEVS) formalism, and then extended to incorporate fault tolerance mechanisms. The modularity of the DEVS formalism facilitates this extension. The simulation demonstrates that the employed fault tolerance techniques are effective. That is, the system performs satisfactorily despite the presence of faults. This approach also makes it possible to make an informed choice between different fault tolerance techniques. Performance metrics are used to measure the reliability and safety of the system, and to evaluate the dependability achieved by the design. In our model-based development process, modelling, simulation and eventual deployment of the system are seamlessly integrated. [ABSTRACT FROM AUTHOR]

This paper presents the combined use of meta-modelling and graph grammars for the generation of visual modelling tools for simulation formalisms. In meta-modelling, formalisms are described at a meta-level. This information is used by a meta-model processor to generate modelling tools for the described formalisms. We combine meta-modelling with graph grammars to extend the model manipulation capabilities of the generated modelling tools: edit, simulate, transform into another formalism, optimize and generate code. We store all (meta-)models as graphs, and thus, express model manipulations as graph grammars. We present the design and implementation of these concepts in AToM3 (A_To_ol for M_ulti-formalism, M_eta-M_odelling). AToM3 supports modelling of complex systems using different formalisms, all meta-modelled in their own right. Models in different formalisms may be transformed into a single common formalism for further processing. These transformations are specified by graph grammars. Mosterman and Vangheluwe [18] introduced the term multi-paradigm modelling to denote the combination of multiple formalisms, multiple abstraction levels, and meta-modelling. As an example of multi-paradigm modelling we present a meta-model for the Object-Oriented Continuous Simulation Language OOCSMP, in which we combine ideas from UML class diagrams (to express the OOCSMP model structure), Causal Block Diagrams (CBDs), and Statecharts (to specify the methods of the OOCSMP classes). A graph grammar is able to generate OOCSMP code, and then a compiler for this language (C-OOL) generates Java applets for the simulation execution. [ABSTRACT FROM AUTHOR]

This paper presents the combined use of meta-modelling and graph grammars for the generation of visual modelling tools for simulation formalisms. In meta-modelling, formalisms are described at a meta-level. This information is used by a meta-model processor to generate modelling tools for the described formalisms. We combine meta-modelling with graph grammars to extend the model manipulation capabilities of the generated modelling tools: edit, simulate, transform into another formalism, optimize and generate code. We store all (meta-)models as graphs, and thus, express model manipulations as graph grammars. We present the design and implementation of these concepts in AToM3 (A_To_ol for M_ulti-formalism, M_eta-M_odelling). AToM3 supports modelling of complex systems using different formalisms, all meta-modelled in their own right. Models in different formalisms may be transformed into a single common formalism for further processing. These transformations are specified by graph grammars. Mosterman and Vangheluwe [18] introduced the term multi-paradigm modelling to denote the combination of multiple formalisms, multiple abstraction levels, and meta-modelling. As an example of multi-paradigm modelling we present a meta-model for the Object-Oriented Continuous Simulation Language OOCSMP, in which we combine ideas from UML class diagrams (to express the OOCSMP model structure), Causal Block Diagrams (CBDs), and Statecharts (to specify the methods of the OOCSMP classes). A graph grammar is able to generate OOCSMP code, and then a compiler for this language (C-OOL) generates Java applets for the simulation execution. [ABSTRACT FROM AUTHOR]