Skip to main content
Fachgebiete
Automobil + Motoren Bauwesen + Immobilien Business IT + Informatik Elektrotechnik + Elektronik Energie + Nachhaltigkeit Finance + Banking Management + Führung Marketing + Vertrieb Maschinenbau + Werkstoffe Versicherung + Risiko
DE
EN
Themenseiten
Organisationspsychologie Projektmanagement Marketing Smart Manufacturing
Bücher
Zeitschriften
Weitere Formate
Podcasts Webinare Technik Webinare Wirtschaft Kongresse Veranstaltungskalender Awards
Jetzt Einzelzugang starten
Zugang für Unternehmen
Referenzkunden
MTZ-Fachkongress

Antriebe und Energiesysteme von morgen


Austausch von Automobil- und Energiewirtschaft

Am 14./15. Mai geht es in Chemnitz um die Mobilitätswende durch Elektro- und Wasserstofffahrzeuge.
Erweiterte Suche
Anmelden
nach oben
Software Quality Journal
Erschienen in: Software Quality Journal 3/2018

10.08.2017

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

verfasst von: Haojie Fu, Zan Wang, Xiang Chen, Xiangyu Fan

Erschienen in: Software Quality Journal | Ausgabe 3/2018

Einloggen

Aktivieren Sie unsere intelligente Suche, um passende Fachinhalte oder Patente zu finden.

search-config
loading …

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.
Vorheriger Artikel Guest editorial: special issue on concurrent software quality
Nächster Artikel A survey on dynamic mobile malware detection

Sie haben noch keine Lizenz? Dann Informieren Sie sich jetzt über unsere Produkte:

Springer Professional "Wirtschaft"

Online-Abonnement

Mit Springer Professional "Wirtschaft" erhalten Sie Zugriff auf:

  • über 67.000 Bücher
  • über 340 Zeitschriften

aus folgenden Fachgebieten:

  • Bauwesen + Immobilien
  • Business IT + Informatik
  • Finance + Banking
  • Management + Führung
  • Marketing + Vertrieb
  • Versicherung + Risiko




Jetzt Wissensvorsprung sichern!

Jetzt informieren

Springer Professional "Wirtschaft+Technik"

Online-Abonnement

Mit Springer Professional "Wirtschaft+Technik" erhalten Sie Zugriff auf:

  • über 102.000 Bücher
  • über 537 Zeitschriften

aus folgenden Fachgebieten:

  • Automobil + Motoren
  • Bauwesen + Immobilien
  • Business IT + Informatik
  • Elektrotechnik + Elektronik
  • Energie + Nachhaltigkeit
  • Finance + Banking
  • Management + Führung
  • Marketing + Vertrieb
  • Maschinenbau + Werkstoffe
  • Versicherung + Risiko

Jetzt Wissensvorsprung sichern!

Jetzt informieren

Springer Professional "Technik"

Online-Abonnement

Mit Springer Professional "Technik" erhalten Sie Zugriff auf:

  • über 67.000 Bücher
  • über 390 Zeitschriften

aus folgenden Fachgebieten:

  • Automobil + Motoren
  • Bauwesen + Immobilien
  • Business IT + Informatik
  • Elektrotechnik + Elektronik
  • Energie + Nachhaltigkeit
  • Maschinenbau + Werkstoffe




 

Jetzt Wissensvorsprung sichern!

Jetzt informieren
Literatur
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.CrossRef
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.CrossRef
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.
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.CrossRef
Cai, Y., & Lu, Q. (2016). Dynamic testing for deadlocks via constraints. IEEE Transactions on Software Engineering, 42(9), 825–842.CrossRef
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.CrossRef
Clarke, E.M., & Wing, J.M. (1996). Formal methods: State of the art and future directions. ACM Computing Surveys, 28, 626–643.CrossRef
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.CrossRef
Deng, D., Zhang, W., & Lu, S. (2013). Efficient concurrency-bug detection across inputs. ACM Sigplan Notices, 48, 785–802.CrossRef
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.
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.CrossRefMATH
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.CrossRef
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.CrossRef
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.CrossRef
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.CrossRef
Jin, G., Song, L., Zhang, W., Lu, S., & Liblit, B. (2011). Automated atomicity-violation fixing. ACM Sigplan Notices, 46, 389–400.CrossRef
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.CrossRef
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.CrossRef
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.CrossRef
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.
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.CrossRefMATH
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.CrossRef
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.CrossRef
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.CrossRef
Lu, S., Tucek, J., Qin, F., & Zhou, Y. (2007). Avio: detecting atomicity violations via access-interleaving invariants. IEEE Micro, 27, 26–35.CrossRef
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.
Lu, S., Park, S., & Zhou, Y. (2011). Finding atomicity-violation bugs through unserializable interleaving testing. IEEE Transactions on Software Engineering, 38, 844–860.CrossRef
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.CrossRef
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.CrossRef
Lucia, B., Wood, B.P., & Ceze, L. (2011). Isolating and understanding concurrency errors using reconstructed execution fragments. ACM Sigplan Notices, 46, 378–388.CrossRef
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.CrossRef
Moore, K., Bobba, J., Moravan, M.J., & Hill, M. (2006). Logtm: log-based transactional memory. HPCA, 27, 254–265.
Musuvathi, M., & Qadeer, S. (2007). Iterative context bounding for systematic testing of multithreaded programs. ACM Sigplan Notices, 42, 446–455.CrossRef
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.
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.CrossRef
Nirbuchbinder, Y., Tzoref, R., & Ur, S. (2008). Deadlocks: from exhibiting to healing. Lecture Notes in Computer Science, 5289, 104–118.CrossRef
Park, S., Lu, S., & Zhou, Y. (2009). Ctrigger: exposing atomicity violation bugs from their hiding places. ACM Sigplan Notices, 44, 25–36.CrossRef
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.CrossRef
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.
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.CrossRef
Sen, K. (2008). Race directed random testing of concurrent programs. ACM Sigplan Notices, 43, 11–21.CrossRef
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.CrossRef
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.CrossRef
Smaragdakis, Y., Evans, J., Sadowski, C., Yi, J., & Flanagan, C. (2012). Sound predictive race detection in polynomial time. ACM Sigplan Notices, 47, 387–400.CrossRef
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.CrossRef
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.CrossRefMATH
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.MathSciNetCrossRefMATH
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).
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).
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.CrossRef
Weeratunge, D., Zhang, X., & Jaganathan, S. (2011). Accentuating the positive: atomicity inference and enforcement using correct executions. ACM SIGPLAN Notices, 46, 19–34.CrossRef
Xu, M., Bodík, R., & Hill, M. D. (2005). A serializability violation detector for shared-memory server programs. ACM Sigplan Notices, 40, 1–14.
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.CrossRef
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.CrossRef
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.CrossRef
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.CrossRef
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.
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.CrossRef
Metadaten
Titel
A systematic survey on automated concurrency bug detection, exposing, avoidance, and fixing techniques
verfasst von
Haojie Fu
Zan Wang
Xiang Chen
Xiangyu Fan
Publikationsdatum
10.08.2017
Verlag
Springer US
Erschienen in
Software Quality Journal / Ausgabe 3/2018
Print ISSN: 0963-9314
Elektronische ISSN: 1573-1367
DOI
https://doi.org/10.1007/s11219-017-9385-3

Weitere Artikel der Ausgabe 3/2018

Software Quality Journal 3/2018 Zur Ausgabe

OriginalPaper

System-level attacks against android by exploiting asynchronous programming

OriginalPaper

Dynamic structure measurement for distributed software

OriginalPaper

A survey on dynamic mobile malware detection

EditorialNotes

Guest editorial: special issue on concurrent software quality

EditorialNotes

In this issue

OriginalPaper

Detecting potential deadlocks through change impact analysis

Premium Partner

    Bildnachweise