May-Happen-in-Parallel Analysis for Actor-Based Concurrency

This article presents a may-happen-in-parallel (MHP) analysis for languages with actor-based concurrency. In this concurrency model, actors are the concurrency units such that, when a method is invoked on an actor a2 from a task executing on actor a1, statements of the current task in a1 may run in parallel with those of the (asynchronous) call on a2, and with those of transitively invoked methods. The goal of the MHP analysis is to identify pairs of statements in the program that may run in parallel in any execution. Our MHP analysis is formalized as a method-level (local) analysis whose information can be modularly composed to obtain application-level (global) information. The information yielded by the MHP analysis is essential to infer more complex properties of actor-based concurrent programs, for example, data race detection, deadlock freeness, termination, and resource consumption analyses can greatly benefit from the MHP relations to increase their accuracy. We report on MayPar, a prototypical implementation of an MHP static analyzer for a distributed asynchronous language.

[1]  George S. Avrunin,et al.  An efficient algorithm for computing MHP information for concurrent Java programs , 1999, ESEC/FSE-7.

[2]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[3]  Andrey Rybalchenko,et al.  Compositional Termination Proofs for Multi-threaded Programs , 2012, TACAS.

[4]  Reiner Hähnle,et al.  ABS: A Core Language for Abstract Behavioral Specification , 2010, FMCO.

[5]  Elvira Albert,et al.  Peak Cost Analysis of Distributed Systems , 2014, SAS.

[6]  Peter A. Buhr,et al.  Monitor classification , 1995, CSUR.

[7]  George S. Avrunin,et al.  A conservative data flow algorithm for detecting all pairs of statements that may happen in parallel , 1998, SIGSOFT '98/FSE-6.

[8]  David Gay,et al.  Effective static deadlock detection , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[9]  Mary Lou Soffa,et al.  Concurrency analysis in the presence of procedures using a data-flow framework , 1991, TAV4.

[10]  Monica S. Lam,et al.  Cloning-based context-sensitive pointer alias analysis using binary decision diagrams , 2004, PLDI '04.

[11]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[12]  Jens Palsberg,et al.  Featherweight X10: a core calculus for async-finish parallelism , 2010, PPoPP '10.

[13]  Elvira Albert,et al.  SACO: Static Analyzer for Concurrent Objects , 2014, TACAS.

[14]  Frank S. de Boer,et al.  A Complete Guide to the Future , 2007, ESOP.

[15]  Barbara G. Ryder,et al.  Parameterized object sensitivity for points-to and side-effect analyses for Java , 2002, ISSTA '02.

[16]  Einar Broch Johnsen,et al.  Concurrent Objects à la Carte , 2010, Concurrency, Compositionality, and Correctness.

[17]  Vivek Sarkar,et al.  May-happen-in-parallel analysis of X10 programs , 2007, PPoPP.

[18]  Stephen P. Masticola,et al.  Static detection of deadlocks in polynomial time , 1993 .

[19]  Lin Li,et al.  A Practical MHP Information Analysis for Concurrent Java Programs , 2004, LCPC.

[20]  Andreas Podelski,et al.  Proving thread termination , 2007, PLDI '07.

[21]  Elvira Albert,et al.  May-Happen-in-Parallel Analysis for Asynchronous Programs with Inter-Procedural Synchronization , 2015, SAS.

[22]  Patrick Cousot,et al.  A constructive characterization of the lattices of all retractions, pre-closure, quasi-closure and closure operators on a complete lattice , 1979 .

[23]  Martin Odersky,et al.  Scala Actors: Unifying thread-based and event-based programming , 2009, Theor. Comput. Sci..

[24]  Jeffrey D. Ullman,et al.  Analysis of a simple algorithm for global data flow problems , 1973, POPL.

[25]  Jorge A. Navas,et al.  Abstract Interpretation over Non-lattice Abstract Domains , 2013, SAS.

[26]  Richard N. Taylor,et al.  Complexity of analyzing the synchronization structure of concurrent programs , 1983, Acta Informatica.

[27]  Flemming Nielson,et al.  Principles of Program Analysis , 1999, Springer Berlin Heidelberg.

[28]  Elvira Albert,et al.  May-Happen-in-Parallel Based Deadlock Analysis for Concurrent Objects , 2013, FMOODS/FORTE.

[29]  G. Ramalingam,et al.  Context-sensitive synchronization-sensitive analysis is undecidable , 2000, TOPL.

[30]  Akash Lal,et al.  Asynchronous programs with prioritized task-buffers , 2012, SIGSOFT FSE.

[31]  Jens Palsberg,et al.  Efficient May Happen in Parallel Analysis for Async-Finish Parallelism , 2012, SAS.

[32]  Barbara G. Ryder,et al.  Non-concurrency analysis , 1993, PPOPP '93.

[33]  Elvira Albert,et al.  Analysis of May-Happen-in-Parallel in Concurrent Objects , 2012, FMOODS/FORTE.

[34]  Rajkishore Barik,et al.  Efficient Computation of May-Happen-in-Parallel Information for Concurrent Java Programs , 2005, LCPC.

[35]  Jeffrey D. Ullman,et al.  Global Data Flow Analysis and Iterative Algorithms , 1976, J. ACM.

[36]  Elvira Albert,et al.  Termination and Cost Analysis of Loops with Concurrent Interleavings , 2013, ATVA.

[37]  Benjamin C. Pierce,et al.  Concurrent Objects in a Process Calculus , 1994, Theory and Practice of Parallel Programming.