Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
skip to main content
research-article
Open access

Persistent software transactional memory in Haskell

Published: 19 August 2021 Publication History

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.

Supplementary Material

Auxiliary Presentation Video (icfp21main-p6-p-video.mp4)
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.
MP4 File (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
[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
[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
[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.pdf
[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/
[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
[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
[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
[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
[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
[11]
Paul Chiusano. 2020. How Unison reduces ecosystem churn. https://www.unisonweb.org/2020/04/10/reducing-churn/
[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
[13]
Richard C. H. Connor. 1991. Types and polymorphism in persistent programming systems. Ph.D. Dissertation. University of St Andrews.
[14]
Alberto G. Corona. 2017. TCache: A Transactional cache with user-defined persistence. http://hackage.haskell.org/package/TCache
[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
[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
[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
[18]
Conal Elliot. 2008. Elegant memoization with functional memo tries. http://conal.net/blog/posts/elegant-memoization-with-functional-memo-tries
[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
[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
[21]
Ben Gamari and Ömer Sinan Ağacan. 2019. COMPACT_NFDATA support for the nonmoving collector. https://gitlab.haskell.org/ghc/ghc/commit/77341c734f6c619d281c308b58a0f59b0b032aa2
[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
[23]
GHC Team. 2020. The Block Allocator. https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/rts/storage/block-alloc
[24]
GHC Team. 2020. GHC Commentary: The Layout of Heap Objects. https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/rts/storage/heap-objects
[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
[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
[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
[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
[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.
[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
[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
[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
[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.
[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
[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.05714
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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.
[46]
Sanketh Nalli. 2018. GCC port of TM system Mnemosyne. https://github.com/snalli/mnemosyne-gcc
[47]
Luke Palmer. 2013. Data.MemoCombinators: Combinators for building memo tables. https://hackage.haskell.org/package/data-memocombinators
[48]
Stuart S. P. Parkin, Masamitsu Hayashi, and Luc Thomas. 2008. Magnetic Domain-Wall Racetrack Memory. Science, 320, 5873 (2008), 190–194.
[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
[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
[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
[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
[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
[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.
[55]
Peter Robinson. 2019. concurrent-hashtable: Thread-safe hash tables for multi-cores!. http://hackage.haskell.org/package/concurrent-hashtable
[56]
Andy Rudoff. 2017. Persistent Memory Programming. login Usenix Mag., 42, 2 (2017), https://www.usenix.org/publications/login/summer2017/rudoff
[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
[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
[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
[60]
Robert D. Tennent. 1977. Language Design Methods Based on Semantic Principles. Acta Informatica, 8 (1977), 97–112. https://doi.org/10.1007/BF00289243
[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
[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
[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
[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
[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
[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/xu
[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
[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
[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
[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

Cited By

View all
  • (2023)PM.NET: Uma biblioteca de desenvolvimento para memória persistente com C#Anais do XXIV Simpósio em Sistemas Computacionais de Alto Desempenho (SSCAD 2023)10.5753/wscad.2023.235779(325-336)Online publication date: 17-Oct-2023

Recommendations

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages
Proceedings of the ACM on Programming Languages  Volume 5, Issue ICFP
August 2021
1011 pages
EISSN:2475-1421
DOI:10.1145/3482883
Issue’s Table of Contents
This work is licensed under a Creative Commons Attribution International 4.0 License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 19 August 2021
Published in PACMPL Volume 5, Issue ICFP

Permissions

Request permissions for this article.

Check for updates

Badges

Author Tags

  1. non-volatile heap
  2. persistent transaction support

Qualifiers

  • Research-article

Contributors

Other Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

  • Downloads (Last 12 months)148
  • Downloads (Last 6 weeks)17
Reflects downloads up to 15 Oct 2024

Other Metrics

Citations

Cited By

View all
  • (2023)PM.NET: Uma biblioteca de desenvolvimento para memória persistente com C#Anais do XXIV Simpósio em Sistemas Computacionais de Alto Desempenho (SSCAD 2023)10.5753/wscad.2023.235779(325-336)Online publication date: 17-Oct-2023

View Options

View options

PDF

View or Download as a PDF file.

PDF

eReader

View online with eReader.

eReader

Get Access

Login options

Full Access

Media

Figures

Other

Tables

Share

Share

Share this Publication link

Share on social media