Flow Analysis for Verifying Specifications of Concurrent and Distributed Software

This paper presents FLAVERS, a finite state verification approach that analyzes whether concurrent or sequential programs satisfy user-defined correctness properties. In contrast to other finite- state verification techniques, FLAVERS is based on algorithms with low-order polynomial bounds on their running time. FLAVERS achieves this efficiency at the cost of precision. Users, however, can improve the precision of the results by selectively and judiciously incorporating additional semantic information into the analysis problem. The FLAVERS analysis approach has been implemented for programs written in Ada. We report on an empirical study of the performance of applying the FLAVERS/Ada tool set to a collection of multi-tasking Ada programs. This study indicates that sufficient precision for proving program properties can be achieved and that the cost for such analysis grows as a low-order polynomial in the size of the program.

[1]  Mark N. Wegman,et al.  Constant propagation with conditional branches , 1985, POPL.

[2]  George S. Avrunin,et al.  An efficient algorithm for computing MHP information for concurrent Java programs , 1999, ESEC/FSE-7.

[3]  Ken Kennedy,et al.  Analysis of event synchronization in a parallel programming tool , 1990, PPOPP '90.

[4]  Matthew B. Dwyer.  Modular flow analysis for concurrent software , 1997, Proceedings 12th IEEE International Conference Automated Software Engineering.

[5]  Matthew B. DwyerKansas.  Patterns in Property Speciications for Finite-state Veriication , 1999 .

[6]  Keith D. Cooper,et al.  Combining analyses, combining optimizations , 1995, TOPL.

[7]  Nicolas Mercouroff,et al.  An Algorithm for Analyzing Communicating Processes , 1991, MFPS.

[8]  L. Clarke,et al.  Veri � cation of Communication Protocols Using Data Flow Analysis � , 1996 .

[9]  Pierre Wolper,et al.  Using partial orders for the efficient verification of deadlock freedom and safety properties , 1991, Formal Methods Syst. Des..

[10]  Carl A. Gunter.  Semantics of programming languages: structures and techniques , 1993, Choice Reviews Online.

[11]  Lori A. Clarke,et al.  Data flow analysis for verifying correctness properties of concurrent programs , 1995 .

[12]  Sérgio Vale Aguiar Campos,et al.  Symbolic Model Checking , 1993, CAV.

[13]  George S. Avrunin,et al.  Automated Analysis of Concurrent Systems With the Constrained Expression Toolset , 1991, IEEE Trans. Software Eng..

[14]  William E. Howden,et al.  A functional approach to program testing and analysis , 1986, IEEE Transactions on Software Engineering.

[15]  Matthew B. Dwyer,et al.  Filter-based model checking of partial systems , 1998, SIGSOFT '98/FSE-6.

[16]  Matthew S. Hecht,et al.  Flow Analysis of Computer Programs , 1977 .

[17]  Leon J. Osterweil,et al.  Cecil: A Sequencing Constraint Language for Automatic Static Analysis Generation , 1990, IEEE Trans. Software Eng..

[18]  James C. Corbett,et al.  Verifying General Safety and Liveness Propterties with Integer Programming , 1992, CAV.

[19]  Louise E. Moser,et al.  A graphical interval logic for specifying concurrent systems , 1994, TSEM.

[20]  Dirk Grunwald,et al.  Efficient Computation of Precedence Information in Parallel Programs , 1993, LCPC.

[21]  Pierre Wolper.  Temporal Logic Can Be More Expressive , 1983, Inf. Control..

[22]  George S. Avrunin,et al.  Data flow analysis for checking properties of concurrent Java programs , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[23]  Shing-Chi Cheung,et al.  Tractable Flow Analysis for Anomaly Detection in Distributed Programs , 1993, ESEC.

[24]  Leon J. Osterweil,et al.  Interprocedural static analysis of sequencing constraints , 1992, TSEM.

[25]  David A. Schmidt.  Data flow analysis is model checking of abstract interpretations , 1998, POPL '98.

[26]  Lori A. Clarke,et al.  Efficient composite data flow analysis applied to concurrent programs , 1998, PASTE '98.

[27]  Barbara G. Ryder,et al.  Non-concurrency analysis , 1993, PPOPP '93.

[28]  Richard N. Taylor,et al.  A Concurrency Analysis Tool Suite: Rationale, Design, and Preliminary Experience , 1992 .

[29]  Stephen P. Masticola,et al.  Static detection of deadlocks in polynomial time , 1993 .

[30]  Jack C. Wileden,et al.  Foundations for the Arcadia environment architecture , 1989, SDE 3.

[31]  George S. Avrunin,et al.  Applying static analysis to software architectures , 1997, ESEC '97/FSE-5.

[32]  Michal Young,et al.  Compositional reachability analysis using process algebra , 1991, TAV4.

[33]  Mary Lou Soffa,et al.  Concurrency analysis in the presence of procedures using a data-flow framework , 1991, TAV4.

[34]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[35]  Robin Milner,et al.  A Calculus of Communicating Systems , 1980, Lecture Notes in Computer Science.

[36]  David Luckham,et al.  Debugging Ada Tasking Programs , 1985, IEEE Software.

[37]  Gerard J. Holzmann,et al.  The Model Checker SPIN , 1997, IEEE Trans. Software Eng..

[38]  Lori A. Clarke,et al.  Using partial order techniques to improve performance of data flow analysis based verification , 1999, PASTE '99.

[39]  David A. SchmidtKansas.  Limiting State Explosion with Filter-Based Re nement , 1997 .

[40]  Barbara G. Ryder,et al.  Lattice frameworks for multisource and bidirectional data flow problems , 1995, TOPL.

[41]  George S. Avrunin,et al.  A conservative data flow algorithm for detecting all pairs of statements that may happen in parallel , 1998, SIGSOFT '98/FSE-6.

[42]  Richard N. Taylor,et al.  Anomaly Detection in Concurrent Software by Static Data Flow Analysis , 1980, IEEE Transactions on Software Engineering.

[43]  Alfred V. Aho,et al.  The Design and Analysis of Computer Algorithms , 1974 .

[44]  Tadao Murata,et al.  Petri nets: Properties, analysis and applications , 1989, Proc. IEEE.

[45]  Sol M. Shatz,et al.  Design and Implementation of a Petri Net Based Toolkit for Ada Tasking Analysis , 1990, IEEE Trans. Parallel Distributed Syst..

[46]  Amir Pnueli,et al.  Applications of Temporal Logic to the Specification and Verification of Reactive Systems: A Survey of Current Trends , 1986, Current Trends in Concurrency.

[47]  Antti Valmari,et al.  A stubborn attack on state explosion , 1990, Formal Methods Syst. Des..

[48]  Richard N. Taylor,et al.  A general-purpose algorithm for analyzing concurrent programs , 1983, CACM.

[49]  E. Clarke,et al.  Automatic Veriication of Nite-state Concurrent Systems Using Temporal-logic Speciications. Acm , 1993 .

[50]  Barton P. Miller,et al.  Detecting Data Races in Parallel Program Executions , 1989 .

[51]  Bernhard Steffen,et al.  Parallelism for Free : E cient and Optimal Bitvector Analyses for Parallel Programs , 1996 .

[52]  Jan A. Bergstra,et al.  Process Algebra for Synchronous Communication , 1984, Inf. Control..

[53]  George S. Avrunin,et al.  Towards scalable compositional analysis , 1994, SIGSOFT '94.

[54]  D FosdickLloyd,et al.  Data Flow Analysis in Software Reliability , 1976 .

[55]  Lori A. Clarke,et al.  An empirical comparison of static concurrency analysis techniques , 1996 .

[56]  Rance Cleaveland,et al.  The concurrency workbench: a semantics-based tool for the verification of concurrent systems , 1993, TOPL.

[57]  James C. Corbett,et al.  Evaluating Deadlock Detection Methods for Concurrent Software , 1996, IEEE Trans. Software Eng..