35 research outputs found
Discrete Simulation of Behavioural Hybrid Process Calculus
Hybrid systems combine continuous-time and discrete behaviours. Simulation is one of the tools to obtain insight in dynamical systems behaviour. Simulation results provide information on performance of system and are helpful in detecting potential weaknesses and errors. Moreover, the results are handy in choosing adequate control strategies and parameters. In our contribution we report a work in progress, a technique for simulation of Behavioural Hybrid Process Calculus, an extension of process algebra that is suitable for the modelling and analysis of hybrid systems
Formal methods for test case generation
The invention relates to the use of model checkers to generate efficient test sets for hardware and software systems. The method provides for extending existing tests to reach new coverage targets; searching *to* some or all of the uncovered targets in parallel; searching in parallel *from* some or all of the states reached in previous tests; and slicing the model relative to the current set of coverage targets. The invention provides efficient test case generation and test set formation. Deep regions of the state space can be reached within allotted time and memory. The approach has been applied to use of the model checkers of SRI's SAL system and to model-based designs developed in Stateflow. Stateflow models achieving complete state and transition coverage in a single test case are reported
Model Based Analysis and Test Generation for Flight Software
We describe a framework for model-based analysis and test case generation in the context of a heterogeneous model-based development paradigm that uses and combines Math- Works and UML 2.0 models and the associated code generation tools. This paradigm poses novel challenges to analysis and test case generation that, to the best of our knowledge, have not been addressed before. The framework is based on a common intermediate representation for different modeling formalisms and leverages and extends model checking and symbolic execution tools for model analysis and test case generation, respectively. We discuss the application of our framework to software models for a NASA flight mission
Refinement-based verification of sequential implementations of Stateflow charts
Simulink/Stateflow charts are widely used in industry for the specification
of control systems, which are often safety-critical. This suggests a need for a
formal treatment of such models. In previous work, we have proposed a technique
for automatic generation of formal models of Stateflow blocks to support
refinement-based reasoning. In this article, we present a refinement strategy
that supports the verification of automatically generated sequential C
implementations of Stateflow charts. In particular, we discuss how this
strategy can be specialised to take advantage of architectural features in
order to allow a higher level of automation.Comment: In Proceedings Refine 2011, arXiv:1106.348
SMA -- The Smyle Modeling Approach
This paper introduces the model-based software development lifecycle model SMA -- the Smyle Modeling Approach -- which is centered around Smyle. Smyle is a dedicated learning procedure to support engineers to interactively obtain design models from requirements, characterized as either being desired (positive) or unwanted (negative) system behavior. Within SMA, the learning approach is complemented by so-called scenario patterns where the engineer can specify clearly desired or unwanted behavior. This way, user interaction is reduced to the interesting scenarios limiting the design effort considerably. In SMA, the learning phase is further complemented by an effective analysis phase that allows for detecting design flaws at an early design stage. Using learning techniques allows us to gradually develop and refine requirements, naturally supporting evolving requirements, and allows for a rather inexpensive redesign in case anomalous system behavior is detected during analysis, testing, or maintenance. This paper describes the approach and reports on first practical experiences
Modal Reactors
Complex software systems often feature distinct modes of operation, each
designed to handle a particular scenario that may require the system to respond
in a certain way. Breaking down system behavior into mutually exclusive modes
and discrete transitions between modes is a commonly used strategy to reduce
implementation complexity and promote code readability. However, such
capabilities often come in the form of self-contained domain specific languages
or language-specific frameworks. The work in this paper aims to bring the
advantages of modal models to mainstream programming languages, by following
the polyglot coordination approach of Lingua Franca (LF), in which verbatim
target code (e.g., C, C++, Python, Typescript, or Rust) is encapsulated in
composable reactive components called reactors. Reactors can form a dataflow
network, are triggered by timed as well as sporadic events, execute
concurrently, and can be distributed across nodes on a network.
With modal models in LF, we introduce a lean extension to the concept of
reactors that enables the coordination of reactive tasks based on modes of
operation. The implementation of modal reactors outlined in this paper
generalizes to any LF-supported language with only modest modifications to the
generic runtime system