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.
Supplemental Material
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Ö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 Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Paul Chiusano. 2020. How Unison reduces ecosystem churn. https://www.unisonweb.org/2020/04/10/reducing-churn/Google Scholar
- 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 Scholar
Digital Library
- Richard C. H. Connor. 1991. Types and polymorphism in persistent programming systems. Ph.D. Dissertation. University of St Andrews.Google Scholar
- Alberto G. Corona. 2017. TCache: A Transactional cache with user-defined persistence. http://hackage.haskell.org/package/TCacheGoogle Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Conal Elliot. 2008. Elegant memoization with functional memo tries. http://conal.net/blog/posts/elegant-memoization-with-functional-memo-triesGoogle Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Ben Gamari and Ömer Sinan Ağacan. 2019. COMPACT_NFDATA support for the nonmoving collector. https://gitlab.haskell.org/ghc/ghc/commit/77341c734f6c619d281c308b58a0f59b0b032aa2Google Scholar
- 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 Scholar
Digital Library
- GHC Team. 2020. The Block Allocator. https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/rts/storage/block-allocGoogle Scholar
- GHC Team. 2020. GHC Commentary: The Layout of Heap Objects. https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/rts/storage/heap-objectsGoogle Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
- 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 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 ACM Symposium on Principles of Distributed Computing (PODC), Boston, Massachusetts, USA, July 13-16. 92–101. 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), San Diego, CA, USA, May 1993. 289–300. https://doi.org/10.1145/165123.165164 Google Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- Sanketh Nalli. 2018. GCC port of TM system Mnemosyne. https://github.com/snalli/mnemosyne-gccGoogle Scholar
- Luke Palmer. 2013. Data.MemoCombinators: Combinators for building memo tables. https://hackage.haskell.org/package/data-memocombinatorsGoogle Scholar
- Stuart S. P. Parkin, Masamitsu Hayashi, and Luc Thomas. 2008. Magnetic Domain-Wall Racetrack Memory. Science, 320, 5873 (2008), 190–194.Google Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Peter Robinson. 2019. concurrent-hashtable: Thread-safe hash tables for multi-cores!. http://hackage.haskell.org/package/concurrent-hashtableGoogle Scholar
- Andy Rudoff. 2017. Persistent Memory Programming. login Usenix Mag., 42, 2 (2017), https://www.usenix.org/publications/login/summer2017/rudoffGoogle Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Robert D. Tennent. 1977. Language Design Methods Based on Semantic Principles. Acta Informatica, 8 (1977), 97–112. https://doi.org/10.1007/BF00289243 Google Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
Index Terms
Persistent software transactional memory in Haskell
Recommendations
Revisiting software transactional memory in Haskell
Haskell '16Software Transactional Memory (STM) has become very popular in Haskell. Currently, there are nearly 500 packages on Haskell’s package archive that directly use STM. Despite the widespread use in real world applications, Haskell’s STM implementation has ...
Persistent Transactional Memory
This paper proposes persistent transactional memory (PTM), a new design that adds durability to transactional memory (TM) by incorporating with the emerging non-volatile memory (NVM). PTM dynamically tracks transactional updates to cache lines to ensure ...
Transactional memory: from semantics to silicon
IWMSE '08: Proceedings of the 1st international workshop on Multicore software engineeringMulti-core architectures bring parallel programming into the mainstream. Parallel programming poses many new challenges to the developer, one of which is synchronizing concurrent access to shared memory by multiple threads. Programmers have ...






Comments