skip to main content

Verifying concurrent multicopy search structures

Published:15 October 2021Publication History
Skip Abstract Section

Abstract

Multicopy search structures such as log-structured merge (LSM) trees are optimized for high insert/update/delete (collectively known as upsert) performance. In such data structures, an upsert on key k, which adds (k,v) where v can be a value or a tombstone, is added to the root node even if k is already present in other nodes. Thus there may be multiple copies of k in the search structure. A search on k aims to return the value associated with the most recent upsert. We present a general framework for verifying linearizability of concurrent multicopy search structures that abstracts from the underlying representation of the data structure in memory, enabling proof-reuse across diverse implementations. Based on our framework, we propose template algorithms for (a) LSM structures forming arbitrary directed acyclic graphs and (b) differential file structures, and formally verify these templates in the concurrent separation logic Iris. We also instantiate the LSM template to obtain the first verified concurrent in-memory LSM tree implementation.

Skip Supplemental Material Section

Supplemental Material

Auxiliary Presentation Video

Multicopy search structures such as log-structured merge (LSM) trees are optimized for high insert/update/delete (collectively known as upsert) performance. In such data structures, an upsert on key k, which adds (k,v) where v can be a value or a tombstone, is added to the root node even if k is already present in other nodes. A search on k aims to return the value associated with the most recent upsert. We present a general framework for verifying linearizability of concurrent multicopy search structures that abstracts from the underlying representation of the data structure in memory, enabling proof-reuse across diverse implementations. Based on our framework, we propose template algorithms for (a) LSM structures forming arbitrary directed acyclic graphs and (b) differential file structures, and formally verify these templates in the concurrent separation logic Iris. We also instantiate the LSM template to obtain the first verified concurrent in-memory LSM tree implementation.

References

  1. Martín Abadi and Leslie Lamport. 1988. The Existence of Refinement Mappings. In Proceedings of the Third Annual Symposium on Logic in Computer Science (LICS ’88), Edinburgh, Scotland, UK, July 5-8, 1988. IEEE Computer Society, 165–175. https://doi.org/10.1109/LICS.1988.5115 Google ScholarGoogle ScholarCross RefCross Ref
  2. 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 Tools and Algorithms for the Construction and Analysis of Systems - 19th International Conference, TACAS 2013, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2013, Rome, Italy, March 16-24, 2013. Proceedings, Nir Piterman and Scott A. Smolka (Eds.) (Lecture Notes in Computer Science, Vol. 7795). Springer, 324–338. https://doi.org/10.1007/978-3-642-36742-7_23 Google ScholarGoogle ScholarDigital LibraryDigital Library
  3. Parosh Aziz Abdulla, Bengt Jonsson, and Cong Quy Trinh. 2018. Fragment Abstraction for Concurrent Shape Analysis. In Programming Languages and Systems - 27th European Symposium on Programming, ESOP 2018, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2018, Thessaloniki, Greece, April 14-20, 2018, Proceedings, Amal Ahmed (Ed.) (Lecture Notes in Computer Science, Vol. 10801). Springer, 442–471. https://doi.org/10.1007/978-3-319-89884-1_16 Google ScholarGoogle ScholarCross RefCross Ref
  4. Daphna Amit, Noam Rinetzky, Thomas W. Reps, Mooly Sagiv, and Eran Yahav. 2007. Comparison Under Abstraction for Verifying Linearizability. In Computer Aided Verification, 19th International Conference, CAV 2007, Berlin, Germany, July 3-7, 2007, Proceedings, Werner Damm and Holger Hermanns (Eds.) (Lecture Notes in Computer Science, Vol. 4590). Springer, 477–490. https://doi.org/10.1007/978-3-540-73368-3_49 Google ScholarGoogle ScholarDigital LibraryDigital Library
  5. Apache Software Foundation. 2021. Apache Cassandra. https://cassandra.apache.org/ Last accessed on August 12, 2021.Google ScholarGoogle Scholar
  6. Maya Arbel and Hagit Attiya. 2014. Concurrent updates with RCU: search tree as an example. In ACM Symposium on Principles of Distributed Computing, PODC ’14, Paris, France, July 15-18, 2014, Magnús M. Halldórsson and Shlomi Dolev (Eds.). ACM, 196–205. https://doi.org/10.1145/2611462.2611471 Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. Anindya Banerjee, David A. Naumann, and Mohammad Nikouei. 2016. Relational Logic with Framing and Hypotheses. In 36th IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science, FSTTCS 2016, December 13-15, 2016, Chennai, India, Akash Lal, S. Akshay, Saket Saurabh, and Sandeep Sen (Eds.) (LIPIcs, Vol. 65). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 11:1–11:16. https://doi.org/10.4230/LIPIcs.FSTTCS.2016.11 Google ScholarGoogle ScholarCross RefCross Ref
  8. James Bornholt, Antoine Kaufmann, Jialin Li, Arvind Krishnamurthy, Emina Torlak, and Xi Wang. 2016. Specifying and Checking File System Crash-Consistency Models. In Proceedings of the Twenty-First International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2016, Atlanta, GA, USA, April 2-6, 2016, Tom Conte and Yuanyuan Zhou (Eds.). ACM, 83–98. https://doi.org/10.1145/2872362.2872406 Google ScholarGoogle ScholarDigital LibraryDigital Library
  9. Ahmed Bouajjani, Michael Emmi, Constantin Enea, and Jad Hamza. 2013. Verifying Concurrent Programs against Sequential Specifications. In Programming Languages and Systems - 22nd European Symposium on Programming, ESOP 2013, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2013, Rome, Italy, March 16-24, 2013. Proceedings, Matthias Felleisen and Philippa Gardner (Eds.) (Lecture Notes in Computer Science, Vol. 7792). Springer, 290–309. https://doi.org/10.1007/978-3-642-37036-6_17 Google ScholarGoogle ScholarDigital LibraryDigital Library
  10. Ahmed Bouajjani, Michael Emmi, Constantin Enea, and Jad Hamza. 2015. On Reducing Linearizability to State Reachability. In Automata, Languages, and Programming - 42nd International Colloquium, ICALP 2015, Kyoto, Japan, July 6-10, 2015, Proceedings, Part II, Magnús M. Halldórsson, Kazuo Iwama, Naoki Kobayashi, and Bettina Speckmann (Eds.) (Lecture Notes in Computer Science, Vol. 9135). Springer, 95–107. https://doi.org/10.1007/978-3-662-47666-6_8 Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. Ahmed Bouajjani, Michael Emmi, Constantin Enea, and Suha Orhun Mutluergil. 2017. Proving Linearizability Using Forward Simulations. In Computer Aided Verification - 29th International Conference, CAV 2017, Heidelberg, Germany, July 24-28, 2017, Proceedings, Part II, Rupak Majumdar and Viktor Kuncak (Eds.) (Lecture Notes in Computer Science, Vol. 10427). Springer, 542–563. https://doi.org/10.1007/978-3-319-63390-9_28 Google ScholarGoogle ScholarCross RefCross Ref
  12. Pavol Cerný, Arjun Radhakrishna, Damien Zufferey, Swarat Chaudhuri, and Rajeev Alur. 2010. Model Checking of Linearizability of Concurrent List Implementations. In Computer Aided Verification, 22nd International Conference, CAV 2010, Edinburgh, UK, July 15-19, 2010. Proceedings, Tayssir Touili, Byron Cook, and Paul B. Jackson (Eds.) (Lecture Notes in Computer Science, Vol. 6174). Springer, 465–479. https://doi.org/10.1007/978-3-642-14295-6_41 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Haogang Chen, Tej Chajed, Alex Konradi, Stephanie Wang, Atalay Mert Ileri, Adam Chlipala, M. Frans Kaashoek, and Nickolai Zeldovich. 2017. Verifying a high-performance crash-safe file system using a tree specification. In Proceedings of the 26th Symposium on Operating Systems Principles, Shanghai, China, October 28-31, 2017. ACM, 270–286. https://doi.org/10.1145/3132747.3132776 Google ScholarGoogle ScholarDigital LibraryDigital Library
  14. Haogang Chen, Daniel Ziegler, Tej Chajed, Adam Chlipala, M. Frans Kaashoek, and Nickolai Zeldovich. 2015. Using Crash Hoare logic for certifying the FSCQ file system. In Proceedings of the 25th Symposium on Operating Systems Principles, SOSP 2015, Monterey, CA, USA, October 4-7, 2015, Ethan L. Miller and Steven Hand (Eds.). ACM, 18–37. https://doi.org/10.1145/2815400.2815402 Google ScholarGoogle ScholarDigital LibraryDigital Library
  15. Sagar Chordia, Sriram K. Rajamani, Kaushik Rajan, Ganesan Ramalingam, and Kapil Vaswani. 2013. Asynchronous Resilient Linearizability. In Distributed Computing - 27th International Symposium, DISC 2013, Jerusalem, Israel, October 14-18, 2013. Proceedings, Yehuda Afek (Ed.) (Lecture Notes in Computer Science, Vol. 8205). Springer, 164–178. https://doi.org/10.1007/978-3-642-41527-2_12 Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. Pedro da Rocha Pinto, Thomas Dinsdale-Young, and Philippa Gardner. 2014. TaDA: A Logic for Time and Data Abstraction. In ECOOP 2014 - Object-Oriented Programming - 28th European Conference, Uppsala, Sweden, July 28 - August 1, 2014. Proceedings, Richard E. Jones (Ed.) (Lecture Notes in Computer Science, Vol. 8586). Springer, 207–231. https://doi.org/10.1007/978-3-662-44202-9_9 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Niv Dayan and Stratos Idreos. 2018. Dostoevsky: Better Space-Time Trade-Offs for LSM-Tree Based Key-Value Stores via Adaptive Removal of Superfluous Merging. In Proceedings of the 2018 International Conference on Management of Data, SIGMOD Conference 2018, Houston, TX, USA, June 10-15, 2018, Gautam Das, Christopher M. Jermaine, and Philip A. Bernstein (Eds.). ACM, 505–520. https://doi.org/10.1145/3183713.3196927 Google ScholarGoogle ScholarDigital LibraryDigital Library
  18. Germán Andrés Delbianco, Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2017. Concurrent Data Structures Linked in Time. In 31st European Conference on Object-Oriented Programming, ECOOP 2017, June 19-23, 2017, Barcelona, Spain, Peter Müller (Ed.) (LIPIcs, Vol. 74). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 8:1–8:30. https://doi.org/10.4230/LIPIcs.ECOOP.2017.8 Google ScholarGoogle ScholarCross RefCross Ref
  19. Thomas Dinsdale-Young, Lars Birkedal, Philippa Gardner, Matthew J. Parkinson, and Hongseok Yang. 2013. Views: compositional reasoning for concurrent programs. In The 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL ’13, Rome, Italy - January 23 - 25, 2013, Roberto Giacobazzi and Radhia Cousot (Eds.). ACM, 287–300. https://doi.org/10.1145/2429069.2429104 Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Dana Drachsler-Cohen, Martin T. Vechev, and Eran Yahav. 2018. Practical concurrent traversals in search trees. In Proceedings of the 23rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP 2018, Vienna, Austria, February 24-28, 2018, Andreas Krall and Thomas R. Gross (Eds.). ACM, 207–218. https://doi.org/10.1145/3178487.3178503 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Cezara Dragoi, Ashutosh Gupta, and Thomas A. Henzinger. 2013. Automatic Linearizability Proofs of Concurrent Objects with Cooperating Updates. In Computer Aided Verification - 25th International Conference, CAV 2013, Saint Petersburg, Russia, July 13-19, 2013. Proceedings, Natasha Sharygina and Helmut Veith (Eds.) (Lecture Notes in Computer Science, Vol. 8044). Springer, 174–190. https://doi.org/10.1007/978-3-642-39799-8_11 Google ScholarGoogle ScholarCross RefCross Ref
  22. Tayfun Elmas, Shaz Qadeer, Ali Sezgin, Omer Subasi, and Serdar Tasiran. 2010. Simplifying Linearizability Proofs with Reduction and Abstraction. In Tools and Algorithms for the Construction and Analysis of Systems, 16th International Conference, TACAS 2010, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2010, Paphos, Cyprus, March 20-28, 2010. Proceedings, Javier Esparza and Rupak Majumdar (Eds.) (Lecture Notes in Computer Science, Vol. 6015). Springer, 296–311. https://doi.org/10.1007/978-3-642-12002-2_25 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Manuel Fahndrich and Rustan Leino. 2003. Heap Monotonic Typestate. In Proceedings of the first International Workshop on Alias Confinement and Ownership (IWACO) (proceedings of the first international workshop on alias confinement and ownership (iwaco) ed.). https://www.microsoft.com/en-us/research/publication/heap-monotonic-typestate/Google ScholarGoogle Scholar
  24. Yotam M. Y. Feldman, Constantin Enea, Adam Morrison, Noam Rinetzky, and Sharon Shoham. 2018. Order out of Chaos: Proving Linearizability Using Local Views. In 32nd International Symposium on Distributed Computing, DISC 2018, New Orleans, LA, USA, October 15-19, 2018, Ulrich Schmid and Josef Widder (Eds.) (LIPIcs, Vol. 121). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 23:1–23:21. https://doi.org/10.4230/LIPIcs.DISC.2018.23 Google ScholarGoogle ScholarCross RefCross Ref
  25. Yotam M. Y. Feldman, Artem Khyzha, Constantin Enea, Adam Morrison, Aleksandar Nanevski, Noam Rinetzky, and Sharon Shoham. 2020. Proving highly-concurrent traversals correct. Proc. ACM Program. Lang., 4, OOPSLA (2020), 128:1–128:29. https://doi.org/10.1145/3428196 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Dan Frumin, Robbert Krebbers, and Lars Birkedal. 2018. ReLoC: A Mechanised Relational Logic for Fine-Grained Concurrency. In Proceedings of the 33rd Annual ACM/IEEE Symposium on Logic in Computer Science, LICS 2018, Oxford, UK, July 09-12, 2018, Anuj Dawar and Erich Grädel (Eds.). ACM, 442–451. https://doi.org/10.1145/3209108.3209174 Google ScholarGoogle ScholarDigital LibraryDigital Library
  27. Dan Frumin, Robbert Krebbers, and Lars Birkedal. 2020. ReLoC Reloaded: A Mechanized Relational Logic for Fine-Grained Concurrency and Logical Atomicity. CoRR, abs/2006.13635 (2020), arxiv:2006.13635. arxiv:2006.13635Google ScholarGoogle Scholar
  28. Ming Fu, Yong Li, Xinyu Feng, Zhong Shao, and Yu Zhang. 2010. Reasoning about Optimistic Concurrency Using a Program Logic for History. In CONCUR 2010 - Concurrency Theory, 21th International Conference, CONCUR 2010, Paris, France, August 31-September 3, 2010. Proceedings, Paul Gastin and François Laroussinie (Eds.) (Lecture Notes in Computer Science, Vol. 6269). Springer, 388–402. https://doi.org/10.1007/978-3-642-15375-4_27 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Philippa Gardner, Azalea Raad, Mark J. Wheelhouse, and Adam Wright. 2014. Abstract Local Reasoning for Concurrent Libraries: Mind the Gap. In Proceedings of the 30th Conference on the Mathematical Foundations of Programming Semantics, MFPS 2014, Ithaca, NY, USA, June 12-15, 2014, Bart Jacobs, Alexandra Silva, and Sam Staton (Eds.) (Electronic Notes in Theoretical Computer Science, Vol. 308). Elsevier, 147–166. https://doi.org/10.1016/j.entcs.2014.10.009 Google ScholarGoogle ScholarDigital LibraryDigital Library
  30. Google. 2021. LevelDB. https://github.com/google/leveldb Last accessed on August 12, 2021.Google ScholarGoogle Scholar
  31. Alexey Gotsman, Noam Rinetzky, and Hongseok Yang. 2013. Verifying Concurrent Memory Reclamation Algorithms with Grace. In Programming Languages and Systems - 22nd European Symposium on Programming, ESOP 2013, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2013, Rome, Italy, March 16-24, 2013. Proceedings, Matthias Felleisen and Philippa Gardner (Eds.) (Lecture Notes in Computer Science, Vol. 7792). Springer, 249–269. https://doi.org/10.1007/978-3-642-37036-6_15 Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. Thomas A. Henzinger, Ali Sezgin, and Viktor Vafeiadis. 2013. Aspect-Oriented Linearizability Proofs. In CONCUR 2013 - Concurrency Theory - 24th International Conference, CONCUR 2013, Buenos Aires, Argentina, August 27-30, 2013. Proceedings, Pedro R. D’Argenio and Hernán C. Melgratti (Eds.) (Lecture Notes in Computer Science, Vol. 8052). Springer, 242–256. https://doi.org/10.1007/978-3-642-40184-8_18 Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Maurice Herlihy and J. D. Tygar. 1987. How to Make Replicated Data Secure. In Advances in Cryptology - CRYPTO ’87, A Conference on the Theory and Applications of Cryptographic Techniques, Santa Barbara, California, USA, August 16-20, 1987, Proceedings, Carl Pomerance (Ed.) (Lecture Notes in Computer Science, Vol. 293). Springer, 379–391. https://doi.org/10.1007/3-540-48184-2_33 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. Maurice Herlihy and Jeannette M. Wing. 1990. Linearizability: A Correctness Condition for Concurrent Objects. ACM Trans. Program. Lang. Syst., 12, 3 (1990), 463–492. https://doi.org/10.1145/78969.78972 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Bart Jacobs and Frank Piessens. 2011. Expressive modular fine-grained concurrency specification. In Proceedings of the 38th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2011, Austin, TX, USA, January 26-28, 2011, Thomas Ball and Mooly Sagiv (Eds.). ACM, 271–282. https://doi.org/10.1145/1926385.1926417 Google ScholarGoogle ScholarDigital LibraryDigital Library
  36. Jonas Braband Jensen and Lars Birkedal. 2012. Fictional Separation Logic. In Programming Languages and Systems - 21st European Symposium on Programming, ESOP 2012, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2012, Tallinn, Estonia, March 24 - April 1, 2012. Proceedings, Helmut Seidl (Ed.) (Lecture Notes in Computer Science, Vol. 7211). Springer, 377–396. https://doi.org/10.1007/978-3-642-28869-2_19 Google ScholarGoogle ScholarDigital LibraryDigital Library
  37. Jonathan Ellis. 2011. Leveled Compaction in Apache Cassandra. https://www.datastax.com/blog/2011/10/leveled-compaction-apache-cassandra Last accessed on August 12, 2021.Google ScholarGoogle Scholar
  38. Cliff B. Jones. 1983. Specification and Design of (Parallel) Programs. In Information Processing 83, Proceedings of the IFIP 9th World Computer Congress, Paris, France, September 19-23, 1983, R. E. A. Mason (Ed.). North-Holland/IFIP, 321–332.Google ScholarGoogle Scholar
  39. Ralf Jung, Robbert Krebbers, Jacques-Henri Jourdan, Ales Bizjak, Lars Birkedal, and Derek Dreyer. 2018. Iris from the ground up: A modular foundation for higher-order concurrent separation logic. J. Funct. Program., 28 (2018), e20. https://doi.org/10.1017/S0956796818000151 Google ScholarGoogle ScholarCross RefCross Ref
  40. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  41. 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 Proceedings of the 42nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2015, Mumbai, India, January 15-17, 2015, Sriram K. Rajamani and David Walker (Eds.). ACM, 637–650. https://doi.org/10.1145/2676726.2676980 Google ScholarGoogle ScholarDigital LibraryDigital Library
  42. Gowtham Kaki, Kartik Nagar, Mahsa Najafzadeh, and Suresh Jagannathan. 2018. Alone together: compositional reasoning and inference for weak isolation. Proc. ACM Program. Lang., 2, POPL (2018), 27:1–27:34. https://doi.org/10.1145/3158115 Google ScholarGoogle ScholarDigital LibraryDigital Library
  43. Artem Khyzha, Mike Dodds, Alexey Gotsman, and Matthew J. Parkinson. 2017. Proving Linearizability Using Partial Orders. In Programming Languages and Systems - 26th European Symposium on Programming, ESOP 2017, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2017, Uppsala, Sweden, April 22-29, 2017, Proceedings, Hongseok Yang (Ed.) (Lecture Notes in Computer Science, Vol. 10201). Springer, 639–667. https://doi.org/10.1007/978-3-662-54434-1_24 Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. Bernhard Kragl and Shaz Qadeer. 2018. Layered Concurrent Programs. In Computer Aided Verification - 30th International Conference, CAV 2018, Held as Part of the Federated Logic Conference, FloC 2018, Oxford, UK, July 14-17, 2018, Proceedings, Part I, Hana Chockler and Georg Weissenbacher (Eds.) (Lecture Notes in Computer Science, Vol. 10981). Springer, 79–102. https://doi.org/10.1007/978-3-319-96145-3_5 Google ScholarGoogle Scholar
  45. Bernhard Kragl, Shaz Qadeer, and Thomas A. Henzinger. 2020. Refinement for Structured Concurrent Programs. In Computer Aided Verification - 32nd International Conference, CAV 2020, Los Angeles, CA, USA, July 21-24, 2020, Proceedings, Part I, Shuvendu K. Lahiri and Chao Wang (Eds.) (Lecture Notes in Computer Science, Vol. 12224). Springer, 275–298. https://doi.org/10.1007/978-3-030-53288-8_14 Google ScholarGoogle ScholarCross RefCross Ref
  46. Robbert Krebbers, Jacques-Henri Jourdan, Ralf Jung, Joseph Tassarotti, Jan-Oliver Kaiser, Amin Timany, Arthur Charguéraud, and Derek Dreyer. 2018. MoSeL: a general, extensible modal framework for interactive proofs in separation logic. Proc. ACM Program. Lang., 2, ICFP (2018), 77:1–77:30. https://doi.org/10.1145/3236772 Google ScholarGoogle ScholarDigital LibraryDigital Library
  47. Robbert Krebbers, Amin Timany, and Lars Birkedal. 2017. Interactive proofs in higher-order concurrent separation logic. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL 2017, Paris, France, January 18-20, 2017, Giuseppe Castagna and Andrew D. Gordon (Eds.). ACM, 205–217. https://doi.org/10.1145/3009837.3009855 Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Siddharth Krishna, Nisarg Patel, Dennis Shasha, and Thomas Wies. 2021. Automated Verification of Concurrent Search Structures. Morgan & Claypool Publishers. https://doi.org/10.2200/S01089ED1V01Y202104CSL013 Google ScholarGoogle Scholar
  49. Siddharth Krishna, Nisarg Patel, Dennis E. Shasha, and Thomas Wies. 2020. Verifying concurrent search structure templates. In Proceedings of the 41st ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2020, London, UK, June 15-20, 2020, Alastair F. Donaldson and Emina Torlak (Eds.). ACM, 181–196. https://doi.org/10.1145/3385412.3386029 Google ScholarGoogle ScholarDigital LibraryDigital Library
  50. Siddharth Krishna, Dennis E. Shasha, and Thomas Wies. 2018. Go with the flow: compositional abstractions for concurrent data structures. Proc. ACM Program. Lang., 2, POPL (2018), 37:1–37:31. https://doi.org/10.1145/3158125 Google ScholarGoogle ScholarDigital LibraryDigital Library
  51. Siddharth Krishna, Alexander J. Summers, and Thomas Wies. 2020. Local Reasoning for Global Graph Properties. In Programming Languages and Systems - 29th European Symposium on Programming, ESOP 2020, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2020, Dublin, Ireland, April 25-30, 2020, Proceedings, Peter Müller (Ed.) (Lecture Notes in Computer Science, Vol. 12075). Springer, 308–335. https://doi.org/10.1007/978-3-030-44914-8_12 Google ScholarGoogle ScholarCross RefCross Ref
  52. Mohsen Lesani, Todd D. Millstein, and Jens Palsberg. 2014. Automatic Atomicity Verification for Clients of Concurrent Data Structures. In Computer Aided Verification - 26th International Conference, CAV 2014, Held as Part of the Vienna Summer of Logic, VSL 2014, Vienna, Austria, July 18-22, 2014. Proceedings, Armin Biere and Roderick Bloem (Eds.) (Lecture Notes in Computer Science, Vol. 8559). Springer, 550–567. https://doi.org/10.1007/978-3-319-08867-9_37 Google ScholarGoogle ScholarDigital LibraryDigital Library
  53. Justin J. Levandoski, David B. Lomet, and Sudipta Sengupta. 2013. The Bw-Tree: A B-tree for new hardware platforms. In 29th IEEE International Conference on Data Engineering, ICDE 2013, Brisbane, Australia, April 8-12, 2013, Christian S. Jensen, Christopher M. Jermaine, and Xiaofang Zhou (Eds.). IEEE Computer Society, 302–313. https://doi.org/10.1109/ICDE.2013.6544834 Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Hongjin Liang and Xinyu Feng. 2013. Modular verification of linearizability with non-fixed linearization points. In ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’13, Seattle, WA, USA, June 16-19, 2013, Hans-Juergen Boehm and Cormac Flanagan (Eds.). ACM, 459–470. https://doi.org/10.1145/2491956.2462189 Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. Chen Luo and Michael J. Carey. 2020. LSM-based storage techniques: a survey. VLDB J., 29, 1 (2020), 393–418. https://doi.org/10.1007/s00778-019-00555-y Google ScholarGoogle ScholarDigital LibraryDigital Library
  56. Peter W. O’Hearn, Noam Rinetzky, Martin T. Vechev, Eran Yahav, and Greta Yorsh. 2010. Verifying linearizability with hindsight. In Proceedings of the 29th Annual ACM Symposium on Principles of Distributed Computing, PODC 2010, Zurich, Switzerland, July 25-28, 2010, Andréa W. Richa and Rachid Guerraoui (Eds.). ACM, 85–94. https://doi.org/10.1145/1835698.1835722 Google ScholarGoogle ScholarDigital LibraryDigital Library
  57. Patrick E. O’Neil, Edward Cheng, Dieter Gawlick, and Elizabeth J. O’Neil. 1996. The Log-Structured Merge-Tree (LSM-Tree). Acta Informatica, 33, 4 (1996), 351–385. https://doi.org/10.1007/s002360050048 Google ScholarGoogle ScholarDigital LibraryDigital Library
  58. Nisarg Patel, Siddharth Krishna, Dennis Shasha, and Thomas Wies. 2021. Verifying Concurrent Multicopy Search Structures. CoRR, abs/2109.05631 (2021), arxiv:2109.05631. arxiv:2109.05631 Google ScholarGoogle ScholarDigital LibraryDigital Library
  59. Ruzica Piskac, Thomas Wies, and Damien Zufferey. 2014. GRASShopper - Complete Heap Verification with Mixed Specifications. In Tools and Algorithms for the Construction and Analysis of Systems - 20th International Conference, TACAS 2014, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2014, Grenoble, France, April 5-13, 2014. Proceedings, Erika Ábrahám and Klaus Havelund (Eds.) (Lecture Notes in Computer Science, Vol. 8413). Springer, 124–139. https://doi.org/10.1007/978-3-642-54862-8_9 Google ScholarGoogle ScholarCross RefCross Ref
  60. Azalea Raad, Jules Villard, and Philippa Gardner. 2015. CoLoSL: Concurrent Local Subjective Logic. In Programming Languages and Systems - 24th European Symposium on Programming, ESOP 2015, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2015, London, UK, April 11-18, 2015. Proceedings, Jan Vitek (Ed.) (Lecture Notes in Computer Science, Vol. 9032). Springer, 710–735. https://doi.org/10.1007/978-3-662-46669-8_29 Google ScholarGoogle ScholarCross RefCross Ref
  61. Pandian Raju, Rohan Kadekodi, Vijay Chidambaram, and Ittai Abraham. 2017. PebblesDB: Building Key-Value Stores using Fragmented Log-Structured Merge Trees. In Proceedings of the 26th Symposium on Operating Systems Principles, Shanghai, China, October 28-31, 2017. ACM, 497–514. https://doi.org/10.1145/3132747.3132765 Google ScholarGoogle ScholarDigital LibraryDigital Library
  62. Tom Ridge, David Sheets, Thomas Tuerk, Andrea Giugliano, Anil Madhavapeddy, and Peter Sewell. 2015. SibylFS: formal specification and oracle-based testing for POSIX and real-world file systems. In Proceedings of the 25th Symposium on Operating Systems Principles, SOSP 2015, Monterey, CA, USA, October 4-7, 2015, Ethan L. Miller and Steven Hand (Eds.). ACM, 38–53. https://doi.org/10.1145/2815400.2815411 Google ScholarGoogle ScholarDigital LibraryDigital Library
  63. Russell Sears and Raghu Ramakrishnan. 2012. bLSM: a general purpose log structured merge tree. In Proceedings of the ACM SIGMOD International Conference on Management of Data, SIGMOD 2012, Scottsdale, AZ, USA, May 20-24, 2012, K. Selçuk Candan, Yi Chen, Richard T. Snodgrass, Luis Gravano, and Ariel Fuxman (Eds.). ACM, 217–228. https://doi.org/10.1145/2213836.2213862 Google ScholarGoogle ScholarDigital LibraryDigital Library
  64. Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2015. Mechanized verification of fine-grained concurrent programs. In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation, Portland, OR, USA, June 15-17, 2015, David Grove and Stephen M. Blackburn (Eds.). ACM, 77–87. https://doi.org/10.1145/2737924.2737964 Google ScholarGoogle ScholarDigital LibraryDigital Library
  65. Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2015. Specifying and Verifying Concurrent Algorithms with Histories and Subjectivity. In Programming Languages and Systems - 24th European Symposium on Programming, ESOP 2015, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2015, London, UK, April 11-18, 2015. Proceedings, Jan Vitek (Ed.) (Lecture Notes in Computer Science, Vol. 9032). Springer, 333–358. https://doi.org/10.1007/978-3-662-46669-8_14 Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. Dennis G. Severance and Guy M. Lohman. 1976. Differential Files: Their Application to the Maintenance of Large Databases. ACM Trans. Database Syst., 1, 3 (1976), 256–267. https://doi.org/10.1145/320473.320484 Google ScholarGoogle ScholarDigital LibraryDigital Library
  67. Ali Sezgin, Serdar Tasiran, and Shaz Qadeer. 2010. Tressa: Claiming the Future. In Verified Software: Theories, Tools, Experiments, Third International Conference, VSTTE 2010, Edinburgh, UK, August 16-19, 2010. Proceedings, Gary T. Leavens, Peter W. O’Hearn, and Sriram K. Rajamani (Eds.) (Lecture Notes in Computer Science, Vol. 6217). Springer, 25–39. https://doi.org/10.1007/978-3-642-15057-9_2 Google ScholarGoogle ScholarDigital LibraryDigital Library
  68. Dennis E. Shasha and Nathan Goodman. 1988. Concurrent Search Structure Algorithms. ACM Trans. Database Syst., 13, 1 (1988), 53–90. https://doi.org/10.1145/42201.42204 Google ScholarGoogle ScholarDigital LibraryDigital Library
  69. Helgi Sigurbjarnarson, James Bornholt, Emina Torlak, and Xi Wang. 2016. Push-Button Verification of File Systems via Crash Refinement. In 12th USENIX Symposium on Operating Systems Design and Implementation, OSDI 2016, Savannah, GA, USA, November 2-4, 2016, Kimberly Keeton and Timothy Roscoe (Eds.). USENIX Association, 1–16. https://www.usenix.org/conference/osdi16/technical-sessions/presentation/sigurbjarnarson Google ScholarGoogle ScholarDigital LibraryDigital Library
  70. Risi Thonangi and Jun Yang. 2017. On Log-Structured Merge for Solid-State Drives. In 33rd IEEE International Conference on Data Engineering, ICDE 2017, San Diego, CA, USA, April 19-22, 2017. IEEE Computer Society, 683–694. https://doi.org/10.1109/ICDE.2017.121 Google ScholarGoogle ScholarCross RefCross Ref
  71. Aaron Joseph Turon, Jacob Thamsborg, Amal Ahmed, Lars Birkedal, and Derek Dreyer. 2013. Logical relations for fine-grained concurrency. In The 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL ’13, Rome, Italy - January 23 - 25, 2013, Roberto Giacobazzi and Radhia Cousot (Eds.). ACM, 343–356. https://doi.org/10.1145/2429069.2429111 Google ScholarGoogle ScholarDigital LibraryDigital Library
  72. Viktor Vafeiadis. 2008. Modular fine-grained concurrency verification. Ph.D. Dissertation. University of Cambridge, UK. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.612221Google ScholarGoogle Scholar
  73. Viktor Vafeiadis. 2009. Shape-Value Abstraction for Verifying Linearizability. In Verification, Model Checking, and Abstract Interpretation, 10th International Conference, VMCAI 2009, Savannah, GA, USA, January 18-20, 2009. Proceedings, Neil D. Jones and Markus Müller-Olm (Eds.) (Lecture Notes in Computer Science, Vol. 5403). Springer, 335–348. https://doi.org/10.1007/978-3-540-93900-9_27 Google ScholarGoogle ScholarDigital LibraryDigital Library
  74. Chao Wang, Constantin Enea, Suha Orhun Mutluergil, and Gustavo Petri. 2019. Replication-aware linearizability. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2019, Phoenix, AZ, USA, June 22-26, 2019, Kathryn S. McKinley and Kathleen Fisher (Eds.). ACM, 980–993. https://doi.org/10.1145/3314221.3314617 Google ScholarGoogle ScholarDigital LibraryDigital Library
  75. Xingbo Wu, Yuehai Xu, Zili Shao, and Song Jiang. 2015. LSM-trie: An LSM-tree-based Ultra-Large Key-Value Store for Small Data Items. In 2015 USENIX Annual Technical Conference, USENIX ATC ’15, July 8-10, Santa Clara, CA, USA, Shan Lu and Erik Riedel (Eds.). USENIX Association, 71–82. https://www.usenix.org/conference/atc15/technical-session/presentation/wu Google ScholarGoogle ScholarDigital LibraryDigital Library
  76. Shale Xiong, Andrea Cerone, Azalea Raad, and Philippa Gardner. 2020. Data Consistency in Transactional Storage Systems: A Centralised Semantics. In 34th European Conference on Object-Oriented Programming, ECOOP 2020, November 15-17, 2020, Berlin, Germany (Virtual Conference), Robert Hirschfeld and Tobias Pape (Eds.) (LIPIcs, Vol. 166). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 21:1–21:31. https://doi.org/10.4230/LIPIcs.ECOOP.2020.21 Google ScholarGoogle ScholarCross RefCross Ref
  77. Zipeng Zhang, Xinyu Feng, Ming Fu, Zhong Shao, and Yong Li. 2012. A Structural Approach to Prophecy Variables. In Theory and Applications of Models of Computation - 9th Annual Conference, TAMC 2012, Beijing, China, May 16-21, 2012. Proceedings, Manindra Agrawal, S. Barry Cooper, and Angsheng Li (Eds.) (Lecture Notes in Computer Science, Vol. 7287). Springer, 61–71. https://doi.org/10.1007/978-3-642-29952-0_12 Google ScholarGoogle ScholarDigital LibraryDigital Library
  78. He Zhu, Gustavo Petri, and Suresh Jagannathan. 2015. Poling: SMT Aided Linearizability Proofs. In Computer Aided Verification - 27th International Conference, CAV 2015, San Francisco, CA, USA, July 18-24, 2015, Proceedings, Part II, Daniel Kroening and Corina S. Pasareanu (Eds.) (Lecture Notes in Computer Science, Vol. 9207). Springer, 3–19. https://doi.org/10.1007/978-3-319-21668-3_1 Google ScholarGoogle ScholarCross RefCross Ref

Index Terms

  1. Verifying concurrent multicopy search structures

        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!