research-article

Open access

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

Authors:

Sebastian WolffAuthors Info & Claims

Proceedings of the ACM on Programming Languages, Volume 4, Issue POPL

Article No.: 68, Pages 1 - 36

https://doi.org/10.1145/3371136

Published: 20 December 2019 Publication History

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.

Supplementary Material

WEBM File (a68-meyer.webm)

Download
81.62 MB

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.

[2]

Parosh Aziz Abdulla, Bengt Jonsson, and Cong Quy Trinh. 2016. Automated Verification of Linearization Policies. In SAS (LNCS), Vol. 9837. Springer, 61–83.

[3]

Zahra Aghazadeh, Wojciech M. Golab, and Philipp Woelfel. 2014. Making Objects Writable. In PODC. ACM, 385–395.

[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.

[5]

Dan Alistarh, William M. Leiserson, Alexander Matveev, and Nir Shavit. 2015. ThreadScan: Automatic and Scalable Memory Reclamation. In SPAA. ACM, 123–132.

[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.

[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.

[8]

Ralph-Johan Back. 1989. A Method for Refining Atomicity in Parallel Algorithms. In PARLE (LNCS), Vol. 366. Springer, 199–216.

[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.

[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.

[11]

Josh Berdine, Byron Cook, and Samin Ishtiaq. 2011. SLAyer: Memory Safety for Systems-Level Code. In CAV (LNCS), Vol. 6806. Springer, 178–183.

[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.

[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.

[14]

Kevin Bierhoff and Jonathan Aldrich. 2007. Modular Typestate Checking of Aliased Objects. In OOPSLA. ACM, 301–320.

[15]

Garrett Birkhoff. 1948. Lattice Theory (revised edition). American Mathematical Society.

[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.

[17]

Richard Bornat, Cristiano Calcagno, Peter W. O’Hearn, and Matthew J. Parkinson. 2005. Permission Accounting in Separation Logic. In POPL. ACM, 259–270.

[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.

[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.

[20]

John Boyland. 2003. Checking Interference with Fractional Permissions. In SAS (LNCS), Vol. 2694. Springer, 55–72.

[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.

[22]

Stephen D. Brookes. 2004. A Semantics for Concurrent Separation Logic. In CONCUR (LNCS), Vol. 3170. Springer, 16–34.

[23]

Trevor Alexander Brown. 2015. Reclaiming Memory for Lock-Free Data Structures: There has to be a Better Way. In PODC. ACM, 261–270.

[24]

Sebastian Burckhardt, Chris Dern, Madanlal Musuvathi, and Roy Tan. 2010. Line-up: A Complete and Automatic Linearizability Checker. In PLDI. ACM, 330–340.

[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.

[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.

[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.

[28]

Nachshon Cohen. 2018. Every Data Structure Deserves Lock-free Memory Reclamation. PACMPL 2, OOPSLA (2018), 143:1–143:24.

[29]

Nachshon Cohen and Erez Petrank. 2015a. Automatic Memory Reclamation for Lock-free Data Structures. In OOPSLA. ACM, 260–279.

[30]

Nachshon Cohen and Erez Petrank. 2015b. Efficient Memory Management for Lock-Free Data Structures with Optimistic Access. In SPAA. ACM, 254–263.

[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.

[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.

[33]

Mario Coppo and Mariangiola Dezani-Ciancaglini. 1978. A New Type Assignment for 𝜆-Terms. Arch. Math. Log. 19, 1 (1978), 139–156.

[34]

Karl Crary, David Walker, and J. Gregory Morrisett. 1999. Typed Memory Management in a Calculus of Capabilities. In POPL. ACM, 262–275.

[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.

[36]

Manuvir Das, Sorin Lerner, and Mark Seigle. 2002. ESP: Path-Sensitive Program Verification in Polynomial Time. In PLDI. ACM, 57–68.

[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.

[38]

Robert DeLine and Manuel Fähndrich. 2004. Typestates for Objects. In ECOOP (LNCS), Vol. 3086. Springer, 465–490.

[39]

John Derrick, Gerhard Schellhorn, and Heike Wehrheim. 2011. Mechanically Verified Proof Obligations for Linearizability. ToPLaS 33, 1 (2011), 4:1–4:43.

[40]

David Detlefs, Paul Alan Martin, Mark Moir, and Guy L. Steele Jr. 2001. Lock-free Reference Counting. In PODC. ACM, 190–199.

[41]

Dave Dice, Maurice Herlihy, and Alex Kogan. 2016. Fast Non-intrusive Memory Reclamation for Highly-concurrent Data Structures. In ISMM. ACM, 36–45.

[42]

Edsger W. Dijkstra. 1982. On Making Solutions More and More Fine-Grained. Springer New York, New York, NY, 292–307.

[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.

[44]

Mike Dodds, Xinyu Feng, Matthew J. Parkinson, and Viktor Vafeiadis. 2009. Deny-Guarantee Reasoning. In ESOP (LNCS), Vol. 5502. Springer, 363–377.

[45]

Mike Dodds, Andreas Haas, and Christoph M. Kirsch. 2015. A Scalable, Correct Time-Stamped Stack. In POPL. ACM, 233–246.

[46]

Thomas W. Doeppner, Jr. 1977. Parallel Program Correctness Through Refinement. In POPL. ACM, 155–169.

[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.

[48]

Simon Doherty and Mark Moir. 2009. Nonblocking Algorithms and Backward Simulation. In DISC (LNCS), Vol. 5805. Springer, 274–288.

[49]

Brijesh Dongol and John Derrick. 2015. Verifying Linearisability: A Comparative Survey. ACM Comput. Surv. 48 (2015).

[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.

[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.

[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.

[53]

Tayfun Elmas, Shaz Qadeer, and Serdar Tasiran. 2009. A Calculus of Atomic Actions. In POPL. ACM, 2–15.

[54]

Michael Emmi and Constantin Enea. 2018. Sound, Complete, and Tractable Linearizability Monitoring for Concurrent Collections. PACMPL 2, POPL (2018), 25:1–25:27.

[55]

Michael Emmi, Constantin Enea, and Jad Hamza. 2015. Monitoring Refinement via Symbolic Reasoning. In PLDI. ACM, 260–269.

[56]

Manuel Fähndrich and Robert DeLine. 2002. Adoption and Focus: Practical Linear Types for Imperative Programming. In PLDI. ACM, 13–24.

[57]

Xinyu Feng. 2009. Local Rely-guarantee Reasoning. In POPL. ACM, 315–327.

[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.

[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.

[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.

[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.

[62]

Cormac Flanagan and Shaz Qadeer. 2003. A Type and Effect System for Atomicity. In PLDI. ACM, 338–349.

[63]

Cormac Flanagan, Shaz Qadeer, and Sanjit A. Seshia. 2002. A Modular Checker for Multithreaded Programs. In CAV (LNCS), Vol. 2404. Springer, 180–194.

[64]

Jeffrey S. Foster, Tachio Terauchi, and Alexander Aiken. 2002. Flow-Sensitive Type Qualifiers. In PLDI. ACM, 1–12.

[65]

Keir Fraser. 2004. Practical Lock-freedom. Ph.D. Dissertation. University of Cambridge, UK. http://ethos.bl.uk/OrderDetails. do?uin=uk.bl.ethos.599193

[66]

Stephen N. Freund and Shaz Qadeer. 2004. Checking Concise Specifications for Multithreaded Software. Journal of Object Technology 3, 6 (2004), 81–101.

[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.

[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.

[69]

Alexey Gotsman, Noam Rinetzky, and Hongseok Yang. 2013. Verifying Concurrent Memory Reclamation Algorithms with Grace. In ESOP (LNCS), Vol. 7792. Springer, 249–269.

[70]

Erich Grädel, Wolfgang Thomas, and Thomas Wilke (Eds.). 2002. Automata, Logics, and Infinite Games. LNCS, Vol. 2500. Springer.

[71]

Lindsay Groves. 2007. Reasoning about Nonblocking Concurrency using Reduction. In ICECCS. IEEE, 107–116.

[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.html

[73]

Timothy L. Harris. 2001. A Pragmatic Implementation of Non-blocking Linked-Lists. In DISC (LNCS), Vol. 2180. Springer, 300–314.

[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.

[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.

[76]

Nir Hemed, Noam Rinetzky, and Viktor Vafeiadis. 2015. Modular Verification of Concurrency-Aware Linearizability. In DISC (LNCS), Vol. 9363. Springer, 371–387.

[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.

[78]

Thomas A. Henzinger, Ali Sezgin, and Viktor Vafeiadis. 2013. Aspect-Oriented Linearizability Proofs. In CONCUR (LNCS), Vol. 8052. Springer, 242–256.

[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.

[80]

Maurice Herlihy and Nir Shavit. 2008. The Art of Multiprocessor Programming. Morgan Kaufmann.

[81]

Maurice Herlihy and Jeannette M. Wing. 1990. Linearizability: A Correctness Condition for Concurrent Objects. ToPLaS 12, 3 (1990), 463–492.

[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.

[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.

[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.

[85]

Alex Horn and Daniel Kroening. 2015. Faster Linearizability Checking via P-Compositionality. In FORTE (LNCS), Vol. 9039. Springer, 50–65.

[86]

Sebastian Hunt and David Sands. 2006. On Flow-sensitive Security Types. In POPL. ACM, 79–90.

[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.html

[88]

Cliff B. Jones. 1983. Tentative Steps Toward a Development Method for Interfering Programs. ToPLaS 5, 4 (1983), 596–619.

[89]

Bengt Jonsson. 2012. Using refinement calculus techniques to prove linearizability. Formal Asp. Comput. 24, 4-6 (2012), 537–554.

[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.

[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.

[92]

Bernhard Kragl and Shaz Qadeer. 2018. Layered Concurrent Programs. In CAV (LNCS), Vol. 10981. Springer, 79–102.

[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.

[94]

Ismail Kuru and Colin S. Gordon. 2019. Safe Deferred Memory Reclamation with Types. In ESOP (LNCS), Vol. 11423. Springer, 88–116.

[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/

[96]

Vincent Laviron, Bor-Yuh Evan Chang, and Xavier Rival. 2010. Separating Shape Graphs. In ESOP (LNCS), Vol. 6012. Springer, 387–406.

[97]

Hongjin Liang and Xinyu Feng. 2013. Modular Verification of Linearizability with Non-fixed Linearization Points. In PLDI. ACM, 459–470.

[98]

Hongjin Liang, Xinyu Feng, and Ming Fu. 2012. A Rely-guarantee-based Simulation for Verifying Concurrent Program Transformations. In POPL. ACM, 455–468.

[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.

[100]

Richard J. Lipton. 1975. Reduction: A Method of Proving Properties of Parallel Programs. CACM 18, 12 (1975), 717–721.

[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.

[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.

[103]

Gavin Lowe. 2017. Testing for linearizability. Concurrency and Computation: Practice and Experience 29, 4 (2017).

[104]

Paul E. McKenney and John D. Slingwine. 1998. Read-copy Update: Using Execution History to Solve Concurrency Problems.

[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.

[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.11714

[107]

Maged M. Michael. 2002a. High Performance Dynamic Lock-free Hash Tables and List-based Sets. In SPAA. ACM, 73–82.

[108]

Maged M. Michael. 2002b. Safe Memory Reclamation for Dynamic Lock-free Objects Using Atomic Reads and Writes. In PODC. ACM, 21–30.

[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.

[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.

[111]

George C. Necula, Scott McPeak, and Westley Weimer. 2002. CCured: Type-safe Retrofitting of Legacy Code. In POPL. ACM, 128–139.

[112]

Ruslan Nikolaev and Binoy Ravindran. 2019. Hyaline: Fast and Transparent Lock-Free Memory Reclamation. In PODC. ACM, 419–421.

[113]

Peter W. O’Hearn. 2004. Resources, Concurrency and Local Reasoning. In CONCUR (LNCS), Vol. 3170. Springer, 49–67.

[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.

[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.

[116]

Susan S. Owicki and David Gries. 1976. An Axiomatic Proof Technique for Parallel Programs I. Acta Inf. 6 (1976), 319–340.

[117]

Matthew J. Parkinson, Richard Bornat, and Peter W. O’Hearn. 2007. Modular Verification of a Non-blocking Stack. In POPL. ACM, 297–302.

[118]

Benjamin C. Pierce. 2002. Types and programming languages. MIT Press.

[119]

Pedro Ramalhete and Andreia Correia. 2017. Brief Announcement: Hazard Eras - Non-Blocking Memory Reclamation. In SPAA. ACM, 367–369.

[120]

John C. Reynolds. 2002. Separation Logic: A Logic for Shared Mutable Data Structures. In LICS. IEEE, 55–74.

[121]

Gerhard Schellhorn, Heike Wehrheim, and John Derrick. 2012. How to Prove Algorithms Linearisable. In CAV (LNCS), Vol. 7358. Springer, 243–259.

[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.

[123]

Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2015a. Mechanized Verification of Fine-grained Concurrent Programs. In PLDI. ACM, 77–87.

[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.

[125]

Divjyot Sethi, Muralidhar Talupur, and Sharad Malik. 2013. Model Checking Unbounded Concurrent Lists. In SPIN (LNCS), Vol. 7976. Springer, 320–340.

[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.

[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.

[128]

Kasper Svendsen and Lars Birkedal. 2014. Impredicative Concurrent Abstract Predicates. In ESOP (LNCS), Vol. 8410. Springer, 149–168.

[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.

[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.

[131]

R. Kent Treiber. 1986. Systems Programming: Coping with Parallelism. Technical Report RJ 5118. IBM.

[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.

[133]

Aaron Turon, Viktor Vafeiadis, and Derek Dreyer. 2014. GPS: Navigating Weak Memory with Ghosts, Protocols, and Separation. In OOPSLA. ACM, 691–707.

[134]

Viktor Vafeiadis. 2009. Shape-Value Abstraction for Verifying Linearizability. In VMCAI (LNCS), Vol. 5403. Springer, 335–348.

[135]

Viktor Vafeiadis. 2010a. Automatically Proving Linearizability. In CAV (LNCS), Vol. 6174. Springer, 450–464.

[136]

Viktor Vafeiadis. 2010b. RGSep Action Inference. In VMCAI (LNCS), Vol. 5944. Springer, 345–361.

[137]

Viktor Vafeiadis and Matthew J. Parkinson. 2007. A Marriage of Rely/Guarantee and Separation Logic. In CONCUR (LNCS), Vol. 4703. Springer, 256–271.

[138]

Martin T. Vechev and Eran Yahav. 2008. Deriving Linearizable Fine-grained Concurrent Objects. In PLDI. ACM, 125–135.

[139]

Martin T. Vechev, Eran Yahav, and Greta Yorsh. 2009. Experience with Model Checking Linearizability. In SPIN (LNCS), Vol. 5578. Springer, 261–278.

[140]

Haosen Wen, Joseph Izraelevitz, Wentao Cai, H. Alan Beadle, and Michael L. Scott. 2018. Interval-based Memory Reclamation. In PPOPP. ACM, 1–13.

[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.

[142]

Albert Mingkun Yang and Tobias Wrigstad. 2017. Type-assisted Automatic Garbage Collection for Lock-free Data Structures. In ISMM. ACM, 14–24.

[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.

[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.06104

[145]

Shao Jie Zhang. 2011. Scalable Automatic Linearizability Checking. In ICSE. ACM, 1185–1187.

[146]

He Zhu, Gustavo Petri, and Suresh Jagannathan. 2015. Poling: SMT Aided Linearizability Proofs. In CAV (LNCS), Vol. 9207. Springer, 3–19.

Cited By

Bastidas Fuertes APérez MMeza Hormaza J(2023)Transpilers: A Systematic Mapping Review of Their Usage in Research and IndustryApplied Sciences10.3390/app1306366713:6(3667)Online publication date: 13-Mar-2023
https://doi.org/10.3390/app13063667
Jung JLee JChoi JKim JPark SKang J(2023)Modular Verification of Safe Memory Reclamation in Concurrent Separation LogicProceedings of the ACM on Programming Languages10.1145/36228277:OOPSLA2(828-856)Online publication date: 16-Oct-2023
https://dl.acm.org/doi/10.1145/3622827
Meyer RWies TWolff S(2022)A concurrent program logic with a future and historyProceedings of the ACM on Programming Languages10.1145/35633376:OOPSLA2(1378-1407)Online publication date: 31-Oct-2022
https://dl.acm.org/doi/10.1145/3563337
Show More Cited By

Index Terms

Recommendations

A marriage of pointer- and epoch-based reclamation
PLDI 2020: Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation

All pointer-based nonblocking concurrent data structures should deal with the problem of safe memory reclamation: before reclaiming a memory block, a thread should ensure no other threads hold a local pointer to the block that may later be dereferenced. ...
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 ...

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages

Proceedings of the ACM on Programming Languages Volume 4, Issue POPL

January 2020

1984 pages

EISSN:2475-1421

DOI:10.1145/3377388

Issue’s Table of Contents

Copyright © 2019 Owner/Author.

This work is licensed under a Creative Commons Attribution International 4.0 License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 20 December 2019

Published in PACMPL Volume 4, Issue POPL

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Badges

Author Tags

Qualifiers

Research-article

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

5
Total Citations
View Citations
828
Total Downloads

Downloads (Last 12 months)121
Downloads (Last 6 weeks)18

Reflects downloads up to 26 Jan 2025

Other Metrics

View Author Metrics

Citations

Cited By

Bastidas Fuertes APérez MMeza Hormaza J(2023)Transpilers: A Systematic Mapping Review of Their Usage in Research and IndustryApplied Sciences10.3390/app1306366713:6(3667)Online publication date: 13-Mar-2023
https://doi.org/10.3390/app13063667
Jung JLee JChoi JKim JPark SKang J(2023)Modular Verification of Safe Memory Reclamation in Concurrent Separation LogicProceedings of the ACM on Programming Languages10.1145/36228277:OOPSLA2(828-856)Online publication date: 16-Oct-2023
https://dl.acm.org/doi/10.1145/3622827
Meyer RWies TWolff S(2022)A concurrent program logic with a future and historyProceedings of the ACM on Programming Languages10.1145/35633376:OOPSLA2(1378-1407)Online publication date: 31-Oct-2022
https://dl.acm.org/doi/10.1145/3563337
Haas TMeyer RPonce de León H(2022)CAAT: consistency as a theoryProceedings of the ACM on Programming Languages10.1145/35632926:OOPSLA2(114-144)Online publication date: 31-Oct-2022
https://dl.acm.org/doi/10.1145/3563292
Kang JJung JDonaldson ATorlak E(2020)A marriage of pointer- and epoch-based reclamationProceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation10.1145/3385412.3385978(314-328)Online publication date: 11-Jun-2020
https://dl.acm.org/doi/10.1145/3385412.3385978

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Login options

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

Full Access

Get this Article

Figures

Tables

Media

View Issue’s Table of Contents