In this paper, I present the topic of my PhD: the explicit modelling of model debugging and experimentation. Semantics of modelling formalisms include non-determinism, concurrency, and hierarchy, amongst others. Moreover, simulated time can have di erent relations to the wall-clock time and supports certain operations such as pausing. Providing debugging support for model simulations is non-trivial using traditional software development techniques. We therefore propose to model simulators, their debuggers, and environments explicitly. The systems we analyse, design, and develop today are characterized by an ever growing complexity. Modelling and Simulation (M&S ) become increasingly important enablers in the development of such systems, as they allow rapid prototyping and early validation of designs. Domain experts, such as automotive or aerospace engineers, build models of the (software-intensive) system being developed and subsequently simulate them having a set of \goals" or desired properties in mind. Every aspect of the system is modelled, at the most appropriate level of abstraction, using the most appropriate formalism [1]. The M&S approach can only be successful if there is su cient tool support, i.e., if the modeller has access to tools which su ciently support each phase in the M&S approach. This is no di erent from traditional, code-based software development methods: programmers have access to various helpful tools such as version control software, testing tools, and debuggers. Debuggers allow to locate the source of a defect (which was detected by a failing test, meaning that one of its properties was not satis ed) using breakpoints, stepping, and tracing of runtime variables [2]. Support for simulation debugging is currently limited, and a challenging issue, as the next subsections explain.
As was mentioned above, di erent aspects of a system are modelled
in a number of di erent modelling formalisms. This means that,
unlike a programming project, where usually one programming language
is used, a debugger has to be aware of the di erent semantic aspects of
these formalisms. A few examples of such languages include Petrinets [
The notion of time plays a prominent role in model simulation. Simulated time di ers from the wall-clock time: it is the internal clock of the simulator. In general, a simulator updates some state variable vector, which keeps track of the current simulation state, each time increment. This is shown visually in Figure 1a. The state is updated by some computations, or \steps": a big step corresponds to the computation of the next value of the state variable, and consists of a number of small steps. 5 ) T (S 4 e m iT 3 d e lta 2 u m iS 1 0 "smal step" "big step" ) V S ( e l b a i r a V e t a t S 1
2 3 Simulated Time (ST) 4 5
Simulation Step (SSTEP) (a) Change of the state variable over time. (b) Multiple steps executed on a single simulation time instance.
Executing program code is always done as fast as possible, i.e., the speed of the program is limited by the machine executing it. Simulations, however, have an additional notion of time: the simulated time. A simulation can be run as-fast-as-possible, or in (scaled) real-time, which is useful for simulating models of real-time systems which might be deployed as such on a real-time device. In this case, there is a linear relation between the wall-clock time and the simulated time. The relation of the di erent notions of simulated time and the wall-clock time is shown visually in Figure 2. Note that there is no linear relation in as-fast-as-possible simulation, meaning that the \current simulation time" is simply a variable in the simulator. Moreover, operations can be performed on simulated time, such as pausing, or stepping back, which are not allowed on wall-clock time. analytical time (as fast as possible) stop event
ST0=0WCT not possible pause event resume event scale factor changed after resume
ST0<0WCT 4
PAUSE 1 2 3 5 6 7 8 9 10
Wallclock0Time0(WCT) Users interact with a simulation through the simulation environment. The interleaving of user events coming from the environment with the real-time, interruptible behaviour of the simulator (or interacting simulators, in the case of hybrid system simulation), is non-trivial. The challenge is to manage the inherent complexity of constructing model debugging and experimentation environments. The interplay of formalism execution semantics, di erent notions of simulated time, and user interaction makes this a challenging task if traditional software development methods are used. While examples exist of model simulation debuggers implemented in code, it is clear that, especially for multiformalism environments, techniques are needed to overcome this complexity. 2
One research question of the PhD is how concepts of program debugging
are mapped onto model simulation. For example, what does it mean to
step over or into a state in a Statecharts model, or a Place in a Petrinets
model? In some cases, this mapping is straightforward: stepping into a
composite Statechart state will change the scope of the simulation to
its contained states. Sometimes, such a mapping cannot be constructed.
Mannadiar and Vangheluwe [
In [
The goal of this thesis is to construct a set of techniques for developing
useful debuggers for model simulations, taking inspiration from the code
debugging world and the simulation-speci c concepts discussed in
Section 1. In this section, we further split this up into a number of sub-goals.
A rst goal is to construct a set of debugging environments for a number
of well-known general-purpose modelling formalisms: Petrinets,
Statecharts, Causal Block Diagrams (CBDs) [
In Figure 3c, the last step in creating an instrumented simulator is shown. We merge the modal part of the simulator for F with the behavioural pause resume MDebug
SC ready
reset start/initialize paused running stop stopped
M
SIMSC
SIMFmodal
SC [!finished] running
stopped [finished] (a) A model in formalism ulation kernel for F.
F and a sim
(b) De/Reconstructing the simulator.
SIMFmodal paused pause resume
MERGE INSTRUMENT ready start/initialize [!finished] running
stopped [finished]/stop
reset stop
SC stopped (c) Merging the debugging concepts haviour of the simulator. with the modal beow for explicitly modelling the simulator's behaviour. model of the debugger. This results in an instrumented model of the modal behaviour of the simulator. The last step is to replace SIMFmodal in Figure 3b with this instrumented model. Again, this should not change the behaviour of the simulator in any way if the user does not make use of the debugging functionality. Extra behaviour has been added, but running the simulator as before is still possible. In the (trivial, but representative) example shown, the debugger includes the concepts of start, pause, resume, and stop. The simulator only has two states: running, and stopped. It runs the main loop of the simulator until the nished condition is satis ed, signalling that the simulation is done.
In a more advanced stage of the thesis, the idea is to apply the same techniques for environments which allow heterogeneous model composition, for which multiple simulators and semantic adaptation are necessary. It is our intuition that explicitly modelling the debugger and simulator will facilitate this. 4
The techniques described in the previous section have been successfully applied to model an experimentation and debugging environment for Causal-Block Diagrams. We took an existing CBD simulator, identi ed its modal part, and extracted it as a Statechart model. We then instrumented this model with debugging support. A graphical user interface allowed users to simulate (as-fast-as-possible or in (scaled) real-time), pause simulation, and step through the simulation (either \big step", meaning the values of all blocks for the next iteration were calculated at once, or \small step", where only the value of one block was computed). It also allowed to set breakpoints and de ne the maximum number of simulation iterations. 5
From the very onset of the project, the goal is adoption of the developed methods, techniques, (prototype) tools and processes in industry (and academics). During each phase of the project, interaction with companies is planned as to align industrial needs and scienti c developments. This will ensure the results are relevant and usable in an industrial context. Moreover, the results of my work are to be published in a number of di erent communities. For the simulation side, conferences such as SpringSim and WinterSim are ideal venues for early validation of results. In a later stage, results will be published in the SIMULATION journal. For the model-driven engineering side, the MODELS and ECMFA conferences, and the journals Software and Systems Modelling (SoSyM) and Science of Computer Programming are ideal. The ICGT and ICMT conferences, as well as the GraBaTs workshop, are ideal venues for the validation of results when using model transformations. Having both industrial and scienti c feedback from a strong community will ensure the quality of the work, and the relevance of the results. Currently, I do not plan usability studies of the proposed approaches. The main contribution of my work are the techniques for constructing advanced debugging environments by explicitly modelling them. Validation of the techniques is provided by implementations for speci c (combinations of) formalisms. 6
Currently, most of my e orts are directed towards developing the
required foundations. In particular, I'm working on a new metamodelling
framework, which enables modular language design and uniform access
to models called the Modelverse. This framework, as well as its web-based
front-end called AToMPM [
I started in September of 2013. The end of my PhD is planned in
December 2017. Below is a course-grained schedule, with expected contributions
per year:
{ 2014: In the coming months, I will be working on a debugging
environment for Parallel DEVS. I will also redo the work of [
I will also continue working on the language engineering topics - in
particular, the explicit modelling of entire modelling languages using the
Modelverse, and the e ect on explicit modelling of transformation and
the technique of RAMi cation [
Acknowledgements. This work was partly funded with a grant from the Agency for Innovation by Science and Technology in Flanders (IWT).