# US 2025/0147694 A1 · Write ordering for persistent memory

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2025/0147694 A1
- Document ID: US20250147694A1
- Status: Published application
- Kind: A1
- Application number: 18/943,522
- Filed: 2024-11-11
- Published: 2025-05-08
- Earliest claimed: 2020-04-20
- Assignees: NetApp, Inc.
- Applicants: NetApp, Inc.
- Inventors: Ram Kesavan; Matthew Fontaine Curtis-Maury; Abdul Basit; Vinay Devadas; Ananthan Subramanian
- Web page: https://patentgrep.com/patent/US20250147694A1

## CPC

- G06F 3/0659: {Command handling arrangements, e.g. command buffers, queues, command scheduling}
- G06F 11/1453: {using de-duplication of the data}
- G06F 3/061: {Improving I/O performance}
- G06F 3/0619: {in relation to data integrity, e.g. data losses, bit errors}
- G06F 3/0644: {Management of space entities, e.g. partitions, extents, pools}
- G06F 3/0653: {Monitoring storage devices or systems}
- G06F 3/067: {Distributed or networked storage systems, e.g. storage area networks [SAN], network attached storage [NAS]}
- G06F 3/0683: {Plurality of storage devices}
- G06F 11/1417: {Boot up procedures}
- G06F 11/1464: {for networked environments}
- G06F 11/1469: {Backup restoration techniques}
- G06F 11/1471: involving logging of persistent data for recovery
- G06F 11/2028: {eliminating a faulty processor or activating a spare}
- G06F 11/2038: {with a single idle spare processing component}
- G06F 11/2048: {where the redundant components share neither address space nor persistent storage}
- G06F 11/2094: {Redundant storage or storage space (G06F11/2056 takes precedence)}
- G06F 11/2097: {maintaining the standby controller/processing unit updated (initialisation or re-synchronisation thereof G06F11/1658 and subgroups)}
- G06F 2201/84: Using snapshots, i.e. a logical point-in-time copy of the data
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Techniques are provided for implementing write ordering for persistent memory. A set of actions are identified for commitment to persistent memory of a node for executing an operation upon the persistent memory. An episode is created to comprise a first subset of actions of the set of actions that can be committed to the persistent memory in any order with respect to one another such that a consistent state of the persistent memory can be reconstructed in the event of a crash of the node during execution of the operation. The first subset of actions within the episode are committed to the persistent memory and further execution of the operation is blocked until the episode completes.

## Claims

### Claim at position 1

1-20. (canceled)

### Claim 21

A method, comprising:
writing data into persistent memory of a node according to a byte-addressable format;
creating a first entry within a log to track the data being written into the persistent memory;
identifying existing data within the persistent memory that is being overwritten by the data being written to the persistent memory;
creating a second entry within the log to track the existing data being overwritten by the data being written to the persistent memory; and
in response to detecting the node recovering from a failure, initiating a reconstruction process that utilizes the first entry and second entry to reconstruct the persistent memory into a consistent state.

### Claim 22 (depends on 21)

The method of claim 21, comprising:
grouping one or more actions to commit to the persistent memory in any order while retaining an ability to reconstruct the persistent memory into the consistent state, wherein an action of the one or more actions includes writing the data into the persistent memory.

### Claim 23 (depends on 21)

The method of claim 21, comprising:
mirroring stored data within the persistent memory of the node to a partner persistent memory of a partner node; and
in response to the node failing, redirecting I/O operations from targeting the node to targeting the partner node for commitment to the partner persistent memory.

### Claim 24 (depends on 23)

The method of claim 23, comprising:
in response to detecting the failure of the node, reconstructing the partner persistent memory into the consistent state before redirecting the I/O operations.

### Claim 25 (depends on 21)

The method of claim 21, comprising:
identifying a plurality of actions of a write operation to write the data to the persistent memory;
grouping a first subset of the plurality of actions into a first group to commit the persistent memory in any order while retaining an ability to reconstruct the persistent memory into the consistent state; and
committing the first subset of the plurality of actions to the persistent memory.

### Claim 26 (depends on 25)

The method of claim 25, comprising:
grouping a second subset of the plurality of actions into a second group to commit the persistent memory in any order while retaining an ability to reconstruct the persistent memory into the consistent state; and
committing the second subset of the plurality of actions to the persistent memory.

### Claim 27 (depends on 26)

The method of claim 26, comprising:
sequentially committing the first subset of the plurality of actions and the second subset of the plurality of actions to the persistent memory.

### Claim 28 (depends on 26)

The method of claim 26, comprising:
committing the first subset of the plurality of actions to the persistent memory; and
mirroring the first subset of the plurality of actions to a partner node for commitment to a partner persistent memory.

### Claim 29 (depends on 28)

The method of claim 28, comprising:
in response to successfully committing the first subset of the plurality of actions to the persistent memory and before the partner node responds that the first subset of the plurality of actions were successfully committed to the partner persistent memory, committing the second subset of the plurality of actions to the persistent memory.

### Claim 30

A node comprising:
a memory storing instructions; and
a processor coupled to the memory, the processor configured to execute the instructions to cause the node to:
write data into persistent memory of the node according to a byte-addressable format;
create a first entry within a log to track the data being written into the persistent memory;
identify existing data within the persistent memory that is being overwritten by the data being written to the persistent memory;
create a second entry within the log to track the existing data being overwritten by the data being written to the persistent memory; and
in response to detecting the node recovering from a failure, initiate a reconstruction process that utilizes the first entry and second entry to reconstruct the persistent memory into a consistent state.

### Claim 31 (depends on 30)

The node of claim 30, wherein the instructions cause the node to:
group a first subset of actions of an operation, targeting the persistent memory, into a first group of actions to commit to the persistent memory in any order while retaining an ability to reconstruct the persistent memory into the consistent state; and
commit the first group of actions to the persistent memory.

### Claim 32 (depends on 31)

The node of claim 31, wherein the instructions cause the node to:
group a second subset of the actions of the operation into a second group of actions to commit to the persistent memory in any order while retaining an ability to reconstruct the persistent memory into the consistent state; and
commit the second group of actions to the persistent memory.

### Claim 33 (depends on 32)

The node of claim 32, wherein the instructions cause the node to:
sequentially commit the first group of actions and then the second group of actions to the persistent memory.

### Claim 34 (depends on 32)

The node of claim 32, wherein the instructions cause the node to:
commit the first group of actions to the persistent memory; and
mirror the first group of actions to a partner node for commitment to a partner persistent memory.

### Claim 35 (depends on 34)

The node of claim 34, wherein the instructions cause the node to:
in response to successfully committing the first group of actions to the persistent memory and before the partner node responds that the first group of actions were successfully committed to the partner persistent memory, committing the second group of actions to the persistent memory.

### Claim 36

A non-transitory machine readable medium comprising instructions for performing a method, which when executed by a node, causes the node to:
write data into persistent memory of a node according to a byte-addressable format;
create a first entry within a log to track the data being written into the persistent memory;
identify existing data within the persistent memory that is being overwritten by the data being written to the persistent memory;
create a second entry within the log to track the existing data being overwritten by the data being written to the persistent memory; and
in response to detecting the node recovering from a failure, initiate a reconstruction process that utilizes the first entry and second entry to reconstruct the persistent memory into a consistent state.

### Claim 37 (depends on 36)

The non-transitory machine readable medium of claim 36, wherein the instructions cause the node to:
create a group of actions to commit to the persistent memory in any order while retaining an ability to reconstruct the persistent memory into the consistent state.

### Claim 38 (depends on 36)

The non-transitory machine readable medium of claim 36, wherein the instructions cause the node to:
redirect I/O operations from targeting the node to targeting a partner node for commitment to a partner persistent memory of the partner node based upon the node failing.

### Claim 39 (depends on 38)

The non-transitory machine readable medium of claim 38, wherein the instructions cause the node to:
reconstruct the partner persistent memory into the consistent state before redirecting the I/O operations.

### Claim 40 (depends on 36)

The non-transitory machine readable medium of claim 36, wherein the instructions cause the node to:
accumulate actions into a group of actions to commit to the persistent memory in any order while retaining an ability to reconstruct the persistent memory into the consistent state.
