A Survey of Recent Trends in Testing Concurrent Software Systems

Many modern software systems are composed of multiple execution flows that run simultaneously, spanning from applications designed to exploit the power of modern multi-core architectures to distributed systems consisting of multiple components deployed on different physical nodes. We collectively refer to such systems as concurrent systems. Concurrent systems are difficult to test, since the faults that derive from their concurrent nature depend on the interleavings of the actions performed by the individual execution flows. Testing techniques that target these faults must take into account the concurrency aspects of the systems. The increasingly rapid spread of parallel and distributed architectures led to a deluge of concurrent software systems, and the explosion of testing techniques for such systems in the last decade. The current lack of a comprehensive classification, analysis and comparison of the many testing techniques for concurrent systems limits the understanding of the strengths and weaknesses of each approach and hampers the future advancements in the field. This survey provides a framework to capture the key features of the available techniques to test concurrent software systems, identifies a set of classification criteria to review and compare the available techniques, and discusses in details their strengths and weaknesses, leading to a thorough assessment of the field and paving the road for future progresses.

[1]  Peter Norvig,et al.  Artificial Intelligence: A Modern Approach , 1995 .

[2]  Stefan Haar,et al.  Unfolding-Based Test Selection for Concurrent Conformance , 2013, ICTSS.

[3]  Yuanyuan Zhou,et al.  Learning from mistakes: a comprehensive study on real world concurrency bug characteristics , 2008, ASPLOS.

[4]  Murali Krishna Ramanathan,et al.  Synthesizing tests for detecting atomicity violations , 2015, ESEC/SIGSOFT FSE.

[5]  Naoki Kobayashi,et al.  A New Type System for Deadlock-Free Processes , 2006, CONCUR.

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

[7]  Richard H. Carver,et al.  Use of sequencing constraints for specification-based testing of concurrent programs , 1998 .

[8]  Michael D. Ernst,et al.  Static Deadlock Detection for Java Libraries , 2005, ECOOP.

[9]  Koushik Sen,et al.  Automated Systematic Testing of Open Distributed Programs , 2006, FASE.

[10]  Hans-Juergen Boehm,et al.  Foundations of the C++ concurrency memory model , 2008, PLDI '08.

[11]  Gilles Pokam,et al.  Selective mutation testing for concurrent code , 2013, ISSTA.

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

[13]  Keijo Heljanko,et al.  Using unfoldings in automated testing of multithreaded programs , 2012, 2012 Proceedings of the 27th IEEE/ACM International Conference on Automated Software Engineering.

[14]  Gregg Rothermel,et al.  SimRT: an automated framework to support regression testing for data races , 2014, ICSE.

[15]  Martin C. Rinard,et al.  A parameterized type system for race-free Java programs , 2001, OOPSLA '01.

[16]  Yannis Smaragdakis,et al.  Sound predictive race detection in polynomial time , 2012, POPL '12.

[17]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[18]  Serdar Tasiran,et al.  Goldilocks: a race and transaction-aware java runtime , 2007, PLDI '07.

[19]  Lex Heerink,et al.  Factorized Test Generation for Multi-Input/Output Transition Systems , 1998, IWTCS.

[20]  C. A. Petri Communication with automata , 1966 .

[21]  Jens Palsberg,et al.  Race directed scheduling of concurrent programs , 2014, PPoPP '14.

[22]  Koushik Sen,et al.  Randomized active atomicity violation detection in concurrent programs , 2008, SIGSOFT '08/FSE-16.

[23]  T. H. Tse,et al.  CARISMA: a context-sensitive approach to race-condition sample-instance selection for multithreaded applications , 2012, ISSTA 2012.

[24]  Satish Narayanasamy,et al.  Detecting and surviving data races using complementary schedules , 2011, SOSP.

[25]  Koushik Sen,et al.  Race directed random testing of concurrent programs , 2008, PLDI '08.

[26]  Shin Hong,et al.  Testing concurrent programs to achieve high synchronization coverage , 2012, ISSTA 2012.

[27]  Chao Wang,et al.  Staged concurrent program analysis , 2010, FSE '10.

[28]  David Gay,et al.  SharC: checking data sharing strategies for multithreaded c , 2008, PLDI '08.

[29]  Thomas Ball,et al.  Finding and Reproducing Heisenbugs in Concurrent Programs , 2008, OSDI.

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

[31]  Jens Palsberg,et al.  Sherlock: scalable deadlock detection for concurrent programs , 2014, SIGSOFT FSE.

[32]  Darko Marinov,et al.  Change-aware preemption prioritization , 2011, ISSTA '11.

[33]  Assaf Schuster,et al.  Efficient on-the-fly data race detection in multithreaded C++ programs , 2003, PPoPP '03.

[34]  Magdy S. Abadir,et al.  Coverage metrics for verification of concurrent SystemC designs using mutation testing , 2010, 2010 IEEE International High Level Design Validation and Test Workshop (HLDVT).

[35]  Eitan Farchi,et al.  Applications of synchronization coverage , 2005, PPoPP.

[36]  Murali Krishna Ramanathan,et al.  Multithreaded test synthesis for deadlock detection , 2014, OOPSLA.

[37]  Leslie Lamport,et al.  Time, clocks, and the ordering of events in a distributed system , 1978, CACM.

[38]  Viktor Kuncak,et al.  CrystalBall: Predicting and Preventing Inconsistencies in Deployed Distributed Systems , 2009, NSDI.

[39]  Jong-Deok Choi,et al.  Efficient and precise datarace detection for multithreaded object-oriented programs , 2002, PLDI '02.

[40]  Aditya Kanade,et al.  Efficient race detection in the presence of programmatic event loops , 2016, ISSTA.

[41]  Chao Wang,et al.  Universal Causality Graphs: A Precise Happens-Before Model for Detecting Bugs in Concurrent Programs , 2010, CAV.

[42]  Martín Abadi,et al.  Types for Safe Locking , 1999, ESOP.

[43]  Mark Harman,et al.  An Analysis and Survey of the Development of Mutation Testing , 2011, IEEE Transactions on Software Engineering.

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

[45]  Tomohiko Furumoto,et al.  Pro Multithreading and Memory Management for iOS and OS X , 2012, Apress.

[46]  Robert M. Hierons,et al.  The Effect of the Distributed Test Architecture on the Power of Testing , 2008, Comput. J..

[47]  George Candea,et al.  Data races vs. data race bugs: telling the difference with portend , 2012, ASPLOS XVII.

[48]  Richard N. Taylor,et al.  Structural Testing of Concurrent Programs , 1992, IEEE Trans. Software Eng..

[49]  Jeremy Manson,et al.  The Java memory model , 2005, POPL '05.

[50]  Dimitar Dimitrov,et al.  Commutativity race detection , 2014, PLDI.

[51]  Satish Narayanasamy,et al.  Parallelizing data race detection , 2013, ASPLOS '13.

[52]  Satish Narayanasamy,et al.  Race detection for event-driven mobile applications , 2014, PLDI.

[53]  David Gay,et al.  An effective dynamic analysis for detecting generalized deadlocks , 2010, FSE '10.

[54]  Richard Mortier,et al.  Using Magpie for Request Extraction and Workload Modelling , 2004, OSDI.

[55]  Xuezheng Liu,et al.  D3S: Debugging Deployed Distributed Systems , 2008, NSDI.

[56]  Jennifer Neville,et al.  Structured Comparative Analysis of Systems Logs to Diagnose Performance Problems , 2012, NSDI.

[57]  Felix Naumann,et al.  The Stratosphere platform for big data analytics , 2014, The VLDB Journal.

[58]  Gregg Rothermel,et al.  The Impact of Concurrent Coverage Metrics on Testing Effectiveness , 2013, 2013 IEEE Sixth International Conference on Software Testing, Verification and Validation.

[59]  Vikram S. Adve,et al.  The tasks with effects model for safe concurrency , 2013, PPoPP '13.

[60]  Wei Lin,et al.  WiDS Checker: Combating Bugs in Distributed Systems , 2007, NSDI.

[61]  Randy H. Katz,et al.  X-Trace: A Pervasive Network Tracing Framework , 2007, NSDI.

[62]  Zijiang Yang,et al.  HAVE: Detecting Atomicity Violations via Integrated Dynamic and Static Analysis , 2009, FASE.

[63]  W. K. Chan,et al.  MagicFuzzer: Scalable deadlock detection for large-scale applications , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[64]  Darko Marinov,et al.  MuTMuT: Efficient Exploration for Mutation Testing of Multithreaded Code , 2010, 2010 Third International Conference on Software Testing, Verification and Validation.

[65]  Shing-Chi Cheung,et al.  RECONTEST: Effective Regression Testing of Concurrent Programs , 2015, 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering.

[66]  Ralph E. Johnson,et al.  Bita: Coverage-guided, automatic testing of actor programs , 2013, 2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE).

[67]  Christos H. Papadimitriou,et al.  The serializability of concurrent database updates , 1979, JACM.

[68]  Emery D. Berger,et al.  Dthreads: efficient deterministic multithreading , 2011, SOSP.

[69]  Gregory R. Andrews,et al.  Concurrent programming - principles and practice , 1991 .

[70]  Maurice Herlihy,et al.  Linearizability: a correctness condition for concurrent objects , 1990, TOPL.

[71]  Bernhard K. Aichernig,et al.  From Faults Via Test Purposes to Test Cases: On the Fault-Based Testing of Concurrent Systems , 2006, FASE.

[72]  Peter M. Chen,et al.  Whither generic recovery from application faults? A fault study using open-source software , 2000, Proceeding International Conference on Dependable Systems and Networks. DSN 2000.

[73]  Witawas Srisa-an,et al.  SOS: saving time in dynamic race detection with stationary analysis , 2011, OOPSLA '11.

[74]  Cheng Li,et al.  A study of the internal and external effects of concurrency bugs , 2010, 2010 IEEE/IFIP International Conference on Dependable Systems & Networks (DSN).

[75]  Eran Yahav,et al.  Testing atomicity of composed concurrent operations , 2011, OOPSLA '11.

[76]  Robert E. Strom,et al.  Typestate: A programming language concept for enhancing software reliability , 1986, IEEE Transactions on Software Engineering.

[77]  Assaf Schuster,et al.  Scaling model checking of dataraces using dynamic information , 2005, J. Parallel Distributed Comput..

[78]  Koushik Sen,et al.  Predictive Typestate Checking of Multithreaded Java Programs , 2008, 2008 23rd IEEE/ACM International Conference on Automated Software Engineering.

[79]  Gregor von Bochmann,et al.  Testing Systems Specified as Partial Order Input/Output Automata , 2008, TestCom/FATES.

[80]  Mukesh Singhal,et al.  Deadlock detection in distributed systems , 1989, Computer.

[81]  Darko Marinov,et al.  A Framework for State-Space Exploration of Java-Based Actor Programs , 2009, 2009 IEEE/ACM International Conference on Automated Software Engineering.

[82]  H. V. Jagadish,et al.  A compression technique to materialize transitive closure , 1990, TODS.

[83]  Rajiv Gupta,et al.  Dynamic recognition of synchronization operations for improved data race detection , 2008, ISSTA '08.

[84]  Patrice Godefroid,et al.  Partial-Order Methods for the Verification of Concurrent Systems , 1996, Lecture Notes in Computer Science.

[85]  Amin Vahdat,et al.  Pip: Detecting the Unexpected in Distributed Systems , 2006, NSDI.

[86]  Edmund M. Clarke,et al.  Characterizing Correctness Properties of Parallel Programs Using Fixpoints , 1980, ICALP.

[87]  Alastair F. Donaldson,et al.  Asynchronous programming, analysis and testing with state machines , 2015, PLDI.

[88]  Yan Cai,et al.  Effective and precise dynamic detection of hidden races for Java programs , 2015, ESEC/SIGSOFT FSE.

[89]  Sorav Bansal,et al.  Variable and thread bounding for systematic testing of multithreaded programs , 2012, ISSTA.

[90]  Klaus Havelund,et al.  Model Checking Programs , 2004, Automated Software Engineering.

[91]  Pravesh Kothari,et al.  A randomized scheduler with probabilistic guarantees of finding bugs , 2010, ASPLOS XV.

[92]  Lars Michael Kristensen,et al.  Coloured Petri Nets - Modelling and Validation of Concurrent Systems , 2009 .

[93]  Yuanyuan Zhou,et al.  CTrigger: exposing atomicity violation bugs from their hiding places , 2009, ASPLOS.

[94]  Thomas R. Gross,et al.  Automatic testing of sequential and concurrent substitutability , 2013, 2013 35th International Conference on Software Engineering (ICSE).

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

[96]  Madan Musuvathi,et al.  Iterative context bounding for systematic testing of multithreaded programs , 2007, PLDI '07.

[97]  Danny Dig A Refactoring Approach to Parallelism , 2011, IEEE Software.

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

[99]  Manu Sridharan,et al.  Effective race detection for event-driven programs , 2013, OOPSLA.

[100]  Patrice Godefroid,et al.  Model checking for programming languages using VeriSoft , 1997, POPL '97.

[101]  Atul Singh,et al.  Using queries for distributed monitoring and forensics , 2006, EuroSys.

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

[103]  Alfonso Niño,et al.  A Survey of Parallel Programming Models and Tools in the Multi and Many-core Era , 2022 .

[104]  Stephen N. Freund,et al.  Velodrome: a sound and complete dynamic atomicity checker for multithreaded programs , 2008, PLDI '08.

[105]  NaumannFelix,et al.  The Stratosphere platform for big data analytics , 2014, VLDB 2014.

[106]  Cheng Li,et al.  Finding complex concurrency bugs in large multi-threaded applications , 2011, EuroSys '11.

[107]  Beverly A. Sanders,et al.  Precise Data Race Detection in a Relaxed Memory Model Using Heuristic-Based Model Checking , 2009, 2009 IEEE/ACM International Conference on Automated Software Engineering.

[108]  Richard H. Carver,et al.  Mutation-based testing of concurrent programs , 1993, Proceedings of IEEE International Test Conference - (ITC).

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

[110]  Scott Shenker,et al.  Spark: Cluster Computing with Working Sets , 2010, HotCloud.

[111]  Arie van Deursen,et al.  A study and toolkit for asynchronous programming in c# , 2014, ICSE.

[112]  Jianjun Zhao,et al.  JaConTeBe: A Benchmark Suite of Real-World Java Concurrency Bugs (T) , 2015, 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE).

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

[114]  Stephen N. Freund,et al.  FastTrack: efficient and precise dynamic race detection , 2009, PLDI '09.

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

[116]  Gregor von Bochmann,et al.  Synchronization and Specification Issues in Protocol Testing , 1984, IEEE Trans. Commun..

[117]  Michael D. Bond,et al.  PACER: proportional detection of data races , 2010, PLDI '10.

[118]  Simon L. Peyton Jones,et al.  Concurrent Haskell , 1996, POPL '96.

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

[120]  Tomás Vojnar,et al.  Coverage Metrics for Saturation-Based and Search-Based Testing of Concurrent Software , 2011, RV.

[121]  Shan Lu,et al.  ConMem: detecting severe concurrency bugs through an effect-oriented approach , 2010, ASPLOS XV.

[122]  Xiao Ma,et al.  MUVI: automatically inferring multi-variable access correlations and detecting related semantic and concurrency bugs , 2007, SOSP.

[123]  Eran Yahav,et al.  Experience with Model Checking Linearizability , 2009, SPIN.

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

[125]  Francesco Sorrentino,et al.  PENELOPE: weaving threads to expose atomicity violations , 2010, FSE '10.

[126]  William Pugh Fixing the Java memory model , 1999, JAVA '99.

[127]  Darren Duc Dao,et al.  Live debugging of distributed systems , 2009, CC.

[128]  Shing-Chi Cheung,et al.  Detecting atomic-set serializability violations in multithreaded programs through active randomized testing , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[129]  Adam Betts,et al.  Concurrency testing using schedule bounding: an empirical study , 2014, PPoPP '14.

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

[131]  Francesco Sorrentino,et al.  Predicting null-pointer dereferences in concurrent programs , 2012, SIGSOFT FSE.

[132]  Brian Demsky,et al.  CDSchecker: checking concurrent data structures written with C/C++ atomics , 2013, OOPSLA.

[133]  Grigore Rosu,et al.  jPredictor: a predictive runtime analysis tool for java , 2008, ICSE '08.

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

[135]  Arun K. Rajagopalan RDIT - Race Detection from Incomplete Traces , 2016, 2016 IEEE/ACM 38th International Conference on Software Engineering Companion (ICSE-C).

[136]  Benjamin Livshits,et al.  Detecting JavaScript races that matter , 2015, ESEC/SIGSOFT FSE.

[137]  Gerard J. Holzmann,et al.  The Model Checker SPIN , 1997, IEEE Trans. Software Eng..

[138]  Koushik Sen,et al.  Testing concurrent programs on relaxed memory models , 2011, ISSTA '11.

[139]  Shan Lu,et al.  ConSeq: detecting concurrency bugs through sequential errors , 2011, ASPLOS XVI.

[140]  Christian Hammer,et al.  Detecting deadlock in programs with data-centric synchronization , 2013, 2013 35th International Conference on Software Engineering (ICSE).

[141]  Malay K. Ganai Scalable and precise symbolic analysis for atomicity violations , 2011, 2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011).

[142]  Grigore Rosu,et al.  GPredict: Generic Predictive Concurrency Analysis , 2015, 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering.

[143]  Claude Jard,et al.  Testing Input/Output Partial Order Automata , 2007, TestCom/FATES.

[144]  Jeff Huang,et al.  Persuasive prediction of concurrency access anomalies , 2011, ISSTA '11.

[145]  Susmit Sarkar,et al.  Nitpicking c++ concurrency , 2011, PPDP.

[146]  Joseph Sifakis,et al.  Specification and verification of concurrent systems in CESAR , 1982, Symposium on Programming.

[147]  J. Dingel,et al.  Mutation Operators for Concurrent Java (J2SE 5.0) , 2006, Second Workshop on Mutation Analysis (Mutation 2006 - ISSRE Workshops 2006).

[148]  Peter J. Keleher,et al.  Online data-race detection via coherency guarantees , 1996, OSDI '96.

[149]  Gregg Rothermel,et al.  SimRacer: an automated framework to support testing for process-level races , 2013, ISSTA.

[150]  Vivek Sarkar,et al.  Phasers: a unified deadlock-free construct for collective and point-to-point synchronization , 2008, ICS '08.

[151]  Gregory R. Andrews,et al.  Concepts and Notations for Concurrent Programming , 1983, CSUR.

[152]  Koushik Sen,et al.  Runtime safety analysis of multithreaded programs , 2003, ESEC/FSE-11.

[153]  Yu Lin,et al.  CHECK-THEN-ACT Misuse of Java Concurrent Collections , 2013, 2013 IEEE Sixth International Conference on Software Testing, Verification and Validation.

[154]  Richard W. Vuduc,et al.  Falcon: fault localization in concurrent programs , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[155]  P. Madhusudan,et al.  Thread contracts for safe parallelism , 2011, PPoPP '11.

[156]  Peter Norvig,et al.  Artificial intelligence - a modern approach, 2nd Edition , 2003, Prentice Hall series in artificial intelligence.

[157]  Sanjay Ghemawat,et al.  MapReduce: Simplified Data Processing on Large Clusters , 2004, OSDI.

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

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

[160]  Robert M. Hierons,et al.  Conditions for Resolving Observability Problems in Distributed Testing , 2004, FORTE.

[161]  Murali Krishna Ramanathan,et al.  Trace driven dynamic deadlock detection and reproduction , 2014, PPoPP.

[162]  Koushik Sen,et al.  Effective random testing of concurrent programs , 2007, ASE.

[163]  Sebastian Burckhardt,et al.  Effective ? , 2010 .

[164]  W. K. Chan,et al.  ConLock: a constraint-based approach to dynamic checking on deadlocks in multithreaded programs , 2014, ICSE.

[165]  Robert H. B. Netzer Race condition detection for debugging of shared-memoryparallel programs , 1991 .

[166]  Chao Wang,et al.  Coverage guided systematic concurrency testing , 2011, 2011 33rd International Conference on Software Engineering (ICSE).

[167]  Sarfraz Khurshid,et al.  Test input generation with java PathFinder , 2004, ISSTA '04.

[168]  Robert M. Hierons,et al.  Implementation relations and test generation for systems with distributed interfaces , 2011, Distributed Computing.

[169]  Qi Gao,et al.  2ndStrike: toward manifesting hidden concurrency typestate bugs , 2011, ASPLOS XVI.

[170]  Klaus Havelund,et al.  Using Runtime Analysis to Guide Model Checking of Java Programs , 2013, SPIN.

[171]  Grigore Rosu,et al.  Maximal sound predictive race detection with control flow abstraction , 2014, PLDI.

[172]  Robin Milner,et al.  A Calculus of Communicating Systems , 1980, Lecture Notes in Computer Science.

[173]  Thomas R. Gross,et al.  Performance regression testing of concurrent classes , 2014, ISSTA 2014.

[174]  Wenguang Chen,et al.  Do I use the wrong definition?: DeFuse: definition-use invariants for detecting concurrency and sequential bugs , 2010, OOPSLA.

[175]  Suresh Jagannathan,et al.  Synthesizing racy tests , 2015, PLDI.

[176]  Manu Sridharan,et al.  Race detection for web applications , 2012, PLDI.

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

[178]  Eitan Farchi,et al.  Forcing small models of conditions on program interleaving for detection of concurrent bugs , 2009, PADTAD '09.

[179]  Satish Narayanasamy,et al.  Maple: a coverage-driven testing tool for multithreaded programs , 2012, OOPSLA '12.

[180]  Shan Lu,et al.  A study of interleaving coverage criteria , 2007, ESEC-FSE companion '07.

[181]  David Hovemeyer,et al.  Atomic Instructions in Java , 2002, ECOOP.

[182]  Zvonimir Rakamaric,et al.  Delay-bounded scheduling , 2011, POPL '11.

[183]  Edith Schonberg,et al.  An empirical comparison of monitoring algorithms for access anomaly detection , 2011, PPOPP '90.

[184]  Rupak Majumdar,et al.  Race detection for Android applications , 2014, PLDI.

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

[186]  Erik Meijer Your Mouse is a Database , 2012, ACM Queue.

[187]  Jun Chen,et al.  Testing concurrent programs using value schedules , 2007, ASE.

[188]  Madan Musuvathi,et al.  Fair stateless model checking , 2008, PLDI '08.

[189]  Ion Stoica,et al.  Friday: Global Comprehension for Distributed Replay , 2007, NSDI.

[190]  Swarnendu Biswas,et al.  DoubleChecker: efficient sound and precise atomicity checking , 2014, PLDI.

[191]  Frank Tip,et al.  Dynamic detection of atomic-set-serializability violations , 2008, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[192]  Josep Torrellas,et al.  ReEnact: using thread-level speculation mechanisms to debug data races in multithreaded codes , 2003, ISCA '03.

[193]  Leslie Lamport,et al.  How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs , 2016, IEEE Transactions on Computers.

[194]  Thomas R. Gross,et al.  Ballerina: Automatic generation and clustering of efficient random unit tests for multithreaded code , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[195]  Satish Narayanasamy,et al.  LiteRace: effective sampling for lightweight data-race detection , 2009, PLDI '09.

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

[197]  Jürgen Dingel,et al.  Automating comprehensive safety analysis of concurrent programs using verisoft and TXL , 2004, SIGSOFT '04/FSE-12.

[198]  Koushik Sen,et al.  A randomized dynamic program analysis technique for detecting real deadlocks , 2009, PLDI '09.

[199]  Thomas R. Gross,et al.  FULLY AUTOMATIC AND PRECISE DETECTION OF THREAD SAFETY VIOLATIONS PLDI 2012 , 2013 .

[200]  George Candea,et al.  RaceMob: crowdsourced data race detection , 2013, SOSP.

[201]  Peter Sewell,et al.  Mathematizing C++ concurrency , 2011, POPL '11.

[202]  Wenguang Chen,et al.  RACEZ: a lightweight and non-invasive race detection tool for production applications , 2011, 2011 33rd International Conference on Software Engineering (ICSE).

[203]  Patrice Godefroid,et al.  Dynamic partial-order reduction for model checking software , 2005, POPL '05.

[204]  Nobuko Yoshida,et al.  Dynamic deadlock verification for general barrier synchronisation , 2015, PPoPP.