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.
Supplemental Material
- 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 Scholar
- Parosh Aziz Abdulla, Bengt Jonsson, and Cong Quy Trinh. 2016. Automated Verification of Linearization Policies. In SAS (LNCS), Vol. 9837. Springer, 61–83. Google Scholar
- Zahra Aghazadeh, Wojciech M. Golab, and Philipp Woelfel. 2014. Making Objects Writable. In PODC. ACM, 385–395. Google Scholar
- 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 Scholar
- Dan Alistarh, William M. Leiserson, Alexander Matveev, and Nir Shavit. 2015. ThreadScan: Automatic and Scalable Memory Reclamation. In SPAA. ACM, 123–132. Google Scholar
- 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 Scholar
- 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 Scholar
- Ralph-Johan Back. 1989. A Method for Refining Atomicity in Parallel Algorithms. In PARLE (LNCS), Vol. 366. Springer, 199–216. Google Scholar
- 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 Scholar
- 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 Scholar
- Josh Berdine, Byron Cook, and Samin Ishtiaq. 2011. SLAyer: Memory Safety for Systems-Level Code. In CAV (LNCS), Vol. 6806. Springer, 178–183. Google Scholar
- 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 Scholar
- 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 Scholar
- Kevin Bierhoff and Jonathan Aldrich. 2007. Modular Typestate Checking of Aliased Objects. In OOPSLA. ACM, 301–320. Google Scholar
- Garrett Birkhoff. 1948. Lattice Theory (revised edition). American Mathematical Society.Google Scholar
- 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 Scholar
- Richard Bornat, Cristiano Calcagno, Peter W. O’Hearn, and Matthew J. Parkinson. 2005. Permission Accounting in Separation Logic. In POPL. ACM, 259–270. Google Scholar
- 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 Scholar
- 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 Scholar
- John Boyland. 2003. Checking Interference with Fractional Permissions. In SAS (LNCS), Vol. 2694. Springer, 55–72. Google Scholar
- 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 Scholar
- Stephen D. Brookes. 2004. A Semantics for Concurrent Separation Logic. In CONCUR (LNCS), Vol. 3170. Springer, 16–34. Google Scholar
- Trevor Alexander Brown. 2015. Reclaiming Memory for Lock-Free Data Structures: There has to be a Better Way. In PODC. ACM, 261–270. Google Scholar
- Sebastian Burckhardt, Chris Dern, Madanlal Musuvathi, and Roy Tan. 2010. Line-up: A Complete and Automatic Linearizability Checker. In PLDI. ACM, 330–340. Google Scholar
- 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 Scholar
- 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 Scholar
- 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 Scholar
- Nachshon Cohen. 2018. Every Data Structure Deserves Lock-free Memory Reclamation. PACMPL 2, OOPSLA (2018), 143:1–143:24. Google Scholar
- Nachshon Cohen and Erez Petrank. 2015a. Automatic Memory Reclamation for Lock-free Data Structures. In OOPSLA. ACM, 260–279. Google Scholar
- Nachshon Cohen and Erez Petrank. 2015b. Efficient Memory Management for Lock-Free Data Structures with Optimistic Access. In SPAA. ACM, 254–263. Google Scholar
- 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 Scholar
- 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 Scholar
- Mario Coppo and Mariangiola Dezani-Ciancaglini. 1978. A New Type Assignment for 𝜆-Terms. Arch. Math. Log. 19, 1 (1978), 139–156. Google Scholar
- Karl Crary, David Walker, and J. Gregory Morrisett. 1999. Typed Memory Management in a Calculus of Capabilities. In POPL. ACM, 262–275. Google Scholar
- 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 Scholar
- Manuvir Das, Sorin Lerner, and Mark Seigle. 2002. ESP: Path-Sensitive Program Verification in Polynomial Time. In PLDI. ACM, 57–68. Google Scholar
- 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 Scholar
- Robert DeLine and Manuel Fähndrich. 2004. Typestates for Objects. In ECOOP (LNCS), Vol. 3086. Springer, 465–490. Google Scholar
- John Derrick, Gerhard Schellhorn, and Heike Wehrheim. 2011. Mechanically Verified Proof Obligations for Linearizability. ToPLaS 33, 1 (2011), 4:1–4:43. Google Scholar
- David Detlefs, Paul Alan Martin, Mark Moir, and Guy L. Steele Jr. 2001. Lock-free Reference Counting. In PODC. ACM, 190–199. Google Scholar
- Dave Dice, Maurice Herlihy, and Alex Kogan. 2016. Fast Non-intrusive Memory Reclamation for Highly-concurrent Data Structures. In ISMM. ACM, 36–45. Google Scholar
- Edsger W. Dijkstra. 1982. On Making Solutions More and More Fine-Grained. Springer New York, New York, NY, 292–307. Google Scholar
- 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 Scholar
- Mike Dodds, Xinyu Feng, Matthew J. Parkinson, and Viktor Vafeiadis. 2009. Deny-Guarantee Reasoning. In ESOP (LNCS), Vol. 5502. Springer, 363–377. Google Scholar
- Mike Dodds, Andreas Haas, and Christoph M. Kirsch. 2015. A Scalable, Correct Time-Stamped Stack. In POPL. ACM, 233–246. Google Scholar
- Thomas W. Doeppner, Jr. 1977. Parallel Program Correctness Through Refinement. In POPL. ACM, 155–169. Google Scholar
- 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 Scholar
- Simon Doherty and Mark Moir. 2009. Nonblocking Algorithms and Backward Simulation. In DISC (LNCS), Vol. 5805. Springer, 274–288. Google Scholar
- Brijesh Dongol and John Derrick. 2015. Verifying Linearisability: A Comparative Survey. ACM Comput. Surv. 48 (2015). Google Scholar
- 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 Scholar
- 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 Scholar
- 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 Scholar
- Tayfun Elmas, Shaz Qadeer, and Serdar Tasiran. 2009. A Calculus of Atomic Actions. In POPL. ACM, 2–15. Google Scholar
- Michael Emmi and Constantin Enea. 2018. Sound, Complete, and Tractable Linearizability Monitoring for Concurrent Collections. PACMPL 2, POPL (2018), 25:1–25:27. Google Scholar
- Michael Emmi, Constantin Enea, and Jad Hamza. 2015. Monitoring Refinement via Symbolic Reasoning. In PLDI. ACM, 260–269. Google Scholar
- Manuel Fähndrich and Robert DeLine. 2002. Adoption and Focus: Practical Linear Types for Imperative Programming. In PLDI. ACM, 13–24. Google Scholar
- Xinyu Feng. 2009. Local Rely-guarantee Reasoning. In POPL. ACM, 315–327. Google Scholar
- 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 Scholar
- 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 Scholar
- 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 Scholar
- 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 Scholar
- Cormac Flanagan and Shaz Qadeer. 2003. A Type and Effect System for Atomicity. In PLDI. ACM, 338–349. Google Scholar
- Cormac Flanagan, Shaz Qadeer, and Sanjit A. Seshia. 2002. A Modular Checker for Multithreaded Programs. In CAV (LNCS), Vol. 2404. Springer, 180–194. Google Scholar
- Jeffrey S. Foster, Tachio Terauchi, and Alexander Aiken. 2002. Flow-Sensitive Type Qualifiers. In PLDI. ACM, 1–12. Google Scholar
- Keir Fraser. 2004. Practical Lock-freedom. Ph.D. Dissertation. University of Cambridge, UK. http://ethos.bl.uk/OrderDetails. do?uin=uk.bl.ethos.599193Google Scholar
- Stephen N. Freund and Shaz Qadeer. 2004. Checking Concise Specifications for Multithreaded Software. Journal of Object Technology 3, 6 (2004), 81–101. Google Scholar
- 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 Scholar
- 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 Scholar
- Alexey Gotsman, Noam Rinetzky, and Hongseok Yang. 2013. Verifying Concurrent Memory Reclamation Algorithms with Grace. In ESOP (LNCS), Vol. 7792. Springer, 249–269. Google Scholar
- Erich Grädel, Wolfgang Thomas, and Thomas Wilke (Eds.). 2002. Automata, Logics, and Infinite Games. LNCS, Vol. 2500. Springer. Google Scholar
- Lindsay Groves. 2007. Reasoning about Nonblocking Concurrency using Reduction. In ICECCS. IEEE, 107–116. Google Scholar
- 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 Scholar
- Timothy L. Harris. 2001. A Pragmatic Implementation of Non-blocking Linked-Lists. In DISC (LNCS), Vol. 2180. Springer, 300–314. Google Scholar
- 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 Scholar
- 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 Scholar
- Nir Hemed, Noam Rinetzky, and Viktor Vafeiadis. 2015. Modular Verification of Concurrency-Aware Linearizability. In DISC (LNCS), Vol. 9363. Springer, 371–387. Google Scholar
- 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 Scholar
- Thomas A. Henzinger, Ali Sezgin, and Viktor Vafeiadis. 2013. Aspect-Oriented Linearizability Proofs. In CONCUR (LNCS), Vol. 8052. Springer, 242–256. Google Scholar
- 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 Scholar
- Maurice Herlihy and Nir Shavit. 2008. The Art of Multiprocessor Programming. Morgan Kaufmann.Google Scholar
- Maurice Herlihy and Jeannette M. Wing. 1990. Linearizability: A Correctness Condition for Concurrent Objects. ToPLaS 12, 3 (1990), 463–492. Google Scholar
- 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 Scholar
- 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 Scholar
- 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 Scholar
- Alex Horn and Daniel Kroening. 2015. Faster Linearizability Checking via P-Compositionality. In FORTE (LNCS), Vol. 9039. Springer, 50–65. Google Scholar
- Sebastian Hunt and David Sands. 2006. On Flow-sensitive Security Types. In POPL. ACM, 79–90. Google Scholar
- 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 Scholar
- Cliff B. Jones. 1983. Tentative Steps Toward a Development Method for Interfering Programs. ToPLaS 5, 4 (1983), 596–619. Google Scholar
- Bengt Jonsson. 2012. Using refinement calculus techniques to prove linearizability. Formal Asp. Comput. 24, 4-6 (2012), 537–554. Google Scholar
- 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 Scholar
- 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 Scholar
- Bernhard Kragl and Shaz Qadeer. 2018. Layered Concurrent Programs. In CAV (LNCS), Vol. 10981. Springer, 79–102. Google Scholar
- 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 Scholar
- Ismail Kuru and Colin S. Gordon. 2019. Safe Deferred Memory Reclamation with Types. In ESOP (LNCS), Vol. 11423. Springer, 88–116. Google Scholar
- 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 Scholar
- Vincent Laviron, Bor-Yuh Evan Chang, and Xavier Rival. 2010. Separating Shape Graphs. In ESOP (LNCS), Vol. 6012. Springer, 387–406. Google Scholar
- Hongjin Liang and Xinyu Feng. 2013. Modular Verification of Linearizability with Non-fixed Linearization Points. In PLDI. ACM, 459–470. Google Scholar
- Hongjin Liang, Xinyu Feng, and Ming Fu. 2012. A Rely-guarantee-based Simulation for Verifying Concurrent Program Transformations. In POPL. ACM, 455–468. Google Scholar
- 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 Scholar
- Richard J. Lipton. 1975. Reduction: A Method of Proving Properties of Parallel Programs. CACM 18, 12 (1975), 717–721.Google Scholar
- 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 Scholar
- 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 Scholar
- Gavin Lowe. 2017. Testing for linearizability. Concurrency and Computation: Practice and Experience 29, 4 (2017). Google Scholar
- Paul E. McKenney and John D. Slingwine. 1998. Read-copy Update: Using Execution History to Solve Concurrency Problems.Google Scholar
- 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 Scholar
- 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 Scholar
- Maged M. Michael. 2002a. High Performance Dynamic Lock-free Hash Tables and List-based Sets. In SPAA. ACM, 73–82. Google Scholar
- Maged M. Michael. 2002b. Safe Memory Reclamation for Dynamic Lock-free Objects Using Atomic Reads and Writes. In PODC. ACM, 21–30. Google Scholar
- 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 Scholar
- 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 Scholar
- George C. Necula, Scott McPeak, and Westley Weimer. 2002. CCured: Type-safe Retrofitting of Legacy Code. In POPL. ACM, 128–139. Google Scholar
- Ruslan Nikolaev and Binoy Ravindran. 2019. Hyaline: Fast and Transparent Lock-Free Memory Reclamation. In PODC. ACM, 419–421. Google Scholar
- Peter W. O’Hearn. 2004. Resources, Concurrency and Local Reasoning. In CONCUR (LNCS), Vol. 3170. Springer, 49–67. Google Scholar
- 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 Scholar
- 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 Scholar
- Susan S. Owicki and David Gries. 1976. An Axiomatic Proof Technique for Parallel Programs I. Acta Inf. 6 (1976), 319–340. Google Scholar
- Matthew J. Parkinson, Richard Bornat, and Peter W. O’Hearn. 2007. Modular Verification of a Non-blocking Stack. In POPL. ACM, 297–302. Google Scholar
- Benjamin C. Pierce. 2002. Types and programming languages. MIT Press.Google Scholar
- Pedro Ramalhete and Andreia Correia. 2017. Brief Announcement: Hazard Eras - Non-Blocking Memory Reclamation. In SPAA. ACM, 367–369. Google Scholar
- John C. Reynolds. 2002. Separation Logic: A Logic for Shared Mutable Data Structures. In LICS. IEEE, 55–74. Google Scholar
- Gerhard Schellhorn, Heike Wehrheim, and John Derrick. 2012. How to Prove Algorithms Linearisable. In CAV (LNCS), Vol. 7358. Springer, 243–259. Google Scholar
- 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 Scholar
- Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2015a. Mechanized Verification of Fine-grained Concurrent Programs. In PLDI. ACM, 77–87. Google Scholar
- 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 Scholar
- Divjyot Sethi, Muralidhar Talupur, and Sharad Malik. 2013. Model Checking Unbounded Concurrent Lists. In SPIN (LNCS), Vol. 7976. Springer, 320–340. Google Scholar
- 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 Scholar
- 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 Scholar
- Kasper Svendsen and Lars Birkedal. 2014. Impredicative Concurrent Abstract Predicates. In ESOP (LNCS), Vol. 8410. Springer, 149–168. Google Scholar
- 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 Scholar
- 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 Scholar
- R. Kent Treiber. 1986. Systems Programming: Coping with Parallelism. Technical Report RJ 5118. IBM.Google Scholar
- 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 Scholar
- Aaron Turon, Viktor Vafeiadis, and Derek Dreyer. 2014. GPS: Navigating Weak Memory with Ghosts, Protocols, and Separation. In OOPSLA. ACM, 691–707. Google Scholar
- Viktor Vafeiadis. 2009. Shape-Value Abstraction for Verifying Linearizability. In VMCAI (LNCS), Vol. 5403. Springer, 335–348. Google Scholar
- Viktor Vafeiadis. 2010a. Automatically Proving Linearizability. In CAV (LNCS), Vol. 6174. Springer, 450–464. Google Scholar
- Viktor Vafeiadis. 2010b. RGSep Action Inference. In VMCAI (LNCS), Vol. 5944. Springer, 345–361. Google Scholar
- Viktor Vafeiadis and Matthew J. Parkinson. 2007. A Marriage of Rely/Guarantee and Separation Logic. In CONCUR (LNCS), Vol. 4703. Springer, 256–271. Google Scholar
- Martin T. Vechev and Eran Yahav. 2008. Deriving Linearizable Fine-grained Concurrent Objects. In PLDI. ACM, 125–135. Google Scholar
- Martin T. Vechev, Eran Yahav, and Greta Yorsh. 2009. Experience with Model Checking Linearizability. In SPIN (LNCS), Vol. 5578. Springer, 261–278. Google Scholar
- Haosen Wen, Joseph Izraelevitz, Wentao Cai, H. Alan Beadle, and Michael L. Scott. 2018. Interval-based Memory Reclamation. In PPOPP. ACM, 1–13. Google Scholar
- 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 Scholar
- Albert Mingkun Yang and Tobias Wrigstad. 2017. Type-assisted Automatic Garbage Collection for Lock-free Data Structures. In ISMM. ACM, 14–24. Google Scholar
- 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 Scholar
- 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 Scholar
- Shao Jie Zhang. 2011. Scalable Automatic Linearizability Checking. In ICSE. ACM, 1185–1187. Google Scholar
- He Zhu, Gustavo Petri, and Suresh Jagannathan. 2015. Poling: SMT Aided Linearizability Proofs. In CAV (LNCS), Vol. 9207. Springer, 3–19. Google Scholar
Index Terms
Pointer life cycle types for lock-free data structures with memory reclamation
Recommendations
Decoupling lock-free data structures from memory reclamation for static analysis
Verification of concurrent data structures is one of the most challenging tasks in software verification. The topic has received considerable attention over the course of the last decade. Nevertheless, human-driven techniques remain cumbersome and ...
Types for atomicity: Static checking and inference for Java
Atomicity is a fundamental correctness property in multithreaded programs. A method is atomic if, for every execution, there is an equivalent serial execution in which the actions of the method are not interleaved with actions of other threads. Atomic ...
Automatic memory reclamation for lock-free data structures
OOPSLA '15Lock-free data-structures are widely employed in practice, yet designing lock-free memory reclamation for them is notoriously difficult. In particular, all known lock-free reclamation schemes are ``manual'' in the sense that the developer has to ...






Comments