11 research outputs found
Extending Nunchaku to Dependent Type Theory
Nunchaku is a new higher-order counterexample generator based on a sequence
of transformations from polymorphic higher-order logic to first-order logic.
Unlike its predecessor Nitpick for Isabelle, it is designed as a stand-alone
tool, with frontends for various proof assistants. In this short paper, we
present some ideas to extend Nunchaku with partial support for dependent types
and type classes, to make frontends for Coq and other systems based on
dependent type theory more useful.Comment: In Proceedings HaTT 2016, arXiv:1606.0542
BMC with Memory Models as Modules
This paper reports progress in verification tool engineering for weak memory models. We present two bounded model checking tools for concurrent programs. Their distinguishing feature is modularity: Besides a program, they expect as input a module describing the hardware architecture for which the program should be verified. DARTAGNAN verifies state reachability under the given memory model using a novel SMT encoding. PORTHOS checks state equivalence under two given memory models using a guided search strategy. We have performed experiments to compare our tools against other memory model-aware verifiers and find them very competitive, despite the modularity offered by our approach.Peer reviewe
Extensional Higher-Order Paramodulation in Leo-III
Leo-III is an automated theorem prover for extensional type theory with
Henkin semantics and choice. Reasoning with primitive equality is enabled by
adapting paramodulation-based proof search to higher-order logic. The prover
may cooperate with multiple external specialist reasoning systems such as
first-order provers and SMT solvers. Leo-III is compatible with the TPTP/TSTP
framework for input formats, reporting results and proofs, and standardized
communication between reasoning systems, enabling e.g. proof reconstruction
from within proof assistants such as Isabelle/HOL. Leo-III supports reasoning
in polymorphic first-order and higher-order logic, in all normal quantified
modal logics, as well as in different deontic logics. Its development had
initiated the ongoing extension of the TPTP infrastructure to reasoning within
non-classical logics.Comment: 34 pages, 7 Figures, 1 Table; submitted articl
Advances in Property-Based Testing for αProlog
Check is a light-weight property-based testing tool built on top of
Prolog, a logic programming language based on nominal logic.
Prolog is particularly suited to the validation of the meta-theory of
formal systems, for example correctness of compiler translations involving
name-binding, alpha-equivalence and capture-avoiding substitution. In this
paper we describe an alternative to the negation elimination algorithm
underlying Check that substantially improves its effectiveness. To
substantiate this claim we compare the checker performances w.r.t. two of its
main competitors in the logical framework niche, namely the QuickCheck/Nitpick
combination offered by Isabelle/HOL and the random testing facility in
PLT-Redex.Comment: To appear, Tests and Proofs 2016; includes appendix with details not
in the conference versio
Automatically Comparing Memory Consistency Models
A memory consistency model (MCM) is the part of a programming language or computer architecture specification that defines which values can legally be read from shared memory locations. Because MCMs take into account various optimisations employed by archi- tectures and compilers, they are often complex and counterintu- itive, which makes them challenging to design and to understand.
We identify four tasks involved in designing and understanding MCMs: generating conformance tests, distinguishing two MCMs, checking compiler optimisations, and checking compiler mappings. We show that all four tasks are instances of a general constraint-satisfaction problem to which the solution is either a program or a pair of programs. Although this problem is intractable for automatic solvers when phrased over programs directly, we show how to solve analogous constraints over program executions, and then construct programs that satisfy the original constraints.
Our technique, which is implemented in the Alloy modelling framework, is illustrated on several software- and architecture-level MCMs, both axiomatically and operationally defined. We automatically recreate several known results, often in a simpler form, including: distinctions between variants of the C11 MCM; a failure of the ‘SC-DRF guarantee’ in an early C11 draft; that x86 is ‘multi-copy atomic’ and Power is not; bugs in common C11 compiler optimisations; and bugs in a compiler mapping from OpenCL to AMD-style GPUs. We also use our technique to develop and validate a new MCM for NVIDIA GPUs that supports a natural mapping from OpenCL
Dynamic analysis for concurrent modern C/C++ applications
Concurrent programs are executed by multiple threads that run simultaneously. While this allows programs to run more efficiently by utilising multiple processors, it brings with it numerous complications. For example, a program may behave unpredictably or erroneously when multiple threads modify the same memory location in an uncoordinated manner. Issues such as this are difficult to avoid, and when introduced, can break the program in unpredictable ways. Programmers will therefore often turn towards automated tools to aide in the detection of concurrency bugs.
The work presented in this thesis aims to provide methods to aid in the creation of tools for the purpose of finding and explaining concurrency bugs. In particular, the following studies have been conducted:
Dynamic Race Detection for C/C++11 With the introduction of a weak memory model in C++, many tools that provide dynamic race detection have become outdated, and are unable to adequately identify data races. This work updates an existing data race detection algorithm such that it can identify data races according to this new definition. A method for allowing programs to explore many of the weak behaviours that this new memory model permits is also provided.
Record and Replay Much work has gone into record and replay, however, most of this work is focussed on whole system replay, whereby a tool will aim to record as much of the program execution as possible. Contrasting this, the work presented here aims to record as little as possible. This sparse approach has many interesting implications: some programs that were previously out of reach for record and reply become tractable, and vice versa. To back this up, controlled scheduling is introduced that is capable of applying different scheduling strategies, which combined with the record and replay is beneficial for helping to root out bugs. Tool Support Both of the above techniques have been implemented in a tool, tsan11rec,
that builds on the tsan dynamic race detection tool. A large experimental evaluation is
presented investigating the effectiveness of the enhanced data race detection algorithm
when applied to the Firefox and Chromium web browsers, and of the novel approach to
record and replay when applied to a diverse set of concurrent applications.Open Acces
A Machine-Checked, Type-Safe Model of Java Concurrency : Language, Virtual Machine, Memory Model, and Verified Compiler
The Java programming language provides safety and security guarantees such as type safety and its security architecture. They distinguish it from other mainstream programming languages like C and C++. In this work, we develop a machine-checked model of concurrent Java and the Java memory model and investigate the impact of concurrency on these guarantees. From the formal model, we automatically obtain an executable verified compiler to bytecode and a validated virtual machine