Model-Checking Software Using Precise Abstractions,Model-Checking Software Using Precise Abstractions
Download Software Abstractions PDF/ePub, Mobi eBooks by Click Download or Read Online button. Instant access to millions of titles from Our Library and it’s FREE to try! All books are in 01/08/ · (PDF) Software Abstractions and Human-Cyber-Physical Systems Architecture Modelling Software Abstractions and Human-Cyber-Physical Systems Architecture Downloads (cumulative) 0 Sections Software Abstractions: Logic, Language, and Analysis Abstract Cited By Contributors Index Terms Reviews Comments Abstract In Software Abstraction Software is built on abstractions. Abstraction is a way of hiding details in order to make it easier to see the big picture model. Good abstraction will generalize that which can be Software abstractions: logic, language, and analysis / Daniel Jackson. p. cm. Includes bibliographical references and index. ISBN (alk. paper) 1. Computer ... read more
Overall, our abstraction phase is quite standard and is in- dependent of our use of Belnap logic for the analysis. We also discovered that it is relatively straightforward to incorporate and ex- tend existing advances in software model-checking technology, such as interpolant- based predicate discovery [HJMM04] and lazy abstraction [HJMS02], into our frame- work. Thus, in the refinement phase, it is not necessary to check whether the execution produced by model-checking is feasible. Instead, we sim- ply refine abstractions that produce the Maybe answer, by extracting new predicates for refinement from such partial proofs.
Our approach can work regardless of the structure of the property, and thus can be applied to a larger set of properties, such as liveness e. The current version of the tool can check properties of C programs with complex language features such as structures, pointers, and recursion. We have also implemented lazy and eager abstraction and a limited form of non-determinism, which will lead to the analysis of concurrent programs. Our experience showed that the introduction of additional logic values does not reduce the feasibility of the analysis. In fact, the analysis remains as feasible as the classical one while making it possible to effectively reason about a larger class of properties.
Thus, one way to improve scalability of a verification technique is by making it com- positional. For example, to analyze a given thread, we can generate a most general environment that is sufficient to ensure that the desired property holds, and then check that the combination of other threads satisfies this environment. We also propose to apply symmetry reduction to build abstractions of concurrent systems with several similar components [WGC05]. We believe that a similar approach can be taken to facilitate the analysis of component-based and parameterized systems. Instead of handling function calls by inlining, SLAM treats each function as a component, analyzes it once, and uses the computed function summary in the rest of the analysis. However, the traditional notion of a component i. This is espe- cially highlighted by the recent popularity of non-traditional decomposition techniques such as aspect-based programming [EFB01]. An approach complementary to compositional verification is regression verification.
In particular, it is necessary to determine when previous abstractions can be reused in checking the modified program. Further, changes in software often affect a large number of compo- nents, and we believe that the re-verification effort must be proportional to the amount of change, not to the number of affected components. The lack of support for regression verification is particularly evident in the current applications of the CEGAR framework. However, with the notable exception of [HJMS02,GC05], this is not taken into account during the verification phase. Early experience with regression verification shows a lot of promise. For example, Henzinger et al. Our own experience [GC05] shows that program analysis using Belnap logic that precisely identifies which results of a verification can be trusted, is particularly well suited to localizing the effort of regression verification.
Moreover, our current work on merging [UC04] allows us to combine function and other component summaries obtained during different analysis passes through the program being modi- fied. In theory, it promises to completely eliminate dynamic analysis such as testing and runtime monitoring; moreover, this has been possible in practice, for analyzing relatively small components such as device drivers. We believe that static techniques alone may not scale to reasoning about large distributed programs that are routinely being built today, and may need to be supplemented by a careful application of dynamic analysis.
There are numerous ways in which static and dynamic analysis can be combined. For example, program execution can supplement theorem-proving in construction of abstract models [KGC04]: if the program reaches the desired state, then the value of the transition should be True; otherwise. no information is available. Another approach is to combine results of testing to help navigate static analysis towards a possible error. We are currently exploring a variation of this approach by building an abstract model from regression test suites. Such suites are available with most large-scale software systems and can be thought of as detailed scenarios describing the system. We can combine these into partial behavioural models [UC04,WS00] to use in formal analysis. We are firm believers in automated symbolic verification which combines static and dynamic analyses, theorem-proving and model-checking, and think such techniques can be effectively extended to reasoning about complex soft- ware systems.
Currently, the automated verification research community has several competing approaches to analyzing software. We hope that bringing us together will facilitate tool sharing, so we can evaluate improvement of our tools against the state-of-the-art. These requirements can take a form of a benchmark suite combining programs of varying complexity and size, with different language features and different correctness criteria. References [BB04] C. Barrett and S. Ball, B. Cook, S. Lahiri, and L. Bruns and P. Ball, A. Podelski, and S. Ball and S. Chechik, B. Devereux, S. Easterbrook, and A. ACM Transactions on Software Engineering and Methodol- ogy, 12 4 :1—38, October Devereux, and A. Constraint Processing. Morgan Kaufmann, Elrad, R. Filman, and A. Communications of the ACM, pages 29—32, October Gurfinkel and M. Technical Report , University of Toronto, April Graf and H.
Henzinger, R. Jhala, R. Majumdar, and K. In Proceedings of 31st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages POPL , pages —, Venice, Italy, January Majumdar, and G. In Pro- ceedings of 29th SIGPLAN-SIGACT Symposium on Principles of Programming Lan- guages POPL , pages 58—70, Portland, Oregon, January Majumdar, and M. In Verification: Theory and Practice, volume of LNCS, pages — Springer-Verlag, Kroening, A. Groce, and E. In Proceedings of International Conference on Formal Engineering Methods, pages —, November Larsen and B. IEEE Computer Society Press, Reps, M. Sagiv, and R. Uchitel and M. In Proceedings of 12th ACM SIGSOFT International Symposium on Foundations of Software Engi- neering, pages 43—52, November Visser, K. Havelund, G. Brat, S. Park, and F. Journal of Automated Software Engineering, 10 2 , April Wei, A. Gurfinkel, and M. Springer, September to appear. Whittle and J. In Proceedings of 22nd International Conference on Software Engineering, pages — , May RELATED PAPERS.
Proof-like counter-examples. Mixed transition systems revisited. A posteriori soundness for non-deterministic abstract interpretations. Multiple-counterexample guided iterative abstraction refinement: An industrial evaluation. Verification, Model Checking, and Abstract … A logic and decision procedure for predicate abstraction of heap-manipulating programs. Formal Methods in Computer Aided Design FMCAD'07 Computing Predicate Abstractions by Integrating BDDs and SMT Solvers. Finding environment guarantees.
Predicate Abstraction of ANSI-C Programs Using SAT. UFO: A framework for abstraction-and interpolation-based software verification. Abstract Counterexample-based Refinement for Powerset Domains. Temporal property verification as a program analysis task. Verification of SpecC using predicate abstraction. Predicate Abstraction and Refinement Techniques for Verifying Verilog. Overview of ComFoRT: A Model Checking Reasoning Framework. Formal Aspects of Computing A model checking-based approach for security policy verification of mobile systems. Proceedings of the ACM symposium on Applied Computing - SAC '09 The synergy of precise and fast abstractions for program verification. Choosing correct abstractions to base your design The analysis brings software abstractions to life. Most hotels now issue disposable room keys. PDF is a hugely popular format for documents simply because it is independent of the hardware or application used to create that file.
This means it can be viewed across multiple devices, regardless of the underlying operating system. LibreOffice is a free-to-download open-source office productivity suite that you can easily edit PDFs LaptopMag is supported by its audience. When you purchase through links on our site, we may earn an affiliate commission. Learn more By Ma. By Gerry ITworld As we all know that PDF is the best format for viewing and sharing documents, it is widely used by computer users. RAW Paste Data Copied. Public Pastes. Lua 3 min ago 0.
Lua 46 min ago 2. Lua 1 hour ago JSON 1 hour ago 5. Java 2 hours ago 2.
edu no longer supports Internet Explorer. To browse Academia. edu and the wider internet faster and more securely, please take a few seconds to upgrade your browser. Formal verification techniques are not yet widely used in the software industry, perhaps because software tends to be more complex than hardware, and the penalty for bugs is often lower software can be patched after the release. Instead, a large amount of time and money is being spent on software testing, which misses many subtle errors, especially in concurrent programs. kelvin ku. Marsha Chechik. Automated verification tools vary widely in the types of properties they are able to analyze, the complexity of their algorithms, and the amount of necessary user involvement.
In this paper we propose a framework for step-wise automatic verification and describe a lightweight scalable program analysis tool that combines abstraction and model checking. The tool guarantees that its True and False answers are sound with respect to the original system. Natasha Sharygina. Bor-Yuh Evan Chang. A certified program analysis is an analysis whose implementation is accompanied by a checkable proof of soundness. We present a framework whose purpose is to simplify the development of certified program analyses without compromising the run-time efficiency of the analyses.
At the core of the framework is a novel technique for automatically extracting Coq proof-assistant specifications from ML implementations of program analyses, while preserving to a large extent the structure of the implementation. Zvonimir Rakamaric. Marco Peña. Matthew Might. Moshe Vardi. Alessandro Cimatti. Himanshu Jain. Himanshu jain. Natasha Sharygina , Katerina Barone-adesi. Proceedings of the ACM symposium on Applied Computing - SAC ' Cindy González Rubio. Proceedings of the 8th international workshop on Specification and verification of component-based systems - SAVCBS ' Matthias Dangl. Altaf Hussain. International Journal on Software Tools for Technology Transfer. ashutosh gupta. Javier Esparza. Alexey Khoroshilov. Mikoláš Janota. Joost-Pieter Katoen. Dan Taca. Christoph Wintersteiger. Log in with Facebook Log in with Google. Remember me on this computer. Enter the email address you signed up with and we'll email you a reset link.
Need an account? Click here to sign up. Download Free PDF. Model-Checking Software Using Precise Abstractions. Abstract Formal verification techniques are not yet widely used in the software industry, perhaps because software tends to be more complex than hardware, and the penalty for bugs is often lower software can be patched after the release. Related Papers. Augmenting Counterexample-Guided Abstraction Refinement with Proof Templates. Download Free PDF View PDF. A Buffer Overflow Benchmark for Software Model Checkers Short Paper. Lightweight reasoning about program correctness. Formal Methods in System Design Verification of evolving software via component substitutability analysis. Lecture Notes in Computer Science Accurate Theorem Proving for Program Verification. Lecture Notes in Computer Science Cogent: Accurate Theorem Proving for Program Verification. A framework for certified program analysis and its applications to mobile-code safety. A buffer overflow benchmark for software model checkers.
Verification, Model Checking, and Abstract … A scalable memory model for low-level code. Lecture Notes in Computer Science TRANSYT:A Tool for the Verification of Asynchronous Concurrent Systems. Model-Checking Software Using Precise Abstractions Marsha Chechik and Arie Gurfinkel Department of Computer Science, University of Toronto, Toronto, ON M5S 3G4, Canada. Email: chechik,arie cs. Instead, a large amount of time and money is being spent on software testing, which misses many subtle errors, espe- cially in concurrent programs. Increased use of concurrency, e. Many formal techniques can effectively analyze models of software. However, ob- taining these models directly from the program text is non-trivial. Not only are there lan- guage issues pointers, dynamic memory allocation, object-orientation, dynamic thread creation to deal with, but the most important problem is automatically determining the level of abstraction for creating such a model: it should be simple enough to analyze and yet detailed enough to be conclusive on the properties of interest.
Thus, we believe that part of the challenge of creating a verifying compiler is creation of fully automated light-weight verification and validation techniques which help detect bugs and yet scale to handle large complex software. Furthermore, the techniques should be supported by a methodology that enables developers to pose questions about correctness of their programs and effectively understand the results of the analysis. We believe that the existing techniques based on the CEGAR framework see Fig- ure 1 that use a theorem-prover for constructing models and a model-checker for ex- ploration is a reasonable way to go for analyzing realistic programs. However, such methods should be enhanced in a number of directions if our goal is to create a truly effective program verifier. In Section 2, we describe our existing work on creating better abstractions. In Section 3, we discuss two approaches that we believe are essential for scaling automated analysis: reuse via compositional analysis and regression verifica- tion and combining static and dynamic reasoning.
We conclude in Section 4. Abstraction-refinement cycle. Experi- ence in static analysis [RSW04] showed that a logic with values other than just True and False can be used effectively to create abstractions that preserve both truth and falsity: when a property is inconclusive in the abstraction, the analysis simply returns a special value Maybe. Traditional model-checking approaches already build such abstractions. Here, two choices are avail- able. Truth order cs. knowledge order of a : Kleene and b : Belnap logics. Thus, the additional power of already avail- able rich abstractions remains untapped. Clearly, this can and should be avoided. To show that the additional reasoning power can be obtained without sacrificing per- formance, we have recently built a prototype software model-checker YASM [GC05] which implements the CEGAR framework using Belnap logic.
This logic, shown in Figure 3 b , extends Kleene logic with another value, which we use to improve pre- cision of our models. The remainder of this section comments on how our approach differs from the classical one, phase by phase. The abstraction phase builds an abstract model, using a theorem-prover YASM uses CVCLite [BB04] to approximate the effect of each statement by a propositional for- mula over the available predicates. This number can be minimized by the application of constraint-satisfaction algorithms [Dec03], and we are currently experimenting with several CSP techniques to improve the performance of our tool. Overall, our abstraction phase is quite standard and is in- dependent of our use of Belnap logic for the analysis. We also discovered that it is relatively straightforward to incorporate and ex- tend existing advances in software model-checking technology, such as interpolant- based predicate discovery [HJMM04] and lazy abstraction [HJMS02], into our frame- work.
Thus, in the refinement phase, it is not necessary to check whether the execution produced by model-checking is feasible. Instead, we sim- ply refine abstractions that produce the Maybe answer, by extracting new predicates for refinement from such partial proofs. Our approach can work regardless of the structure of the property, and thus can be applied to a larger set of properties, such as liveness e. The current version of the tool can check properties of C programs with complex language features such as structures, pointers, and recursion. We have also implemented lazy and eager abstraction and a limited form of non-determinism, which will lead to the analysis of concurrent programs. Our experience showed that the introduction of additional logic values does not reduce the feasibility of the analysis. In fact, the analysis remains as feasible as the classical one while making it possible to effectively reason about a larger class of properties.
Thus, one way to improve scalability of a verification technique is by making it com- positional. For example, to analyze a given thread, we can generate a most general environment that is sufficient to ensure that the desired property holds, and then check that the combination of other threads satisfies this environment. We also propose to apply symmetry reduction to build abstractions of concurrent systems with several similar components [WGC05]. We believe that a similar approach can be taken to facilitate the analysis of component-based and parameterized systems. Instead of handling function calls by inlining, SLAM treats each function as a component, analyzes it once, and uses the computed function summary in the rest of the analysis. However, the traditional notion of a component i. This is espe- cially highlighted by the recent popularity of non-traditional decomposition techniques such as aspect-based programming [EFB01].
Please wait while your request is being verified...,
However, due to PDF’s special feature - un-editable, what will you do if you need to edit or revise a PDF. RAW Paste Data Download Here - blogger.com (Copy and Paste Link) This Download Full PDF Package Translate PDF Model-Checking Software Using Precise Abstractions Marsha Chechik and Arie Gurfinkel Department of Computer Science, 01/08/ · (PDF) Software Abstractions and Human-Cyber-Physical Systems Architecture Modelling Software Abstractions and Human-Cyber-Physical Systems Architecture Software abstractions: logic, language, and analysis / Daniel Jackson. p. cm. Includes bibliographical references and index. ISBN (alk. paper) 1. Computer DOWNLOAD: SOFTWARE ABSTRACTIONS: LOGIC, LANGUAGE, AND ANALYSIS. Software Abstractions: Logic, Language, and Analysis PDF Book The Venerable Bede's account Download Software Abstractions PDF/ePub, Mobi eBooks by Click Download or Read Online button. Instant access to millions of titles from Our Library and it’s FREE to try! All books are in ... read more
paper 1. Since the relation itself represents the paths that are one step long, its square the paths that are two steps long, and so on, the closure logic 65 relates one atom to another when they are connected by a path of any length except for zero. The inventors of Z had dispensed with many of the complexities of earlier languages, and based their language on the simplest notions of set theory. For a set e, the declaration sig A {f: m e} adds the constraint all this: A this. Following the same strategy we used for states, we can explore more interesting transitions by adding constraints. Brat, S.
Although the analysis of an assertion might not find a counterexample—because one only exists in a larger scope—it will never report a spurious one. Not in the standard sense, software abstractions pdf download. Rather than treating options as singleton or empty sets, most modeling and programming languages use a union type. Printed and bound in the United States of Software abstractions pdf download. You might think that these constants could be omitted, and defined instead in a library module. Building a model incrementally with an analyzer, simulating and checking as you go along, is a very different experience from using pencil and paper alone.
No comments:
Post a Comment