Skip to main content
SpringerLink
Log in

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

  • Published:
Software Quality Journal Aims and scope Submit manuscript

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.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7
Fig. 8
Fig. 9
Fig. 10

Similar content being viewed by others

References

  • 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.

    Article  Google Scholar 

  • 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).

  • 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.

  • 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).

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

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

  • 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.

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

    Article  Google Scholar 

  • 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.

    Google Scholar 

  • 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.

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

  • 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.

    Article  Google Scholar 

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

    Article  Google Scholar 

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

  • 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.

  • Černỳ, 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).

  • Černỳ, 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.

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

  • 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.

  • 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.

    Article  Google Scholar 

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

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

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

    Article  Google Scholar 

  • 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.

    Google Scholar 

  • 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).

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

    Article  MATH  Google Scholar 

  • 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.

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

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

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

  • 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).

  • 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).

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

  • 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.

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

    Article  Google Scholar 

  • 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.

  • 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).

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

  • 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).

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

    Article  Google Scholar 

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

    Article  Google Scholar 

  • 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).

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

  • 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.

    Article  Google Scholar 

  • 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.

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

  • 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.

  • 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).

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

  • 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.

    Article  Google Scholar 

  • 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.

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

    Article  Google Scholar 

  • 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.

  • 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.

  • 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.

    Google Scholar 

  • 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).

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

    Article  MATH  Google Scholar 

  • Letko, Z., Vojnar, T., & Křena, 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.

  • 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.

    Article  Google Scholar 

  • 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.

  • 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.

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

    Article  Google Scholar 

  • 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.

  • 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.

    Article  Google Scholar 

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

    Article  Google Scholar 

  • 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.

  • 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.

    Google Scholar 

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

    Article  Google Scholar 

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

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

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

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

    Article  Google Scholar 

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

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

    Article  Google Scholar 

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

    Google Scholar 

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

    Article  Google Scholar 

  • 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.

    Google Scholar 

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

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

    Article  Google Scholar 

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

    Article  Google Scholar 

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

    Article  Google Scholar 

  • 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.

  • 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.

  • 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.

    Article  Google Scholar 

  • Pyla, H.K., & Varadarajan, S. (2010). Avoiding deadlock avoidance. In International conference on parallel architecture and compilation techniques (pp. 75–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).

  • 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.

  • 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).

  • 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.

  • 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.

  • 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.

    Google Scholar 

  • 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).

  • 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.

    Article  Google Scholar 

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

    Article  Google Scholar 

  • 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).

  • 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.

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

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

    Article  Google Scholar 

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

  • 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.

    Article  Google Scholar 

  • 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.

  • 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).

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

    Article  MATH  Google Scholar 

  • 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.

  • 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.

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

    Article  MathSciNet  MATH  Google Scholar 

  • 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).

    Google Scholar 

  • 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).

    Google Scholar 

  • 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).

  • 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.

    Article  Google Scholar 

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

    Article  Google Scholar 

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

    Google Scholar 

  • 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.

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

    Article  Google Scholar 

  • 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.

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

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

  • 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.

    Google Scholar 

  • 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.

    Article  Google Scholar 

Download references

Acknowledgements

This work is partly supported by projects from National Natural Science Foundation of China, with the project number ‘61202030’, ‘71502125’, ‘61373012’, and ‘61202006’. The authors also thank anonymous reviewers for their constructive comments.

Author information

Authors and Affiliations

  1. School of Computer Software, Tianjin University, Tianjin, People’s Republic of China

    Haojie Fu, Zan Wang & Xiangyu Fan

  2. School of Computer Science and Technology, Nantong University, Nantong, People’s Republic of China

    Xiang Chen

Authors
  1. Haojie Fu
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Zan Wang
    View author publications

    You can also search for this author in PubMed Google Scholar

  3. Xiang Chen
    View author publications

    You can also search for this author in PubMed Google Scholar

  4. Xiangyu Fan
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Zan Wang.

Rights and permissions

Reprints and permissions

About this article

Check for updates. Verify currency and authenticity via CrossMark

Cite this article

Fu, H., Wang, Z., Chen, X. et al. A systematic survey on automated concurrency bug detection, exposing, avoidance, and fixing techniques. Software Qual J 26, 855–889 (2018). https://doi.org/10.1007/s11219-017-9385-3

Download citation

  • Published:

  • Issue Date:

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

Keywords

Search

Navigation