Dynamic detection of atomic-set-serializability violations

Previously we presented atomic sets, memory locations that share some consistency property, and units of work, code fragments that preserve consistency of atomic sets on which they are declared. We also proposed atomic-set serializability as a correctness criterion for concurrent programs, stating that units of work must be serializable for each atomic set. We showed that a set of problematic data access patterns characterize executions that are not atomic-set serializable. Our criterion subsumes data races (single-location atomic sets) and serializability (all locations in one set). In this paper, we present a dynamic analysis for detecting violations of atomic-set serializability. The analysis can be implemented efficiently, and does not depend on any specific synchronization mechanism. We implemented the analysis and evaluated it on a suite of real programs and benchmarks. We found a number of known errors as well as several problems not previously reported.

[1]  Richard J. Lipton,et al.  Reduction: a method of proving properties of parallel programs , 1975, CACM.

[2]  Scott D. Stoller,et al.  Run-Time Analysis for Atomicity , 2003, RV@CAV.

[3]  Dawson R. Engler,et al.  RacerX: effective, static detection of race conditions and deadlocks , 2003, SOSP '03.

[4]  Frank Tip,et al.  Refactoring support for class library migration , 2005, OOPSLA '05.

[5]  Yuanyuan Zhou,et al.  AVIO: Detecting Atomicity Violations via Access-Interleaving Invariants , 2007, IEEE Micro.

[6]  Yosi Ben-Asher,et al.  Noise Makers Need to Know Where to be Silent – Producing Schedules That Find Bugs , 2006, Second International Symposium on Leveraging Applications of Formal Methods, Verification and Validation (isola 2006).

[7]  Klaus Havelund,et al.  Towards a framework and a benchmark for testing tools for multi‐threaded programs , 2007, Concurr. Comput. Pract. Exp..

[8]  Sagar Chaki,et al.  Verifying Concurrent Message-Passing C Programs with Recursive Calls , 2006, TACAS.

[9]  Rahul Agarwal,et al.  Optimized run-time race detection and atomicity checking using partial discovered types , 2005, ASE.

[10]  Shmuel Ur,et al.  Compiling a benchmark of documented multi-threaded bugs , 2004, 18th International Parallel and Distributed Processing Symposium, 2004. Proceedings..

[11]  Thomas R. Gross,et al.  Static Detection of Atomicity Violations in Object-Oriented Programs , 2004, J. Object Technol..

[12]  Scott D. Stoller,et al.  Accurate and efficient runtime detection of atomicity errors in concurrent programs , 2006, PPoPP '06.

[13]  Stefan Schwoon,et al.  Model checking pushdown systems , 2002 .

[14]  M. Burrows,et al.  Finding stale‐value errors in concurrent programs , 2004, Concurr. Pract. Exp..

[15]  Satish Narayanasamy,et al.  Automatically classifying benign and harmful data races using replay analysis , 2007, PLDI '07.

[16]  Dinghao Wu,et al.  KISS: keep it simple and sequential , 2004, PLDI '04.

[17]  Alexander Aiken,et al.  Effective static race detection for Java , 2006, PLDI '06.

[18]  Armin Biere,et al.  High‐level data races , 2003, Softw. Test. Verification Reliab..

[19]  Thomas R. Gross,et al.  Object race detection , 2001, OOPSLA '01.

[20]  Barton P. Miller,et al.  What are race conditions?: Some issues and formalizations , 1992, LOPL.

[21]  Armin Biere,et al.  Using Block-Local Atomicity to Detect Stale-Value Concurrency Errors , 2004, ATVA.

[22]  Alan Bundy,et al.  Constructing Induction Rules for Deductive Synthesis Proofs , 2006, CLASE.

[23]  Jason Gait,et al.  A probe effect in concurrent programs , 1986, Softw. Pract. Exp..

[24]  Jeffrey S. Foster,et al.  LOCKSMITH: context-sensitive correlation analysis for race detection , 2006, PLDI '06.

[25]  Cormac Flanagan,et al.  A type and effect system for atomicity , 2003, PLDI.

[26]  Min Xu,et al.  A serializability violation detector for shared-memory server programs , 2005, PLDI '05.

[27]  Stephen N. Freund,et al.  Type inference for atomicity , 2005, TLDI '05.

[28]  Jong-Deok Choi,et al.  Hybrid dynamic data race detection , 2003, PPoPP '03.

[29]  Guy L. Steele,et al.  Java(TM) Language Specification, The (3rd Edition) (Java (Addison-Wesley)) , 2005 .

[30]  Stephen N. Freund,et al.  Type-based race detection for Java , 2000, PLDI '00.

[31]  Alexander Aiken,et al.  Conditional must not aliasing for static race detection , 2007, POPL '07.

[32]  Martin C. Rinard,et al.  ACM Conference on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA), November 2002 Ownership Types for Safe Programming: Preventing Data Races and Deadlocks , 2022 .

[33]  David Holmes,et al.  Java Concurrency in Practice , 2006 .

[34]  Frank Tip,et al.  Associating synchronization constraints with data in an object-oriented language , 2006, POPL '06.

[35]  Tayssir Touili,et al.  A Generic Approach to the Static Analysis of Concurrent Programs with Procedures , 2003, Int. J. Found. Comput. Sci..

[36]  Jong-Deok Choi,et al.  An efficient cache-based access anomaly detection scheme , 1991, ASPLOS IV.

[37]  Rahul Agarwal,et al.  Automated type-based analysis of data races and atomicity , 2005, PPoPP.

[38]  Stephen N. Freund,et al.  Atomizer: a dynamic atomicity checker for multithreaded programs , 2004, 18th International Parallel and Distributed Processing Symposium, 2004. Proceedings..

[39]  Barbara G. Ryder,et al.  Parameterized object sensitivity for points-to analysis for Java , 2005, TSEM.

[40]  Cormac Flanagan,et al.  Types for atomicity , 2003, TLDI '03.

[41]  Scott D. Stoller,et al.  Runtime analysis of atomicity for multithreaded programs , 2006, IEEE Transactions on Software Engineering.

[42]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[43]  C. A. R. Hoare,et al.  Proof of correctness of data representations , 1972, Acta Informatica.

[44]  Michael Burrows,et al.  Eraser: a dynamic data race detector for multithreaded programs , 1997, TOCS.