Skip to main content
Log in

Debugging Concurrent Software: Advances and Challenges

  • Survey
  • Published:
Journal of Computer Science and Technology Aims and scope Submit manuscript

Abstract

Concurrency debugging is an extremely important yet challenging problem that has been hampering developer productivity and software reliability in the multicore era. We have worked on this problem in the past eight years and have developed several effective methods and automated tools for helping developers debugging shared memory concurrent programs. This article discusses challenges in concurrency debugging and summarizes our research contributions in four important directions: concurrency bug reproduction, detection, understanding, and fixing. It also discusses other recent advances in tackling these challenges.

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

Access this article

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

Instant access to the full article PDF.

Institutional subscriptions

Similar content being viewed by others

References

  1. Britton T, Jeng L, Carver G et al. Reversible debugging software. Technical Report, Judge Business School, University of Cambridge, 2013.

  2. Guo P, Zimmermann T, Nagappan N et al. Characterizing and predicting which bugs get fixed: An empirical study of Microsoft windows. In Proc. the 32nd ACM/IEEE International Conference on Software Engineering, May 2010, pp.495-504.

  3. Gray J. Why do computers stop and what can be done about it? In Proc. the 5th Symp. Reliability in Distributed Software and Database Systems, Jan. 1986, pp.3-12.

  4. Lamport L. How to make a multiprocessor computer that correctly executes multiprocess programs. IEEE Trans. Comput., 1979, 28(9): 690-691.

    Article  MATH  Google Scholar 

  5. Weaver D, Germond T (eds.). The SPARC Architecture Manual, Version 9. SPARC International, Inc., 1994.

  6. Lu S, Park S, Seo E et al. Learning from mistakes: A comprehensive study on real world concurrency bug characteristics. In Proc. the 13th ASPLO, Mar. 2008, pp.329-339.

  7. Yin Z, Yuan D, Zhou Y et al. How do fixes become bugs? In Proc. the 19th ACM SIGSOFT Symp. the Foundations of Software Engineering and the 13th European Software Engineering Conference, Sept. 2011, pp.26-36.

  8. Huang J, Liu P, Zhang C. LEAP: Lightweight deterministic multi-processor replay of concurrent Java programs. In Proc. the 18th ACM SIGSOFT FSE, Nov. 2010, pp.207-216.

  9. Huang J, Liu P, Zhang C. LEAP: Lightweight deterministic multi-processor replay of concurrent Java programs. In Proc. the 18th ACM SIGSOFT FSE, Nov. 2010, pp.385-386.

  10. Huang J, Zhang C, Dolby J. CLAP: Recording local executions to reproduce concurrency failures. In Proc. ACM PLDI, June 2013, pp.141-152.

  11. Ball T, Larus J R. Efficient path profiling. In Proc. the 29th IEEE/ACM MICRO, Dec. 1996, pp.46-57.

  12. de Moura L M, Bjørner N. Z3: An efficient SMT solver. In Proc. the 14th TACAS, March 29-April 6, 2008, pp.337-340.

  13. Vaswani K, Thazhuthaveetil M J, Srikant Y N. A programmable hardware path profiler. In Proc. the 3rd IEEE/ACM CGO, Mar. 2005, pp.217-228.

  14. Huang J, Zhang C. PECAN: Persuasive prediction of concurrency access anomalies. In Proc. the 20th ISSTA, July 2011, pp.144-154.

  15. Huang J, Zhou J, Zhang C. Scaling predictive analysis of concurrent programs by removing trace redundancy. ACM Trans. Softw. Eng. Methodol., 2013, 22(1): Article No. 8.

  16. Huang J, Meredith P O, Rosu G. Maximal sound predictive race detection with control flow abstraction. In Proc. ACM PLDI, June 2014.

  17. Huang J, Luo Q, Rosu G. GPredict: Generic predictive concurrency analysis. In Proc. the 37th ICSE, May 2015, pp.847-857.

  18. Huang J, Zhang C. An efficient static trace simplification technique for debugging concurrent programs. In Proc. the 18th SAS, Sept. 2011, pp.163-179.

  19. Huang J, Zhang C. LEAN: Simplifying concurrency bug reproduction via replay-supported execution reduction. In Proc. the 27th OOPSLA, Oct. 2012, pp.451-466.

  20. Jin G, Song L, Zhang W et al. Automated atomicityviolation fixing. In Proc. PLDI, June 2011, pp.389-400.

  21. Jin G, Zhang W, Deng D. Automated concurrency-bug fixing. In Proc. the 10th OSDI, Oct. 2012, pp.221-236.

  22. Liu P, Zhang C. Axis: Automatically fixing atomicity violations through solving control constraints. In Proc. the 34th ICSE, June 2012, pp.299-309.

  23. Huang J, Zhang C. Execution privatization for scheduleroblivious concurrent programs. In Proc. OOPSLA, Oct. 2012, pp.737-752.

  24. Shi Q, Huang J, Chen Z et al. Verifying synchronization for atomicity violations. IEEE Trans. Software Eng., 2016, 42(3): 280-296.

    Article  MathSciNet  Google Scholar 

  25. Godefroid P. Software model checking: The VeriSoft approach. Formal Methods in System Design, 2005, 26(2): 77-101.

    Article  Google Scholar 

  26. Musuvathi M, Qadeer S, Ball T et al. Finding and reproducing Heisenbugs in concurrent programs. In Proc. the 8th USENIX Symposium on Operating Systems Design and Implementation, Dec. 2008, pp.267-280.

  27. Flanagan C, Godefroid P. Dynamic partial-order reduction for model checking software. In Proc. the 32nd ACM POPL, Jan. 2005, pp.110-121.

  28. Devietti J, Lucia B, Ceze L et al. DMP: Deterministic shared memory multi-processing. In Proc. the 14th ASPLO, Mar. 2009, pp.85-96.

  29. Liu T, Curtsinger C, Berger E D. Dthreads: Efficient deterministic multithreading. In Proc. the 33rd ACM SOSP, Oct. 2011, pp.327-336.

  30. Cui H, Simsa J, Lin Y H et al. Parrot: A practical runtime for deterministic, stable, and reliable threads. In Proc. the 24th ACM SOSP, Nov. 2013, pp.388-405.

Download references

Acknowledgment

We thank the anonymous JCST reviewers for their comments on an initial version of this paper.

Author information

Authors and Affiliations

Authors

Corresponding author

Correspondence to Jeff Huang.

Rights and permissions

Reprints and permissions

About this article

Check for updates. Verify currency and authenticity via CrossMark

Cite this article

Huang, J., Zhang, C. Debugging Concurrent Software: Advances and Challenges. J. Comput. Sci. Technol. 31, 861–868 (2016). https://doi.org/10.1007/s11390-016-1669-8

Download citation

  • Received:

  • Revised:

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s11390-016-1669-8

Keywords

Navigation