Resource-sensitive synchronisation inference by abduction

We present an analysis which takes as its input a sequential program, augmented with annotations indicating potential parallelization opportunities, and a sequential proof, written in separation logic, and produces a correctly-synchronized parallelized program and proof of that program. Unlike previous work, ours is not an independence analysis; we insert synchronization constructs to preserve relevant dependencies found in the sequential program that may otherwise be violated by a näıve translation. Separation logic allows us to parallelize fine-grained patterns of resource-usage, moving beyond straightforward points-to analysis. Our analysis works by using the sequential proof to discover dependencies between different parts of the program. It leverages these discovered dependencies to guide the insertion of synchronization primitives into the parallelized program, and to ensure that the resulting parallelized program satisfies the same specification as the original sequential program, and exhibits the same sequential behaviour. Our analysis is built using frame inference and abduction, two techniques supported by an increasing number of separation logic tools.

[1]  Håkan Grahn,et al.  Transactional memory , 2010, J. Parallel Distributed Comput..

[2]  Frank Piessens,et al.  Modular full functional specification and verification of lock-free data structures , 2009 .

[3]  Matthew J. Parkinson,et al.  jStar: towards practical verification for java , 2008, OOPSLA.

[4]  Suresh Jagannathan,et al.  Modular reasoning for deterministic parallelism , 2011, POPL '11.

[5]  Jan Smans,et al.  Deadlock-Free Channels and Locks , 2010, ESOP.

[6]  Peiyi Tang,et al.  Reducing data communication overhead for DOACROSS loop nests , 1994, ICS '94.

[7]  Viktor Vafeiadis,et al.  Bi-abductive Resource Invariant Synthesis , 2009, APLAS.

[8]  Radu Grigore,et al.  coreStar : the Core of jStar , 2011 .

[9]  Byron Cook,et al.  Making fast hardware with separation logic , 2009 .

[10]  Philippa Gardner,et al.  Automatic Parallelization with Separation Logic , 2009, ESOP.

[11]  Marieke Huisman,et al.  Reasoning about Java's Reentrant Locks , 2008, APLAS.

[12]  Andrew W. Appel,et al.  Concurrent Separation Logic for Pipelined Parallelization , 2010, SAS.

[13]  Andrew W. Appel,et al.  Oracle Semantics for Concurrent Separation Logic , 2008, ESOP.

[14]  Peter W. O'Hearn,et al.  Local Action and Abstract Separation Logic , 2007, 22nd Annual IEEE Symposium on Logic in Computer Science (LICS 2007).

[15]  Xiangyu Zhang,et al.  Quasi-static scheduling for safe futures , 2008, PPoPP.

[16]  Cristiano Calcagno,et al.  Tracking Heaps That Hop with Heap-Hop , 2010, TACAS.

[17]  Jyotirmoy V. Deshmukh,et al.  Logical Concurrency Control from Sequential Proofs , 2010, Log. Methods Comput. Sci..

[18]  Jeffrey Overbey,et al.  A type and effect system for deterministic parallel Java , 2009, OOPSLA 2009.

[19]  Peter W. O'Hearn,et al.  Separation Logic Semantics for Communicating Processes , 2008, FICS.

[20]  John C. Reynolds,et al.  Separation logic: a logic for shared mutable data structures , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[21]  Peter W. O'Hearn,et al.  Smallfoot: Modular Automatic Assertion Checking with Separation Logic , 2005, FMCO.

[22]  Alexey Gotsman,et al.  Local Reasoning for Storable Locks and Threads , 2007, APLAS.

[23]  Peter W. O'Hearn,et al.  Permission accounting in separation logic , 2005, POPL '05.

[24]  Dan Grossman,et al.  CoreDet: a compiler and runtime system for deterministic multithreaded execution , 2010, ASPLOS XV.

[25]  Koushik Sen,et al.  Asserting and checking determinism for multithreaded programs , 2009, ESEC/FSE '09.

[26]  Emery D. Berger,et al.  Grace: safe multithreaded programming for C/C++ , 2009, OOPSLA 2009.

[27]  James R. Larus,et al.  Transactional Memory, 2nd edition , 2010, Transactional Memory.

[28]  Clément Hurlin,et al.  Automatic Parallelization and Optimization of Programs by Proof Rewriting , 2009, SAS.

[29]  Keshav Pingali,et al.  The tao of parallelism in algorithms , 2011, PLDI '11.

[30]  Guilherme Ottoni,et al.  Automatic thread extraction with decoupled software pipelining , 2005, 38th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO'05).

[31]  Dino Distefano,et al.  Memory Leaks Detection in Java by Bi-abductive Inference , 2010, FASE.

[32]  Peter W. O'Hearn,et al.  Resources, concurrency, and local reasoning , 2007 .

[33]  Serdar Tasiran,et al.  A calculus of atomic actions , 2009, POPL '09.