Abstract
Visibility relations have been proposed by Henzinger et al. as an abstraction for proving linearizability of concurrent algorithms that obtains modular and reusable proofs. This is in contrast to the customary approach based on exhibiting the algorithm's linearization points. In this paper we apply visibility relations to develop modular proofs for three elegant concurrent snapshot algorithms of Jayanti. The proofs are divided by signatures into components of increasing level of abstraction; the components at higher abstraction levels are shared, i.e., they apply to all three algorithms simultaneously. Importantly, the interface properties mathematically capture Jayanti's original intuitions that have previously been given only informally.
Supplemental Material
Available for Download
Appendices to the paper.
- Martín Abadi and Leslie Lamport. 1991. The existence of refinement mappings. Theoretical Computer Science, 82, 2 (1991), 253–284. https://doi.org/10.1016/0304-3975(91)90224-P Google Scholar
Digital Library
- Yehuda Afek, Hagit Attiya, Danny Dolev, Eli Gafni, Michael Merritt, and Nir Shavit. 1993. Atomic snapshots of shared memory. J. ACM, 40, 4 (1993), Sept., 873–890. issn:0004-5411 https://doi.org/10.1145/153724.153741 Google Scholar
Digital Library
- Ahmed Bouajjani, Michael Emmi, Constantin Enea, and Suha Orhun Mutluergil. 2017. Proving linearizability using forward simulations. In Computer-Aided Verification (CAV) (LNCS, Vol. 10427). 542–563. https://doi.org/10.1007/978-3-319-63390-9_28 Google Scholar
Cross Ref
- Soham Chakraborty, Thomas A. Henzinger, Ali Sezgin, and Viktor Vafeiadis. 2015. Aspect-oriented linearizability proofs. Logical Methods in Computer Science, Volume 11, Issue 1 (2015), https://doi.org/10.2168/LMCS-11(1:20)2015 Google Scholar
Cross Ref
- Germán Andrés Delbianco, Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2017. Concurrent Data Structures Linked in Time. In European Conference on Object-Oriented Programming, ECOOP (LIPIcs, Vol. 74). 8:1–8:30. https://doi.org/10.4230/LIPIcs.ECOOP.2017.8 Google Scholar
Cross Ref
- Mike Dodds, Andreas Haas, and Christoph M. Kirsch. 2015. A scalable, correct time-stamped stack. In Symposium on Principles of Programming Languages (POPL). 233–246. isbn:978-1-4503-3300-9 https://doi.org/10.1145/2676726.2676963 Google Scholar
Digital Library
- Michael Emmi and Constantin Enea. 2019. Weak-consistency specification via visibility relaxation. Proc. ACM Program. Lang., 3, POPL (2019), 60:1–60:28. https://doi.org/10.1145/3290373 Google Scholar
Digital Library
- Stefan Felsner. 1992. Interval orders: combinatorial structure and algorithms. Ph.D. Dissertation. Technical University of Berlin. http://page.math.tu-berlin.de/~felsner/Paper/diss.pdfGoogle Scholar
- Thomas A. Henzinger, Ali Sezgin, and Viktor Vafeiadis. 2013. Aspect-oriented linearizability proofs. In International Conference on Concurrency Theory (CONCUR). 242–256. isbn:978-3-642-40184-8 https://doi.org/10.1007/978-3-642-40184-8_18 Google Scholar
Digital Library
- Maurice Herlihy and Nir Shavit. 2008. The art of multiprocessor programming. M. Kaufmann. https://doi.org/10.1108/03684920810907904 Google Scholar
Cross Ref
- Maurice P. Herlihy and Jeannette M. Wing. 1990. Linearizability: a correctness condition for concurrent objects. ACM Trans. Program. Lang. Syst., 12, 3 (1990), 463–492. issn:0164-0925 https://doi.org/10.1145/78969.78972 Google Scholar
Digital Library
- Bart Jacobs. 2018. Jayanti’s algorithm using prophecies in VeriFast. https://github.com/verifast/verifast/blob/master/examples/jayantiGoogle Scholar
- Bart Jacobs, Willem Penninckx, and Amin Timany. 2018. Abstract I/O specification. Department Of Computer Science KU Leuven. https://lirias.kuleuven.be/2088062Google Scholar
- Prasad Jayanti. 2005. An optimal multi-writer snapshot algorithm. In Symposium on Theory of Computing (STOC ’05). 723–732. isbn:1-58113-960-8 https://doi.org/10.1145/1060590.1060697 Google Scholar
Digital Library
- Prasad Jayanti and Srdjan Petrovic. 2005. Efficient wait-free implementation of multiword LL/SC variables. In International Conference on Distributed Computing Systems (ICDCS). 59–68. https://doi.org/10.1109/ICDCS.2005.29 Google Scholar
Digital Library
- Eric H Jensen, Gary W Hagensen, and Jeffrey M Broughton. 1987. A new approach to exclusive data access in shared memory multiprocessors. Lawrence Livermore National Laboratory. https://llnl.primo.exlibrisgroup.com/permalink/01LLNL_INST/1g1o79t/alma991001081569706316Google Scholar
- Ralf Jung, Rodolphe Lepigre, Gaurav Parthasarathy, Marianna Rapoport, Amin Timany, Derek Dreyer, and Bart Jacobs. 2020. The future is ours: prophecy variables in separation logic. Proc. ACM Program. Lang., 4, POPL (2020), 45:1–45:32. https://doi.org/10.1145/3371113 Google Scholar
Digital Library
- Siddharth Krishna, Michael Emmi, Constantin Enea, and Dejan Jovanovic. 2020. Verifying visibility-based weak consistency. In European Symposium on Programming (ESOP) (LNCS, Vol. 12075). 280–307. https://doi.org/10.1007/978-3-030-44914-8_11 Google Scholar
Digital Library
- Nancy A. Lynch and Frits W. Vaandrager. 1995. Forward and Backward Simulations: I. Untimed Systems. Inf. Comput., 121, 2 (1995), 214–233. https://doi.org/10.1006/inco.1995.1134 Google Scholar
Digital Library
- Erez Petrank and Shahar Timnat. 2013. Lock-free data-structure iterators. In International Symposium on Distributed Computing (DISC). 224–238. isbn:978-3-642-41527-2 https://doi.org/10.1007/978-3-642-41527-2_16 Google Scholar
Digital Library
- Azalea Raad, Marko Doko, Lovro Rožić, Ori Lahav, and Viktor Vafeiadis. 2019. On library correctness under weak memory consistency: specifying and verifying concurrent libraries under declarative consistency models. Proc. ACM Program. Lang., 3, POPL (2019), Article 68, https://doi.org/10.1145/3290381 Google Scholar
Digital Library
- Shahar Timnat. 2015. Practical parallel data structures. Ph.D. Dissertation. Computer Science Department, Technion. http://www.cs.technion.ac.il/users/wwwb/cgi-bin/tr-info.cgi/2015/PHD/PHD-2015-06Google Scholar
- Paolo Viotti and Marko Vukolić. 2016. Consistency in non-transactional distributed storage systems. ACM Comput. Surv., 49, 1 (2016), Article 19, issn:0360-0300 https://doi.org/10.1145/2926965 Google Scholar
Digital Library
Index Terms
Visibility reasoning for concurrent snapshot algorithms
Recommendations
Looking for efficient implementations of concurrent objects
PaCT'11: Proceedings of the 11th international conference on Parallel computing technologiesAs introduced by Taubenfeld, a contention-sensitive implementation of a concurrent object is an implementation such that the overhead introduced by locking is eliminated in the common cases, i.e., when there is no contention or when the operations ...
On the implementation of concurrent objects
Dependable and Historic ComputingThe implementation of objects shared by concurrent processes, with provable safety and liveness guarantees, is a fundamental issue of concurrent programming in shared memory systems. It is now largely accepted that linearizability (or atomicity) is an ...
A Sound and Complete Proof Technique for Linearizability of Concurrent Data Structures
Efficient implementations of data structures such as queues, stacks or hash-tables allow for concurrent access by many processes at the same time. To increase concurrency, these algorithms often completely dispose with locking, or only lock small parts ...






Comments