article

A systematic survey on automated concurrency bug detection, exposing, avoidance, and fixing techniques

Authors:

Xiangyu FanAuthors Info & Claims

Software Quality Journal, Volume 26, Issue 3

Pages 855 - 889

https://doi.org/10.1007/s11219-017-9385-3

Published: 01 September 2018 Publication History

Abstract

Currently, concurrent programs are becoming increasingly widespread to meet the demands of the rapid development of multi-core hardware. However, it could be quite expensive and challenging to guarantee the correctness and efficiency of concurrent programs. In this paper, we provide a systematic review of the existing research on fighting against concurrency bugs, including automated concurrency bug exposing, detection, avoidance, and fixing. These four categories cover the different aspects of concurrency bug problems and are complementary to each other. For each category, we survey the motivation, key issues, solutions, and the current state of the art. In addition, we summarize the classical benchmarks widely used in previous empirical studies and the contribution of active research groups. Finally, some future research directions on concurrency bugs are recommended. We believe this survey would be useful for concurrency programmers and researchers.

References

[1]

Abadi, M., Flanagan, C., & Freund, S.N. (2006). Types for safe locking: static race detection for Java. ACM Transactions on Programming Languages and Systems (TOPLAS), 28, 207-255.

Digital Library

[2]

Ananian, C.S., Asanovic, K., Kuszmaul, B.C., Leiserson, C.E., & Lie, S. (2006). Unbounded transactional memory. In International conference on high-performance computer architecture (pp. 59-69).

[3]

Berger, E.D., Yang, T., Liu, T., & Novark, G. (2009). Grace: Safe multithreaded programming for C/C++. In ACM Sigplan Notices, (Vol. 44 pp. 81-96): ACM.

[4]

Boigelot, B., & Godefroid, P. (1996). Model checking in practice: an analysis of the access. bus protocol using spin. In Proceedings of the 3rd international symposium of formal methods Europe on industrial benefit and advances in formal methods (pp. 465-478).

[5]

Boudol, G. (2009). A deadlock-free semantics for shared memory concurrency. In International colloquium on theoretical aspects of computing (pp. 140-154).

[6]

Bradbury, J.S., & Jalbert, K. (2010). Automatic repair of concurrency bugs. In International symposium on search based software engineering (pp. 1-2).

[7]

Bron, A., Farchi, E., Magid, Y., Nir, Y., & Ur, S. (2005). Applications of synchronization coverage. In Proceedings of the 10th ACM SIGPLAN symposium on principles and practice of parallel programming pp. (206-212). ACM.

[8]

Burckhardt, S., Kothari, P., Musuvathi, M., & Nagarakatte, S. (2010). A randomized scheduler with probabilistic guarantees of finding bugs. ACM Sigplan Notices, 45, 167-178.

Digital Library

[9]

Cadar, C., Dunbar, D., & Engler, D. (2008). Klee: unassisted and automatic generation of high-coverage tests for complex systems programs. In Usenix symposium on operating systems design and implementation, OSDI 2008 (pp. 209-224). California, USA: Proceedings.

[10]

Cai, Y., & Cao, L. (2016). Fixing deadlocks via lock pre-acquisitions. In Proceedings of the 38th international conference on software engineering (pp. 1109-1120). ACM.

[11]

Cai, Y., & Chan, W.K. (2012). Magicfuzzer: scalable deadlock detection for large-scale applications. In International conference on software engineering (pp. 606-616).

[12]

Cai, Y., & Chan, W.K. (2014). Magiclock: scalable detection of potential deadlocks in large-scale multithreaded programs. IEEE Transactions on Software Engineering, 40, 266-281.

Digital Library

[13]

Cai, Y., & Lu, Q. (2016). Dynamic testing for deadlocks via constraints. IEEE Transactions on Software Engineering, 42(9), 825-842.

[14]

Cai, Y., Chan, W.K., & Yu, Y.T. (2013). Taming deadlocks in multithreaded programs. In International conference on quality software (pp. 276-279).

[15]

Cai, Y., Wu, S., & Chan, W. (2014). Conlock: a constraint-based approach to dynamic checking on deadlocks in multithreaded programs. In Proceedings of the 36th international conference on software engineering (pp. 491-502). ACM.

[16]

?erny, P., Henzinger, T.A., Radhakrishna, A., Ryzhyk, L., & Tarrach, T. (2013). Efficient synthesis for concurrency by semantics-preserving transformations. Lecture Notes in Computer Science (pp. 951-967).

[17]

?erny, P., Henzinger, T.A., Radhakrishna, A., Ryzhyk, L., & Tarrach, T. (2014). Regression-free synthesis for concurrency. In International conference on computer aided verification (pp. 568-584). Springer.

[18]

Chew, L. (2009). A system for detecting, preventing and exposing atomicity violations in multithreaded programs. University of Toronto.

[19]

Chew, L., & Lie, D. (2010). Kivati: fast detection and prevention of atomicity violations. In European conference on computer systems, proceedings of the European conference on computer systems, EUROSYS 2010 (pp. 307-320). Paris, France.

[20]

Choi, J.D., Lee, K., Loginov, A., O'Callahan, R., Sarkar, V., & Sridharan, M. (2002). Efficient and precise datarace detection for multithreaded object-oriented programs. ACM Sigplan Notices, 37, 258-269.

[21]

Clarke, E.M., & Wing, J.M. (1996). Formal methods: State of the art and future directions. ACM Computing Surveys, 28, 626-643.

Digital Library

[22]

Clarke, E.M., Grumberg, O., Hiraishi, H., Jha, S., Long, D.E., McMillan, K.L., & Ness, L.A. (1995). Verification of the futurebus+ cache coherence protocol. Formal Methods in System Design, 6(2), 217-232.

Digital Library

[23]

Deng, D., Zhang, W., & Lu, S. (2013). Efficient concurrency-bug detection across inputs. ACM Sigplan Notices, 48, 785-802.

Digital Library

[24]

Deng, D.D., Jin, G.L., Marc, D.K., Ang, L.I., Ben, L., Shan, L.U., Shanxiang, Q.I., Ren, J.L., Karthikeyan, S., & Song, L.H. (2015). Fixing, preventing, and recovering from concurrency bugs. Science China Information Sciences, 58, 1-18.

[25]

Edelstein, O., Farchi, E., Nir, Y., Ratsaby, G., & Ur, S. (2001). Multithreaded Java program test generation. In Joint ACM-iscope conference on Java grande (pp. 111-125).

[26]

Edelstein, O., Farchi, E., Goldin, E., Nir, Y., Ratsaby, G., & Ur, S. (2003). Framework for testing multithreaded Java programs. Concurrency and Computation: Practice and Experience, 15, 485-499.

[27]

Engler, D.R., & Ashcraft, K. (2003). Racerx: effective, static detection of race conditions and deadlocks. In ACM SIGOPS operating systems review (Vol. 37, 237-252). ACM.

[28]

Flanagan, C., & Freund, S.N. (2000). Type-based race detection for Java. ACM Sigplan Notices, 35, 219-232.

[29]

Flanagan, C., Freund, S.N., & Yi, J. (2008). Velodrome: a sound and complete dynamic atomicity checker for multithreaded programs. ACM SIGPLAN Notices, 43(6), 293-303.

Digital Library

[30]

Gerakios, P., Papaspyrou, N., & Sagonas, K. (2011). A type and effect system for deadlock avoidance in lowlevel languages. In Proceedings of the 7th ACM SIGPLAN workshop on types in language design and implementation (pp. 15-28). ACM.

[31]

Godefroid, P. (1997). Model checking for programming languages using VeriSoft. In Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on principles of programming languages (pp. 174-186).

[32]

Godefroid, P., Klarlund, N., & Sen, K. (2005). Dart: Directed automated random testing. In Proceedings of the 2005 ACM SIGPLAN conference on programming language design and implementation (pp. 213-223).

[33]

Godefroid, P., & Nagappan, N. (2008). Concurrency at Microsoft: An exploratory survey. In CAV workshop on exploiting concurrency efficiently and correctly.

[34]

Gordon, C.S., Ernst, M.D., & Grossman, D. (2012). Static lock capabilities for deadlock freedom. In Proceedings of the 8th ACM SIGPLAN workshop on types in language design and implementation (pp. 67-78). ACM.

[35]

Harris, T., & Fraser, K. (2003). Language support for lightweight transactions. ACM Sigplan Notices, 38, 388-402.

Digital Library

[36]

Harris, T., Marlow, S., Peyton-Jones, S., & Herlihy, M. (2005). Composable memory transactions. In Proceedings of the 10th ACM SIGPLAN symposium on principles and practice of parallel programming (pp. 48-60). ACM.

[37]

Herlihy, M., Eliot, J., & Moss, B. (1993). Transactional memory: architectural support for lock-free data structures. In International symposium on computer architecture (pp. 289-300).

[38]

Herlihy, M., Luchangco, V., & Moir, M. (2006). A flexible framework for implementing software transactional memory. ACM Sigplan Notices (p. 41).

[39]

Huang, J., & Zhang, C. (2012). Execution privatization for scheduler-oblivious concurrent programs. In ACM international conference on object oriented programming systems languages and applications (pp. 737-752).

[40]

Jin, G., Thakur, A., Liblit, B., & Lu, S. (2010). Instrumentation and sampling strategies for cooperative concurrency bug isolation. ACM Sigplan Notices, 45, 241-255.

Digital Library

[41]

Jin, G., Song, L., Zhang, W., Lu, S., & Liblit, B. (2011). Automated atomicity-violation fixing. ACM Sigplan Notices, 46, 389-400.

Digital Library

[42]

Jin, G., Zhang, W., Deng, D., Liblit, B., & Lu, S. (2012). Automated concurrency-bug fixing. In Usenix conference on operating systems design and implementation (pp. 221-236).

[43]

Joshi, S., & Lal, A. (2014). Automatically finding atomic regions for fixing bugs in concurrent programs. Computing Research Repository.

[44]

Joshi, P., Park, C.S., Sen, K., & Naik, M. (2009). A randomized dynamic program analysis technique for detecting real deadlocks. ACM Sigplan Notices, 44, 110-120.

Digital Library

[45]

Joshi, P., Naik, M., Sen, K., & Gay, D. (2010). An effective dynamic analysis for detecting generalized deadlocks. In ACM sigsoft international symposium on foundations of software engineering (pp. 327- 336). NM, USA.

[46]

Jula, H., & Candea, G. (2008). A scalable, sound, eventually-complete algorithm for deadlock immunity. In International workshop on runtime verification (pp. 119-136). Springer.

[47]

Jula, H., Tralamazza, D., Zamfir, C., & Candea, G. (2008). Deadlock immunity: enabling systems to defend against deadlocks. In Proceedings of the 8th USENIX conference on operating systems design and implementation (pp. 295-308). USENIX Association.

[48]

Kahlon, V., Gupta, A., & Sinha, N. (2006). Symbolic model checking of concurrent programs using partial orders and on-the-fly transactions. In International conference on computer aided verification (pp. 286-299).

[49]

Kasikci, B., Zamfir, C., & Candea, G. (2013). Racemob: crowdsourced data race detection. In Twenty-Fourth ACM symposium on operating systems principles (pp. 406-422).

[50]

Kasikci, B., Zamfir, C., & Candea, G. (2015). Automated classification of data races under both strong and weak memory models. ACM Transactions on Programming Languages & Systems, 37, 1-44.

Digital Library

[51]

Kelk, D., Jalbert, K., & Bradbury, J.S. (2013). Automatically repairing concurrency bugs with arc. In International conference on multicore software engineering, performance, and tools (pp. 73-84). Springer.

[52]

Kelly, T. (2009). Eliminating concurrency bugs with control engineering. Computer, 42, 52-60.

Digital Library

[53]

Khoshnood, S., Kusano, M., &Wang, C. (2015). Concbugassist: constraint solving for diagnosis and repair of concurrency bugs. In Proceedings of the 2015 international symposium on software testing and analysis (pp. 165-176). ACM.

[54]

Krena, B., Letko, Z., Tzoref, R., Ur, S., & Vojnar, T. (2007). Healing data races on-the-fly. In Proceedings of the 2007 ACM workshop on parallel and distributed systems: testing and debugging (pp. 54-64). ACM.

[55]

Kundu, S., Ganai, M.K., & Wang, C. (2010). Contessa: concurrency testing augmented with symbolic analysis. In Computer aided verification, international conference, CAV 2010 (pp. 127-131). Edinburgh, UK: Proceedings.

[56]

Lahiri, S.K., Qadeer, S., & Rakamari?, Z. (2009). Static and precise detection of concurrency errors in systems code using SMT solvers. In Proceedings of the 21st international conference on computer aided verification (pp. 509-524).

[57]

Lal, A., & Reps, T. (2009). Reducing concurrent analysis under a context bound to sequential analysis. Formal Methods in System Design, 35, 73-97.

Digital Library

[58]

Letko, Z., Vojnar, T., & K?rena, B. (2008). Atomrace: data race and atomicity violation detector and healer. In Proceedings of the 6th workshop on parallel and distributed systems: testing, analysis, and debugging (pp. 7:1-7:10). ACM.

[59]

Liao, H., & Wang, Y. (2013). Eliminating concurrency bugs in multithreaded software: a new approach based on discrete-event control. IEEE Transactions on Control Systems Technology, 21, 2067-2082.

[60]

Liu, P., & Zhang, C. (2012). Axis: Automatically fixing atomicity violations through solving control constraints. In Proceedings of the 34th international conference on software engineering (pp. 299-309). IEEE Press.

[61]

Liu, P., Tripp, O., & Zhang, C. (2014). Grail: context-aware fixing of concurrency bugs. In Proceedings of the 22nd ACM SIGSOFT international symposium on foundations of software engineering (pp. 318-329). ACM.

[62]

Liu, P., Tripp, O., & Zhang, X. (2014). Flint: fixing linearizability violations. ACM Sigplan Notices, 49, 543-560.

[63]

Liu, H., Chen, Y., & Lu, S. (2016). Understanding and generating high quality patches for concurrency bugs. In Proceedings of the 2016 24th ACM SIGSOFT international symposium on foundations of software engineering (pp. 715-726). ACM.

[64]

Lu, S., Park, S., Hu, C., Ma, X., Jiang, W., Li, Z., Popa, R.A., & Zhou, Y. (2007). MUVI: automatically inferring multi-variable access correlations and detecting related semantic and concurrency bugs. ACM Sigops Operating Systems Review, 41, 103-116.

Digital Library

[65]

Lu, S., Tucek, J., Qin, F., & Zhou, Y. (2007). Avio: detecting atomicity violations via access-interleaving invariants. IEEE Micro, 27, 26-35.

Digital Library

[66]

Lu, S., Park, S., Seo, E., & Zhou, Y. (2008). Learning from mistakes: a comprehensive study on real-world concurrency bug characteristics. In International conference on architectural support for programming languages and operating systems, ASPLOS 2008 (pp. 329-339). WA, USA.

[67]

Lu, S., Park, S., & Zhou, Y. (2011). Detecting concurrency bugs from the perspectives of synchronization intentions. IEEE Transactions on Parallel and Distributed Systems, 23, 1060-1072.

[68]

Lu, S., Park, S., & Zhou, Y. (2011). Finding atomicity-violation bugs through unserializable interleaving testing. IEEE Transactions on Software Engineering, 38, 844-860.

Digital Library

[69]

Lucia, B., & Ceze, L. (2013). Cooperative empirical failure avoidance for multithreaded programs. In ACM SIGPLAN notices (Vol. 48, pp. 39-50). ACM.

[70]

Lucia, B., Devietti, J., Strauss, K., & Ceze, L. (2008). Atom-aid: detecting and surviving atomicity violations. IEEE Micro, 29, 73-83.

[71]

Lucia, B., Ceze, L., & Strauss, K. (2010). Colorsafe: architectural support for debugging and dynamically avoiding multi-variable atomicity violations. ACM SIGARCH Computer Architecture News, 38, 222-233.

Digital Library

[72]

Lucia, B., Wood, B.P., & Ceze, L. (2011). Isolating and understanding concurrency errors using reconstructed execution fragments. ACM Sigplan Notices, 46, 378-388.

Digital Library

[73]

Michael, C.H. (1997). Why engineers should consider formal methods. Technical report, NASA Langley Technical Report Server.

[74]

Mccloskey, B., Zhou, F., Gay, D., & Brewer, E. (2006). Autolocker: synchronization inference for atomic sections. ACM Sigplan Notices, 41, 346-358.

Digital Library

[75]

Moore, K., Bobba, J., Moravan, M.J., & Hill, M. (2006). Logtm: log-based transactional memory. HPCA, 27, 254-265.

[76]

Musuvathi, M., & Qadeer, S. (2007). Iterative context bounding for systematic testing of multithreaded programs. ACM Sigplan Notices, 42, 446-455.

Digital Library

[77]

Musuvathi, M., Qadeer, S., Ball, T., Basler, G., Nainar, P.A., & Neamtiu, I. (2008). Finding and reproducing Heisenbugs in concurrent programs. In Usenix symposium on operating systems design and implementation, OSDI 2008 (pp. 267-280). California, USA: Proceedings.

[78]

Naik, M., & Aiken, A. (2007). Conditional must not aliasing for static race detection. In ACM SIGPLAN notices (Vol. 42, pp. 327-338). ACM.

[79]

Naik, M., Aiken, A., & Whaley, J. (2006). Effective static race detection for Java. ACM Sigplan Notices, 41, 308-319.

Digital Library

[80]

Nirbuchbinder, Y., Tzoref, R., & Ur, S. (2008). Deadlocks: from exhibiting to healing. Lecture Notes in Computer Science, 5289, 104-118.

[81]

Park, S., Lu, S., & Zhou, Y. (2009). Ctrigger: exposing atomicity violation bugs from their hiding places. ACM Sigplan Notices, 44, 25-36.

Digital Library

[82]

Park, S., Vuduc, R., & Harrold, M.J. (2012). A unified approach for localizing non-deadlock concurrency bugs. In 2012 IEEE 5th international conference on software testing, verification and validation (pp. 51-60). IEEE.

[83]

Park, S., Vuduc, R.W., & Harrold, M.J. (2010). Falcon: fault localization in concurrent programs. In Proceedings of the 32nd ACM/IEEE international conference on software engineering (Vol. 1, pp. 245-254). ACM.

[84]

Prvulovic, M., & Torrellas, J. (2003). Reenact: using thread-level speculation mechanisms to debug data races in multithreaded codes. ACM Sigarch Computer Architecture News, 31, 110-121.

Digital Library

[85]

Pyla, H.K., & Varadarajan, S. (2010). Avoiding deadlock avoidance. In International conference on parallel architecture and compilation techniques (pp. 75-86).

[86]

Qadeer, S., & Rehof, J. (2005). Context-bounded model checking of concurrent software. In Proceedings of the 11th international conference on tools and algorithms for the construction and analysis of systems (pp. 93-107).

[87]

Qin, F., Tucek, J., Sundaresan, J., & Zhou, Y. (2005). Rx: treating bugs as allergies--a safe method to survive software failures. In ACM sigops operating systems review (Vol. 39, pp. 235-248). ACM.

[88]

Rabinovitz, I., & Grumberg, O. (2005). Bounded model checking of concurrent programs. In Proceedings of the 17th international conference on computer aided verification (pp. 82-97).

[89]

Rajamani, S., Ramalingam, G., Ranganath, V.P., & Vaswani, K. (2009). Isolator: dynamically ensuring isolation in concurrent programs. In International conference on architectural support for programming languages and operating systems, ASPLOS 2009 (pp. 181-192). Washington DC, USA.

[90]

Ratanaworabhan, P., Burtscher, M., Kirovski, D., Zorn, B., Nagpal, R., & Pattabiraman, K. (2009). Detecting and tolerating asymmetric races. In ACM sigplan notices (Vol. 44, pp. 173-184). ACM.

[91]

Rungta, N., Mercer, E.G., & Visser, W. (2009). Efficient testing of concurrent programs with abstraction-guided symbolic execution. In Model checking software, international SPIN workshop (pp. 1885-1904). Grenoble, France: Proceedings.

[92]

Said, M., Wang, C., Yang, Z., & Sakallah, K. (2011). Generating data race witnesses by an SMT-based analysis. In International Conference on NASA Formal Methods (pp. 313-327).

[93]

Savage, S., Burrows, M., Nelson, G., Sobalvarro, P., & Anderson, T. (1997). Eraser: a dynamic data race detector for multi-threaded programs. ACM Transactions on Computer Systems, 15, 391-411.

Digital Library

[94]

Sen, K. (2008). Race directed random testing of concurrent programs. ACM Sigplan Notices, 43, 11-21.

Digital Library

[95]

Sen, K., Marinov, D., & Agha, G. (2005). Cute: a concolic unit testing engine for C. In Proceedings of the 10th European software engineering conference held jointly with 13th ACM SIGSOFT international symposium on foundations of software engineering (pp. 263-272).

[96]

Shi, Y., Park, S., Yin, Z., Lu, S., Zhou, Y., Chen, W., & Zheng, W. (2010). Do I use the wrong definition?: Defuse: definition-use invariants for detecting concurrency and sequential bugs. ACM Sigplan Notices, 45, 160-174.

Digital Library

[97]

Sidiroglou, S., Laadan, O., Perez, C., Viennot, N., Nieh, J., & Keromytis, A.D. (2009). Assure: automatic software self-healing using rescue points. ACM Sigarch Computer Architecture News, 37, 37-48.

Digital Library

[98]

Smaragdakis, Y., Evans, J., Sadowski, C., Yi, J., & Flanagan, C. (2012). Sound predictive race detection in polynomial time. ACM Sigplan Notices, 47, 387-400.

Digital Library

[99]

Smith, S.O. (2013). Raft: automated techniques for diagnosing, reproducing, and fixing concurrency bugs. Ph.D. thesis, University of Cambridge.

[100]

Tan, L., Liu, C., Li, Z., Wang, X., Zhou, Y., & Zhai, C. (2014). Bug characteristics in open source software. Empirical Software Engineering, 19, 1665-1705.

Digital Library

[101]

Tian, Z., Liu, T., ZHENG, Q., Zhuang, E., Fan, M., & Yang, Z. (2017). Reviving sequential program birthmarking for multithreaded software plagiarism detection. IEEE Transactions on Software Engineering (99), pp. 1-1.

[102]

Tillmann, N., & Halleux, J.D. (2008). Pex: white box test generation for.net. In TAP'08 Proceedings of the 2nd International Conference on Tests and Proofs (pp. 134-153).

[103]

Vaziri, M., Tip, F.,&Dolby, J. (2006). Associating synchronization constraints with data in an object-oriented language. ACM Sigplan Notices, 41, 334-345.

Digital Library

[104]

Veeraraghavan, K., Chen, P.M., Flinn, J., & Narayanasamy, S. (2011). Detecting and surviving data races using complementary schedules. In Proceedings of the 23rd ACM symposium on operating systems principles (pp. 369-384). ACM.

[105]

Voung, J.W., Jhala, R., & Lerner, S. (2007). Relay: static race detection on millions of lines of code. In Joint meeting of the European software engineering conference and the ACM sigsoft international symposium on foundations of software Engineering (pp. 205-214). Dubrovnik, Croatia.

[106]

Wang, C., Kundu, S., Limaye, R., Ganai, M., & Gupta, A. (2011). Symbolic predictive analysis for concurrent programs. Formal Aspects of Computing, 23, 781-805.

[107]

Wang, C., Yang, Z., Kahlon, V., & Gupta, A. (2008). Peephole partial order reduction. In Theory and practice of software, international conference on TOOLS and algorithms for the construction and analysis of systems (pp. 382-396).

[108]

Wang, Y., Liao, H., Reveliotis, S., Kelly, T., Mahlke, S., & Lafortune, S. (2009). Gadara nets: Modeling and analyzing lock allocation for deadlock avoidance in multithreaded software. In IEEE conference on decision and control (pp. 4971-4976).

[109]

Wang, C., Limaye, R., Ganai, M., & Gupta, A. (2010). Trace-based symbolic analysis for atomicity violations. In Proceedings of the 16th international conference on tools and algorithms for the construction and analysis of systems (pp. 328-342).

[110]

Wang, H., Liu, T., Guan, X., Shen, C., Zheng, Q., & Yang, Z. (2017). Dependence guided symbolic execution. IEEE Transactions on Software Engineering, 43(3), 252-271.

Digital Library

[111]

Weeratunge, D., Zhang, X., & Jaganathan, S. (2011). Accentuating the positive: atomicity inference and enforcement using correct executions. ACM SIGPLAN Notices, 46, 19-34.

Digital Library

[112]

Xu, M., Bodík, R., & Hill, M.D. (2005). A serializability violation detector for shared-memory server programs. ACM Sigplan Notices, 40, 1-14.

Digital Library

[113]

Yin, Z., Yuan, D., Zhou, Y., Pasupathy, S., & Bairavasundaram, L. (2011). How do fixes become bugs? In Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on foundations of software Engineering (pp. 26-36). ACM.

[114]

Yu, J., & Narayanasamy, S. (2009). A case for an interleaving constrained shared-memory multi-processor. ACM Sigarch Computer Architecture News, 37, 325-336.

Digital Library

[115]

Yu, Y., Rodeheffer, T., & Chen, W. (2005). Racetrack: efficient detection of data race conditions via adaptive tracking. In ACM SIGOPS operating systems review (Vol. 39, pp. 221-234). ACM.

[116]

Yu, J., Narayanasamy, S., Pereira, C., & Pokam, G. (2012). Maple: a coverage-driven testing tool for multithreaded programs. ACM Sigplan Notices, 47, 485-502.

Digital Library

[117]

Zhang, W., Sun, C., & Lu, S. (2010). Conmem: detecting severe concurrency bugs through an effect-oriented approach. ACM Sigarch Computer Architecture News, 38, 179-192.

Digital Library

[118]

Zhang, W., Lim, J., Olichandran, R., Scherpelz, J., Jin, G., Lu, S., & Reps, T. (2011). Conseq: detecting concurrency bugs through sequential errors. ACM Sigplan Notices, 39, 251-264.

[119]

Zhang, W., De Kruijf, M., Li, A., Lu, S., & Sankaralingam, K. (2013). Conair: featherweight concurrency bug recovery via single-threaded idempotent execution. ACM SIGARCH Computer Architecture News, 41, 113-126.

Digital Library

[120]

Zhang, M., Wu, Y., Shan, L.U., Qi, S., Ren, J., & Zheng, W. (2016). A lightweight system for detecting and tolerating concurrency bugs. IEEE Transactions on Software Engineering, 42(10), 899-917.

Digital Library

Cited By

Zhao JWu YDong J(2024)Efficient data race detection for interrupt-driven programs via path feasibility analysisThe Journal of Supercomputing10.1007/s11227-024-06189-480:15(21699-21725)Online publication date: 1-Oct-2024
https://dl.acm.org/doi/10.1007/s11227-024-06189-4
Li CChen RWang BWang ZYu TJiang YGu BYang MJust RFraser G(2023)An Empirical Study on Concurrency Bugs in Interrupt-Driven Embedded SoftwareProceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3597926.3598140(1345-1356)Online publication date: 12-Jul-2023
https://dl.acm.org/doi/10.1145/3597926.3598140
Jeong EJeong DHa S(2021)Dataflow Model–based Software Synthesis Framework for Parallel and Distributed Embedded SystemsACM Transactions on Design Automation of Electronic Systems10.1145/344768026:5(1-38)Online publication date: 5-Jun-2021
https://dl.acm.org/doi/10.1145/3447680
Show More Cited By

A systematic survey on automated concurrency bug detection, exposing, avoidance, and fixing techniques

Recommendations

Collaborative Technique for Concurrency Bug Detection

Concurrency bugs hidden in deployed software can cause severe failures and real-world disasters. They are notoriously difficult to detect during in-house testing due to huge and non-deterministic interleaving space. Unfortunately, the multicore ...
Automated concurrency-bug fixing
OSDI'12: Proceedings of the 10th USENIX conference on Operating Systems Design and Implementation

Concurrency bugs are widespread in multithreaded programs. Fixing them is time-consuming and error-prone. We present CFix, a system that automates the repair of concurrency bugs. CFix works with a wide variety of concurrency-bug detectors. For each ...
Convoider: A Concurrency Bug Avoider Based on Transparent Software Transactional Memory
Abstract
Software transactional memory is an effective mechanism to avoid concurrency bugs in multi-threaded programs. However, two problems hinder the adoption of traditional such systems in wild world: high human cost for equipping programs with ...

Comments

Information & Contributors

Information

Published In

cover image Software Quality Journal

Software Quality Journal Volume 26, Issue 3

September 2018

326 pages

ISSN:0963-9314

Issue’s Table of Contents

Copyright © Copyright © 2018 Springer Science+Business Media, LLC, part of Springer Nature.

Publisher

Kluwer Academic Publishers

United States

Publication History

Published: 01 September 2018

Author Tags

Qualifiers

Article

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

4
Total Citations
View Citations
0
Total Downloads

Downloads (Last 12 months)0
Downloads (Last 6 weeks)0

Reflects downloads up to 15 Oct 2024

Other Metrics

View Author Metrics

Citations

Cited By

Zhao JWu YDong J(2024)Efficient data race detection for interrupt-driven programs via path feasibility analysisThe Journal of Supercomputing10.1007/s11227-024-06189-480:15(21699-21725)Online publication date: 1-Oct-2024
https://dl.acm.org/doi/10.1007/s11227-024-06189-4
Li CChen RWang BWang ZYu TJiang YGu BYang MJust RFraser G(2023)An Empirical Study on Concurrency Bugs in Interrupt-Driven Embedded SoftwareProceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3597926.3598140(1345-1356)Online publication date: 12-Jul-2023
https://dl.acm.org/doi/10.1145/3597926.3598140
Jeong EJeong DHa S(2021)Dataflow Model–based Software Synthesis Framework for Parallel and Distributed Embedded SystemsACM Transactions on Design Automation of Electronic Systems10.1145/344768026:5(1-38)Online publication date: 5-Jun-2021
https://dl.acm.org/doi/10.1145/3447680
Chen DJiang YXu CMa X(2021)On interleaving space exploration of multi-threaded programsFrontiers of Computer Science: Selected Publications from Chinese Universities10.1007/s11704-020-9501-615:4Online publication date: 11-Feb-2021
https://dl.acm.org/doi/10.1007/s11704-020-9501-6
Park JChoi BJang S(2020)Dynamic Analysis Method for Concurrency Bugs in Multi-process/Multi-thread EnvironmentsInternational Journal of Parallel Programming10.1007/s10766-020-00661-348:6(1032-1060)Online publication date: 25-May-2020
https://dl.acm.org/doi/10.1007/s10766-020-00661-3

View Options

View options

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

Media

Figures

Other

Tables

View Issue’s Table of Contents