Verifying Parallel Loops with Separation Logic

  title={Verifying Parallel Loops with Separation Logic},
  author={Stefan Blom and Saeed Darabi and Marieke Huisman},
This paper proposes a technique to specify and verify whether a loop can be parallelised. Our approach can be used as an additional step in a parallelising compiler to verify user annotations about loop dependences. Essentially, our technique requires each loop iteration to be specified with the locations it will read and write. From the loop iteration specifications, the loop (in)dependences can be derived. Moreover, the loop iteration specifications also reveal where synchronisation is needed… 

Verification of Loop Parallelisations

A technique based on separation logic to verify whether a loop can be parallelised and how the loop iteration contracts can be compiled into specifications for the code coming out of the parallelising compiler is proposed.

Verification of Program Parallelization

This thesis presents a set of verification techniques based on permission-based separation logic to reason about the data race freedom and functional correctness of program parallelizations, effectively enabling a holistic verification solution for such parallelization frameworks.



Checking Interference with Fractional Permissions

An operational semantics of a simple imperative language with structured parallelism is given and it is proved that the permission system enables parallelism to proceed with deterministic results.

The VerCors Tool for Verification of Concurrent Programs

The VerCors tool implements thread-modular static verification of concurrent programs, annotated with functional properties and heap access permissions, and the features of its specification language are discussed.

Types, bytes, and separation logic

A formal model of memory is presented that both captures the low-level features of C's pointers and memory, and forms the basis for an expressive implementation of separation logic that is applicable to real, security- and safety-critical code by formally verifying the memory allocator of the L4 microkernel.

Permission accounting in separation logic

A lightweight logical approach to race-free sharing of heap storage between concurrent threads is described, based on the notion of permission to access, which mirrors the programming technique called permission counting.

Specified Blocks

This paper argues that specified blocks have every advantage over the combination of assertions, preconditions, postconditions, invariants, and variants, both for verifying programs, and for program

Separation logic: a logic for shared mutable data structures

  • J. C. Reynolds
  • Computer Science
    Proceedings 17th Annual IEEE Symposium on Logic in Computer Science
  • 2002
An extension of Hoare logic that permits reasoning about low-level imperative programs that use shared mutable data structure is developed, including extensions that permit unrestricted address arithmetic, dynamically allocated arrays, and recursive procedures.

Specification and verification of GPGPU programs

OpenMP: an industry standard API for shared-memory programming

At its most elemental level, OpenMP is a set of compiler directives and callable runtime library routines that extend Fortran (and separately, C and C++ to express shared memory parallelism. It

Resources, Concurrency and Local Reasoning

In this paper we show how a resource-oriented logic, separation logic, can be used to reason about the usage of resources in concurrent programs.

PENCIL: Towards a Platform-Neutral Compute Intermediate Language for DSLs

We motivate the design and implementation of a platform-neutral compute intermediate language (PENCIL) for productive and performance-portable accelerator programming.