Results 1  10
of
15
Evaluating Deadlock Detection Methods for Concurrent Software
 IEEE Transactions on Software Engineering
, 1996
"... Static analysis of concurrent programs has been hindered by the well known state explosion problem. Although many different techniques have been proposed to combat this state explosion, there is little empirical data comparing the performance of the methods. This information is essential for assessi ..."
Abstract

Cited by 132 (6 self)
 Add to MetaCart
(Show Context)
Static analysis of concurrent programs has been hindered by the well known state explosion problem. Although many different techniques have been proposed to combat this state explosion, there is little empirical data comparing the performance of the methods. This information is essential for assessing the practical value of a technique and for choosing the best method for a particular problem. In this paper, we carry out an evaluation of three techniques for combating the state explosion problem in deadlock detection: reachability search with a partial order state space reduction, symbolic model checking, and inequality necessary conditions. We justify the method used for the comparison, and carefully analyze several sources of potential bias. The results of our evaluation provide valuable data on the kinds of programs to which each technique might best be applied. Furthermore, we believe that the methodological issues we discuss are of general significance in comparison of analysis te...
Using Shape Analysis to Reduce FiniteState Models of Concurrent Java Programs
 In Proceedings of the International Symposium on Software Testing and Analysis
, 1998
"... Finitestate verification (e.g., model checking) provides a powerful means to detect concurrency errors, which are often subtle and difficult to reproduce. Nevertheless, widespread use of this technology by developers is unlikely until tools provide automated support for extracting the required fini ..."
Abstract

Cited by 37 (0 self)
 Add to MetaCart
(Show Context)
Finitestate verification (e.g., model checking) provides a powerful means to detect concurrency errors, which are often subtle and difficult to reproduce. Nevertheless, widespread use of this technology by developers is unlikely until tools provide automated support for extracting the required finitestate models directly from program source. Unfortunately, the dynamic features of modern languages such as Java complicate the construction of compact finitestate models for verification. In this paper, we show how shape analysis, which has traditionally been used for computing alias information in optimizers, can be used to greatly reduce the size of finitestate models of concurrent Java programs by determining which heapallocated variables are accessible only by a single thread, and which shared variables are protected by locks. We also provide several other statespace reductions based on the semantics of Java monitors. A prototype implementation of the reductions demonstrates their ...
Constructing Compact Models of Concurrent Java Programs
 In Proceedings of the ACM Sigsoft Symposium on Software Testing and Analysis
, 1998
"... Finitestate verification technology (e.g., model checking) provides a powerful means to detect concurrency errors, which are often subtle and difficult to reproduce. Nevertheless, widespread use of this technology by developers is unlikely until tools provide automated support for extracting the re ..."
Abstract

Cited by 28 (4 self)
 Add to MetaCart
(Show Context)
Finitestate verification technology (e.g., model checking) provides a powerful means to detect concurrency errors, which are often subtle and difficult to reproduce. Nevertheless, widespread use of this technology by developers is unlikely until tools provide automated support for extracting the required finitestate models directly from program source. In this paper, we explore the extraction of compact concurrency models from Java code. In particular, we show how static pointer analysis, which has traditionally been used for computing alias information in optimizers, can be used to greatly reduce the size of finitestate models of concurrent Java programs.
An Application Of Petri Net Reduction For Ada Tasking Deadlock Analysis
, 1996
"... As part of our continuing research on using Petri nets to support automated analysis of Ada tasking behavior, we have investigated the application of Petri net reduction for deadlock analysis. Although reachability analysis is an important method to detect deadlocks, it is in general inefficient or ..."
Abstract

Cited by 28 (6 self)
 Add to MetaCart
As part of our continuing research on using Petri nets to support automated analysis of Ada tasking behavior, we have investigated the application of Petri net reduction for deadlock analysis. Although reachability analysis is an important method to detect deadlocks, it is in general inefficient or even intractable. Net reduction can aid the analysis by reducing the size of the net while preserving relevant properties. We introduce a number of reduction rules and show how they can be applied to Ada nets, which are automatically generated Petri net models of Ada tasking. We define a reduction process and a method by which a useful description of a detected deadlock state can be obtained from the reduced net's information. A reduction tool and experimental results from applying the reduction process are discussed.
Reduction Rules for Time Petri Nets
, 1996
"... The goal of net reduction is to increase the effectiveness of Petrinet based realtime program analysis. Petrinetbased analysis, like all reachabilitybased methods, suffers from the state explosion problem. Petri net reduction is one key method for combating this problem. In this paper, we exten ..."
Abstract

Cited by 15 (3 self)
 Add to MetaCart
The goal of net reduction is to increase the effectiveness of Petrinet based realtime program analysis. Petrinetbased analysis, like all reachabilitybased methods, suffers from the state explosion problem. Petri net reduction is one key method for combating this problem. In this paper, we extend several rules for the reduction of ordinary Petri nets to work with time Petri nets. We introduce a notion of equivalence among time Petri nets, and prove that our reduction rules yield equivalent nets. This notion of equivalence guarantees that crucial timing and concurrency properties are preserved. Partially supported by NSF grants CCR9108753 and CCR9314258. Email: sloan@eecs.uic.edu. y Partially supported by NSF grants CCR9109231 and CCR9314258. Email: buy@eecs.uic.edu. 1 Introduction Petri nets have proven to be a very useful tool for the analysis of concurrent systems. To date several approaches have been defined that use Petri nets to model a system being analyzed (e.g...
An Empirical Evaluation of Three Methods for Deadlock Analysis of Ada Tasking Programs
 Proceedings of the 1994 International Symposium on Software Testing and Analysis (ISSTA
, 1994
"... Static analysis of Ada tasking programs has been hindered by the well known state explosion problem that arises in the verification of concurrent systems. Many different techniques have been proposed to combat this state explosion. All proposed methods excel on certain kinds of systems, but there is ..."
Abstract

Cited by 9 (1 self)
 Add to MetaCart
(Show Context)
Static analysis of Ada tasking programs has been hindered by the well known state explosion problem that arises in the verification of concurrent systems. Many different techniques have been proposed to combat this state explosion. All proposed methods excel on certain kinds of systems, but there is little empirical data comparing the performance of the methods. In this paper, we select one representative from each of three very different approaches to the state explosion problem: partialorders (representing statespace reductions), symbolic model checking (representing OBDDbased approaches), and inequality necessary conditions (representing integer programmingbased approaches). We apply the methods to several scalable concurrency examples from the literature and to one real Ada tasking program. The results of these experiments are presented and their significance is discussed. 1 Introduction Ada tasks arm software developers with the power, and dangers, of concurrency. With this p...
Analysis of RealTime Programs with Simple Time Petri Nets
 In Proc. 1994 Internat. Sympos. on Software Testing and Analysis
, 1994
"... We present a first report on our PARTS toolset for the automated static analysis of realtime systems. The PARTS toolset is based upon a timed extension of Petri nets. Our simple time Petri nets or STP nets are specifically aimed at facilitating realtime analysis. Our analysis approach uses the sta ..."
Abstract

Cited by 8 (5 self)
 Add to MetaCart
(Show Context)
We present a first report on our PARTS toolset for the automated static analysis of realtime systems. The PARTS toolset is based upon a timed extension of Petri nets. Our simple time Petri nets or STP nets are specifically aimed at facilitating realtime analysis. Our analysis approach uses the state space of an STP net in order to answer queries about the concurrency and timing behavior of the corresponding system. An attractive feature of STP nets is that they support a variety of techniques for controlling the number of states that must be explicitly enumerated. These techniques were originally defined for the analysis of concurrency properties of untimed systems, and in this paper we discuss the extension of each to the timed domain. We also report on some preliminary experimental results that we obtained by running our toolset on examples of realtime systems. In: Proceedings of the 1994 Internatinal Symposium on Software Testing and Analysis (ISSTA '94), pp. 228239, August 1...
A PetriNetBased Approach to RealTime Program Analysis
 In Proc. Seventh Internat. Workshop on Software Specification and Design
, 1993
"... We propose to extend existing Petrinetbased tools for concurrency analysis to realtime analysis. The goal is to create a fully automated system, which starts from code in a higher level language for realtime programming, and answers programmers' queries about timing properties of the code. ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
We propose to extend existing Petrinetbased tools for concurrency analysis to realtime analysis. The goal is to create a fully automated system, which starts from code in a higher level language for realtime programming, and answers programmers' queries about timing properties of the code. The key difficulty with all reachabilitybased approaches is that the state space quickly becomes intractably large. To circumvent this state explosion problem, we propose using a combination of several heuristics for model reduction and state space reduction that have been effective for untimed concurrency analysis. In: Proceedings of the Seventh International Workshop on Software Specification and Design, pp. 5660, December 1993, IEEE Computer Society Press. 1 Introduction The analysis of realtime software is very difficult. Indeed, the activities of design, implementation and testing are costly and complex even for traditional software, considerably more costly and complex for untimed co...
Stubborn Sets for RealTime Petri Nets
, 1994
"... The stubbornset method attempts to reduce the number of states that must be explicitly enumerated during reachability analysis of a concurrent system, while preserving crucial concurrency properties in the reduced state space. Here we extend the method to the analysis of certain timed models. We al ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
The stubbornset method attempts to reduce the number of states that must be explicitly enumerated during reachability analysis of a concurrent system, while preserving crucial concurrency properties in the reduced state space. Here we extend the method to the analysis of certain timed models. We also prove that timing properties of interest, such as minimum and maximum delays between events, are preserved in the reduced model. Finally, we report on some experimental results that we have obtained with our extension. These results show that realtime stubborn sets can often provide significant reductions in state space size. 1 Introduction Both formal analysis and testing of realtime programs are very difficult, and yet at the same time very important, since there are so many safetycritical realtime programs. Formal analysis methods are conceptually appealing because these methods, unlike testing, can guarantee that a realtime system satisfies given timing properties. Of course, in...