A Scalable Incomplete Test for the Boundedness of UML RT Models

12th IFAC Conference on Programmable Devices and Embedded Systems (2013), 2013

One of the most important problems of verification of discrete event control systems is detection of possible incorrect communication between concurrent processes, such as mutual blocking. Processes can be modeled as state machines, and such detection can be performed by analysis of behavior of the communicating automata. For such analysis in general case the model checking methods are used, nevertheless some practically important results can be obtained by the methods with lower computational complexity. In the paper a special case of the problem is considered, which is a detection of possible frozen states in a pair of communicating state machines. The algorithm solving this task is presented, its computational complexity is evaluated.

ACM Transactions on Software Engineering and Methodology, 1995

Reachability analysis is an attractive technique for analysis of concurrent programs because it is simple and relatively straightforward to automate, and can be used in conjunction with model-checking procedures to check for application-specific as well as general properties. Several techniques have been proposed differing mainly. on the model used; some of these propose the use of fiowgraph based models, some others of Petri nets. This paper addresses the question: What essential difference does it make, if any, what sort of finite-state model we extract from program texts for purposes of reachability analysis? How do they differ in expressive power, decision power, or accuracy? Since each is intended to model synchronization structure while abstracting away other features, one would expect them to be roughly equivalent. vVe confirm that there is no essential semantic difference between the most well known models proposed in the literature by providing algorithms for translation among these models. This implies that the choice of model rests on other factors, including convenience and efficiency. Since combinatorial explosion is the primary impediment to application of reachability analysis, a particular concern in choosing a model is facilitating divide-andconquer analysis of large programs. Recently, much interest in finite-state verification systems has centered on algebraic theories of concurrency. Yeh and Young have exploited algebraic structure to decompose reachability analysis based on a fiowgraph model. The semantic equivalence of graph and Petri net based models suggests that one ought to be able to apply a similar strategy for decomposing Petri nets. We show this is indeed possible through application of category theory.

1

Second ACIS International Conference on Software …, 2004

In this paper we present an ``on the fly'' model checker for the verification of the dynamic behavior of UML models seen as a set of communicating state machines. The logic supported by the tool is an extension of the action based branching time temporal logic µ-ACTL and has the power of full µ-calculus. Early results on the application of this model checker to a case study have been also reported.

Proceedings of the 42nd annual conference on Design automation - DAC '05, 2005

Signal processing and multimedia applications are often implemented on resource constrained embedded systems. It is therefore important to find implementations that use as little resources as possible. These applications are frequently specified as synchronous dataflow graphs. Communication between actors of these graphs requires storage capacity. In this paper, we present an exact method to determine the minimum storage capacity required to execute the graph using model-checking techniques. This can be done for different measures of storage capacity. The problem is known to be NP-complete and because of this, existing buffer minimisation techniques are heuristics and hence not exact. Modern model-checking tools are quite efficient and they have been successfully applied to scheduling-related problems. We study the feasibility of this approach with examples.

Proceedings of 3rd IEEE International Symposium on High Performance Distributed Computing, 1994

Consider a system of two communicating finite state machines that exchange messages over two unbounded, one-directional, FIFO channels. In our main result, we show that the boundedness problem is decidable for the class of such systems, where the two CFSM's are identical and constituted of only initial elementary circuits, and where the two CFSM's are linear. To analyse such systems, we introduce a reduction relation on the words. We then, give examples to illustrate our purpose.

IFAC Proceedings Volumes, 2012

To decrease the costs associated with repairing errors introduced during the system design, engineers must detect these errors as soon as possible; ideally, in the phase in which they are produced. In Model-Driven Engineering, the models are used to generate automatically large portions of the system implementation, and hence, if there are errors in the models, they are spread onward to the implementation. This work is a first step toward an automatic verification approach for embedded and real-time systems' high-level specifications, such as UML models. A model-driven framework to simulate the execution of system behavior is proposed in order to identify the presence of errors already in early design phases, prior to the implementation phase. The main idea is to allow the simulation of the behavior specified within UML models, from which a trace of the executed actions is created to enable the analysis of the obtained results. This work has been validated in several case studies, including a real-world embedded and real-time system. The achieved results provide indications that early simulation of UML models is practicable, opening room for using the proposed framework in different CASE tools for early verification (based on simulation) of embedded and real-time systems.

2006

ABSTRACT This paper describes ongoing work aimed at the construction of formal cost models and analyses that are capable of producing verifiable guarantees of resource usage (space, time and ultimately power consumption) in the context of realtime embedded systems. Our work is conducted in terms of the domain-specific language Hume, a language that combines functional programming for computations with finitestate automata for specifying reactive systems.

2008 8th International Conference on Application of Concurrency to System Design, 2008

The design of complex concurrent systems often involves intricate performance and dependability considerations. Continuous-time Markov chains (CTMCs) are widely used models for concurrent system designs making it possible to model check such properties. In this paper, we focus on probabilistic timing properties of infinite-state CTMCs, expressible in continuous stochastic logic (CSL). Such properties comprise important dependability measures, such as timed probabilistic reachability, performability, survivability, and various availability measures like instantaneous availabilities, conditional instantaneous availabilities and interval availabilities. Conventional model checkers explore the given model exhaustively which is not always possible either due to state explosion or because the model is infinite. This paper presents a method that only explores the infinite (or prohibitively large) model up to a finite depth, with the depth bound being computed on-the-fly. We provide experimental evidence showing that our method is effective.

Lecture Notes in Computer Science, 2012

We present McScM, a platform for implementing and comparing verification algorithms for the class of finite-state processes exchanging messages over reliable, unbounded FIFO channels. McScM provides tools for the safety verification and controller synthesis of these infinite-state models. Our verification tool implements several modelchecking techniques: CEGAR with different abstraction-refinement methods, abstract interpretation, abstract regular model checking, and lazy abstraction. Seen as a general framework for the class of transition systems with finite control/infinite data, McScM delivers the basic infrastructure for implementing verification algorithms, and privileges to conveniently implement new ideas on a high level of abstraction. It also allows us to compare and benchmark different algorithmic approaches with the same backend.