Access Official Technical PDF

Share Summary:LinkedInEmail

Persistent memory could change how industrial automation systems handle data between a failure and a restart. Unlike conventional DRAM, which loses its contents when power is removed, non-volatile memory can retain data while allowing software to access it through memory operations. That combination may reduce the need to reload working data from storage, but it also shifts responsibility for consistency, recovery and software changes into the application and runtime.

For automation engineers and system integrators, the key point is that persistent memory is not simply a faster disk or a larger RAM module. It changes the boundary between volatile working state and durable data—and that boundary has long shaped how systems are designed to restart safely.

Persistent memory changes the memory hierarchy

Computing systems balance capacity, speed and cost across a hierarchy that includes processor caches, DRAM and storage such as flash or disk. Faster memory is generally more expensive and offers less capacity, while storage provides persistence at a different access speed and through different software interfaces.

Persistent memory sits between familiar categories. It retains data without power, yet can be accessed through a memory-mapped region rather than only through a conventional file or block interface. The 2019 whitepaper describes Intel Optane DC Persistent Memory as one example of this approach. Its cited figures show that this class of memory did not match DRAM’s speed and bandwidth, while offering a lower cost per bit. Those trade-offs matter: persistent memory should be evaluated as a distinct tier, not treated as interchangeable with DRAM.

In memory mode, persistent memory can extend the system’s memory capacity while DRAM serves as a cache. In App Direct mode, software can work with persistent regions directly. With Direct Access (DAX), a file-backed region can be mapped into a process’s address space, reducing the need for an intermediate buffer. The right model depends on whether the goal is capacity expansion or direct control over durable data.

Durability requires more than a memory write

A processor store may update a cache line without immediately making the change durable in non-volatile media. Software that needs a confirmed persistent update must account for the path from processor cache through the memory controller and module to the memory device.

The described programming approach uses cache write-back operations, such as CLWB, to move modified cache lines toward memory, followed by a fence such as SFENCE or MFENCE to wait for the operation to complete. The sequence matters: a program must not assume that a value is durable merely because another thread can read it. Cache coherence can make a change visible to another processor before it is safely persisted.

This distinction introduces a design requirement for concurrent systems: visibility and durability are separate states. Software may need an explicit mechanism to tell other threads when an update has become durable. Applications also need to define which updates must be atomic and what state is valid after an interruption.

Recovery and consistency become application concerns

Conventional systems often treat memory as a working area that can be discarded after a failure, then reconstruct needed state from storage. When working data itself persists, a restart may encounter a partially completed update. Recovery must restore a consistent state rather than simply resume from whatever bytes remain.

Transactions, logging and checkpoints are established ways to manage this problem. A transaction can make a group of changes atomic: the system either commits the complete update or rolls it back. A checkpoint records a known state, while later changes can be discarded or replayed during recovery. These mechanisms are useful only when the software identifies appropriate consistency boundaries.

One proposed design divides memory into persistent regions and volatile regions. Each region can be checkpointed independently or together with others. Between checkpoints, changes form an epoch; if the system restarts before the latest epoch is committed, recovery can revert to the last completed checkpoint. This approach makes recovery boundaries explicit, but requires application code to place checkpoints where its data is consistent.

References, software updates and external state

Persistent data may be mapped at a different address after restart. Pointers that store absolute addresses can therefore become invalid. Position-independent representations, such as self-relative pointers, avoid depending on a fixed mapping address. Relocating pointers after attachment is another option, but can be difficult for large data structures and can itself be interrupted by a crash.

References between persistent and volatile data create a related lifetime problem: volatile objects disappear on restart, while persistent objects remain. A persistent object should not retain a reference to state that no longer exists unless software can detect and repair that reference before it is used. Files, network connections and process identifiers are examples of references to external state that may be invalid after a restart.

Data structures also change as software evolves. A newer program version may expect fields or relationships that older persistent data does not contain. This is the persistence equivalent of database schema evolution: systems need a deliberate strategy to transform stored data while preserving object identity, sharing and consistency.

Practical considerations for automation teams

Persistent memory can potentially reduce startup work by avoiding the need to reload all working data from block storage, and it can make updates durable without a conventional storage round trip. But these benefits depend on the workload and implementation; they do not remove the need for reliable recovery or backups.

Before adopting persistent memory, technical teams should assess:

  • Data boundaries: Which information is durable, and which is temporary working state?
  • Recovery behavior: How will the system handle a power loss during an update or an uncorrectable memory error?
  • Checkpoint strategy: Where can the application establish a consistent state, and how much data must be recovered?
  • Software lifecycle: How will persistent data be migrated when software or data structures change?
  • Security: Does retaining more live state in memory change the system’s exposure to unauthorized access or tampering?

These questions are especially relevant where automation software must recover predictably and maintain correct relationships between data and external equipment or services. Persistent memory provides a new storage tier, not an automatic guarantee of application-level consistency.

Conclusion

Persistent memory blurs the traditional line between memory and storage. Its combination of memory-style access and non-volatile retention can reduce data reloads and support durable updates, but it also makes restart behavior, transaction design, pointer validity, software evolution and security central engineering concerns. For automation decision-makers, the practical starting point is to identify which data must survive failure and define how the application will restore a known, consistent state before selecting a persistence model.

Access Official Technical PDF

About The Author