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.
- 2014. Multicore OCaml. https://github.com/ocaml-multicore/ocaml-multicore
Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Rasha Eqbal. 2014. ScaleFS: A multicore-scalable file system. Ph. D. Dissertation. Massachusetts Institute of Technology.
Google Scholar
- Gidon Ernst. 2020. A Complete Approach to Loop Verification with Invariants and Summaries. https://doi.org/10.48550/ARXIV.2010.05812
Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 2013. libcuckoo: A high-performance, concurrent hash table. http://efficient.github.io/libcuckoo/
Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Raghu Prabhakar and Rohit Kumar. 2011. Concurrent programming with Go. Citeseer.
Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 2018. Servois: Synthesizing Commutativity Conditions. https://github.com/kbansal/servois
Google Scholar
- 2022. Servois2: An Extended Commutativity Condition Synthesizer. https://github.com/veracity-lang/servois2
Google Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Various. 2007–2012. Proceedings of the Workshop on Declarative Aspects of Multicore Programming (DAMP). https://doi.org/10.1145/1481839
Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
Index Terms
Veracity: declarative multicore programming with commutativity
Recommendations
Commutativity-Based Concurrency Control for Abstract Data Types
Two novel concurrency algorithms for abstract data types are presented that ensure serializability of transactions. It is proved that both algorithms ensure a local atomicity property called dynamic atomicity. The algorithms are quite general, ...
Read invisibility, virtual world consistency and probabilistic permissiveness are compatible
ICA3PP'11: Proceedings of the 11th international conference on Algorithms and architectures for parallel processing - Volume Part IThe aim of a Software Transactional Memory (STM) is to discharge the programmers from the management of synchronization in multiprocess programs that access concurrent objects. To that end, an STM system provides the programmer with the concept of a ...
Correct Execution of Transactions at Different Isolation Levels
Many transaction processing applications execute at isolation levels lower than SERIALIZABLE in order to increase throughput and reduce response time. However, the resulting schedules might not be serializable and, hence, not necessarily correct. The ...






Comments