# Improving the Performance and Endurance of Persistent Memory with Loose-Ordering Consistency

## TL;DR

This paper proposes Loose-Ordering Consistency (LOC), a mechanism that improves persistent memory performance and endurance by relaxing strict write ordering through techniques like Eager Commit and Speculative Persistence, enabling faster recovery and reduced overhead.

## Contribution

LOC introduces a novel approach to reduce performance and endurance loss in persistent memory by relaxing ordering constraints with static metadata and speculative writes.

## Key findings

- LOC reduces performance overhead from 66.9% to 34.9%.
- LOC decreases memory write traffic overhead from 17.1% to 3.4%.
- LOC maintains correctness while improving efficiency.

## Abstract

Persistent memory provides high-performance data persistence at main memory. Memory writes need to be performed in strict order to satisfy storage consistency requirements and enable correct recovery from system crashes. Unfortunately, adhering to such a strict order significantly degrades system performance and persistent memory endurance. This paper introduces a new mechanism, Loose-Ordering Consistency (LOC), that satisfies the ordering requirements at significantly lower performance and endurance loss. LOC consists of two key techniques. First, Eager Commit eliminates the need to perform a persistent commit record write within a transaction. We do so by ensuring that we can determine the status of all committed transactions during recovery by storing necessary metadata information statically with blocks of data written to memory. Second, Speculative Persistence relaxes the write ordering between transactions by allowing writes to be speculatively written to persistent memory. A speculative write is made visible to software only after its associated transaction commits. To enable this, our mechanism supports the tracking of committed transaction ID and multi-versioning in the CPU cache. Our evaluations show that LOC reduces the average performance overhead of memory persistence from 66.9% to 34.9% and the memory write traffic overhead from 17.1% to 3.4% on a variety of workloads.