scholarly journals Persistent software transactional memory in Haskell

2021 ◽  
Vol 5 (ICFP) ◽  
pp. 1-29
Author(s):  
Nicolas Krauter ◽  
Patrick Raaf ◽  
Peter Braam ◽  
Reza Salkhordeh ◽  
Sebastian Erdweg ◽  
...  
Keyword(s):  
Memory Management ◽  
Transactional Memory ◽  
Software Transactional Memory ◽  
Data Types ◽  
System Failures ◽  
Persistent Memory ◽  
Execution Model ◽  
Persistent Data ◽  
High Level ◽  
Automatic Memory

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.

scholarly journals PETRA

2021 ◽  
Vol 18 (2) ◽  
pp. 1-26
Author(s):  
Ramin Izadpanah ◽  
Christina Peterson ◽  
Yan Solihin ◽  
Damian Dechev
Keyword(s):  
Data Structures ◽  
High Performance ◽  
Transactional Memory ◽  
Superior Performance ◽  
New Approach ◽  
Ordering Constraints ◽  
Level Information ◽  
Order Of Magnitude ◽  
Persistent Data ◽  
High Level

Emerging byte-addressable Non-Volatile Memories (NVMs) enable persistent memory where process state can be recovered after crashes. To enable applications to rely on persistent data, durable data structures with failure-atomic operations have been proposed. However, they lack the ability to allow users to execute a sequence of operations as transactions. Meanwhile, persistent transactional memory (PTM) has been proposed by adding durability to Software Transactional Memory (STM). However, PTM suffers from high performance overheads and low scalability due to false aborts, logging, and ordering constraints on persistence. In this article, we propose PETRA, a new approach for constructing persistent transactional linked data structures. PETRA natively supports transactions, but unlike PTM, relies on the high-level information from the data structure semantics. This gives PETRA unique advantages in the form of high performance and high scalability. Our experimental results using various benchmarks demonstrate the scalability of PETRA in all workloads and transaction sizes. PETRA outperforms the state-of-the-art PTMs by an order of magnitude in transactions of size greater than one, and demonstrates superior performance in transactions of size one.

scholarly journals Composable scheduler activations for Haskell

2016 ◽  
Vol 26 ◽  
Author(s):  
K. C. SIVARAMAKRISHNAN ◽  
TIM HARRIS ◽  
SIMON MARLOW ◽  
SIMON PEYTON JONES
Keyword(s):  
Operating System ◽  
Transactional Memory ◽  
Runtime System ◽  
Software Transactional Memory ◽  
High Level Language ◽  
High Level

AbstractThe runtime for a modern, concurrent, garbage collected language like Java or Haskell is like an operating system: sophisticated, complex, performant, but alas very hard to change. If more of the runtime system were in the high-level language, it would be far more modular and malleable. In this paper, we describe a novel concurrency substrate design for the Glasgow Haskell Compiler that allows multicore schedulers for concurrent and parallel Haskell programs to be safely and modularly described as libraries in Haskell. The approach relies on abstracting the interface to the user-implemented schedulers through scheduler activations, together with the use of Software Transactional Memory to promote safety in a multicore context.

scholarly journals Distributed communication in ML

2000 ◽  
Vol 10 (1) ◽  
pp. 91-120
Author(s):  
MARK HAYDEN
Keyword(s):  
Programming Languages ◽  
Memory Management ◽  
Group Communication ◽  
Careful Attention ◽  
Distributed Communication ◽  
High Level ◽  
Automatic Memory ◽  
High Level Abstraction

We present our experience in implementing a group communication toolkit in Objective Caml, a dialect of the ML family of programming languages. We compare the toolkit both quantitatively and qualitatively to a predecessor toolkit which was implemented in C. Our experience shows that using the high-level abstraction features of ML gives substantial advantages. Some of these features, such as automatic memory management and message marshalling, allowed us to concentrate on those pieces of the implementation which required careful attention in order to achieve good performance. We conclude with a set of suggested changes to ML implementations.

scholarly journals Revisiting software transactional memory in Haskell

2018 ◽  
Vol 51 (12) ◽  
pp. 105-113
Author(s):  
Matthew Le ◽  
Ryan Yates ◽  
Matthew Fluet
Keyword(s):  
Transactional Memory ◽  
Software Transactional Memory
Sign in / Sign up

Export Citation Format

Share Document