skip to main content
research-article
Open Access
Artifacts Available
Artifacts Evaluated & Reusable

Pointer life cycle types for lock-free data structures with memory reclamation

Published:20 December 2019Publication History
Related Artifact: seal software https://doi.org/10.1145/3373115
Skip Abstract Section

Abstract

We consider the verification of lock-free data structures that manually manage their memory with the help of a safe memory reclamation (SMR) algorithm. Our first contribution is a type system that checks whether a program properly manages its memory. If the type check succeeds, it is safe to ignore the SMR algorithm and consider the program under garbage collection. Intuitively, our types track the protection of pointers as guaranteed by the SMR algorithm. There are two design decisions. The type system does not track any shape information, which makes it extremely lightweight. Instead, we rely on invariant annotations that postulate a protection by the SMR. To this end, we introduce angels, ghost variables with an angelic semantics. Moreover, the SMR algorithm is not hard-coded but a parameter of the type system definition. To achieve this, we rely on a recent specification language for SMR algorithms. Our second contribution is to automate the type inference and the invariant check. For the type inference, we show a quadratic-time algorithm. For the invariant check, we give a source-to-source translation that links our programs to off-the-shelf verification tools. It compiles away the angelic semantics. This allows us to infer appropriate annotations automatically in a guess-and-check manner. To demonstrate the effectiveness of our type-based verification approach, we check linearizability for various list and set implementations from the literature with both hazard pointers and epoch-based memory reclamation. For many of the examples, this is the first time they are verified automatically. For the ones where there is a competitor, we obtain a speed-up of up to two orders of magnitude.

Skip Supplemental Material Section

Supplemental Material

a68-meyer.webm

References

  1. Parosh Aziz Abdulla, Frédéric Haziza, Lukás Holík, Bengt Jonsson, and Ahmed Rezine. 2013. An Integrated Specification and Verification Technique for Highly Concurrent Data Structures. In TACAS (LNCS), Vol. 7795. Springer, 324–338. Google ScholarGoogle Scholar
  2. Parosh Aziz Abdulla, Bengt Jonsson, and Cong Quy Trinh. 2016. Automated Verification of Linearization Policies. In SAS (LNCS), Vol. 9837. Springer, 61–83. Google ScholarGoogle Scholar
  3. Zahra Aghazadeh, Wojciech M. Golab, and Philipp Woelfel. 2014. Making Objects Writable. In PODC. ACM, 385–395. Google ScholarGoogle Scholar
  4. Dan Alistarh, Patrick Eugster, Maurice Herlihy, Alexander Matveev, and Nir Shavit. 2014. StackTrack: An Automated Transactional Approach to Concurrent Memory Reclamation. In EuroSys. ACM, 25:1–25:14. Google ScholarGoogle Scholar
  5. Dan Alistarh, William M. Leiserson, Alexander Matveev, and Nir Shavit. 2015. ThreadScan: Automatic and Scalable Memory Reclamation. In SPAA. ACM, 123–132. Google ScholarGoogle Scholar
  6. Daphna Amit, Noam Rinetzky, Thomas W. Reps, Mooly Sagiv, and Eran Yahav. 2007. Comparison Under Abstraction for Verifying Linearizability. In CAV (LNCS), Vol. 4590. Springer, 477–490. Google ScholarGoogle Scholar
  7. Davide Ancona, Viviana Bono, Mario Bravetti, Joana Campos, Giuseppe Castagna, Pierre-Malo Deniélou, Simon J. Gay, Nils Gesbert, Elena Giachino, Raymond Hu, Einar Broch Johnsen, Francisco Martins, Viviana Mascardi, Fabrizio Montesi, Rumyana Neykova, Nicholas Ng, Luca Padovani, Vasco T. Vasconcelos, and Nobuko Yoshida. 2016. Behavioral Types in Programming Languages. Foundations and Trends in Programming Languages 3, 2-3 (2016), 95–230. Google ScholarGoogle Scholar
  8. Ralph-Johan Back. 1989. A Method for Refining Atomicity in Parallel Algorithms. In PARLE (LNCS), Vol. 366. Springer, 199–216. Google ScholarGoogle Scholar
  9. Oana Balmau, Rachid Guerraoui, Maurice Herlihy, and Igor Zablotchi. 2016. Fast and Robust Memory Reclamation for Concurrent Data Structures. In SPAA. ACM, 349–359. Google ScholarGoogle Scholar
  10. Simon Bäumler, Gerhard Schellhorn, Bogdan Tofan, and Wolfgang Reif. 2011. Proving linearizability with temporal logic. Formal Asp. Comput. 23, 1 (2011), 91–112. Google ScholarGoogle Scholar
  11. Josh Berdine, Byron Cook, and Samin Ishtiaq. 2011. SLAyer: Memory Safety for Systems-Level Code. In CAV (LNCS), Vol. 6806. Springer, 178–183. Google ScholarGoogle Scholar
  12. Josh Berdine, Tal Lev-Ami, Roman Manevich, G. Ramalingam, and Shmuel Sagiv. 2008. Thread Quantification for Concurrent Shape Analysis. In CAV (LNCS), Vol. 5123. Springer, 399–413. Google ScholarGoogle Scholar
  13. Dirk Beyer, Thomas A. Henzinger, Ranjit Jhala, and Rupak Majumdar. 2005. Checking Memory Safety with Blast. In FASE (LNCS), Vol. 3442. Springer, 2–18. Google ScholarGoogle Scholar
  14. Kevin Bierhoff and Jonathan Aldrich. 2007. Modular Typestate Checking of Aliased Objects. In OOPSLA. ACM, 301–320. Google ScholarGoogle Scholar
  15. Garrett Birkhoff. 1948. Lattice Theory (revised edition). American Mathematical Society.Google ScholarGoogle Scholar
  16. Ales Bizjak, Daniel Gratzer, Robbert Krebbers, and Lars Birkedal. 2019. Iron: Managing Obligations in Higher-order Concurrent Separation Logic. PACMPL 3, POPL (2019), 65:1–65:30. Google ScholarGoogle Scholar
  17. Richard Bornat, Cristiano Calcagno, Peter W. O’Hearn, and Matthew J. Parkinson. 2005. Permission Accounting in Separation Logic. In POPL. ACM, 259–270. Google ScholarGoogle Scholar
  18. Ahmed Bouajjani, Michael Emmi, Constantin Enea, and Suha Orhun Mutluergil. 2017. Proving Linearizability Using Forward Simulations. In CAV (LNCS), Vol. 10427. Springer, 542–563. Google ScholarGoogle Scholar
  19. Ahmed Bouajjani, Constantin Enea, Suha Orhun Mutluergil, and Serdar Tasiran. 2018. Reasoning About TSO Programs Using Reduction and Abstraction. In CAV (LNCS), Vol. 10982. Springer, 336–353. Google ScholarGoogle Scholar
  20. John Boyland. 2003. Checking Interference with Fractional Permissions. In SAS (LNCS), Vol. 2694. Springer, 55–72. Google ScholarGoogle Scholar
  21. Anastasia Braginsky, Alex Kogan, and Erez Petrank. 2013. Drop the Anchor: Lightweight Memory Management for Non-blocking Data Structures. In SPAA. ACM, 33–42. Google ScholarGoogle Scholar
  22. Stephen D. Brookes. 2004. A Semantics for Concurrent Separation Logic. In CONCUR (LNCS), Vol. 3170. Springer, 16–34. Google ScholarGoogle Scholar
  23. Trevor Alexander Brown. 2015. Reclaiming Memory for Lock-Free Data Structures: There has to be a Better Way. In PODC. ACM, 261–270. Google ScholarGoogle Scholar
  24. Sebastian Burckhardt, Chris Dern, Madanlal Musuvathi, and Roy Tan. 2010. Line-up: A Complete and Automatic Linearizability Checker. In PLDI. ACM, 330–340. Google ScholarGoogle Scholar
  25. Cristiano Calcagno and Dino Distefano. 2011. Infer: An Automatic Program Verifier for Memory Safety of C Programs. In NASA Formal Methods (LNCS), Vol. 6617. Springer, 459–465. Google ScholarGoogle Scholar
  26. Elias Castegren and Tobias Wrigstad. 2017. Relaxed Linear References for Lock-free Data Structures. In ECOOP (LIPIcs), Vol. 74. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, 6:1–6:32. Google ScholarGoogle Scholar
  27. Pavol Cerný, Arjun Radhakrishna, Damien Zufferey, Swarat Chaudhuri, and Rajeev Alur. 2010. Model Checking of Linearizability of Concurrent List Implementations. In CAV (LNCS), Vol. 6174. Springer, 465–479. Google ScholarGoogle Scholar
  28. Nachshon Cohen. 2018. Every Data Structure Deserves Lock-free Memory Reclamation. PACMPL 2, OOPSLA (2018), 143:1–143:24. Google ScholarGoogle Scholar
  29. Nachshon Cohen and Erez Petrank. 2015a. Automatic Memory Reclamation for Lock-free Data Structures. In OOPSLA. ACM, 260–279. Google ScholarGoogle Scholar
  30. Nachshon Cohen and Erez Petrank. 2015b. Efficient Memory Management for Lock-Free Data Structures with Optimistic Access. In SPAA. ACM, 254–263. Google ScholarGoogle Scholar
  31. Robert Colvin, Simon Doherty, and Lindsay Groves. 2005. Verifying Concurrent Data Structures by Simulation. Electr. Notes Theor. Comput. Sci. 137, 2 (2005), 93–110. Google ScholarGoogle Scholar
  32. Robert Colvin, Lindsay Groves, Victor Luchangco, and Mark Moir. 2006. Formal Verification of a Lazy Concurrent List-Based Set Algorithm. In CAV (LNCS), Vol. 4144. Springer, 475–488. Google ScholarGoogle Scholar
  33. Mario Coppo and Mariangiola Dezani-Ciancaglini. 1978. A New Type Assignment for 𝜆-Terms. Arch. Math. Log. 19, 1 (1978), 139–156. Google ScholarGoogle Scholar
  34. Karl Crary, David Walker, and J. Gregory Morrisett. 1999. Typed Memory Management in a Calculus of Capabilities. In POPL. ACM, 262–275. Google ScholarGoogle Scholar
  35. Pedro da Rocha Pinto, Thomas Dinsdale-Young, and Philippa Gardner. 2014. TaDA: A Logic for Time and Data Abstraction. In ECOOP (LNCS), Vol. 8586. Springer, 207–231. Google ScholarGoogle Scholar
  36. Manuvir Das, Sorin Lerner, and Mark Seigle. 2002. ESP: Path-Sensitive Program Verification in Polynomial Time. In PLDI. ACM, 57–68. Google ScholarGoogle Scholar
  37. Germán Andrés Delbianco, Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2017. Concurrent Data Structures Linked in Time. In ECOOP (LIPIcs), Vol. 74. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, 8:1–8:30. Google ScholarGoogle Scholar
  38. Robert DeLine and Manuel Fähndrich. 2004. Typestates for Objects. In ECOOP (LNCS), Vol. 3086. Springer, 465–490. Google ScholarGoogle Scholar
  39. John Derrick, Gerhard Schellhorn, and Heike Wehrheim. 2011. Mechanically Verified Proof Obligations for Linearizability. ToPLaS 33, 1 (2011), 4:1–4:43. Google ScholarGoogle Scholar
  40. David Detlefs, Paul Alan Martin, Mark Moir, and Guy L. Steele Jr. 2001. Lock-free Reference Counting. In PODC. ACM, 190–199. Google ScholarGoogle Scholar
  41. Dave Dice, Maurice Herlihy, and Alex Kogan. 2016. Fast Non-intrusive Memory Reclamation for Highly-concurrent Data Structures. In ISMM. ACM, 36–45. Google ScholarGoogle Scholar
  42. Edsger W. Dijkstra. 1982. On Making Solutions More and More Fine-Grained. Springer New York, New York, NY, 292–307. Google ScholarGoogle Scholar
  43. Thomas Dinsdale-Young, Mike Dodds, Philippa Gardner, Matthew J. Parkinson, and Viktor Vafeiadis. 2010. Concurrent Abstract Predicates. In ECOOP (LNCS), Vol. 6183. Springer, 504–528. Google ScholarGoogle Scholar
  44. Mike Dodds, Xinyu Feng, Matthew J. Parkinson, and Viktor Vafeiadis. 2009. Deny-Guarantee Reasoning. In ESOP (LNCS), Vol. 5502. Springer, 363–377. Google ScholarGoogle Scholar
  45. Mike Dodds, Andreas Haas, and Christoph M. Kirsch. 2015. A Scalable, Correct Time-Stamped Stack. In POPL. ACM, 233–246. Google ScholarGoogle Scholar
  46. Thomas W. Doeppner, Jr. 1977. Parallel Program Correctness Through Refinement. In POPL. ACM, 155–169. Google ScholarGoogle Scholar
  47. Simon Doherty, Lindsay Groves, Victor Luchangco, and Mark Moir. 2004. Formal Verification of a Practical Lock-Free Queue Algorithm. In FORTE (LNCS), Vol. 3235. Springer, 97–114. Google ScholarGoogle Scholar
  48. Simon Doherty and Mark Moir. 2009. Nonblocking Algorithms and Backward Simulation. In DISC (LNCS), Vol. 5805. Springer, 274–288. Google ScholarGoogle Scholar
  49. Brijesh Dongol and John Derrick. 2015. Verifying Linearisability: A Comparative Survey. ACM Comput. Surv. 48 (2015). Google ScholarGoogle Scholar
  50. Aleksandar Dragojevic, Maurice Herlihy, Yossi Lev, and Mark Moir. 2011. On the Power of Hardware Transactional Memory to Simplify Memory Management. In PODC. ACM, 99–108. Google ScholarGoogle Scholar
  51. Kamil Dudka, Petr Peringer, and Tomás Vojnar. 2013. Byte-Precise Verification of Low-Level List Manipulation. In SAS (LNCS), Vol. 7935. Springer, 215–237. Google ScholarGoogle Scholar
  52. Tayfun Elmas, Shaz Qadeer, Ali Sezgin, Omer Subasi, and Serdar Tasiran. 2010. Simplifying Linearizability Proofs with Reduction and Abstraction. In TACAS (LNCS), Vol. 6015. Springer, 296–311. Google ScholarGoogle Scholar
  53. Tayfun Elmas, Shaz Qadeer, and Serdar Tasiran. 2009. A Calculus of Atomic Actions. In POPL. ACM, 2–15. Google ScholarGoogle Scholar
  54. Michael Emmi and Constantin Enea. 2018. Sound, Complete, and Tractable Linearizability Monitoring for Concurrent Collections. PACMPL 2, POPL (2018), 25:1–25:27. Google ScholarGoogle Scholar
  55. Michael Emmi, Constantin Enea, and Jad Hamza. 2015. Monitoring Refinement via Symbolic Reasoning. In PLDI. ACM, 260–269. Google ScholarGoogle Scholar
  56. Manuel Fähndrich and Robert DeLine. 2002. Adoption and Focus: Practical Linear Types for Imperative Programming. In PLDI. ACM, 13–24. Google ScholarGoogle Scholar
  57. Xinyu Feng. 2009. Local Rely-guarantee Reasoning. In POPL. ACM, 315–327. Google ScholarGoogle Scholar
  58. Xinyu Feng, Rodrigo Ferreira, and Zhong Shao. 2007. On the Relationship Between Concurrent Separation Logic and AssumeGuarantee Reasoning. In ESOP (LNCS), Vol. 4421. Springer, 173–188. Google ScholarGoogle Scholar
  59. Stephen J. Fink, Eran Yahav, Nurit Dor, G. Ramalingam, and Emmanuel Geay. 2006. Effective Typestate Verification in the Presence of Aliasing. In ISSTA. ACM, 133–144. Google ScholarGoogle Scholar
  60. Cormac Flanagan, Stephen N. Freund, Marina Lifshin, and Shaz Qadeer. 2008. Types for Atomicity: Static Checking and Inference for Java. ToPLaS 30, 4 (2008), 20:1–20:53. Google ScholarGoogle Scholar
  61. Cormac Flanagan, Stephen N. Freund, Shaz Qadeer, and Sanjit A. Seshia. 2005. Modular verification of multithreaded programs. Theor. Comput. Sci. 338, 1-3 (2005), 153–183. Google ScholarGoogle Scholar
  62. Cormac Flanagan and Shaz Qadeer. 2003. A Type and Effect System for Atomicity. In PLDI. ACM, 338–349. Google ScholarGoogle Scholar
  63. Cormac Flanagan, Shaz Qadeer, and Sanjit A. Seshia. 2002. A Modular Checker for Multithreaded Programs. In CAV (LNCS), Vol. 2404. Springer, 180–194. Google ScholarGoogle Scholar
  64. Jeffrey S. Foster, Tachio Terauchi, and Alexander Aiken. 2002. Flow-Sensitive Type Qualifiers. In PLDI. ACM, 1–12. Google ScholarGoogle Scholar
  65. Keir Fraser. 2004. Practical Lock-freedom. Ph.D. Dissertation. University of Cambridge, UK. http://ethos.bl.uk/OrderDetails. do?uin=uk.bl.ethos.599193Google ScholarGoogle Scholar
  66. Stephen N. Freund and Shaz Qadeer. 2004. Checking Concise Specifications for Multithreaded Software. Journal of Object Technology 3, 6 (2004), 81–101. Google ScholarGoogle Scholar
  67. Ming Fu, Yong Li, Xinyu Feng, Zhong Shao, and Yu Zhang. 2010. Reasoning about Optimistic Concurrency Using a Program Logic for History. In CONCUR (LNCS), Vol. 6269. Springer, 388–402. Google ScholarGoogle Scholar
  68. Anders Gidenstam, Marina Papatriantafilou, Håkan Sundell, and Philippas Tsigas. 2005. Efficient and Reliable Lock-Free Memory Reclamation Based on Reference Counting. In ISPAN. IEEE, 202–207. Google ScholarGoogle Scholar
  69. Alexey Gotsman, Noam Rinetzky, and Hongseok Yang. 2013. Verifying Concurrent Memory Reclamation Algorithms with Grace. In ESOP (LNCS), Vol. 7792. Springer, 249–269. Google ScholarGoogle Scholar
  70. Erich Grädel, Wolfgang Thomas, and Thomas Wilke (Eds.). 2002. Automata, Logics, and Infinite Games. LNCS, Vol. 2500. Springer. Google ScholarGoogle Scholar
  71. Lindsay Groves. 2007. Reasoning about Nonblocking Concurrency using Reduction. In ICECCS. IEEE, 107–116. Google ScholarGoogle Scholar
  72. Lindsay Groves. 2008. Verifying Michael and Scott’s Lock-Free Queue Algorithm using Trace Reduction. In CATS (CRPIT), Vol. 77. Australian Computer Society, 133–142. http://crpit.com/abstracts/CRPITV77Groves.htmlGoogle ScholarGoogle Scholar
  73. Timothy L. Harris. 2001. A Pragmatic Implementation of Non-blocking Linked-Lists. In DISC (LNCS), Vol. 2180. Springer, 300–314. Google ScholarGoogle Scholar
  74. Chris Hawblitzel, Erez Petrank, Shaz Qadeer, and Serdar Tasiran. 2015. Automated and Modular Refinement Reasoning for Concurrent Programs. In CAV (LNCS), Vol. 9207. Springer, 449–465. Google ScholarGoogle Scholar
  75. Frédéric Haziza, Lukás Holík, Roland Meyer, and Sebastian Wolff. 2016. Pointer Race Freedom. In VMCAI (LNCS), Vol. 9583. Springer, 393–412. Google ScholarGoogle Scholar
  76. Nir Hemed, Noam Rinetzky, and Viktor Vafeiadis. 2015. Modular Verification of Concurrency-Aware Linearizability. In DISC (LNCS), Vol. 9363. Springer, 371–387. Google ScholarGoogle Scholar
  77. Thomas A. Henzinger, Ranjit Jhala, Rupak Majumdar, and Grégoire Sutre. 2003. Software Verification with BLAST. In SPIN (LNCS), Vol. 2648. Springer, 235–239. Google ScholarGoogle Scholar
  78. Thomas A. Henzinger, Ali Sezgin, and Viktor Vafeiadis. 2013. Aspect-Oriented Linearizability Proofs. In CONCUR (LNCS), Vol. 8052. Springer, 242–256. Google ScholarGoogle Scholar
  79. Maurice Herlihy, Victor Luchangco, Paul A. Martin, and Mark Moir. 2005. Nonblocking Memory Management Support for Dynamic-sized Data Structures. ACM Trans. Comput. Syst. 23, 2 (2005), 146–196. Google ScholarGoogle Scholar
  80. Maurice Herlihy and Nir Shavit. 2008. The Art of Multiprocessor Programming. Morgan Kaufmann.Google ScholarGoogle Scholar
  81. Maurice Herlihy and Jeannette M. Wing. 1990. Linearizability: A Correctness Condition for Concurrent Objects. ToPLaS 12, 3 (1990), 463–492. Google ScholarGoogle Scholar
  82. Lukás Holík, Michal Kotoun, Petr Peringer, Veronika Soková, Marek Trtík, and Tomás Vojnar. 2016. Predator Shape Analysis Tool Suite. In HVC (LNCS), Vol. 10028. Springer, 202–209. Google ScholarGoogle Scholar
  83. Lukás Holík, Ondrej Lengál, Adam Rogalewicz, Jirí Simácek, and Tomás Vojnar. 2013. Fully Automated Shape Analysis Based on Forest Automata. In CAV (LNCS), Vol. 8044. Springer, 740–755. Google ScholarGoogle Scholar
  84. Lukás Holík, Roland Meyer, Tomás Vojnar, and Sebastian Wolff. 2017. Effect Summaries for Thread-Modular Analysis -Sound Analysis Despite an Unsound Heuristic. In SAS (LNCS), Vol. 10422. Springer, 169–191. Google ScholarGoogle Scholar
  85. Alex Horn and Daniel Kroening. 2015. Faster Linearizability Checking via P-Compositionality. In FORTE (LNCS), Vol. 9039. Springer, 50–65. Google ScholarGoogle Scholar
  86. Sebastian Hunt and David Sands. 2006. On Flow-sensitive Security Types. In POPL. ACM, 79–90. Google ScholarGoogle Scholar
  87. ISO. 2011. ISO/IEC 14882:2011 Information technology — Programming languages — C++. Standard ISO/IEC 14882:2011. International Organization for Standardization, Geneva, CH. https://www.iso.org/standard/50372.htmlGoogle ScholarGoogle Scholar
  88. Cliff B. Jones. 1983. Tentative Steps Toward a Development Method for Interfering Programs. ToPLaS 5, 4 (1983), 596–619. Google ScholarGoogle Scholar
  89. Bengt Jonsson. 2012. Using refinement calculus techniques to prove linearizability. Formal Asp. Comput. 24, 4-6 (2012), 537–554. Google ScholarGoogle Scholar
  90. Ralf Jung, David Swasey, Filip Sieczkowski, Kasper Svendsen, Aaron Turon, Lars Birkedal, and Derek Dreyer. 2015. Iris: Monoids and Invariants as an Orthogonal Basis for Concurrent Reasoning. In POPL. ACM, 637–650. Google ScholarGoogle Scholar
  91. Artem Khyzha, Mike Dodds, Alexey Gotsman, and Matthew J. Parkinson. 2017. Proving Linearizability Using Partial Orders. In ESOP (LNCS), Vol. 10201. Springer, 639–667. Google ScholarGoogle Scholar
  92. Bernhard Kragl and Shaz Qadeer. 2018. Layered Concurrent Programs. In CAV (LNCS), Vol. 10981. Springer, 79–102. Google ScholarGoogle Scholar
  93. Siddharth Krishna, Dennis E. Shasha, and Thomas Wies. 2018. Go with the Flow: Compositional Abstractions for Concurrent Data Structures. PACMPL 2, POPL (2018), 37:1–37:31. Google ScholarGoogle Scholar
  94. Ismail Kuru and Colin S. Gordon. 2019. Safe Deferred Memory Reclamation with Types. In ESOP (LNCS), Vol. 11423. Springer, 88–116. Google ScholarGoogle Scholar
  95. Leslie Lamport and Fred B. Schneider. 1989. Pretending Atomicity. SRC Research Report 44 (1989). https://www.microsoft. com/en-us/research/publication/pretending-atomicity/Google ScholarGoogle Scholar
  96. Vincent Laviron, Bor-Yuh Evan Chang, and Xavier Rival. 2010. Separating Shape Graphs. In ESOP (LNCS), Vol. 6012. Springer, 387–406. Google ScholarGoogle Scholar
  97. Hongjin Liang and Xinyu Feng. 2013. Modular Verification of Linearizability with Non-fixed Linearization Points. In PLDI. ACM, 459–470. Google ScholarGoogle Scholar
  98. Hongjin Liang, Xinyu Feng, and Ming Fu. 2012. A Rely-guarantee-based Simulation for Verifying Concurrent Program Transformations. In POPL. ACM, 455–468. Google ScholarGoogle Scholar
  99. Hongjin Liang, Xinyu Feng, and Ming Fu. 2014. Rely-Guarantee-Based Simulation for Compositional Verification of Concurrent Program Transformations. ToPLaS 36, 1 (2014), 3:1–3:55. Google ScholarGoogle Scholar
  100. Richard J. Lipton. 1975. Reduction: A Method of Proving Properties of Parallel Programs. CACM 18, 12 (1975), 717–721.Google ScholarGoogle Scholar
  101. Yang Liu, Wei Chen, Yanhong A. Liu, and Jun Sun. 2009. Model Checking Linearizability via Refinement. In FM (LNCS), Vol. 5850. Springer, 321–337. Google ScholarGoogle Scholar
  102. Yang Liu, Wei Chen, Yanhong A. Liu, Jun Sun, Shao Jie Zhang, and Jin Song Dong. 2013. Verifying Linearizability via Optimized Refinement Checking. IEEE Trans. Software Eng. 39, 7 (2013), 1018–1039. Google ScholarGoogle Scholar
  103. Gavin Lowe. 2017. Testing for linearizability. Concurrency and Computation: Practice and Experience 29, 4 (2017). Google ScholarGoogle Scholar
  104. Paul E. McKenney and John D. Slingwine. 1998. Read-copy Update: Using Execution History to Solve Concurrency Problems.Google ScholarGoogle Scholar
  105. Roland Meyer and Sebastian Wolff. 2019a. Decoupling Lock-free Data Structures from Memory Reclamation for Static Analysis. PACMPL 3, POPL (2019), 58:1–58:31. Google ScholarGoogle Scholar
  106. Roland Meyer and Sebastian Wolff. 2019b. Pointer Life Cycle Types for Lock-Free Data Structures with Memory Reclamation. CoRR abs/1910.11714 (2019). http://arxiv.org/abs/1910.11714Google ScholarGoogle Scholar
  107. Maged M. Michael. 2002a. High Performance Dynamic Lock-free Hash Tables and List-based Sets. In SPAA. ACM, 73–82. Google ScholarGoogle Scholar
  108. Maged M. Michael. 2002b. Safe Memory Reclamation for Dynamic Lock-free Objects Using Atomic Reads and Writes. In PODC. ACM, 21–30. Google ScholarGoogle Scholar
  109. Maged M. Michael and Michael L. Scott. 1996. Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms. In PODC. ACM, 267–275. Google ScholarGoogle Scholar
  110. Aleksandar Nanevski, Ruy Ley-Wild, Ilya Sergey, and Germán Andrés Delbianco. 2014. Communicating State Transition Systems for Fine-Grained Concurrent Resources. In ESOP (LNCS), Vol. 8410. Springer, 290–310. Google ScholarGoogle Scholar
  111. George C. Necula, Scott McPeak, and Westley Weimer. 2002. CCured: Type-safe Retrofitting of Legacy Code. In POPL. ACM, 128–139. Google ScholarGoogle Scholar
  112. Ruslan Nikolaev and Binoy Ravindran. 2019. Hyaline: Fast and Transparent Lock-Free Memory Reclamation. In PODC. ACM, 419–421. Google ScholarGoogle Scholar
  113. Peter W. O’Hearn. 2004. Resources, Concurrency and Local Reasoning. In CONCUR (LNCS), Vol. 3170. Springer, 49–67. Google ScholarGoogle Scholar
  114. Peter W. O’Hearn, John C. Reynolds, and Hongseok Yang. 2001. Local Reasoning about Programs that Alter Data Structures. In CSL (LNCS), Vol. 2142. Springer, 1–19. Google ScholarGoogle Scholar
  115. Peter W. O’Hearn, Noam Rinetzky, Martin T. Vechev, Eran Yahav, and Greta Yorsh. 2010. Verifying Linearizability with Hindsight. In PODC. ACM, 85–94. Google ScholarGoogle Scholar
  116. Susan S. Owicki and David Gries. 1976. An Axiomatic Proof Technique for Parallel Programs I. Acta Inf. 6 (1976), 319–340. Google ScholarGoogle Scholar
  117. Matthew J. Parkinson, Richard Bornat, and Peter W. O’Hearn. 2007. Modular Verification of a Non-blocking Stack. In POPL. ACM, 297–302. Google ScholarGoogle Scholar
  118. Benjamin C. Pierce. 2002. Types and programming languages. MIT Press.Google ScholarGoogle Scholar
  119. Pedro Ramalhete and Andreia Correia. 2017. Brief Announcement: Hazard Eras - Non-Blocking Memory Reclamation. In SPAA. ACM, 367–369. Google ScholarGoogle Scholar
  120. John C. Reynolds. 2002. Separation Logic: A Logic for Shared Mutable Data Structures. In LICS. IEEE, 55–74. Google ScholarGoogle Scholar
  121. Gerhard Schellhorn, Heike Wehrheim, and John Derrick. 2012. How to Prove Algorithms Linearisable. In CAV (LNCS), Vol. 7358. Springer, 243–259. Google ScholarGoogle Scholar
  122. Michal Segalov, Tal Lev-Ami, Roman Manevich, Ganesan Ramalingam, and Mooly Sagiv. 2009. Abstract Transformers for Thread Correlation Analysis. In APLAS (LNCS), Vol. 5904. Springer, 30–46. Google ScholarGoogle Scholar
  123. Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2015a. Mechanized Verification of Fine-grained Concurrent Programs. In PLDI. ACM, 77–87. Google ScholarGoogle Scholar
  124. Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2015b. Specifying and Verifying Concurrent Algorithms with Histories and Subjectivity. In ESOP (LNCS), Vol. 9032. Springer, 333–358. Google ScholarGoogle Scholar
  125. Divjyot Sethi, Muralidhar Talupur, and Sharad Malik. 2013. Model Checking Unbounded Concurrent Lists. In SPIN (LNCS), Vol. 7976. Springer, 320–340. Google ScholarGoogle Scholar
  126. Thomas Ströder, Jürgen Giesl, Marc Brockschmidt, Florian Frohn, Carsten Fuhs, Jera Hensel, Peter Schneider-Kamp, and Cornelius Aschermann. 2017. Automatically Proving Termination and Memory Safety for Programs with Pointer Arithmetic. J. Autom. Reasoning 58, 1 (2017), 33–65. Google ScholarGoogle Scholar
  127. Robert E. Strom and Shaula Yemini. 1986. Typestate: A Programming Language Concept for Enhancing Software Reliability. IEEE Trans. Software Eng. 12, 1 (1986), 157–171. Google ScholarGoogle Scholar
  128. Kasper Svendsen and Lars Birkedal. 2014. Impredicative Concurrent Abstract Predicates. In ESOP (LNCS), Vol. 8410. Springer, 149–168. Google ScholarGoogle Scholar
  129. Bogdan Tofan, Gerhard Schellhorn, and Wolfgang Reif. 2011. Formal Verification of a Lock-Free Stack with Hazard Pointers. In ICTAC (LNCS), Vol. 6916. Springer, 239–255. Google ScholarGoogle Scholar
  130. Oleg Travkin, Annika Mütze, and Heike Wehrheim. 2013. SPIN as a Linearizability Checker under Weak Memory Models. In HVC (LNCS), Vol. 8244. Springer, 311–326. Google ScholarGoogle Scholar
  131. R. Kent Treiber. 1986. Systems Programming: Coping with Parallelism. Technical Report RJ 5118. IBM.Google ScholarGoogle Scholar
  132. Aaron Turon, Derek Dreyer, and Lars Birkedal. 2013. Unifying Refinement and Hoare-style Reasoning in a Logic for Higher-order Concurrency. In ICFP. ACM, 377–390. Google ScholarGoogle Scholar
  133. Aaron Turon, Viktor Vafeiadis, and Derek Dreyer. 2014. GPS: Navigating Weak Memory with Ghosts, Protocols, and Separation. In OOPSLA. ACM, 691–707. Google ScholarGoogle Scholar
  134. Viktor Vafeiadis. 2009. Shape-Value Abstraction for Verifying Linearizability. In VMCAI (LNCS), Vol. 5403. Springer, 335–348. Google ScholarGoogle Scholar
  135. Viktor Vafeiadis. 2010a. Automatically Proving Linearizability. In CAV (LNCS), Vol. 6174. Springer, 450–464. Google ScholarGoogle Scholar
  136. Viktor Vafeiadis. 2010b. RGSep Action Inference. In VMCAI (LNCS), Vol. 5944. Springer, 345–361. Google ScholarGoogle Scholar
  137. Viktor Vafeiadis and Matthew J. Parkinson. 2007. A Marriage of Rely/Guarantee and Separation Logic. In CONCUR (LNCS), Vol. 4703. Springer, 256–271. Google ScholarGoogle Scholar
  138. Martin T. Vechev and Eran Yahav. 2008. Deriving Linearizable Fine-grained Concurrent Objects. In PLDI. ACM, 125–135. Google ScholarGoogle Scholar
  139. Martin T. Vechev, Eran Yahav, and Greta Yorsh. 2009. Experience with Model Checking Linearizability. In SPIN (LNCS), Vol. 5578. Springer, 261–278. Google ScholarGoogle Scholar
  140. Haosen Wen, Joseph Izraelevitz, Wentao Cai, H. Alan Beadle, and Michael L. Scott. 2018. Interval-based Memory Reclamation. In PPOPP. ACM, 1–13. Google ScholarGoogle Scholar
  141. Martin De Wulf, Laurent Doyen, Thomas A. Henzinger, and Jean-François Raskin. 2006. Antichains: A New Algorithm for Checking Universality of Finite Automata. In CAV (LNCS), Vol. 4144. Springer, 17–30. Google ScholarGoogle Scholar
  142. Albert Mingkun Yang and Tobias Wrigstad. 2017. Type-assisted Automatic Garbage Collection for Lock-free Data Structures. In ISMM. ACM, 14–24. Google ScholarGoogle Scholar
  143. Hongseok Yang, Oukseh Lee, Josh Berdine, Cristiano Calcagno, Byron Cook, Dino Distefano, and Peter W. O’Hearn. 2008. Scalable Shape Analysis for Systems Code. In CAV (LNCS), Vol. 5123. Springer, 385–398. Google ScholarGoogle Scholar
  144. Xiaoxiao Yang, Joost-Pieter Katoen, Huimin Lin, and Hao Wu. 2017. Verifying Concurrent Stacks by Divergence-Sensitive Bisimulation. CoRR abs/1701.06104 (2017). http://arxiv.org/abs/1701.06104Google ScholarGoogle Scholar
  145. Shao Jie Zhang. 2011. Scalable Automatic Linearizability Checking. In ICSE. ACM, 1185–1187. Google ScholarGoogle Scholar
  146. He Zhu, Gustavo Petri, and Suresh Jagannathan. 2015. Poling: SMT Aided Linearizability Proofs. In CAV (LNCS), Vol. 9207. Springer, 3–19. Google ScholarGoogle Scholar

Index Terms

  1. Pointer life cycle types for lock-free data structures with memory reclamation

                    Recommendations

                    Comments

                    Login options

                    Check if you have access through your login credentials or your institution to get full access on this article.

                    Sign in

                    Full Access

                    PDF Format

                    View or Download as a PDF file.

                    PDF

                    eReader

                    View online with eReader.

                    eReader
                    About Cookies On This Site

                    We use cookies to ensure that we give you the best experience on our website.

                    Learn more

                    Got it!