skip to main content

Veracity: declarative multicore programming with commutativity

Published:31 October 2022Publication History
Skip Abstract Section

Abstract

There is an ongoing effort to provide programming abstractions that ease the burden of exploiting multicore hardware. Many programming abstractions (e.g., concurrent objects, transactional memory, etc.) simplify matters, but still involve intricate engineering. We argue that some difficulty of multicore programming can be meliorated through a declarative programming style in which programmers directly express the independence of fragments of sequential programs.

In our proposed paradigm, programmers write programs in a familiar, sequential manner, with the added ability to explicitly express the conditions under which code fragments sequentially commute. Putting such commutativity conditions into source code offers a new entry point for a compiler to exploit the known connection between commutativity and parallelism. We give a semantics for the programmer’s sequential perspective and, under a correctness condition, find that a compiler-transformed parallel execution is equivalent to the sequential semantics. Serializability/linearizability are not the right fit for this condition, so we introduce scoped serializability and show how it can be enforced with lock synthesis techniques.

We next describe a technique for automatically verifying and synthesizing commute conditions via a new reduction from our commute blocks to logical specifications, upon which symbolic commutativity reasoning can be performed. We implemented our work in a new language called Veracity, implemented in Multicore OCaml. We show that commutativity conditions can be automatically generated across a variety of new benchmark programs, confirm the expectation that concurrency speedups can be seen as the computation increases, and apply our work to a small in-memory filesystem and an adaptation of a crowdfund blockchain smart contract.

References

  1. 2014. Multicore OCaml. https://github.com/ocaml-multicore/ocaml-multicore Google ScholarGoogle Scholar
  2. Farhana Aleen and Nathan Clark. 2009. Commutativity analysis for software parallelization: letting program transformations see the big picture. In Proceedings of the 14th international conference on Architectural support for programming languages and operating systems (ASPLOS-XII), Mary Lou Soffa and Mary Jane Irwin (Eds.). ACM, 241–252. isbn:978-1-60558-406-5 https://doi.org/10.1145/1508244.1508273 Google ScholarGoogle ScholarDigital LibraryDigital Library
  3. Eric Allen, David Chase, Joe Hallett, Victor Luchangco, Jan-Willem Maessen, Sukyoung Ryu, Guy L Steele Jr, Sam Tobin-Hochstadt, Joao Dias, and Carl Eastlund. 2005. The Fortress language specification. Sun Microsystems, 139, 140 (2005), 116. Google ScholarGoogle Scholar
  4. Joe Armstrong. 1997. The development of Erlang. In Proceedings of the second ACM SIGPLAN international conference on Functional programming. 196–203. https://doi.org/10.1145/258948.258967 Google ScholarGoogle ScholarDigital LibraryDigital Library
  5. Kshitij Bansal, Eric Koskinen, and Omer Tripp. 2018. Automatic Generation of Precise and Useful Commutativity Conditions. In Tools and Algorithms for the Construction and Analysis of Systems - 24th International Conference, TACAS 2018, Dirk Beyer and Marieke Huisman (Eds.) (Lecture Notes in Computer Science, Vol. 10805). Springer, 115–132. https://doi.org/10.1007/978-3-319-89960-2_7 Google ScholarGoogle ScholarCross RefCross Ref
  6. Kshitij Bansal, Eric Koskinen, and Omer Tripp. 2020. Synthesizing Precise and Useful Commutativity Conditions. J. Autom. Reason., 64, 7 (2020), 1333–1359. https://doi.org/10.1007/s10817-020-09573-w Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. Haniel Barbosa, Clark W. Barrett, Martin Brain, Gereon Kremer, Hanna Lachnitt, Makai Mann, Abdalrhman Mohamed, Mudathir Mohamed, Aina Niemetz, Andres Nötzli, Alex Ozdemir, Mathias Preiner, Andrew Reynolds, Ying Sheng, Cesare Tinelli, and Yoni Zohar. 2022. cvc5: A Versatile and Industrial-Strength SMT Solver. In Tools and Algorithms for the Construction and Analysis of Systems - 28th International Conference, TACAS 2022, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022, Munich, Germany, April 2-7, 2022, Proceedings, Part I, Dana Fisman and Grigore Rosu (Eds.) (Lecture Notes in Computer Science, Vol. 13243). Springer, 415–442. https://doi.org/10.1007/978-3-030-99524-9_24 Google ScholarGoogle ScholarDigital LibraryDigital Library
  8. Rajkishore Barik, Zoran Budimlic, Vincent Cave, Sanjay Chatterjee, Yi Guo, David Peixotto, Raghavan Raman, Jun Shirako, Sağnak Taşırlar, and Yonghong Yan. 2009. The habanero multicore software research project. In Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications. 735–736. https://doi.org/10.1145/1639950.1639989 Google ScholarGoogle ScholarDigital LibraryDigital Library
  9. Clark Barrett, Aaron Stump, and Cesare Tinelli. 2010. The smt-lib standard: Version 2.0. In Proceedings of the 8th international workshop on satisfiability modulo theories (Edinburgh, England). 13, 14. Google ScholarGoogle Scholar
  10. Arthur Bernstein. 1966. Analysis of programs for parallel processing. IEEE Transactions on Electronic Computers, 15, 5 (1966), 757–763. https://doi.org/10.1109/PGEC.1966.264565 Google ScholarGoogle ScholarCross RefCross Ref
  11. Bill Blume, Rudolf Eigenmann, Keith Faigin, John Grout, Jay Hoeflinger, David Padua, Paul Petersen, Bill Pottenger, Lawrence Rauchwerger, and Peng Tu. 1994. Polaris: The next generation in parallelizing compilers. In Proceedings of the Seventh Workshop on Languages and Compilers for Parallel Computing. 141–154. https://doi.org/10.1007/BFb0025876 Google ScholarGoogle ScholarCross RefCross Ref
  12. William Blume and Rudolf Eigenmann. 1992. Performance analysis of parallelizing compilers on the Perfect Benchmarks Programs. IEEE Transactions on Parallel and Distributed Systems, 3, 6 (1992), 643–656. https://doi.org/10.1109/71.180621 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Robert L. Bocchino, Vikram S. Adve, Danny Dig, Sarita V. Adve, Stephen Heumann, Rakesh Komuravelli, Jeffrey Overbey, Patrick Simmons, Hyojin Sung, and Mohsen Vakilian. 2009. A Type and Effect System for Deterministic Parallel Java. In Proceedings of the 24th ACM SIGPLAN Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA ’09). Association for Computing Machinery, New York, NY, USA. 97–116. isbn:9781605587660 https://doi.org/10.1145/1640089.1640097 Google ScholarGoogle ScholarDigital LibraryDigital Library
  14. Nathan G Bronson, Jared Casper, Hassan Chafi, and Kunle Olukotun. 2010. Transactional predication: high-performance concurrent sets and maps for stm. In Proceedings of the 29th ACM SIGACT-SIGOPS symposium on Principles of distributed computing. 6–15. https://doi.org/10.1145/1835698.1835703 Google ScholarGoogle ScholarDigital LibraryDigital Library
  15. Stephen Brookes and Peter W O’Hearn. 2016. Concurrent separation logic. ACM SIGLOG News, 3, 3 (2016), 47–65. https://doi.org/10.1145/2984450.2984457 Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. Pavol Černỳ, Thomas A Henzinger, Arjun Radhakrishna, Leonid Ryzhyk, and Thorsten Tarrach. 2013. Efficient synthesis for concurrency by semantics-preserving transformations. In International Conference on Computer Aided Verification. 951–967. https://doi.org/10.1007/978-3-642-39799-8_68 Google ScholarGoogle ScholarCross RefCross Ref
  17. Arunodaya Chatterjee. 1989. Futures: a mechanism for concurrency among objects. In Supercomputing’89: Proceedings of the 1989 ACM/IEEE conference on Supercomputing. 562–567. https://doi.org/10.1145/76263.76326 Google ScholarGoogle ScholarDigital LibraryDigital Library
  18. Adam Chen, Parisa Fathololumi, Eric Koskinen, and Jared Pincus. 2022. Veracity: Declarative Multicore Programming with Commutativity. https://doi.org/10.48550/ARXIV.2203.06229 Google ScholarGoogle Scholar
  19. Adam Chen, Parisa Fathololumi, Eric Koskinen, and Jared Pincus. 2022. Veracity: Declarative Multicore Programming with Commutativity. PACMPL, 6, 10 (2022), Sept., 186:1 – 186:31. https://doi.org/10.5281/zenodo.7058421 Funded by NSF Grant #2008633. Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Sigmund Cherem, Trishul M. Chilimbi, and Sumit Gulwani. 2008. Inferring locks for atomic sections. In Proceedings of the ACM SIGPLAN 2008 Conference on Programming Language Design and Implementation (PLDI’08). 304–315. isbn:978-1-59593-860-2 https://doi.org/10.1145/1375581.1375619 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Austin T Clements, M Frans Kaashoek, Nickolai Zeldovich, Robert T Morris, and Eddie Kohler. 2015. The scalable commutativity rule: Designing scalable software for multicore processors. ACM Transactions on Computer Systems (TOCS), 32, 4 (2015), 1–47. https://doi.org/10.1145/2699681 Google ScholarGoogle ScholarDigital LibraryDigital Library
  22. Thomas Dickerson, Paul Gazzillo, Maurice Herlihy, and Eric Koskinen. 2017. Adding Concurrency to Smart Contracts. In Proceedings of the ACM Symposium on Principles of Distributed Computing (PODC ’17). ACM, New York, NY, USA. 303–312. isbn:978-1-4503-4992-5 https://doi.org/10.1145/3087801.3087835 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Thomas D. Dickerson, Eric Koskinen, Paul Gazzillo, and Maurice Herlihy. 2019. Conflict Abstractions and Shadow Speculation for Optimistic Transactional Objects. In Programming Languages and Systems - 17th Asian Symposium, APLAS 2019, Nusa Dua, Bali, Indonesia, December 1-4, 2019, Proceedings. 313–331. https://doi.org/10.1007/978-3-030-34175-6_16 Google ScholarGoogle ScholarCross RefCross Ref
  24. Dimitar Dimitrov, Veselin Raychev, Martin Vechev, and Eric Koskinen. 2014. Commutativity Race Detection. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’14). https://doi.org/10.1145/2594291.2594322 Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. Tayfun Elmas. 2010. QED: a proof system based on reduction and abstraction for the static verification of concurrent software. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering-Volume 2. 507–508. https://doi.org/10.1145/1810295.1810454 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Rasha Eqbal. 2014. ScaleFS: A multicore-scalable file system. Ph. D. Dissertation. Massachusetts Institute of Technology. Google ScholarGoogle Scholar
  27. Gidon Ernst. 2020. A Complete Approach to Loop Verification with Invariants and Summaries. https://doi.org/10.48550/ARXIV.2010.05812 Google ScholarGoogle Scholar
  28. Gidon Ernst. 2022. Loop Verification with Invariants and Contracts. In International Conference on Verification, Model Checking, and Abstract Interpretation. 69–92. https://doi.org/10.1007/978-3-030-94583-1_4 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Bin Fan, David G Andersen, and Michael Kaminsky. 2013. Memc3: Compact and concurrent memcache with dumber caching and smarter hashing. In 10th $USENIX$ Symposium on Networked Systems Design and Implementation ($NSDI$ 13). 371–384. https://doi.org/10.5555/2482626.2482662 Google ScholarGoogle ScholarDigital LibraryDigital Library
  30. Cormac Flanagan and Shaz Qadeer. 2003. A type and effect system for atomicity. In Proceedings of the ACM SIGPLAN 2003 Conference on Programming Language Design and Implementation 2003, San Diego, California, USA, June 9-11, 2003, Ron Cytron and Rajiv Gupta (Eds.). ACM, 338–349. https://doi.org/10.1145/781131.781169 Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. Timon Gehr, Dimitar Dimitrov, and Martin T. Vechev. 2015. Learning Commutativity Specifications. In Computer Aided Verification - 27th International Conference, CAV 2015, San Francisco, CA, USA, July 18-24, 2015, Proceedings, Part I. 307–323. https://doi.org/10.1007/978-3-319-21690-4_18 Google ScholarGoogle ScholarCross RefCross Ref
  32. Guy Golan-Gueta, G Ramalingam, Mooly Sagiv, and Eran Yahav. 2015. Automatic scalable atomicity via semantic locking. ACM SIGPLAN Notices, 50, 8 (2015), 31–41. https://doi.org/10.1145/2688500.2688511 Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Max Grossman, Alina Simion Sbirlea, Zoran Budimlić, and Vivek Sarkar. 2010. CnC-CUDA: declarative programming for GPUs. In International Workshop on Languages and Compilers for Parallel Computing. 230–245. https://doi.org/10.1007/978-3-642-19595-2_16 Google ScholarGoogle ScholarCross RefCross Ref
  34. Rachid Guerraoui and Michal Kapalka. 2008. On the correctness of transactional memory. In Proceedings of the 13th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP’08). ACM, 175–184. isbn:978-1-59593-795-7 https://doi.org/10.1145/1345206.1345233 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Tim Harris and Keir Fraser. 2003. Language support for lightweight transactions. In Proceedings of the 18th ACM SIGPLAN conference on Object-Oriented Programing, Systems, Languages, and Applications (OOPSLA’03). ACM Press, 388–402. isbn:1-58113-712-5 https://doi.org/10.1145/949305.949340 Google ScholarGoogle ScholarDigital LibraryDigital Library
  36. Ahmed Hassan, Roberto Palmieri, and Binoy Ravindran. 2014. Optimistic transactional boosting. In Proceedings of the 19th ACM SIGPLAN symposium on Principles and practice of parallel programming. 387–388. https://doi.org/10.1145/2555243.2555283 Google ScholarGoogle ScholarDigital LibraryDigital Library
  37. Maurice Herlihy and Eric Koskinen. 2008. Transactional Boosting: A Methodology for Highly Concurrent Transactional Objects. In Proceedings of the 13th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP’08). https://doi.org/10.1145/62678.62684 Google ScholarGoogle ScholarDigital LibraryDigital Library
  38. Maurice Herlihy, Victor Luchangco, Mark Moir, and William N. Scherer, III. 2003. Software transactional memory for dynamic-sized data structures. In Proceedings of the 22nd annual symposium on Principles of distributed computing (PODC’03). 92–101. isbn:1-58113-708-7 https://doi.org/10.1145/872035.872048 Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Maurice Herlihy and J. Eliot B. Moss. 1993. Transactional memory: architectural support for lock-free data structures. In Proceedings of the 20th Annual International Symposium on Computer Architecture (ISCA’93). ACM Press, 289–300. isbn:0-8186-3810-9 https://doi.org/10.1145/165123.165164 Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. Maurice P. Herlihy and Jeannette M. Wing. 1990. Linearizability: a correctness condition for concurrent objects. ACM Transactions on Programming Languages and Systems (TOPLAS), 12, 3 (1990), 463–492. issn:0164-0925 https://doi.org/10.1145/78969.78972 Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. Farzin Houshmand and Mohsen Lesani. 2019. Hamsaz: replication coordination analysis and synthesis. Proc. ACM Program. Lang., 3, POPL (2019), 74:1–74:32. https://doi.org/10.1145/3290387 Google ScholarGoogle ScholarDigital LibraryDigital Library
  42. Cliff B. Jones. 1983. Tentative steps toward a development method for interfering programs. ACM Transactions on Programming Languages and Systems (TOPLAS), 5, 4 (1983), 596–619. https://doi.org/10.1145/69575.69577 Google ScholarGoogle ScholarDigital LibraryDigital Library
  43. Deokhwan Kim and Martin C. Rinard. 2011. Verification of semantic commutativity conditions and inverse operations on linked data structures. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’11). 528–541. isbn:978-1-4503-0663-8 https://doi.org/10.1145/1993498.1993561 Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. Henry F. Korth. 1983. Locking Primitives in a Database System. J. ACM, 30, 1 (1983), 55–79. issn:0004-5411 https://doi.org/10.1145/322358.322363 Google ScholarGoogle ScholarDigital LibraryDigital Library
  45. Eric Koskinen and Kshitij Bansal. 2021. Decomposing Data Structure Commutativity Proofs with mn-Differencing. In Verification, Model Checking, and Abstract Interpretation - 22nd International Conference, VMCAI 2021, Copenhagen, Denmark, January 17-19, 2021, Proceedings, Fritz Henglein, Sharon Shoham, and Yakir Vizel (Eds.) (Lecture Notes in Computer Science, Vol. 12597). Springer, 81–103. https://doi.org/10.1007/978-3-030-67067-2_5 Google ScholarGoogle ScholarDigital LibraryDigital Library
  46. Daniel Kroening, Natasha Sharygina, Stefano Tonetta, Aliaksei Tsitovich, and Christoph M Wintersteiger. 2008. Loop summarization using abstract transformers. In International Symposium on Automated Technology for Verification and Analysis. 111–125. https://doi.org/10.1007/978-3-540-88387-6_10 Google ScholarGoogle ScholarDigital LibraryDigital Library
  47. Milind Kulkarni, Donald Nguyen, Dimitrios Prountzos, Xin Sui, and Keshav Pingali. 2011. Exploiting the commutativity lattice. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’11). 542–555. isbn:978-1-4503-0663-8 https://doi.org/10.1145/1993498.1993562 Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Milind Kulkarni, Keshav Pingali, Ganesh Ramanarayanan, Bruce Walter, Kavita Bala, and L Paul Chew. 2008. Optimistic parallelism benefits from data partitioning. ACM SIGOPS Operating Systems Review, 42, 2 (2008), 233–243. https://doi.org/10.1145/1346281.1346311 Google ScholarGoogle ScholarDigital LibraryDigital Library
  49. Milind Kulkarni, Keshav Pingali, Bruce Walter, Ganesh Ramanarayanan, Kavita Bala, and L. Paul Chew. 2007. Optimistic parallelism requires abstractions. In Proceedings of the ACM SIGPLAN 2007 Conference on Programming Language Design and Implementation (PLDI’07). 211–222. isbn:978-1-59593-633-2 https://doi.org/10.1145/1250734.1250759 Google ScholarGoogle ScholarDigital LibraryDigital Library
  50. Xiaozhou Li, David G Andersen, Michael Kaminsky, and Michael J Freedman. 2014. Algorithmic improvements for fast concurrent cuckoo hashing. In Proceedings of the Ninth European Conference on Computer Systems. 1–14. https://doi.org/10.1145/2592798.2592820 Google ScholarGoogle ScholarDigital LibraryDigital Library
  51. Zhiyuan Li, Pen-Chung Yew, and Chuan-Qi Zhu. 1990. An Efficient Data Dependence Analysis for Parallelizing Compilers. IEEE Trans. Parallel Distributed Syst., 1, 1 (1990), 26–34. https://doi.org/10.1109/71.80122 Google ScholarGoogle ScholarDigital LibraryDigital Library
  52. 2013. libcuckoo: A high-performance, concurrent hash table. http://efficient.github.io/libcuckoo/ Google ScholarGoogle Scholar
  53. Sam Lindley. 2007. Implementing deterministic declarative concurrency using sieves. In Proceedings of the 2007 workshop on Declarative aspects of multicore programming. 45–49. https://doi.org/10.1145/1248648.1248657 Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Barbara Liskov and Liuba Shrira. 1988. Promises: Linguistic support for efficient asynchronous procedure calls in distributed systems. ACM Sigplan Notices, 23, 7 (1988), 260–267. https://doi.org/10.1145/960116.54016 Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. Yujie Liu, Kunlong Zhang, and Michael Spear. 2014. Dynamic-sized nonblocking hash tables. In Proceedings of the 2014 ACM symposium on Principles of distributed computing. 242–251. https://doi.org/10.1145/2611462.2611495 Google ScholarGoogle ScholarDigital LibraryDigital Library
  56. Nicholas D. Matsakis and Felix S. Klock. 2014. The Rust Language. In Proceedings of the 2014 ACM SIGAda Annual Conference on High Integrity Language Technology (HILT ’14). Association for Computing Machinery, New York, NY, USA. 103–104. isbn:9781450332170 https://doi.org/10.1145/2663171.2663188 Google ScholarGoogle ScholarDigital LibraryDigital Library
  57. Mahsa Najafzadeh, Alexey Gotsman, Hongseok Yang, Carla Ferreira, and Marc Shapiro. 2016. The CISE tool: proving weakly-consistent applications correct. In Proceedings of the 2nd Workshop on the Principles and Practice of Consistency for Distributed Data, [email protected] 2016, London, United Kingdom, April 18, 2016. 2:1–2:3. https://doi.org/10.1145/2911151.2911160 Google ScholarGoogle ScholarDigital LibraryDigital Library
  58. Yang Ni, Vijay S. Menon, Ali-Reza Adl-Tabatabai, Antony L. Hosking, Richard L. Hudson, J. Eliot B. Moss, Bratin Saha, and Tatiana Shpeisman. 2007. Open nesting in software transactional memory. In Proceedings of the 12th ACM SIGPLAN symposium on Principles and Practice of Parallel Programming (PPoPP’07). 68–78. isbn:978-1-59593-602-8 https://doi.org/10.1145/1229428.1229442 Google ScholarGoogle ScholarDigital LibraryDigital Library
  59. Dominic A Orchard, Max Bolingbroke, and Alan Mycroft. 2010. Ypnos: declarative, parallel structured grid programming. In Proceedings of the 5th ACM SIGPLAN workshop on Declarative aspects of multicore programming. 15–24. https://doi.org/10.1145/1708046.1708053 Google ScholarGoogle ScholarDigital LibraryDigital Library
  60. Susan Owicki and David Gries. 1976. An axiomatic proof technique for parallel programs I. Acta informatica, 6, 4 (1976), 319–340. https://doi.org/10.1007/BF00268134 Google ScholarGoogle ScholarDigital LibraryDigital Library
  61. Christos H Papadimitriou. 1979. The serializability of concurrent database updates. Journal of the ACM (JACM), 26, 4 (1979), 631–653. https://doi.org/10.1145/322154.322158 Google ScholarGoogle ScholarDigital LibraryDigital Library
  62. George Pîrlea, Amrit Kumar, and Ilya Sergey. 2021. Practical smart contract sharding with ownership and commutativity analysis. In PLDI ’21: 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation, Virtual Event, Canada, June 20-25, 20211, Stephen N. Freund and Eran Yahav (Eds.). ACM, 1327–1341. https://doi.org/10.1145/3453483.3454112 Google ScholarGoogle ScholarDigital LibraryDigital Library
  63. Raghu Prabhakar and Rohit Kumar. 2011. Concurrent programming with Go. Citeseer. Google ScholarGoogle Scholar
  64. Prakash Prabhu, Soumyadeep Ghosh, Yun Zhang, Nick P Johnson, and David I August. 2011. Commutative set: A language extension for implicit parallel programming. In Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation. 1–11. https://doi.org/10.1145/1993316.1993500 Google ScholarGoogle ScholarDigital LibraryDigital Library
  65. Chris Purcell and Tim Harris. 2005. Non-blocking hashtables with open addressing. In International Symposium on Distributed Computing. 108–121. https://doi.org/10.1007/11561927_10 Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. Martin C. Rinard and Pedro C. Diniz. 1997. Commutativity Analysis: A New Analysis Technique for Parallelizing Compilers. ACM Transactions on Programming Languages and Systems (TOPLAS), 19, 6 (1997), November, 942–991. https://doi.org/10.1145/267959.269969 Google ScholarGoogle ScholarDigital LibraryDigital Library
  67. Bratin Saha, Ali-Reza Adl-Tabatabai, Richard L. Hudson, Chi Cao Minh, and Benjamin Hertzberg. 2006. McRT-STM: a high performance software transactional memory system for a multi-core runtime. In Proceedings of the 11th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP’06). 187–197. isbn:1-59593-189-9 https://doi.org/10.1145/1122971.1123001 Google ScholarGoogle ScholarDigital LibraryDigital Library
  68. Vikram Saraph and Maurice Herlihy. 2019. An empirical study of speculative concurrency in ethereum smart contracts. arXiv preprint arXiv:1901.01376, https://doi.org/10.48550/arXiv.1901.01376 Google ScholarGoogle Scholar
  69. 2018. Servois: Synthesizing Commutativity Conditions. https://github.com/kbansal/servois Google ScholarGoogle Scholar
  70. 2022. Servois2: An Extended Commutativity Condition Synthesizer. https://github.com/veracity-lang/servois2 Google ScholarGoogle Scholar
  71. Jake Silverman and Zachary Kincaid. 2019. Loop summarization with rational vector addition systems. In International Conference on Computer Aided Verification. 97–115. https://doi.org/10.1007/978-3-030-25543-5_7 Google ScholarGoogle ScholarCross RefCross Ref
  72. Guy L. Steele Jr.. 2005. Parallel Programming and Parallel Abstractions in Fortress. In 14th International Conference on Parallel Architectures and Compilation Techniques (PACT 2005), 17-21 September 2005, St. Louis, MO, USA. IEEE Computer Society, 157. https://doi.org/10.1109/PACT.2005.34 Google ScholarGoogle ScholarDigital LibraryDigital Library
  73. Thi Hong Tran, Hoai Luan Pham, Tri Dung Phan, and Yasuhiko Nakashima. 2021. BCA: A 530-mW Multicore Blockchain Accelerator for Power-Constrained Devices in Securing Decentralized Networks. IEEE Transactions on Circuits and Systems I: Regular Papers, 68, 10 (2021), 4245–4258. https://doi.org/10.1109/TCSI.2021.3102618 Google ScholarGoogle ScholarCross RefCross Ref
  74. Omer Tripp, Greta Yorsh, John Field, and Mooly Sagiv. 2011. HAWKEYE: effective discovery of dataflow impediments to parallelization. In Proceedings of the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2011. 207–224. https://doi.org/10.1145/2048066.2048085 Google ScholarGoogle ScholarDigital LibraryDigital Library
  75. Viktor Vafeiadis. 2010. Automatically proving linearizability. In International Conference on Computer Aided Verification. 450–464. https://doi.org/10.1007/978-3-642-14295-6_40 Google ScholarGoogle ScholarDigital LibraryDigital Library
  76. Mohsen Vakilian, Danny Dig, Robert Bocchino, Jeffrey Overbey, Vikram Adve, and Ralph Johnson. 2009. Inferring Method Effect Summaries for Nested Heap Regions. In 2009 IEEE/ACM International Conference on Automated Software Engineering. 421–432. https://doi.org/10.1109/ASE.2009.68 Google ScholarGoogle ScholarDigital LibraryDigital Library
  77. Various. 2007–2012. Proceedings of the Workshop on Declarative Aspects of Multicore Programming (DAMP). https://doi.org/10.1145/1481839 Google ScholarGoogle ScholarDigital LibraryDigital Library
  78. Martin Vechev, Eran Yahav, and Greta Yorsh. 2010. Abstraction-guided synthesis of synchronization. In Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages. 327–338. https://doi.org/10.1145/1706299.1706338 Google ScholarGoogle ScholarDigital LibraryDigital Library
  79. William Weihl. 1988. Commutativity-Based Concurrency Control for Abstract Data Types. IEEE Trans. Comput., 37, 12 (1988), 1488–1505. issn:0018-9340 https://doi.org/10.1109/12.9728 Google ScholarGoogle ScholarDigital LibraryDigital Library
  80. William E. Weihl. 1983. Data-dependent concurrency control and recovery (Extended Abstract). In Proceedings of the 2nd annual ACM symposium on Principles of Distributed Computing (PODC’83). ACM Press, 63–75. isbn:0-89791-110-5 https://doi.org/10.1145/800221.806710 Google ScholarGoogle ScholarDigital LibraryDigital Library
  81. Xiaofei Xie, Bihuan Chen, Liang Zou, Yang Liu, Wei Le, and Xiaohong Li. 2017. Automatic loop summarization via path dependency analysis. IEEE Transactions on Software Engineering, 45, 6 (2017), 537–557. https://doi.org/10.1109/TSE.2017.2788018 Google ScholarGoogle ScholarCross RefCross Ref

Index Terms

  1. Veracity: declarative multicore programming with commutativity

                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

                • Article Metrics

                  • Downloads (Last 12 months)148
                  • Downloads (Last 6 weeks)6

                  Other Metrics

                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!