Results 1  10
of
10
Efficient Runtime Invariant Checking: A Framework and Case Study ∗
"... This paper describes a general and powerful framework for efficient runtime invariant checking. The framework supports (1) declarative specification of arbitrary invariants using highlevel queries, with easy use of information from any data in the execution, (2) powerful analysis and transformation ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
(Show Context)
This paper describes a general and powerful framework for efficient runtime invariant checking. The framework supports (1) declarative specification of arbitrary invariants using highlevel queries, with easy use of information from any data in the execution, (2) powerful analysis and transformations for automatic generation of instrumentation for efficient incremental checking of invariants, and (3) convenient mechanisms for reporting errors, debugging, and taking preventive or remedial actions, as well as recording history data for use in queries. We demonstrate the advantages and effectiveness of syntax tree transformations, authentication in a SMB client, and the BitTorrent peertopeer file distribution protocol. Categories and Subject Descriptors D.2.4 [Software Engineering]: Software/Program Verification—Class invariants; D.2.4
Runtime Checking for Program Verification
"... Abstract. The process of verifying that a program conforms to its specification is often hampered by errors in both the program and the specification. A runtime checker that can evaluate formal specifications can be useful for quickly identifying such errors. This paper describes our preliminary exp ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
Abstract. The process of verifying that a program conforms to its specification is often hampered by errors in both the program and the specification. A runtime checker that can evaluate formal specifications can be useful for quickly identifying such errors. This paper describes our preliminary experience with incorporating runtime checking into the Jahob verification system and discusses some lessons we learned in this process. One of the challenges in building a runtime checker for a program verification system is that the language of invariants and assertions is designed for simplicity of semantics and tractability of proofs, and not for runtime checking. Some of the more challenging constructs include existential and universal quantification, set comprehension, specification variables, and formulas that refer to past program states. In this paper, we describe how we handle these constructs in our runtime checker, and describe directions for future work. 1
A shape analysis for optimizing parallel graph programs
, 2010
"... Computations on unstructured graphs are challenging to parallelize because dependences in the underlying algorithms are usually complex functions of runtime data values, thwarting static parallelization. One promising generalpurpose parallelization strategy for these algorithms is optimistic parall ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
Computations on unstructured graphs are challenging to parallelize because dependences in the underlying algorithms are usually complex functions of runtime data values, thwarting static parallelization. One promising generalpurpose parallelization strategy for these algorithms is optimistic parallelization. This paper identifies the optimization of optimistically parallelized graph programs as a new application area, and develops the first shape analysis for addressing this problem. Our shape analysis identifies failsafe points in the program after which the execution is guaranteed not to abort and backup copies of modified data are not needed; additionally, the analysis can be used to eliminate redundant conflict checking. It uses two key ideas: a novel topdown heap abstraction that controls state space explosion, and a strategy for predicate discovery that exploits common patterns of data structure
Invariant and Type Inference for Matrices
"... We present a loop property generation method for loops iterating over multidimensional arrays. When used on matrices, our method is able to infer their shapes (also called types), such as uppertriangular, diagonal, etc. To generate loop properties, we first transform a nested loop iterating over ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
We present a loop property generation method for loops iterating over multidimensional arrays. When used on matrices, our method is able to infer their shapes (also called types), such as uppertriangular, diagonal, etc. To generate loop properties, we first transform a nested loop iterating over a multidimensional array into an equivalent collection of unnested loops. Then, we infer quantified loop invariants for each unnested loop using a generalization of a recurrencebased invariant generation technique. These loop invariants give us conditions on matrices from which we can derive matrix types automatically using theorem provers. Invariant generation is implemented in the software package Aligator and types are derived by theorem provers and SMT solvers, including Vampire and Z3. When run on the Java matrix package JAMA, our tool was able to infer automatically all matrix types describing the matrix shapes guaranteed by JAMA’s API.
Towards Verified Distributed Software Through Refinement of Formal Archetypes
"... Abstract. This paper discusses experiments with a “modelbased ” approach for developing verified distributed systems in which program development is carried out by stepwise refinement: we encode, specifications and algorithm archetypes in the PVS theorem prover, carry out stepwise refinement and co ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Abstract. This paper discusses experiments with a “modelbased ” approach for developing verified distributed systems in which program development is carried out by stepwise refinement: we encode, specifications and algorithm archetypes in the PVS theorem prover, carry out stepwise refinement and concomitant proofs, and obtain collections of verified algorithms encoded in PVS. Finally we transform algorithms from PVS to programs in Java. We consider a class of systems in which state spaces may be continuous and state transitions may be continuous or discrete. Coordinated multivehicle systems are examples of this class. Temporal properties of this class of problems are specified in terms of convergence: the system state gets arbitrarily close to a limit as time tends to infinity. Our metatheorems for verifying convergence are extensions from control theory to a temporal logic of continuous time and state spaces. 1
Satisfiability Solving for Program Verification: towards the Efficient Combination of Automated Theorem Provers and Satisfiability Modulo Theory Tools
"... Abstract. Many approaches to software verification require to check the satisfiability of firstorder formulae. For such techniques, it is of crucial importance to have satisfiability solvers which are both scalable, predictable and flexible. We describe our approach to build solvers satisfying such ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. Many approaches to software verification require to check the satisfiability of firstorder formulae. For such techniques, it is of crucial importance to have satisfiability solvers which are both scalable, predictable and flexible. We describe our approach to build solvers satisfying such requirements by combining equational theorem proving, Boolean solving, Arithmetic reasoning, and some transformations on the proof obligations. The viability of the approach has been shown by successfully discharging proof obligations arising in a variety of verification problems with an implementation of the proposed techniques, in a system called haRVey. Finally, we sketch how model building can be integrated in the proposed approach in order to enhance counterexample generation or to generalize the NelsonOppen combination schema. 1
International Journal on Software Tools Technology Transfer manuscript No. (will be inserted by the editor)
"... Abstract Many approaches to software verification require to check the satisfiability of firstorder formulae. For such techniques, it is of crucial importance to have satisfiability solvers which are both scalable, predictable and flexible. We describe our approach to build solvers satisfying such ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract Many approaches to software verification require to check the satisfiability of firstorder formulae. For such techniques, it is of crucial importance to have satisfiability solvers which are both scalable, predictable and flexible. We describe our approach to build solvers satisfying such requirements by combining equational theorem proving, Boolean solving, and some transformations of the proof obligations. We show the viability of the approach by describing the experimental results obtained with an implementation of the proposed techniques, in a system called haRVey, on proof obligations extracted from the certification of aerospace code.
zur Erlangung des Grades des
, 2009
"... Informationhandling systems are becoming ever more complex. They may be pure hardware or software systems, or complex systems of hardware and software that act in a realworld environment. Verification is a method to ensure that systems behave in the expected way, which is a necessity for safetycr ..."
Abstract
 Add to MetaCart
Informationhandling systems are becoming ever more complex. They may be pure hardware or software systems, or complex systems of hardware and software that act in a realworld environment. Verification is a method to ensure that systems behave in the expected way, which is a necessity for safetycritical applications like automatic railway control. The size of such systems makes manual verification impossible. Therefore, we need automatic or computeraided verification procedures. Automated reasoning is already widely used in the analysis and verification of systems. For a restricted class of systems, the resulting verification problems are inherently finite and can be solved efficiently. For complex systems, such finiteness cannot be expected. To express and prove properties of these systems, we need a formal language and reasoners that can deal with universal quantification, arithmetic expressions and unbounded data structures at the same time. Thus, in recent years there has been new interest in the handling of firstorder
A Software Verification Challenge Problem
, 2010
"... Components that encapsulate maps are among the most fundamental for the development of modern software. The concept of associating keys with values is important for a wide range of applications and it can accommodate a broad variety of implementations with diverse performance profiles. The foundatio ..."
Abstract
 Add to MetaCart
(Show Context)
Components that encapsulate maps are among the most fundamental for the development of modern software. The concept of associating keys with values is important for a wide range of applications and it can accommodate a broad variety of implementations with diverse performance profiles. The foundationalyetsophisticated nature of this concept makes it an ideal benchmark for software verification efforts. A tension between modular reasoning and the usefulness of a map can be observed, in particular, in systems where the keys may be reference types. This paper elaborates on the criteria for modular verification of robust map components and their clients and it presents a survey of existing attempts to verify map components. 1.
by
, 2011
"... The foundational goal of this work is the development of mechanizable proof rules and a verification condition generator based on those rules for modern software. The verification system will be modular so that it is possible to verify the implementation of a component relying upon only the specific ..."
Abstract
 Add to MetaCart
(Show Context)
The foundational goal of this work is the development of mechanizable proof rules and a verification condition generator based on those rules for modern software. The verification system will be modular so that it is possible to verify the implementation of a component relying upon only the specifications of underlying components that are reused. The system must enable full behavioral verification. The proof rules used to generate verification conditions (VCs) of correctness must be amenable to automation. While automation requires software developers to annotate implementations with assertions, it should not require assistance in the proofs. This research has led to a VC generator that realizes these goals. The VC generator has been applied to a range of benchmarks to show the viability of verified components. It has been used in classrooms at multiple institutions to teach reasoning principles. A fundamental problem in computing is the inability to show that a software system behaves as required. Modern software systems are composed of numerous software components. The fundamental goal of this work is to verify each independently in a modular fashion, resulting in