Advertisement

Towards Reliable Concurrent Software

  • Marieke Huisman
  • Sebastiaan J. C. JoostenEmail author
Chapter

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.

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

Notes

Acknowledgement

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

References

  1. 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. 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. 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. 4.
    A. Amighi et al. “Permission-based separation logic for multithreaded Java programs”. In: LMCS 11.1 (2015).Google Scholar
  5. 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. 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. 7.
    R. Baghdadi et al. “PENCIL: Towards a Platform-Neutral Compute Intermediate Language for DSLs”. In: CoRR abs/1302.5586 (2013).Google Scholar
  8. 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. 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. 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. 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. 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.CrossRefGoogle Scholar
  13. 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. 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. 15.
    A.R. Bradley. “SAT-Based Model Checking without Unrolling”. In: Verification, Model Checking and Abstract Interpretation (VMCAI) LNCS. Springer, 2011.Google Scholar
  16. 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. 17.
    S. Brookes. “A Semantics for Concurrent Separation Logic”. In: Theoretical Computer Science 375.1–3 (2007), pp. 227–270.MathSciNetCrossRefGoogle Scholar
  18. 18.
    Steve Brookes and Peter O’Hearn. “Concurrent Separation Logic”. In: ACM SIGLOG News 3.3 (2016), pp. 47–65.Google Scholar
  19. 19.
    E. Clarke et al. “Counterexample-Guided Abstraction Refinement”. In: Computer-Aided Verification (CAV) Vol. 1855. LNCS. Springer, 2000.Google Scholar
  20. 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. 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 CrossRefGoogle Scholar
  22. 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. 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. 24.
    Edsger W. Dijkstra. A Discipline of Programming Englewood Cliffs, N.J.: Prentice-Hall, Inc., 1976.Google Scholar
  25. 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. 26.
    T. Dinsdale-Young et al. “Views: Compositional Reasoning for Concurrent Programs”. In: POPL’13 ACM, 2013, pp. 287–300.Google Scholar
  27. 27.
    J. Dohrau et al. “Permission Inference for Array Programs”. In: Computer Aided Verification (CAV) LNCS. Springer, 2018.Google Scholar
  28. 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. 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. 30.
    R. W. Floyd. “Assigning Meanings to Programs”. In: Proceedings Symposium on Applied Mathematics 19 (1967), pp. 19–31.Google Scholar
  31. 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.CrossRefGoogle Scholar
  32. 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. 33.
    Michiel van Genuchten and Les Hatton. “Metrics with Impact”. In: IEEE Software 30 (4 July 2013), pp. 99–101.CrossRefGoogle Scholar
  34. 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. 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. 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. 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. 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. 39.
    B. Jacobs and F. Piessens. The VeriFast program verifier Tech. rep. CW520. Katholieke Universiteit Leuven, 2008.Google Scholar
  40. 40.
    M. Janota. “Assertion-based Loop Invariant Generation”. In: 1st International Workshop on Invariant Generation (WING) 2007.Google Scholar
  41. 41.
    Cliff B. Jones. “Tentative Steps Toward a Development Method for Interfering Programs”. In: 5.4 (1983), pp. 596–619.zbMATHGoogle Scholar
  42. 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. 43.
    U. Juhasz et al. Viper: A Verification Infrastructure for Permission-Based Reasoning Tech. rep. ETH Zurich, 2014.Google Scholar
  44. 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. 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. 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. 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. 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. 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 CrossRefGoogle Scholar
  50. 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. 51.
    P. Müller, M. Schwerhoff and A.J. Summers. “Viper A Verification Infrastructure for Permission-Based Reasoning”. In: VMCAI 2016.Google Scholar
  52. 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. 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. 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. 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.MathSciNetzbMATHGoogle Scholar
  56. 56.
    W. Oortwijn, S. Blom, and M. Huisman. “Future-based Static Analysis of Message Passing Programs”. In: PLACES 2016, pp. 65–72.CrossRefGoogle Scholar
  57. 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. 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 CrossRefGoogle Scholar
  59. 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 CrossRefGoogle Scholar
  60. 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 MathSciNetCrossRefGoogle Scholar
  61. 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. 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. 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. 64.
    J. Shen. “Efficient High Performance Computing on Heterogeneous Platforms”. PhD thesis. Technical University of Delft, 2015.Google Scholar
  65. 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. 66.
    K. Svendsen and L. Birkedal. “Impredicative Concurrent Abstract Predicates”. In: ESOP Vol. 8410. LNCS. Springer, 2014, pp. 149–168.Google Scholar
  67. 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. 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.CrossRefGoogle Scholar
  69. 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. 70.
    J. Zeilstra. “Reasoning about Active Object Programs”. MA thesis. University of Twente, 2016.Google Scholar

Copyright information

© Springer Nature Switzerland AG 2018

Authors and Affiliations

  1. 1.University of TwenteEnschedeThe Netherlands

Personalised recommendations