A Generalized Stepping Semantics for Model Debugging (original) (raw)

Model-Based Debugging – State of the Art And Future Challenges

Electronic Notes in Theoretical Computer Science, 2007

A considerable body of work on model-based software debugging (MBSD) has been published in the past decade. We summarise the underlying ideas and present the different approaches as abstractions of the concrete semantics of the programming language. We compare the model-based framework with other wellknown Automated Debugging approaches and present open issues, challenges and potential future directions of MBSD.

Explicit Modelling and Synthesis of Debuggers for Hybrid Simulation Languages

TMS/DEVS Symposium on Theory of Modeling & Simulation (TMS/DEVS 2017), 2017

Any sufficiently complex system is best described (or specified) with a combination of models in multiple formalisms. To support the creation of such "hybrid models", recent research focuses on the (syntactic and semantic) combination of formalism fragments. To implement the hybrid language's operational semantics, the simulators of each of the formalisms are combined. Inspired by this same principle, we study how hybrid simulators can be instrumented with debugging capabilities. Previous work has shown that an explicit model of any simulator's behaviour can be instrumented with common code debugging operations (e.g., stepwise execution, breakpoints, pause/play) and simulation-specific operations (such as (scaled) real-time simulation, or event injection). We extend this work by combining two debugging-enhanced simulators to create a hybrid simulator in a modular way, and instrument it with debugging support at the hybrid level. To demonstrate feasibility, we create a debugging-enhanced simulator of the Hybrid Automata formalism, by embedding a Causal Block Diagrams simulator in a Timed Finite State Automata simulator.

A portable debugger for algorithmic modelica code

2005

In this paper we present the first comprehensive debugger for the algorithmic subset of the Modelica language, which augments previous work in our group on declarative static and dynamic debugging of equations in Modelica. This replaces debugging of algorithmic code using primitive means such as print statements or asserts which is complex, time-consuming and errorprone.

A Generalized Model for Algorithmic Debugging

Lecture Notes in Computer Science, 2015

Algorithmic debugging is a semi-automatic debugging technique that is present in practically all mature programming languages. In this paper we claim that the state of the practice in algorithmic debugging is a step forward compared with the state of the theory. In particular, we argue that novel techniques for algorithmic debugging cannot be supported by the standard internal data structures, such as the Execution Tree (ET), used in this technique, and hence a generalization of the standard definitions and algorithms is needed. We identify two specific problems of the standard formulation and implementations of algorithmic debugging, and we propose a reformulation to solve both problems. The reformulation has been done in a paradigm-independent manner to make it useful and reusable in different programming languages.

Integrated Debugging of Equation-Based Models

The high abstraction level of equation-based objectoriented languages (EOO) such as Modelica has the drawback that programming and modeling errors are often hard to find. In this paper we present the first integrated debugger for equation-based languages like Modelica, which can combine static and dynamic methods for run-time debugging of equation-based Modelica models during simulations. This builds on and extends previous results from a transformational static equation debugger and a dynamic debugger for the algorithmic subset of Modelica.

Model Execution Tracing: A Systematic Mapping Study

Software and Systems Modeling (Sosym), 2019

Model Driven Engineering is a development paradigm that uses models instead of code as primary development artifacts. In this paper, we focus on exe-cutable models, which are used to abstract the behavior of systems for the purpose of verifying and validating (V&V) a system's properties. Model execution tracing (i.e., obtaining and analyzing traces of model executions) is an important enabler for many V&V techniques including testing, model checking, and system comprehension. This may explain the increase in the number of proposed approaches on tracing model executions in the last years. Despite the increased attention , there is currently no clear understanding of the state of the art in this research field, making it difficult to identify research gaps and opportunities. The goal of this paper is to survey and classify existing work on model execution tracing, and identify promising future research directions. To achieve this, we conducted a systematic mapping study where we examined 64 primary studies out of 645 found publications. We found that the majority of model execution tracing approaches has been developed for the purpose of testing and dynamic analysis. Furthermore, most approaches target specific modeling languages and rely on custom trace representation formats, hindering the synergy among tools and exchange of data. This study also revealed that most existing approaches were not validated empirically, raising doubts as to their effectiveness in practice. Our results suggest that future research should focus on developing a common trace exchange format for traces, designing scalable trace representations, as well as conducting empirical studies to assess the effectiveness of proposed approaches.

Integrated Debugging of Modelica Models

Modeling, Identification and Control: A Norwegian Research Bulletin, 2014

The high abstraction level of equation-based objectoriented languages (EOO) such as Modelica has the drawback that programming and modeling errors are often hard to find. In this paper we present the first integrated debugger for equation-based languages like Modelica, which can combine static and dynamic methods for run-time debugging of equation-based Modelica models during simulations. This builds on and extends previous results from a transformational static equation debugger and a dynamic debugger for the algorithmic subset of Modelica.

Efficient debugging of large algorithmic modelica applications

7th Vienna International Conference on Mathematical Modelling, 2012

Modelica models often contain functions with algorithmic code. The fraction of algorithmic code is increasing in Modelica models since Modelica, in addition to equation-based modeling, is also used for embedded system control code and symbolic model transformations in compilers using the MetaModelica language extension. For these reasons, debugging of algorithmic Modelica code is becoming increasingly relevant.

Static and Dynamic Debugging of Modelica Models

Proceedings of the 9th International MODELICA Conference, September 3-5, 2012, Munich, Germany, 2012

The high abstraction level of equation-based objectoriented languages (EOO) such as Modelica has the drawback that programming and modeling errors are often hard to find. In this paper we present static and dynamic debugging methods for Modelica models and a debugger prototype that addresses several of those problems. The goal is an integrated debugging framework that combines classical debugging techniques with special techniques for equation-based languages partly based on graph visualization and interaction.