skip to main content

Persistent software transactional memory in Haskell

Published:19 August 2021Publication History
Skip Abstract Section

Abstract

Emerging persistent memory in commodity hardware allows byte-granular accesses to persistent state at memory speeds. However, to prevent inconsistent state in persistent memory due to unexpected system failures, different write-semantics are required compared to volatile memory. Transaction-based library solutions for persistent memory facilitate the atomic modification of persistent data in languages where memory is explicitly managed by the programmer, such as C/C++. For languages that provide extended capabilities like automatic memory management, a more native integration into the language is needed to maintain the high level of memory abstraction. It is shown in this paper how persistent software transactional memory (PSTM) can be tightly integrated into the runtime system of Haskell to atomically manage values of persistent transactional data types. PSTM has a clear interface and semantics extending that of software transactional memory (STM). Its integration with the language’s memory management retains features like garbage collection and allocation strategies, and is fully compatible with Haskell's lazy execution model. Our PSTM implementation demonstrates competitive performance with low level libraries and trivial portability of existing STM libraries to PSTM. The implementation allows further interesting use cases, such as persistent memoization and persistent Haskell expressions.

Skip Supplemental Material Section

Supplemental Material

Auxiliary Presentation Video

This is the video presentation of our talk at ICFP 2021 about the integration of Persistent Software Transactional Memory (PSTM) into Haskell. We show that PSTM can be tightly integrated into the runtime system of Haskell to atomically manage values of persistent transactional data types in non-volatile memories. PSTM has a clear interface and semantics extending that of Haskell's Software Transactional Memory (STM). Its integration with the language’s memory management retains features like garbage collection and allocation strategies, and is fully compatible with Haskell's lazy execution model. Our PSTM implementation demonstrates competitive performance with low level libraries and trivial portability of existing STM libraries to PSTM.

3473568.mp4

Presentation Videos

References

  1. Martín Abadi, Luca Cardelli, Benjamin C. Pierce, and Gordon D. Plotkin. 1991. Dynamic Typing in a Statically Typed Language. ACM Transactions on Programming Languages and Systems (TOPLAS), 13, 2 (1991), 237–268. https://doi.org/10.1145/103135.103138 Google ScholarGoogle ScholarDigital LibraryDigital Library
  2. Malcolm P. Atkinson, Peter J. Bailey, Kenneth Chisholm, W. Paul Cockshott, and Ronald Morrison. 1983. An Approach to Persistent Programming. Comput. J., 26, 4 (1983), 360–365. https://doi.org/10.1093/comjnl/26.4.360 Google ScholarGoogle ScholarCross RefCross Ref
  3. Malcolm P. Atkinson, Kenneth Chisholm, and W. Paul Cockshott. 1982. PS-algol: an Algol with a persistent heap. ACM SIGPLAN Notices, 17, 7 (1982), 24–31. https://doi.org/10.1145/988376.988378 Google ScholarGoogle ScholarDigital LibraryDigital Library
  4. Malcolm P. Atkinson and Ronald Morrison. 1995. Orthogonally Persistent Object Systems. VLDB J., 4, 3 (1995), 319–401. http://www.vldb.org/journal/VLDBJ4/P319.pdfGoogle ScholarGoogle ScholarDigital LibraryDigital Library
  5. Ömer S. Ağacan. 2020. The problem with adding functions to compact regions. https://www.well-typed.com/blog/2020/03/functions-in-compact-regions/Google ScholarGoogle Scholar
  6. Jost Berthold. 2010. Orthogonal Serialisation for Haskell. In Implementation and Application of Functional Languages - 22nd International Symposium, IFL 2010, Alphen aan den Rijn, The Netherlands, September 1-3, 2010, Revised Selected Papers (Lecture Notes in Computer Science, Vol. 6647). Springer, 38–53. https://doi.org/10.1007/978-3-642-24276-2_3 Google ScholarGoogle ScholarCross RefCross Ref
  7. Luc Bläser. 2007. Persistent Oberon: A Programming Language with Integrated Persistence. In 5th Asian Symposium on Programming Languages and Systems (APLAS), Singapore, November 29-December 1. 4807, 71–85. https://doi.org/10.1007/978-3-540-76637-7_6 Google ScholarGoogle ScholarDigital LibraryDigital Library
  8. Peter T. Breuer. 2003. A Formal Model for the Block Device Subsystem of the Linux Kernel. In Formal Methods and Software Engineering, Proceedings of the 5th International Conference on Formal Engineering Methods (ICFEM), Singapore, November 5-7. 599–619. https://doi.org/10.1007/978-3-540-39893-6_34 Google ScholarGoogle ScholarCross RefCross Ref
  9. Trevor Brown and Hillel Avni. 2016. PHyTM: Persistent Hybrid Transactional Memory. Proceedings of the VLDB Endowment, 10, 4 (2016), 409–420. https://doi.org/10.14778/3025111.3025122 Google ScholarGoogle ScholarDigital LibraryDigital Library
  10. James Cheney and Ralf Hinze. 2002. A Lightweight Implementation of Generics and Dynamics. In Proceedings of the 2002 ACM SIGPLAN Workshop on Haskell. Association for Computing Machinery, New York, NY, USA. 90–104. isbn:1581136056 https://doi.org/10.1145/581690.581698 Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. Paul Chiusano. 2020. How Unison reduces ecosystem churn. https://www.unisonweb.org/2020/04/10/reducing-churn/Google ScholarGoogle Scholar
  12. Joel Coburn, Adrian M. Caulfield, Ameen Akel, Laura M. Grupp, Rajesh K. Gupta, Ranjit Jhala, and Steven Swanson. 2011. NV-Heaps: making persistent objects fast and safe with next-generation, non-volatile memories. In Proceedings of the 16th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), Newport Beach, CA, USA, March 5-11. 105–118. https://doi.org/10.1145/1950365.1950380 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Richard C. H. Connor. 1991. Types and polymorphism in persistent programming systems. Ph.D. Dissertation. University of St Andrews.Google ScholarGoogle Scholar
  14. Alberto G. Corona. 2017. TCache: A Transactional cache with user-defined persistence. http://hackage.haskell.org/package/TCacheGoogle ScholarGoogle Scholar
  15. Andreia Correia, Pascal Felber, and Pedro Ramalhete. 2018. Romulus: Efficient Algorithms for Persistent Transactional Memory. In Proceedings of the 30th on Symposium on Parallelism in Algorithms and Architectures (SPAA), Vienna, Austria, July 16-18, 2018. ACM, 271–282. https://doi.org/10.1145/3210377.3210392 Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. Rene De La Briandais. 1959. File Searching Using Variable Length Keys. In Papers Presented at the the March 3-5, 1959, Western Joint Computer Conference (IRE-AIEE-ACM ’59 (Western)). ACM, San Francisco, California. 295–298. https://doi.org/10.1145/1457838.1457895 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Subramanya Rao Dulloor, Sanjay Kumar, Anil S. Keshavamurthy, Philip Lantz, Dheeraj Reddy, Rajesh Sankaran, and Jeff Jackson. 2014. System software for persistent memory. In 9th Eurosys Conference, Amsterdam, The Netherlands, April 13-16. 15:1–15:15. https://doi.org/10.1145/2592798.2592814 Google ScholarGoogle ScholarDigital LibraryDigital Library
  18. Conal Elliot. 2008. Elegant memoization with functional memo tries. http://conal.net/blog/posts/elegant-memoization-with-functional-memo-triesGoogle ScholarGoogle Scholar
  19. Pascal Felber, Christof Fetzer, and Torvald Riegel. 2008. Dynamic performance tuning of word-based software transactional memory. In Proceedings of the 13th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP), Salt Lake City, UT, USA, February 20-23. 237–246. https://doi.org/10.1145/1345206.1345241 Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Richard F. Freitas and Winfried W. Wilcke. 2008. Storage-class memory: The next storage system technology. IBM Journal of Research & Development, 52, 4-5 (2008), 439–448. https://doi.org/10.1147/rd.524.0439 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Ben Gamari and Ömer Sinan Ağacan. 2019. COMPACT_NFDATA support for the nonmoving collector. https://gitlab.haskell.org/ghc/ghc/commit/77341c734f6c619d281c308b58a0f59b0b032aa2Google ScholarGoogle Scholar
  22. Ben Gamari and Laura Dietz. 2020. Alligator collector: a latency-optimized garbage collector for functional programming languages. In ACM SIGPLAN International Symposium on Memory Management (ISMM), June 16, 2020. 87–99. https://doi.org/10.1145/3381898.3397214 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. GHC Team. 2020. The Block Allocator. https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/rts/storage/block-allocGoogle ScholarGoogle Scholar
  24. GHC Team. 2020. GHC Commentary: The Layout of Heap Objects. https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/rts/storage/heap-objectsGoogle ScholarGoogle Scholar
  25. Justin E. Gottschlich and Daniel A. Connors. 2007. DracoSTM: A Practical C++ Approach to Software Transactional Memory. In Proceedings of the 2007 Symposium on Library-Centric Software Design, Montreal, Canada, October 21. 52–66. https://doi.org/10.1145/1512762.1512768 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Frank T. Hady, Annie P. Foong, Bryan Veal, and Dan Williams. 2017. Platform Storage Performance With 3D XPoint Technology. Proc. IEEE, 105, 9 (2017), 1822–1833. https://doi.org/10.1109/JPROC.2017.2731776 Google ScholarGoogle ScholarCross RefCross Ref
  27. Theo Haerder and Andreas Reuter. 1983. Principles of Transaction-Oriented Database Recovery. ACM Comput. Surv., 15, 4 (1983), 287–317. https://doi.org/10.1145/289.291 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. Cordelia V. Hall, Kevin Hammond, Will Partain, Simon L. Peyton Jones, and Philip Wadler. 1992. The Glasgow Haskell Compiler: A Retrospective. In Proceedings of the Glasgow Workshop on Functional Programming, Ayr, Scotland, UK, 6-8 July. 62–71. https://doi.org/10.1007/978-1-4471-3215-8_6 Google ScholarGoogle ScholarCross RefCross Ref
  29. Robert Harper. 1985. Modules and Persistence in Standard ML. In Data Types and Persistence. Edited Papers from the Proceedings of the First Workshop on Persistent Objects, Appin, Scotland, UK, August 1985, Malcolm P. Atkinson, Peter Buneman, and Ronald Morrison (Eds.) (Topics in Information Systems). Springer, 21–30.Google ScholarGoogle Scholar
  30. Tim Harris, Simon Marlow, Simon L. Peyton Jones, and Maurice Herlihy. 2005. Composable memory transactions. In Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP), June 15-17, 2005, Chicago, IL, USA. 48–60. https://doi.org/10.1145/1065944.1065952 Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. 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 ACM Symposium on Principles of Distributed Computing (PODC), Boston, Massachusetts, USA, July 13-16. 92–101. https://doi.org/10.1145/872035.872048 Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. 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), San Diego, CA, USA, May 1993. 289–300. https://doi.org/10.1145/165123.165164 Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Antony L. Hosking and Jiawan Chen. 1999. PM3: An Orthogonal Persistent Systems Programming Language - Design, Implementation, Performance. In Proceedings of 25th International Conference on Very Large Data Bases (VLDB), September 7-10, Edinburgh, Scotland, UK. 587–598.Google ScholarGoogle Scholar
  34. Paul Hudak, Simon L. Peyton Jones, Philip Wadler, Brian Boutel, Jon Fairbairn, Joseph H. Fasel, María M. Guzmán, Kevin Hammond, John Hughes, Thomas Johnsson, Richard B. Kieburtz, Rishiyur S. Nikhil, Will Partain, and John Peterson. 1992. Report on the Programming Language Haskell, A Non-strict, Purely Functional Language. ACM SIGPLAN Notices, 27, 5 (1992), https://doi.org/10.1145/130697.130699 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Joseph Izraelevitz, Jian Yang, Lu Zhang, Juno Kim, Xiao Liu, Amirsaman Memaripour, Yun Joon Soh, Zixuan Wang, Yi Xu, Subramanya R. Dulloor, Jishen Zhao, and Steven Swanson. 2019. Basic Performance Measurements of the Intel Optane DC Persistent Memory Module. CoRR, abs/1903.05714 (2019), arxiv:1903.05714Google ScholarGoogle Scholar
  36. Alfons Kemper and Donald Kossmann. 1993. Adaptable Pointer Swizzling Strategies in Object Bases. In Proceedings of the Ninth International Conference on Data Engineering, April 19-23, 1993, Vienna, Austria. IEEE Computer Society, 155–162. https://doi.org/10.1109/ICDE.1993.344067 Google ScholarGoogle ScholarCross RefCross Ref
  37. Emre Kultursay, Mahmut T. Kandemir, Anand Sivasubramaniam, and Onur Mutlu. 2013. Evaluating STT-RAM as an energy-efficient main memory alternative. In 2012 IEEE International Symposium on Performance Analysis of Systems & Software, Austin, TX, USA, 21-23 April, 2013. IEEE Computer Society, 256–267. https://doi.org/10.1109/ISPASS.2013.6557176 Google ScholarGoogle ScholarCross RefCross Ref
  38. Mengxing Liu, Mingxing Zhang, Kang Chen, Xuehai Qian, Yongwei Wu, Weimin Zheng, and Jinglei Ren. 2017. DudeTM: Building Durable Transactions with Decoupling for Persistent Memory. In Proceedings of the 22nd International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), Xi’an, China, April 8-12. 329–343. https://doi.org/10.1145/3037697.3037714 Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Simon Marlow, Tim Harris, Roshan P. James, and Simon L. Peyton Jones. 2008. Parallel generational-copying garbage collection with a block-structured heap. In Proceedings of the 7th International Symposium on Memory Management (ISMM), Tucson, AZ, USA, June 7-8. 11–20. https://doi.org/10.1145/1375634.1375637 Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. Alonso Marquez, Stephen Blackburn, Gavin Mercer, and John N. Zigman. 2000. Implementing Orthogonally Persistent Java. In Persistent Object Systems, 9th International Workshop, POS-9, Lillehammer, Norway, September 6-8, 2000, Revised Papers, Graham N. C. Kirby, Alan Dearle, and Dag I. K. Sjøberg (Eds.) (Lecture Notes in Computer Science, Vol. 2135). Springer, 247–261. https://doi.org/10.1007/3-540-45498-5_22 Google ScholarGoogle ScholarCross RefCross Ref
  41. Markus Mäsker, Tim Süß, Lars Nagel, Lingfang Zeng, and André Brinkmann. 2019. Hyperion: Building the Largest In-memory Search Tree. In Proceedings of the 2019 International Conference on Management of Data (SIGMOD), Amsterdam, The Netherlands, June 30 - July 5. 1207–1222. https://doi.org/10.1145/3299869.3319870 Google ScholarGoogle ScholarDigital LibraryDigital Library
  42. David J. McNally and Antony J. T. Davie. 1991. Two Models For Integrating Persistence and Lazy Functional Languages. ACM SIGPLAN Notices, 26, 5 (1991), 43–52. https://doi.org/10.1145/122501.122504 Google ScholarGoogle ScholarDigital LibraryDigital Library
  43. Chi Cao Minh, JaeWoong Chung, Christos Kozyrakis, and Kunle Olukotun. 2008. STAMP: Stanford Transactional Applications for Multi-Processing. In 4th International Symposium on Workload Characterization (IISWC), Seattle, Washington, USA, September 14-16, 2008. IEEE Computer Society, 35–46. https://doi.org/10.1109/IISWC.2008.4636089 Google ScholarGoogle ScholarCross RefCross Ref
  44. Ron Morrison, Richard Connor, Graham Kirby, David Munro, Malcolm Atkinson, Quintin Cutts, Alfred Brown, and Alan Dearie. 2000. The Napier88 Persistent Programming Language and Environment. 98–154. isbn:978-3-642-64055-1 https://doi.org/10.1007/978-3-642-59623-0_6 Google ScholarGoogle ScholarCross RefCross Ref
  45. Nafiseh Moti, Frederic Schimmelpfennig, Reza Salkhordeh, David Klopp, Toni Cortes, Ulrich Rückert, and André Brinkmann. 2021. Simurgh: A Fully Decentralized and Secure NVMM User Space File System. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC) (accepted for publication), St. Louis, MO, USA, November 14-19, 2021.Google ScholarGoogle ScholarDigital LibraryDigital Library
  46. Sanketh Nalli. 2018. GCC port of TM system Mnemosyne. https://github.com/snalli/mnemosyne-gccGoogle ScholarGoogle Scholar
  47. Luke Palmer. 2013. Data.MemoCombinators: Combinators for building memo tables. https://hackage.haskell.org/package/data-memocombinatorsGoogle ScholarGoogle Scholar
  48. Stuart S. P. Parkin, Masamitsu Hayashi, and Luc Thomas. 2008. Magnetic Domain-Wall Racetrack Memory. Science, 320, 5873 (2008), 190–194.Google ScholarGoogle Scholar
  49. Simon L. Peyton Jones. 1992. Implementing Lazy Functional Languages on Stock Hardware: The Spineless Tagless G-Machine. Journal of Functional Programming, 2, 2 (1992), 127–202. https://doi.org/10.1017/S0956796800000319 Google ScholarGoogle ScholarCross RefCross Ref
  50. Simon L. Peyton Jones, Andrew D. Gordon, and Sigbjørn Finne. 1996. Concurrent Haskell. In 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL), St. Petersburg Beach, Florida, USA, January 21-24. 295–308. https://doi.org/10.1145/237721.237794 Google ScholarGoogle ScholarDigital LibraryDigital Library
  51. Juan J. Quintela and Juan J. Sánchez. 2001. Persistent Haskell. In Computer Aided Systems Theory - EUROCAST 2001, Las Palmas de Gran Canaria, Spain, February 19-23, 2001, Revised Papers, Roberto Moreno-Díaz, Bruno Buchberger, and José Luis Freire (Eds.) (Lecture Notes in Computer Science, Vol. 2178). Springer, 657–667. https://doi.org/10.1007/3-540-45654-6_50 Google ScholarGoogle ScholarCross RefCross Ref
  52. Pedro Ramalhete, Andreia Correia, Pascal Felber, and Nachshon Cohen. 2019. OneFile: A Wait-Free Persistent Transactional Memory. In 49th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN), Portland, OR, USA, June 24-27, 2019. IEEE, 151–163. https://doi.org/10.1109/DSN.2019.00028 Google ScholarGoogle ScholarCross RefCross Ref
  53. Dulloor Subramanya Rao, Sanjay Kumar, Anil S. Keshavamurthy, Philip Lantz, Dheeraj Reddy, Rajesh Sankaran, and Jeff Jackson. 2014. System software for persistent memory. In Ninth Eurosys Conference 2014, EuroSys 2014, Amsterdam, The Netherlands, April 13-16, 2014, Dick C. A. Bulterman, Herbert Bos, Antony I. T. Rowstron, and Peter Druschel (Eds.). ACM, 15:1–15:15. https://doi.org/10.1145/2592798.2592814 Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Simone Raoux, Geoffrey W. Burr, Matthew J. Breitwisch, Charles T. Rettner, Yi-Chou Chen, Robert M. Shelby, Martin Salinga, Daniel Krebs, Shih-Hung Chen, Hsiang-Lan Lung, and Chung Hon Lam. 2008. Phase-change random access memory: A scalable technology. IBM Journal of Research and Development, 52, 4-5 (2008), 465–480.Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. Peter Robinson. 2019. concurrent-hashtable: Thread-safe hash tables for multi-cores!. http://hackage.haskell.org/package/concurrent-hashtableGoogle ScholarGoogle Scholar
  56. Andy Rudoff. 2017. Persistent Memory Programming. login Usenix Mag., 42, 2 (2017), https://www.usenix.org/publications/login/summer2017/rudoffGoogle ScholarGoogle Scholar
  57. Bratin Saha, Ali-Reza Adl-Tabatabai, Richard L. Hudson, Chi Cao Minh, and Ben Hertzberg. 2006. McRT-STM: a high performance software transactional memory system for a multi-core runtime. In Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP), New York, New York, USA, March 29-31. 187–197. https://doi.org/10.1145/1122971.1123001 Google ScholarGoogle ScholarDigital LibraryDigital Library
  58. Thomas Shull, Jian Huang, and Josep Torrellas. 2019. AutoPersist: an easy-to-use Java NVM framework based on reachability. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Phoenix, AZ, USA, June 22-26. 316–332. https://doi.org/10.1145/3314221.3314608 Google ScholarGoogle ScholarDigital LibraryDigital Library
  59. Christopher Strachey. 2000. Fundamental Concepts in Programming Languages. High. Order Symb. Comput., 13, 1/2 (2000), 11–49. https://doi.org/10.1023/A:1010000313106 Google ScholarGoogle ScholarDigital LibraryDigital Library
  60. Robert D. Tennent. 1977. Language Design Methods Based on Semantic Principles. Acta Informatica, 8 (1977), 97–112. https://doi.org/10.1007/BF00289243 Google ScholarGoogle ScholarCross RefCross Ref
  61. Katsuhiro Ueno and Atsushi Ohori. 2016. A fully concurrent garbage collector for functional programs on multicore processors. In Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming (ICFP), Nara, Japan, September 18-22. 421–433. https://doi.org/10.1145/2951913.2951944 Google ScholarGoogle ScholarDigital LibraryDigital Library
  62. Haris Volos, Andres Jaan Tack, and Michael M. Swift. 2011. Mnemosyne: lightweight persistent memory. In Proceedings of the 16th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), Newport Beach, CA, USA, March 5-11. 91–104. https://doi.org/10.1145/1950365.1950379 Google ScholarGoogle ScholarDigital LibraryDigital Library
  63. Michèle Weiland, Holger Brunst, Tiago Quintino, Nick Johnson, Olivier Iffrig, Simon D. Smart, Christian Herold, Antonino Bonanni, Adrian Jackson, and Mark Parsons. 2019. An early evaluation of Intel’s optane DC persistent memory module and its impact on high-performance scientific applications. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC), Denver, Colorado, USA, November 17-19. 76:1–76:19. https://doi.org/10.1145/3295500.3356159 Google ScholarGoogle ScholarDigital LibraryDigital Library
  64. Mingyu Wu, Haibo Chen, Hao Zhu, Binyu Zang, and Haibing Guan. 2020. GCPersist: an efficient GC-assisted lazy persistency framework for resilient Java applications on NVM. In VEE ’20: 16th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments, virtual event, Lausanne, Switzerland, March 17. 1–14. https://doi.org/10.1145/3381052.3381318 Google ScholarGoogle ScholarDigital LibraryDigital Library
  65. Mingyu Wu, Ziming Zhao, Haoyu Li, Heting Li, Haibo Chen, Binyu Zang, and Haibing Guan. 2018. Espresso: Brewing Java For More Non-Volatility with Non-volatile Memory. In Proceedings of the 23rd International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), Williamsburg, VA, USA, March 24-28. 70–83. https://doi.org/10.1145/3173162.3173201 Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. Jian Xu and Steven Swanson. 2016. NOVA: A Log-Structured File System for Hybrid Volatile/Non-Volatile Main Memories. login Usenix Mag., 41, 3 (2016), https://www.usenix.org/publications/login/fall2016/xuGoogle ScholarGoogle Scholar
  67. Jian Xu, Lu Zhang, Amirsaman Memaripour, Akshatha Gangadharaiah, Amit Borase, Tamires Brito Da Silva, Steven Swanson, and Andy Rudoff. 2017. NOVA-Fortis: A Fault-Tolerant Non-Volatile Main Memory File System. In Proceedings of the 26th Symposium on Operating Systems Principles (SOSP), Shanghai, China, October 28-31. 478–496. https://doi.org/10.1145/3132747.3132761 Google ScholarGoogle ScholarDigital LibraryDigital Library
  68. Edward Z. Yang, Giovanni Campagna, Ömer S. Agacan, Ahmed El-Hassany, Abhishek Kulkarni, and Ryan R. Newton. 2015. Efficient communication and collection with compact normal forms. In Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming, ICFP 2015, Vancouver, BC, Canada, September 1-3, 2015. ACM, 362–374. https://doi.org/10.1145/2784731.2784735 Google ScholarGoogle ScholarDigital LibraryDigital Library
  69. Ryan Yates and Michael L. Scott. 2017. Improving STM performance with transactional structs. In Proceedings of the 10th ACM SIGPLAN International Symposium on Haskell, Oxford, United Kingdom, September 7-8, 2017. ACM, 186–196. https://doi.org/10.1145/3122955.3122972 Google ScholarGoogle ScholarDigital LibraryDigital Library
  70. Ryan Yates and Michael L. Scott. 2019. Leveraging hardware TM in Haskell. In Proceedings of the 24th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP), Washington, DC, USA, February 16-20, 2019. ACM, 94–106. https://doi.org/10.1145/3293883.3295711 Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. Persistent software transactional memory in Haskell

      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!