Persistent memory is a groundbreaking technology that offers a way to address critical

performance bottlenecks inherent in traditional systems that rely on legacy hardware.

Although slower than volatile memory, persistent memory offers non-volatility with signif-

icantly better performance than traditional storage solutions, enabling new ways to design

durable systems. However, building correct and performant durable systems that use per-

sistent memory can be very challenging. Firstly, the development is complicated by the

need to insert additional logic to ensure that an application executes in a crash-consistent

way. Secondly, documentation is often obscure or ambiguous, potentially leaving develop-

ers confused about the behaviour of memory instructions, which leaves a formal memory

model as the only reliable source of truth. Lastly, the performance of crash-consistent

applications is negatively impacted by the slower-than-DRAM hardware medium and the

additional logic required to ensure crash consistency. This leads to the need for persistent

memory developers to have an in-depth expertise in memory models, multicore architec-

tures and correctness conditions for crash-consistent applications. Having expertise in all

of these fields, developers can easily introduce incorrect program behaviours by simply

forgetting to add crash-consistency logic for parts of the code base. Such incorrect be-

haviour is challenging to detect, as it only manifests in specific crash recovery scenarios

and remains undetectable during normal execution.

At the core of this research is Mangosteen, a framework designed to easily transform

arbitrary in-memory objects for use with persistent memory on x86 architectures. Man-

gosteen is designed with four key objectives: to abstract developers from the complexities

of weak memory architectures, to deliver high performance, to support a wide range of

use cases, and to ensure correctness. Unlike solutions that require the application to be

originally designed with specific mechanisms such as failure-atomic sections or persistent

transactional memory, Mangosteen can be integrated with any linearizable deadlock-free

application to produce a durably linearizable deadlock-free version.

Developers do not need to understand the internal workings of persistent memory to

use the Mangosteen framework. The original application code, integrated with Mangos-

teen, gains support for concurrent read operations and ensures the correct durability of

data several times faster than any solution that relies on legacy storage hardware. The

integration is made simple by Mangosteen’s callback interface, which invokes application-

specific code when needed. Callbacks act as wrappers around the original object methods

and do not require changes to the internal logic of the original code base. Mangosteen

achieves high performance by co-designing concurrency with persistency, which results in

a performance-friendly access pattern, avoiding the unnecessary overheads of persistent

memory hardware. Finally, Mangosteen adheres PTSOsyn - a formal model that describes

the behaviour of x86 architectures with persistent memory. This allows formal reasoning

about the behaviour of applications transformed using the Mangosteen framework.