10 Years of research on debugging concurrent and multicore software: a systematic mapping study

AbstractDebugging—the process of identifying, localizing and fixing bugs—is a key activity in software development . Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of methods, models and tools for debugging concurrent and multicore software have been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve. This suggests the need for a classification, and an up-to-date comprehensive overview of the area. This paper presents the results of a systematic mapping study in the field of debugging of concurrent and multicore software in the last decade (2005–2014). The study is guided by two objectives: (1) to summarize the recent publication trends and (2) to clarify current research gaps in the field. Through a multi-stage selection process, we identified 145 relevant papers. Based on these, we summarize the publication trend in the field by showing distribution of publications with respect to year, publication venues, representation of academia and industry, and active research institutes. We also identify research gaps in the field based on attributes such as types of concurrency bugs, types of debugging processes, types of research and research contributions. The main observations from the study are that during the years 2005–2014: (1) there is no focal conference or venue to publish papers in this area; hence, a large variety of conferences and journal venues (90) are used to publish relevant papers in this area; (2) in terms of publication contribution, academia was more active in this area than industry; (3) most publications in the field address the data race bug; (4) bug identification is the most common stage of debugging addressed by articles in the period; (5) there are six types of research approaches found, with solution proposals being the most common one; and (6) the published papers essentially focus on four different types of contributions, with “methods” being the most common type. We can further conclude that there are still quite a number of aspects that are not sufficiently covered in the field, most notably including (1) exploring correction and fixing bugs in terms of debugging process; (2) order violation, suspension and starvation in terms of concurrency bugs; (3) validation and evaluation research in the matter of research type; (4) metric in terms of research contribution. It is clear that the concurrent, parallel and multicore software community needs broader studies in debugging. This systematic mapping study can help direct such efforts.

[1]  Brandon Lucia,et al.  DMP: Deterministic Shared-Memory Multiprocessing , 2010, IEEE Micro.

[2]  Nan Wang,et al.  A Transparent Control-Flow Based Approach to Record-Replay Non-deterministic Bugs , 2012, 2012 IEEE Seventh International Conference on Networking, Architecture, and Storage.

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

[4]  Haibo Chen,et al.  Scalable deterministic replay in a parallel full-system emulator , 2013, PPoPP '13.

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

[6]  Eitan Farchi,et al.  Detection of Transactional Memory anomalies using static analysis , 2010, PADTAD '10.

[7]  Shan Lu,et al.  Production-run software failure diagnosis via hardware performance counters , 2013, ASPLOS '13.

[8]  Brandon Lucia,et al.  Finding concurrency bugs with context-aware communication graphs , 2009, 2009 42nd Annual IEEE/ACM International Symposium on Microarchitecture (MICRO).

[9]  Gilles Pokam,et al.  Concurrent predicates: A debugging technique for every parallel programmer , 2013, Proceedings of the 22nd International Conference on Parallel Architectures and Compilation Techniques.

[10]  In-Bon Kuh,et al.  A Race Healing Framework in Simulated ARINC-653 , 2010, FGIT-FGCN.

[11]  Binxing Fang,et al.  An efficient logical clock for replaying message-passing programs , 2005 .

[12]  Roger D. Hersch,et al.  A debugger for flow graph based parallel applications , 2007, PADTAD '07.

[13]  Scott D. Stoller,et al.  Runtime analysis for atomicity for multi-threaded programs , 2005 .

[14]  Peng Zhou,et al.  Deterministic Replay of Multithread Applications Using Virtual Machine , 2012, 2012 26th International Conference on Advanced Information Networking and Applications Workshops.

[15]  Raja Das,et al.  MulticoreSDK: a practical and efficient data race detector for real-world applications , 2009, PADTAD '09.

[16]  Gail C. Murphy,et al.  Who should fix this bug? , 2006, ICSE.

[17]  Josep Torrellas,et al.  Pacman: Tolerating asymmetric data races with unintrusive hardware , 2012, IEEE International Symposium on High-Performance Comp Architecture.

[18]  Ding Yuan,et al.  SherLog: error diagnosis by connecting clues from run-time logs , 2010, ASPLOS XV.

[19]  Louise E. Moser,et al.  Replay debugging of non‐deterministic executions in the Kernel‐based Virtual Machine , 2013, Softw. Pract. Exp..

[20]  Kai Petersen,et al.  Systematic Mapping Studies in Software Engineering , 2008, EASE.

[21]  Gregory R. Watson,et al.  An integrated approach to improving the parallel application development process , 2009, 2009 IEEE International Symposium on Parallel & Distributed Processing.

[22]  Chao Wang,et al.  Generating Data Race Witnesses by an SMT-Based Analysis , 2011, NASA Formal Methods.

[23]  Shantanu Gupta,et al.  Using hardware transactional memory for data race detection , 2009, 2009 IEEE International Symposium on Parallel & Distributed Processing.

[24]  Terence Kelly,et al.  On atomicity enforcement in concurrent software via Discrete Event Systems theory , 2012, 2012 IEEE 51st IEEE Conference on Decision and Control (CDC).

[25]  Per Runeson,et al.  Software product line testing - A systematic mapping study , 2011, Inf. Softw. Technol..

[26]  Xiangyu Zhang,et al.  Analyzing concurrency bugs using dual slicing , 2010, ISSTA '10.

[27]  Stephen N. Freund,et al.  Adversarial memory for detecting destructive races , 2010, PLDI '10.

[28]  Weixing Ji,et al.  Dynamic enforcement of determinism in a parallel scripting language , 2014, PLDI.

[29]  Rajiv Gupta,et al.  Dynamic slicing of multithreaded programs for race detection , 2008, 2008 IEEE International Conference on Software Maintenance.

[30]  Richard W. Vuduc,et al.  A Unified Approach for Localizing Non-deadlock Concurrency Bugs , 2012, 2012 IEEE Fifth International Conference on Software Testing, Verification and Validation.

[31]  Wen-Ben Jone,et al.  IMITATOR: A deterministic multicore replay system with refining techniques , 2012, Proceedings of Technical Program of 2012 VLSI Design, Automation and Test.

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

[33]  Wei Wei,et al.  Static Data Race Detection for Java Programs with Dynamic Class Loading , 2014, IDCS.

[34]  Sascha Uhrig Tracing Static Fields of Embedded Parallel Java Applications , 2011, 2011 IEEE 35th Annual Computer Software and Applications Conference Workshops.

[35]  Yong-Kee Jun,et al.  Program Visualization for Debugging Deadlocks in Multithreaded Programs , 2010, FGIT-ASEA.

[36]  Miguel Castro,et al.  Dynamically checking ownership policies in concurrent c/c++ programs , 2010, POPL '10.

[37]  Xu Zhou,et al.  RaceFree: an efficient multi-threading model for determinism , 2013, PPoPP '13.

[38]  Sriram Sankaranarayanan,et al.  Static analysis for concurrent programs with applications to data race detection , 2013, International Journal on Software Tools for Technology Transfer.

[39]  Josep Torrellas,et al.  The Bulk Multicore architecture for improved programmability , 2009, Commun. ACM.

[40]  Daniel Sundmark,et al.  Towards Classification of Concurrency Bugs Based on Observable Properties , 2015, 2015 IEEE/ACM 1st International Workshop on Complex Faults and Failures in Large Software Systems (COUFLESS).

[41]  Michael Kistler,et al.  Detecting race conditions in asynchronous DMA operations with full system simulation , 2011, (IEEE ISPASS) IEEE INTERNATIONAL SYMPOSIUM ON PERFORMANCE ANALYSIS OF SYSTEMS AND SOFTWARE.

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

[43]  Michael D. Bond,et al.  Efficient context sensitivity for dynamic analyses via calling context uptrees and customized memory management , 2013, OOPSLA.

[44]  Volker Stolz,et al.  Deadlock Checking by Data Race Detection , 2013, FSEN.

[45]  Klemens Böhm,et al.  Data mining for defects in multicore applications: an entropy‐based call‐graph technique , 2014, Concurr. Comput. Pract. Exp..

[46]  Elad Yom-Tov,et al.  Instrumenting where it hurts: an automatic concurrent debugging technique , 2007, ISSTA '07.

[47]  Bertrand Meyer,et al.  Design of an empirical study for comparing the usability of concurrent programming languages , 2013, Inf. Softw. Technol..

[48]  Hyuk-Ro Park,et al.  Visualization of Affect-Relations of Message Races for Debugging MPI Programs , 2007, 2007 IEEE International Conference on Granular Computing (GRC 2007).

[49]  Brandon Lucia,et al.  ColorSafe: architectural support for debugging and dynamically avoiding multi-variable atomicity violations , 2010, ISCA.

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

[51]  Saurabh Bagchi,et al.  Pesticide: Using SMT to Improve Performance of Pointer-Bug Detection , 2006, 2006 International Conference on Computer Design.

[52]  Mateo Valero,et al.  Debugging programs that use atomic blocks and transactional memory , 2010, PPoPP '10.

[53]  H. R. Zarandi,et al.  Two control-flow error recovery methods for multithreaded programs running on multi-core processors , 2012, 2012 28th International Conference on Microelectronics Proceedings.

[54]  Ernesto Pimentel,et al.  On the Evolution of reliability Methods for Critical Software , 2006, Trans. SDPS.

[55]  María-del-Mar Gallardo,et al.  Using SPIN for automated debugging of infinite executions of Java programs , 2014, J. Syst. Softw..

[56]  Maria Luisa Villani,et al.  Ant Colony Optimization for Deadlock Detection in Concurrent Systems , 2011, 2011 IEEE 35th Annual Computer Software and Applications Conference.

[57]  Sang-Hwa Chung,et al.  Detection of first races for debugging message-passing programs , 2008, 2008 8th IEEE International Conference on Computer and Information Technology.

[58]  Vineet Kahlon Automatic lock insertion in concurrent programs , 2012, 2012 Formal Methods in Computer-Aided Design (FMCAD).

[59]  Swarnendu Biswas,et al.  OCTET: capturing and controlling cross-thread dependences efficiently , 2013, OOPSLA.

[60]  David Abramson,et al.  Statistical assertion: A more powerful method for debugging scientific applications , 2014, J. Comput. Sci..

[61]  Martin Schulz,et al.  MPI runtime error detection with MUST: Advances in deadlock detection , 2012, 2012 International Conference for High Performance Computing, Networking, Storage and Analysis.

[62]  Hua Chen,et al.  Towards Detecting Thread Deadlock in Java Programs with JVM Introspection , 2011, 2011IEEE 10th International Conference on Trust, Security and Privacy in Computing and Communications.

[63]  Roel Wieringa,et al.  Requirements engineering paper classification and evaluation criteria: a proposal and a discussion , 2005, Requirements Engineering.

[64]  Shan Lu,et al.  ConAir: featherweight concurrency bug recovery via single-threaded idempotent execution , 2013, ASPLOS '13.

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

[66]  Xu Wang,et al.  Debug Concurrent Programs with Visualization and Inference of Event Structure , 2012, 2012 19th Asia-Pacific Software Engineering Conference.

[67]  Rajiv Gupta,et al.  Lightweight fault detection in parallelized programs , 2013, Proceedings of the 2013 IEEE/ACM International Symposium on Code Generation and Optimization (CGO).

[68]  Lionel C. Briand,et al.  A UML/MARTE Model Analysis Method for Detection of Data Races in Concurrent Systems , 2009, MoDELS.

[69]  Ji Wang,et al.  Data Race Detection for Interrupt-Driven Programs via Bounded Model Checking , 2013, 2013 IEEE Seventh International Conference on Software Security and Reliability Companion.

[70]  Frédéric Loulergue,et al.  Systematic Development of Correct Bulk Synchronous Parallel Programs , 2010, 2010 International Conference on Parallel and Distributed Computing, Applications and Technologies.

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

[72]  Scott A. Mahlke,et al.  Eliminating Concurrency Bugs with Control Engineering , 2009, Computer.

[73]  Young-Joo Kim,et al.  Efficient Race Verification for Debugging Programs with OpenMP Directives , 2007, PaCT.

[74]  Yann-Hang Lee,et al.  Efficient Data Race Detection for C/C++ Programs Using Dynamic Granularity , 2014, 2014 IEEE 28th International Parallel and Distributed Processing Symposium.

[75]  Serdar Tasiran,et al.  An annotation assistant for interactive debugging of programs with common synchronization idioms , 2009, PADTAD '09.

[76]  G. Edward Suh,et al.  Non-race concurrency bug detection through order-sensitive critical sections , 2013, ISCA.

[77]  Sebastian Burckhardt,et al.  Deconstructing concurrency heisenbugs , 2009, 2009 31st International Conference on Software Engineering - Companion Volume.

[78]  Luís E. T. Rodrigues,et al.  Lightweight cooperative logging for fault replication in concurrent programs , 2012, IEEE/IFIP International Conference on Dependable Systems and Networks (DSN 2012).

[79]  Chuan Ma,et al.  A Process Algebra-Based Detection Model for Multithreaded Programs in Communication System , 2014, KSII Trans. Internet Inf. Syst..

[80]  Ce-Kuen Shieh,et al.  Data race avoidance and replay scheme for developing and debugging parallel programs on distributed shared memory systems , 2011, Parallel Comput..

[81]  Konstantin Serebryany,et al.  ThreadSanitizer: data race detection in practice , 2009, WBIA '09.

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

[83]  Ion Stoica,et al.  ODR: output-deterministic replay for multicore debugging , 2009, SOSP '09.

[84]  Shin Hong,et al.  Effective pattern-driven concurrency bug detection for operating systems , 2013, J. Syst. Softw..

[85]  Ganesh Gopalakrishnan,et al.  Scalable verification of MPI programs , 2010, 2010 IEEE International Symposium on Parallel & Distributed Processing, Workshops and Phd Forum (IPDPSW).

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

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

[88]  Andreas Zeller,et al.  Why Programs Fail: A Guide to Systematic Debugging , 2005 .

[89]  Daniel J. Quinlan,et al.  An OpenMP Analyzer for Detecting Concurrency Errors , 2012, 2012 41st International Conference on Parallel Processing Workshops.

[90]  Klemens Böhm,et al.  Graphs for Mining-Based Defect Localization in Multithreaded Programs , 2012, International Journal of Parallel Programming.

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

[92]  Jari-Matti Mäkelä,et al.  Towards a parallel debugging framework for the massively multi-threaded, step-synchronous REPLICA architecture , 2013, CompSysTech '13.

[93]  Wenwen Wang,et al.  Localization of concurrency bugs using shared memory access pairs , 2014, ASE.

[94]  Cecilia Metra,et al.  Low Cost Concurrent Error Detection Strategy for the Control Logic of High Performance Microprocessors and Its Application to the Instruction Decoder , 2013, J. Electron. Test..

[95]  Lauri Malmi,et al.  Visualising concurrent programs with dynamic dependence graphs , 2011, 2011 6th International Workshop on Visualizing Software for Understanding and Analysis (VISSOFT).

[96]  Yong-Kee Jun,et al.  Detecting First Races in Shared-Memory Parallel Programs with Random Synchronization , 2012, FGIT-GDC/IESH/CGAG.

[97]  Josep Torrellas,et al.  Accurate and efficient filtering for the Intel thread checker race detector , 2006, ASID '06.

[98]  Harald Richter,et al.  A static analysis approach to data race detection in SystemC designs , 2013, 2013 IEEE 16th International Symposium on Design and Diagnostics of Electronic Circuits & Systems (DDECS).

[99]  Pin Zhou,et al.  HARD: Hardware-Assisted Lockset-based Race Detection , 2007, 2007 IEEE 13th International Symposium on High Performance Computer Architecture.

[100]  Josep Torrellas,et al.  DeLorean: Recording and Deterministically Replaying Shared-Memory Multiprocessor Execution Ef?ciently , 2008, 2008 International Symposium on Computer Architecture.

[101]  Rajiv Gupta,et al.  Automated dynamic detection of busy–wait synchronizations , 2009 .

[102]  Xiangyu Zhang,et al.  Analyzing multicore dumps to facilitate concurrency bug reproduction , 2010, ASPLOS XV.

[103]  Guojing Cong,et al.  A static analysis tool using a three-step approach for data races in HPC programs , 2012, PADTAD 2012.

[104]  Takao Shimomura,et al.  Waiting blocked-tree type deadlock detection , 2013, 2013 Science and Information Conference.

[105]  Shan Lu,et al.  Automated atomicity-violation fixing , 2011, PLDI '11.

[106]  Victor Samofalov,et al.  Automated, scalable debugging of MPI programs with Intel® Message Checker , 2005, SE-HPCS '05.

[107]  Walter F. Tichy,et al.  On-the-fly race detection in multi-threaded programs , 2008, PADTAD '08.

[108]  Pearl Brereton,et al.  Performing systematic literature reviews in software engineering , 2006, ICSE.

[109]  Klemens Böhm,et al.  Localizing Defects in Multithreaded Programs by Mining Dynamic Call Graphs , 2010, TAIC PART.

[110]  Claes Wohlin,et al.  Systematic literature studies: Database searches vs. backward snowballing , 2012, Proceedings of the 2012 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement.

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

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

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

[114]  Caitlin Sadowski,et al.  Tiddle: a trace description language for generating concurrent benchmarks to test dynamic analyses , 2009, WODA '09.

[115]  Rajiv Gupta,et al.  Automated dynamic detection of busy–wait synchronizations , 2009, Softw. Pract. Exp..

[116]  Christopher Gottbrath Eliminating parallel application memory bugs with TotalView , 2006, SC.

[117]  Vinay Arora,et al.  Debugging and visualization techniques for multithreaded programs: A survey , 2014, International Conference on Recent Advances and Innovations in Engineering (ICRAIE-2014).

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

[119]  He Li,et al.  A formal semantics for debugging synchronous message passing-based concurrent programs , 2014, Science China Information Sciences.

[120]  Tien-Fu Chen,et al.  NUDA: A Non-Uniform Debugging Architecture and Nonintrusive Race Detection for Many-Core Systems , 2012, IEEE Transactions on Computers.

[121]  Lin Gan,et al.  Visualizing concurrency faults in ARINC-653 real-time applications , 2012, 2012 IEEE/AIAA 31st Digital Avionics Systems Conference (DASC).

[122]  Sriram Sankaranarayanan,et al.  Fast and Accurate Static Data-Race Detection for Concurrent Programs , 2007, CAV.

[123]  Charles Zhang,et al.  Axis: Automatically fixing atomicity violations through solving control constraints , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[124]  Xiang Zhang,et al.  Towards the multithreaded deterministic replay in program debugging , 2012, 2012 8th International Conference on Information Science and Digital Content Technology (ICIDT2012).

[125]  In-Bon Kuh,et al.  On-the-fly detection of data races in OpenMP programs , 2012, PADTAD 2012.

[126]  Viktor Schuppan,et al.  JVM Independent Replay in Java , 2005, Electron. Notes Theor. Comput. Sci..

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

[128]  J. Mendel,et al.  Perceptual Reasoning: A New Computing with Words Engine , 2007 .

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

[130]  Johann A. Briffa,et al.  Codebook and marker sequence design for synchronization-correcting codes , 2011, 2011 IEEE International Symposium on Information Theory Proceedings.

[131]  Todd C. Mowry,et al.  Integrated Debugging of Large Modular Robot Ensembles , 2007, Proceedings 2007 IEEE International Conference on Robotics and Automation.

[132]  Milos Prvulovic,et al.  CORD: cost-effective (and nearly overhead-free) order-recording and data race detection , 2006, The Twelfth International Symposium on High-Performance Computer Architecture, 2006..

[133]  Johanna Schneider Tracking down root causes of defects in simulink models , 2014, ASE.

[134]  Qichang Chen,et al.  An Integrated Framework for Checking Concurrency-Related Programming Errors , 2009, 2009 33rd Annual IEEE International Computer Software and Applications Conference.

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

[136]  Ok-Kyoon Ha,et al.  Visualization Tool for Debugging Data Races in Structured Fork-join Parallel Programs , 2014 .

[137]  Derek Hower,et al.  Rerun: Exploiting Episodes for Lightweight Memory Race Recording , 2008, 2008 International Symposium on Computer Architecture.

[138]  Stephen N. Freund,et al.  Types for atomicity: Static checking and inference for Java , 2008, TOPL.

[139]  Tien-Fu Chen,et al.  dIP: A Non-intrusive Debugging IP for Dynamic Data Race Detection in Many-Core , 2009, 2009 10th International Symposium on Pervasive Systems, Algorithms, and Networks.

[140]  Simone R. S. Souza,et al.  Concurrent Software Testing : A Systematic Review ? , 2010 .

[141]  Rahul Agarwal,et al.  Run-time detection of potential deadlocks for programs with locks, semaphores, and condition variables , 2006, PADTAD '06.

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

[143]  Shmuel Ur,et al.  Toward Automatic Concurrent Debugging Via Minimal Program Mutant Generation with AspectJ , 2007, TV@FLoC.

[144]  Roger D. Hersch,et al.  Dynamic testing of flow graph based parallel applications , 2008, PADTAD '08.

[145]  Jason Nieh,et al.  Transparent mutable replay for multicore debugging and patch validation , 2013, ASPLOS '13.

[146]  Huo Yan Chen Analysis of potential deadlock in Java multithreaded object-oriented programs , 2005, 2005 IEEE International Conference on Systems, Man and Cybernetics.

[147]  Sangmin Park,et al.  Debugging non-deadlock concurrency bugs , 2013, ISSTA.

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

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

[150]  Stephen A. Edwards,et al.  A deterministic multi-way rendezvous library for haskell , 2008, 2008 IEEE International Symposium on Parallel and Distributed Processing.

[151]  Reza Azarderakhsh,et al.  Reliable Concurrent Error Detection Architectures for Extended Euclidean-Based Division Over ${\rm GF}(2^{m})$ , 2014, IEEE Transactions on Very Large Scale Integration (VLSI) Systems.

[152]  Young-Joo Kim,et al.  Scalable Thread Visualization for Debugging Data Races in OpenMP Programs , 2007, GPC.

[153]  Xiaodong Liu,et al.  Requirements model driven adaption and evolution of Internetware , 2014, Science China Information Sciences.

[154]  Lionel C. Briand,et al.  A UML/MARTE Model Analysis Method for Uncovering Scenarios Leading to Starvation and Deadlocks in Concurrent Systems , 2012, IEEE Transactions on Software Engineering.

[155]  Koushik Sen,et al.  Concurrent breakpoints , 2012, PPoPP '12.

[156]  Francisco Vilar Brasileiro,et al.  Improving Automated Testing of Multi-threaded Software , 2008, 2008 1st International Conference on Software Testing, Verification, and Validation.

[157]  Irfan Anjum Manarvi,et al.  IDENTIFICATION AND ANALYSIS OF CAUSES FOR SOFTWARE BUG REJECTION WITH THEIR IMPACT OVER TESTING EFFICIENCY , 2011 .

[158]  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).

[159]  Walter F. Tichy,et al.  Library-Independent Data Race Detection , 2014, IEEE Transactions on Parallel and Distributed Systems.