Static Application-Level Race Detection in STM Haskell using Contracts

  title={Static Application-Level Race Detection in STM Haskell using Contracts},
  author={Romain Demeyer and Wim Vanhoof},
Writing concurrent programs is a hard task, even when using high-level synchronization primitives such as transactional memories together with a functional language with well-controlled side-effects such as Haskell, because the interferences generated by the processes to each other can occur at different levels and in a very subtle way. The problem occurs when a thread leaves or exposes the shared data in an inconsistent state with respect to the application logic or the real meaning of the… 

Figures from this paper

Dynamic Validation of Contracts in Concurrent Code

A dynamic method for contract validation, which is more precise and scalable than static approaches, is proposed, with known limitations on precision and scalability.



Goldilocks: a race and transaction-aware java runtime

A Java runtime system that monitors program executions and throws a DataRaceException that may be a viable mechanism to enforce the safety of executions of multithreaded Java programs and a precise and efficient algorithm for dynamically verifying that an execution is free of data races.

Detection of Transactional Memory anomalies using static analysis

Results allow to conclude that the proposed technique, although triggering a moderate number of false positives, can be successfully applied to Java programs, correctly identifying the vast majority of the relevant erroneous patterns.

Ownership types for safe programming: preventing data races and deadlocks

A new static type system for multithreaded programs is presented; well-typed programs in the system are guaranteed to be free of data races and deadlocks.

A type and effect system for atomicity

A type system for specifying and verifying the atomicity of methods in multithreaded Java programs, a synthesis of Lipton's theory of reduction and type systems for race detection is implemented and used to check a variety of standard Java library classes.

A compositional theory for STM Haskell

It is concluded that using a pure functional language extended with STM facilitates reasoning about concurrent implementation code and state and prove liveness, soundness, completeness, safety, and termination properties relating source processes and their Haskell implementation.

Verifying correct usage of atomic blocks and typestate

This paper presents a intraprocedural static analysis, formalized as a type system and proven sound, that helps programmers use atomic blocks correctly and statically prevents race conditions and enforces typestate properties in concurrent programs.

A programming model for concurrent object-oriented programs

A verifier is implemented for programs developed according to the proposed programming regime (or programming model) that rules out data races, and enables local reasoning in the presence of object aliasing and concurrency.

High‐level data races

The paper defines the concepts ‘ view’ and ‘view consistency’ to give a notation for this novel kind of property and describes what kinds of errors can be detected with this new definition, and where its limitations are.

Static contract checking for Haskell

  • Na Xu
  • Computer Science
    POPL '09
  • 2009
A sound and automatic static verification framework for Haskell, that is based on contracts and symbolic execution, that gives precise blame assignments at compile-time in the presence of higher-order functions and laziness is described.

Transactional memory with data invariants

STM Haskell is extended to dynamically evaluate check statements atomically with the user’s updates: the result is that the authors can identify precisely which update is the first one to break an invariant.