1,560 research outputs found
Bounded Refinement Types
We present a notion of bounded quantification for refinement types and show
how it expands the expressiveness of refinement typing by using it to develop
typed combinators for: (1) relational algebra and safe database access, (2)
Floyd-Hoare logic within a state transformer monad equipped with combinators
for branching and looping, and (3) using the above to implement a refined IO
monad that tracks capabilities and resource usage. This leap in expressiveness
comes via a translation to "ghost" functions, which lets us retain the
automated and decidable SMT based checking and inference that makes refinement
typing effective in practice.Comment: 14 pages, International Conference on Functional Programming, ICFP
201
Logic Programming Applications: What Are the Abstractions and Implementations?
This article presents an overview of applications of logic programming,
classifying them based on the abstractions and implementations of logic
languages that support the applications. The three key abstractions are join,
recursion, and constraint. Their essential implementations are for-loops, fixed
points, and backtracking, respectively. The corresponding kinds of applications
are database queries, inductive analysis, and combinatorial search,
respectively. We also discuss language extensions and programming paradigms,
summarize example application problems by application areas, and touch on
example systems that support variants of the abstractions with different
implementations
Contract-Based General-Purpose GPU Programming
Using GPUs as general-purpose processors has revolutionized parallel
computing by offering, for a large and growing set of algorithms, massive
data-parallelization on desktop machines. An obstacle to widespread adoption,
however, is the difficulty of programming them and the low-level control of the
hardware required to achieve good performance. This paper suggests a
programming library, SafeGPU, that aims at striking a balance between
programmer productivity and performance, by making GPU data-parallel operations
accessible from within a classical object-oriented programming language. The
solution is integrated with the design-by-contract approach, which increases
confidence in functional program correctness by embedding executable program
specifications into the program text. We show that our library leads to modular
and maintainable code that is accessible to GPGPU non-experts, while providing
performance that is comparable with hand-written CUDA code. Furthermore,
runtime contract checking turns out to be feasible, as the contracts can be
executed on the GPU
Formal Analysis and Verification of Max-Plus Linear Systems
Max-Plus Linear (MPL) systems are an algebraic formalism with practical
applications in transportation networks, manufacturing and biological systems.
In this paper, we investigate the problem of automatically analyzing the
properties of MPL, taking into account both structural properties such as
transient and cyclicity, and the open problem of user-defined temporal
properties. We propose Time-Difference LTL (TDLTL), a logic that encompasses
the delays between the discrete time events governed by an MPL system, and
characterize the problem of model checking TDLTL over MPL. We first consider a
framework based on the verification of infinite-state transition systems, and
propose an approach based on an encoding into model checking. Then, we leverage
the specific features of MPL systems to devise a highly optimized,
combinational approach based on Satisfiability Modulo Theory (SMT). We
experimentally evaluate the features of the proposed approaches on a large set
of benchmarks. The results show that the proposed approach substantially
outperforms the state of the art competitors in expressiveness and
effectiveness, and demonstrate the superiority of the combinational approach
over the reduction to model checking.Comment: 28 pages (including appendixes
Model Based Synthesis of Control Software from System Level Formal Specifications
Many Embedded Systems are indeed Software Based Control Systems, that is
control systems whose controller consists of control software running on a
microcontroller device. This motivates investigation on Formal Model Based
Design approaches for automatic synthesis of embedded systems control software.
We present an algorithm, along with a tool QKS implementing it, that from a
formal model (as a Discrete Time Linear Hybrid System) of the controlled system
(plant), implementation specifications (that is, number of bits in the
Analog-to-Digital, AD, conversion) and System Level Formal Specifications (that
is, safety and liveness requirements for the closed loop system) returns
correct-by-construction control software that has a Worst Case Execution Time
(WCET) linear in the number of AD bits and meets the given specifications.
We show feasibility of our approach by presenting experimental results on
using it to synthesize control software for a buck DC-DC converter, a widely
used mixed-mode analog circuit, and for the inverted pendulum.Comment: Accepted for publication by ACM Transactions on Software Engineering
and Methodology (TOSEM
GPUVerify: A Verifier for GPU Kernels
We present a technique for verifying race- and divergence-freedom of GPU kernels that are written in mainstream ker-nel programming languages such as OpenCL and CUDA. Our approach is founded on a novel formal operational se-mantics for GPU programming termed synchronous, delayed visibility (SDV) semantics. The SDV semantics provides a precise definition of barrier divergence in GPU kernels and allows kernel verification to be reduced to analysis of a sequential program, thereby completely avoiding the need to reason about thread interleavings, and allowing existing modular techniques for program verification to be leveraged. We describe an efficient encoding for data race detection and propose a method for automatically inferring loop invari-ants required for verification. We have implemented these techniques as a practical verification tool, GPUVerify, which can be applied directly to OpenCL and CUDA source code. We evaluate GPUVerify with respect to a set of 163 kernels drawn from public and commercial sources. Our evaluation demonstrates that GPUVerify is capable of efficient, auto-matic verification of a large number of real-world kernels
07401 Abstracts Collection -- Deduction and Decision Procedures
From 01.10. to 05.10.2007, the Dagstuhl Seminar 07401 ``Deduction and Decision Procedures\u27\u27 was held in the International Conference and Research Center (IBFI),
Schloss Dagstuhl.
During the seminar, several participants presented their current
research, and ongoing work and open problems were discussed. Abstracts of
the presentations given during the seminar
as well as abstracts of seminar results and ideas
are put together in this paper
- …