Deadlock-Free Typestate-Oriented Programming

by   Luca Padovani, et al.

Context. TypeState-Oriented Programming (TSOP) is a paradigm intended to help developers in the implementation and use of mutable objects whose public interface depends on their private state. Under this paradigm, well-typed programs are guaranteed to conform with the protocol of the objects they use. Inquiry. Previous works have investigated TSOP for both sequential and concurrent objects. However, an important difference between the two settings still remains. In a sequential setting, a well-typed program either progresses indefinitely or terminates eventually. In a concurrent setting, protocol conformance is no longer enough to avoid deadlocks, a situation in which the execution of the program halts because two or more objects are involved in mutual dependencies that prevent any further progress. Approach. In this work, we put forward a refinement of TSOP for concurrent objects guaranteeing that well-typed programs not only conform with the protocol of the objects they use, but are also deadlock free. The key ingredients of the type system are behavioral types, used to specify and enforce object protocols, and dependency relations, used to represent abstract descriptions of the dependencies between objects and detect circularities that might cause deadlocks. Knowledge. The proposed approach stands out for two features. First, the approach is fully compositional and therefore scalable: the objects of a large program can be type checked in isolation; deadlock freedom of an object composition solely depends on the types of the objects being composed; any modification/refactoring of an object that does not affect its public interface does not affect other objects either. Second, we provide the first deadlock analysis technique for join patterns, a high-level concurrency abstraction with which programmers can express complex synchronizations in a succinct and declarative form. Grounding. We detail the proposed typing discipline for a core programming language blending concurrent objects, asynchronous message passing and join patterns. We prove that the type system is sound and give non-trivial examples of programs that can be successfully analyzed. A Haskell implementation of the type system that demonstrates the feasibility of the approach is publicly available. Importance. The static analysis technique described in this work can be used to certify programs written in a core language for concurrent TSOP with proven correctness guarantees. This is an essential first step towards the integration and application of the technique in a real-world developer toolchain, making programming of such systems more productive and less frustrating.


Reversing an Imperative Concurrent Programming Language

We introduce a method of reversing the execution of imperative concurren...

Papaya: Global Typestate Analysis of Aliased Objects Extended Version

Typestates are state machines used in object-oriented programming to spe...

Bestow and Atomic: Concurrent Programming using Isolation, Delegation and Grouping

Any non-trivial concurrent system warrants synchronisation, regardless o...

Concurrent Typestate-Oriented Programming in Java

We describe a generative approach that enables concurrent typestate-orie...

Sound Atomicity Inference for Data-Centric Synchronization

Data-Centric Concurrency Control (DCCC) shifts the reasoning about concu...

Existential Types for Relaxed Noninterference

Information-flow security type systems ensure confidentiality by enforci...

An Axiomatic Approach to Detect Information Leaks in Concurrent Programs

Realizing flow security in a concurrent environment is extremely challen...

Please sign up or login with your details

Forgot password? Click here to reset