Skip to main content
SpringerLink
Log in

Towards Reliable Concurrent Software

  • Chapter
  • First Online:
Principled Software Development

Abstract

As the use of concurrent software is increasing, we urgently need techniques to establish the correctness of such applications. Over the last years, significant progress has been made in the area of software verification, making verification techniques usable for realistic applications. However, much of this work concentrates on sequential software, and a next step is necessary to apply these results also on realistic concurrent software. In this paper, we outline a research agenda to realise this goal. We argue that current techniques for verification of concurrent software need to be further developed in multiple directions: extending the class of properties that can be established, improving the level of automation that is available for this kind of verification, and enlarging the class of concurrent programs that can be verified.

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

Access this chapter

Log in via an institution
Chapter
USD 29.95
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
eBook
USD 84.99
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
Softcover Book
USD 109.99
Price excludes VAT (USA)
  • Compact, lightweight edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info
Hardcover Book
USD 109.99
Price excludes VAT (USA)
  • Durable hardcover edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info

Tax calculation will be finalised at checkout

Purchases are for personal use only

Institutional subscriptions

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. Wolfgang Ahrendt et al. Deductive Software Verification – The KeY Book Vol. 10001. Lecture Notes in Computer Science. Springer International Publishing, 2016. ISBN: 9783319498126.

    Google Scholar 

  2. A. Amighi, S. Blom, and M. Huisman. “VerCors: A Layered Approach to Practical Verification of Concurrent Software”. In: PDP 2016, pp. 495–503.

    Google Scholar 

  3. Afshin Amighi et al. “Verification of Concurrent Systems with VerCors”. In: Formal Methods for Executable Software Models 14th International School on Formal Methods for the Design of Computer Communication, and Software Systems, SFM 2014, Bertinoro, Italy June 16–20, 2014, Advanced Lectures 2014, pp. 172–216.

    Google Scholar 

  4. A. Amighi et al. “Permission-based separation logic for multithreaded Java programs”. In: LMCS 11.1 (2015).

    Google Scholar 

  5. A. Amighi et al. “The VerCors Project: Setting Up Basecamp”. In: Programming Languages meets Program Verification (PLPV 2012) ACM Press, 2012, pp. 71–82. https://doi.org/10.1145/2103776.2103785

  6. A. Antonik et al. “20 years of modal and mixed specifications”. In: Bulletin of the EATCS 95 (2008), pp. 94–129.

    Google Scholar 

  7. R. Baghdadi et al. “PENCIL: Towards a Platform-Neutral Compute Intermediate Language for DSLs”. In: CoRR abs/1302.5586 (2013).

    Google Scholar 

  8. G. Barthe et al. “JACK: A Tool for Validation of Security and Behaviour of Java Applications”. In: Formal Methods for Components and Objects (FMCO 2006) Vol. 4709. LNCS. Springer, 2007, pp. 152–174.

    Google Scholar 

  9. B. Beckert, R. Hähnle, and P.H. Schmitt, eds. Verification of Object-Oriented Software: The KeY Approach Vol. 4334. LNCS. Springer, 2007.

    Google Scholar 

  10. J. van den Berg and B. Jacobs. “The LOOP compiler for Java and JML”. In: Tools and Algorithms for the Construction and Analysis of Systems Ed. by T. Margaria and W. Yi. Vol. 2031. LNCS. Springer, 2001, pp. 299–312.

    Google Scholar 

  11. S. Blom, S. Darabi, and M. Huisman. “Verification of loop parallelisations”. In: FASE Vol. 9033. LNCS. Springer, 2015, pp. 202–217.

    Google Scholar 

  12. S. Blom, M. Huisman, and M. Mihelv̌ić “Specification and Verification of GPGPU programs”. In: Science of Computer Programming 95 (3 2014), pp. 376–388. ISSN: 0167–6423.

    Article  Google Scholar 

  13. S. Blom, M. Huisman, and M. Zaharieva-Stojanovski. “History-based verification of functional behaviour of concurrent programs”. In: SEFM. Vol. 9276. LNCS. Springer, 2015, pp. 84–98.

    Google Scholar 

  14. S. Blom et al “The VerCors Tool Set: Verification of Parallel and Concurrent Software”. In: iFM Vol. 10510. LNCS. Springer, 2017, pp. 102–110.

    Google Scholar 

  15. A.R. Bradley. “SAT-Based Model Checking without Unrolling”. In: Verification, Model Checking and Abstract Interpretation (VMCAI) LNCS. Springer, 2011.

    Google Scholar 

  16. Marc Brockschmidt et al. “Certifying safety and termination proofs for integer transition systems”. In: International Conference on Automated Deduction Springer. 2017, pp. 454–471.

    Google Scholar 

  17. S. Brookes. “A Semantics for Concurrent Separation Logic”. In: Theoretical Computer Science 375.1–3 (2007), pp. 227–270.

    Article  MathSciNet  Google Scholar 

  18. Steve Brookes and Peter O’Hearn. “Concurrent Separation Logic”. In: ACM SIGLOG News 3.3 (2016), pp. 47–65.

    Google Scholar 

  19. E. Clarke et al. “Counterexample-Guided Abstraction Refinement”. In: Computer-Aided Verification (CAV) Vol. 1855. LNCS. Springer, 2000.

    Google Scholar 

  20. D. Cok and J. R. Kiniry. “ESC/Java2: Uniting ESC/Java and JML: Progress and issues in building and using ESC/Java2 and a report on a case study involving the use of ESC/Java2 to verify portions of an Internet voting tally system”. In: Proceedings, Construction and Analysis of Safe Secure and Interoperable Smart devices (CASSIS’04) Workshop Ed. by G. Barthe et al. Vol. 3362. LNCS. Springer, 2005, pp. 108–128.

    Google Scholar 

  21. David Cok. “OpenJML: Software verification for Java 7 using JML, OpenJDK, and Eclipse”. In: 1st Workshop on Formal Integrated Development Environment, (F-IDE) Ed. by Catherine Dubois, Dimitra Giannakopoulou, and Dominique Méry. Vol. 149. EPTCS. 2014, pp. 79–92. https://doi.org/10.4204/EPTCS.149.8. URL: http://dx.doi.org/10.4204/EPTCS.149.8

    Article  Google Scholar 

  22. S. Darabi, S.C.C. Blom, and M. Huisman. “A Verification Technique for Deterministic Parallel Programs”. In: NASA Formal Methods (NFM) Ed. by C. Barrett, M. Davies, and T. Kahsai. Vol. 10227. LNCS. 2017, pp. 247–264.

    Google Scholar 

  23. S. De Gouw et al. “OpenJDK’s java.utils.Collection.sort() is broken: The good, the bad and the worst case”. In: Proc. 27th Intl. Conf on Computer Aided Verification (CAV), San Francisco Ed. by D. Kroening and C. Pasareanu. Vol. 9206. LNCS. Springer, July 2015, pp. 273–289.

    Google Scholar 

  24. Edsger W. Dijkstra. A Discipline of Programming Englewood Cliffs, N.J.: Prentice-Hall, Inc., 1976.

    Google Scholar 

  25. T. Dinsdale-Young et al. “Concurrent Abstract Predicates”. In: ECOOP Ed. by Theo D’Hondt. Vol. 6183. LNCS. Springer, 2010, pp. 504–528.

    Google Scholar 

  26. T. Dinsdale-Young et al. “Views: Compositional Reasoning for Concurrent Programs”. In: POPL’13 ACM, 2013, pp. 287–300.

    Google Scholar 

  27. J. Dohrau et al. “Permission Inference for Array Programs”. In: Computer Aided Verification (CAV) LNCS. Springer, 2018.

    Google Scholar 

  28. Manuel Fahndrich et al. “Integrating a Set of Contract Checking Tools into Visual Studio”. In: Proceedings of the 2012 Second International Workshop on Developing Tools as Plug- ins (TOPI) IEEE, June 2012. URL: https://wwwmicrosoftcom/en-us/research/publication/integrating-a-set-of-contract-checking-tools-into-visual-studio/.

  29. P. Ferrara and P. Müller. “Automatic inference of access permissions”. In: Proceedings of the 13th International Conference on Verification, Model Checking and Abstract Interpretation (VMCAI 2012) LNCS. Springer, 2012, pp. 202–218.

    Google Scholar 

  30. R. W. Floyd. “Assigning Meanings to Programs”. In: Proceedings Symposium on Applied Mathematics 19 (1967), pp. 19–31.

    Google Scholar 

  31. J.P. Galeotti et al. “Inferring Loop Invariants by Mutation, Dynamic Analysis, and Static Checking”. In: IEEE Transactions on Software Engineering 41 (10 2015), pp. 1019–1037.

    Article  Google Scholar 

  32. Archana Ganapathi and David A. Patterson. “Crash Data Collection: A Windows Case Study.” In: Dependable Systems and Networks (DSN) IEEE Computer Society, Aug. 1, 2005, pp. 280–285. ISBN: 0-7695-2282-3.

    Google Scholar 

  33. Michiel van Genuchten and Les Hatton. “Metrics with Impact”. In: IEEE Software 30 (4 July 2013), pp. 99–101.

    Article  Google Scholar 

  34. Jürgen Giesl et al. “Proving termination of programs automatically with AProVE”. In: International Joint Conference on Automated Reasoning Springer. 2014, pp. 184–191.

    Google Scholar 

  35. R. Hähnle and M. Huisman. “Deductive Software Verification: From Pen-and-Paper Proofs to Industrial Tools”. In: Computing and Software Science Vol. 10000. LNCS. 2018.

    Google Scholar 

  36. Nir Hemed, Noam Rinetzky, and Viktor Vafeiadis. “Modular Verification of Concurrency- Aware Linearizability”. In: Symposium on Distributed Computing (DISC) Springer, 2015.

    Google Scholar 

  37. C. A. R. Hoare. “An Axiomatic Basis for Computer Programming”. In: Communications of the ACM 12.10 (Oct. 1969), pp. 576–580, 583. URL: http://doi.acmorg/10.1145/363235.363259.

  38. Marieke Huisman. “Reasoning about Java Programs in higher order logic with PVS and Isabelle”. IPA Dissertation Series, 2001-03. University of Nijmegen, Holland, Feb 2001. URL: ftp://ftpsop.inria.fr/lemme/Marieke.Huisman/thesis.ps.gz

  39. B. Jacobs and F. Piessens. The VeriFast program verifier Tech. rep. CW520. Katholieke Universiteit Leuven, 2008.

    Google Scholar 

  40. M. Janota. “Assertion-based Loop Invariant Generation”. In: 1st International Workshop on Invariant Generation (WING) 2007.

    Google Scholar 

  41. Cliff B. Jones. “Tentative Steps Toward a Development Method for Interfering Programs”. In: 5.4 (1983), pp. 596–619.

    MATH  Google Scholar 

  42. Sebastiaan JC Joosten, René Thiemann, and Akihisa Yamada. “CeTA–Certifying Termination and Complexity Proofs in 2016”. In: 15th International Workshop on Termination Ed. by Aart Middeldorp and René Thiemann. 2016.

    Google Scholar 

  43. U. Juhasz et al. Viper: A Verification Infrastructure for Permission-Based Reasoning Tech. rep. ETH Zurich, 2014.

    Google Scholar 

  44. R. Jung et al. “Iris: Monoids and invariants as an orthogonal basis for concurrent reasoning”. In: Principles of Programming Languages (POPL) 2015.

    Google Scholar 

  45. R. Krebbers et al. “The Essence of Higher-Order Concurrent Separation Logic”. In: ESOP Vol. 10201. LNCS. Springer, 2017, pp. 696–723.

    Google Scholar 

  46. K.G. Larsen and B. Thomsen. “A modal process logic”. In: Logic in Computer Science (LICS) IEEE Computer Society, 1988, pp. 203–210.

    Google Scholar 

  47. Francesco Logozzo. “Practical verification for the working programmer with CodeContracts and Abstract Interpretation”. In: Verification, Model Checking and Abstract Interpretation (VMCAI) Springer, 2011.

    Google Scholar 

  48. A. Malkis, A. Podelski, and A. Rybalchenko. “Thread-Modular Counterexample-Guided Abstraction Refinement”. In: Static Analysis (SAS) Vol. 6337. LNCS. Springer, 2010.

    Google Scholar 

  49. Rivalino Matias et al. “An Empirical Exploratory Study on Operating System Reliability”. In: 29th Annual ACM Symposium on Applied Computing (SAC) Gyeongju, Republic of Korea: ACM, 2014, pp. 1523–1528. ISBN: 978-1-4503-2469-4. https://doi.org/10.1145/2554850.2555021

    Chapter  Google Scholar 

  50. Jörg Meyer and Arnd Poetzsch-Heffter. “An Architecture for Interactive Program Provers”. In: Tools and Algorithms for Construction and Analysis of Systems, 6th International Conference TACAS 2000 Ed. by Susanne Graf and Michael I. Schwartzbach. Vol. 1785. Lecture Notes in Computer Science. Springer, 2000, pp. 63–77.

    Google Scholar 

  51. P. Müller, M. Schwerhoff and A.J. Summers. “Viper A Verification Infrastructure for Permission-Based Reasoning”. In: VMCAI 2016.

    Google Scholar 

  52. Aleksandar Nanevski et al. “Communicating State Transition Systems for Fine-Grained Concurrent Resources” In: European Symposium on Programming (ESOP) 2014, pp. 290–310.

    Google Scholar 

  53. P. W. O’Hearn, J. Reynolds, and H. Yang. “Local Reasoning about Programs that Alter Data Structures”. In: Computer Science Logic Ed. by L. Fribourg. Vol. 2142. LNCS. Paris: Springer, 2001, pp. 1–19. https://doi.org/10.1007/3540448020_1

  54. P. W. O’Hearn, H. Yang, and J. C. Reynolds. “Separation and Information Hiding”. In: Principles of Programming Languages Venice, Italy: ACM Press, 2004, pp. 268–280.

    Google Scholar 

  55. Peter W. O’Hearn. “Resources, concurrency and local reasoning”. In: 375.1-3 (2007), pp. 271–307. ISSN: 0304-3975. http://dx.doi.org/10.1016/j.tcs.2006.12.035.

    MathSciNet  MATH  Google Scholar 

  56. W. Oortwijn, S. Blom, and M. Huisman. “Future-based Static Analysis of Message Passing Programs”. In: PLACES 2016, pp. 65–72.

    Article  Google Scholar 

  57. W. Oortwijn et al. “An Abstraction Technique for Describing Concurrent Program Be- haviour”. In: VSTTE Vol. 10712. LNCS. 2017, pp. 191–209.

    Google Scholar 

  58. Thomas J. Ostrand and Elaine J. Weyuker. “The Distribution of Faults in a Large Industrial Software System”. In: 2002 ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA) Roma, Italy: ACM, 2002, pp. 55–64. ISBN: 1-58113-562-9. https://doi.org/10.1145/566172.566181

    Chapter  Google Scholar 

  59. Thomas J. Ostrand, Elaine J. Weyuker, and Robert M. Bell. “Where the Bugs Are”. In: 2004 ACM SIGSOFT International Symposium on Software Testing and Analysis (ISTTA). Boston, Massachusetts, USA: ACM, 2004, pp. 86–96. ISBN: 1-58113-820-2. https://doi.org/10.1145/1007512.1007524

    Chapter  Google Scholar 

  60. S. Owicki and D. Gries. “An Axiomatic Proof Technique for Parallel Programs”. In: Acta Informatica Journal 6 (1975), pp. 319–340. https://doi.org/10.1007/BF00268134

    Article  MathSciNet  Google Scholar 

  61. P. da Rocha Pinto, T. Dinsdale-Young, and P. Gardner. “Steps in Modular Specifications for Concurrent Modules”. In: Mathematical Foundations of Programming Semantics (MFPS). 2015.

    Google Scholar 

  62. P. da Rocha Pinto, T. Dinsdale-Young, and P. Gardner. “TaDA: A Logic for Time and Data Abstraction”. In: European Conference on Object-Oriented Programming (ECOOP) LNCS. Springer, 2014.

    Google Scholar 

  63. I. Sergey, A. Nanevski, and A. Banerjee. “Specifying and Verifying Concurrent Algorithms with Histories and Subjectivity”. In: ESOP Vol. 9032. LNCS. Springer, 2015, pp. 333–358.

    Google Scholar 

  64. J. Shen. “Efficient High Performance Computing on Heterogeneous Platforms”. PhD thesis. Technical University of Delft, 2015.

    Google Scholar 

  65. Jan Smans, Bart Jacobs, and Frank Piessens. “VeriFast for Java: A Tutorial”. In: Aliasing in Object-Oriented Programming Ed. by Dave Clarke, Tobias Wrigstad, and James Noble. Vol. 7850. LNCS. Springer, 2013.

    Google Scholar 

  66. K. Svendsen and L. Birkedal. “Impredicative Concurrent Abstract Predicates”. In: ESOP Vol. 8410. LNCS. Springer, 2014, pp. 149–168.

    Google Scholar 

  67. V. Vafeiadis and M.J. Parkinson. “A Marriage of Rely/Guarantee and Separation Logic”. In: CONCUR Ed. by Luís Caires and Vasco Thudichum Vasconcelos. Vol. 4703. LNCS. Springer, 2007, pp. 256–271.

    Google Scholar 

  68. Viktor Vafeiadis. “Automatically Proving Linearizability”. In: Computer Aided Verification Ed. by Tayssir Touili, Byron Cook, and Paul Jackson. Vol. 6174. Lecture Notes in Computer Science. Springer Berlin Heidelberg, 2010, pp. 450–464. ISBN: 978-3-642-14294-9. https://doi.org/10.1007/978-3-642-14295-6_4. URL: http://dxdoiorg/10.1007/978-3-642-142956_40.

    Chapter  Google Scholar 

  69. M. Zaharieva-Stojanovski. “Closer to Reliable Software: Verifying Functional Behaviour of Concurrent Programs”. PhD thesis. University of Twente, 2015. https://doi.org/10.3990/1.9789036539241.

  70. J. Zeilstra. “Reasoning about Active Object Programs”. MA thesis. University of Twente, 2016.

    Google Scholar 

Download references

Acknowledgement

This work is supported by the NWO VICI 639.023.710 Mercedes project.

Author information

Authors and Affiliations

  1. University of Twente, Enschede, The Netherlands

    Marieke Huisman & Sebastiaan J. C. Joosten

Authors
  1. Marieke Huisman
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Sebastiaan J. C. Joosten
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Sebastiaan J. C. Joosten .

Editor information

Editors and Affiliations

  1. Department of Computer Science, ETH Zürich, Zürich, Switzerland

    Peter Müller

  2. Institut für Softwaretechnik und Fahrzeuginformatik, Technische Universität Braunschweig, Braunschweig, Germany

    Ina Schaefer

Rights and permissions

Reprints and permissions

Copyright information

© 2018 Springer Nature Switzerland AG

About this chapter

Check for updates. Verify currency and authenticity via CrossMark

Cite this chapter

Huisman, M., Joosten, S.J.C. (2018). Towards Reliable Concurrent Software. In: Müller, P., Schaefer, I. (eds) Principled Software Development. Springer, Cham. https://doi.org/10.1007/978-3-319-98047-8_9

Download citation

  • DOI: https://doi.org/10.1007/978-3-319-98047-8_9

  • Published:

  • Publisher Name: Springer, Cham

  • Print ISBN: 978-3-319-98046-1

  • Online ISBN: 978-3-319-98047-8

  • eBook Packages: Computer ScienceComputer Science (R0)

Publish with us

Policies and ethics

Search

Navigation