Quick Start Guide Part 1: Provisioning Basics for Intel® Optane™ Persistent Memory

By Joseph E Oster


Intel® Optane™ persistent memory(PMem) is a disruptive technology that creates a new tier between memory and storage. Intel Optane™ PMem modules support two modes -  Memory Mode for volatile use cases, and App Direct Mode, which provides byte-addressable persistent storage. 

In this guide, we provide instructions for configuring and managing Intel Optane PMem modules. The following tools are covered:

  • ipmctl - Intel Persistent Memory Control - is an open-source utility created and maintained by Intel specifically for configuring and managing Intel Optane memory modules. It is available for both Linux* and Windows* from the ipmctl project page on GitHub*. 
  • ndctl - non-volatile Device Control is an open-source utility used for managing namespaces in Linux for Persistent Memory namespace management.
  • PowerShell* - Microsoft* has created PowerShell cmdlets for Persistent Memory disk management

The quick start guide (QSG) has three sections:

  1. Quick Start Guide Part 1: Provisioning Basics for Intel® Optane™ Persistent Memory
  2. Quick Start Guide Part 2: Linux Provisioning for Intel® Optane™ Persistent Memory
  3. Quick Start Guide Part 3: Windows Provisioning for Intel® Optane™ Persistent Memory


Persistent Memory Provisioning Concepts

This section describes the basic terminology and concepts that apply to the configuration and management ofNon Volatile Dual In-line Memory Modules (NVDIMMs).


Direct Access (DAX) is a mechanism that allows applications to directly access persistent media from the CPU (through loads and stores), bypassing the traditional I/O stack (page cache and block layer). File systems supporting DX include Linux ext4 and XFS, and Windows NTFS. Through memory mapping, these file systems bypass the I/O subsystem and directly use PMem as byte-addressable load/store memory. For PMem, this is the fastest and shortest path to stored data. Eliminating the software overhead of the I/O stack is essential to take advantage of persistent memory's extremely low latencies, which is critical for small and random I/O operations.


The PMem modules support labels, which allow the definition of namespaces inside regions. A Label contains the necessary metadata to define a namespace, and it is stored within the modules. Think of namespaces as a way to divide the available space within a region in a similar way in which one would use partitions with regular HDDs and SSDs.


A namespace defines a contiguously addressed range of non-volatile memory conceptually similar to a hard disk partition, SCSI logical unit (LUN), or an NVM Express* namespace. It is the unit of PMem storage that appears in /dev as a device used for input/output (I/O). Namespaces are associated with App Direct Mode only. Intel recommends using the ndctl utility for creating namespaces for the Linux operating system.

Diagram mapping Diagram physical address space Diagram namespaces
"Regions" are created within interleaved or non-interleaved sets. Interleaving implies n-way mapping. Creates contiguous physical address space and provides striped reads and writes for better throughput. Similar to SSD, the raw capacity of a region is partitioned into one or more logical devices called namespaces.

Persistent Memory Access Modes

You can use PMem devices in the following modes

  • Filesystem-DAX mode is the default mode of a namespace when specifying ndctl create-namespace with no options. The DAX capability enables workloads / working-sets that would exceed the capacity of the page cache to scale up to the capacity of PMem. Workloads that fit in page cache or perform bulk data transfers may not see benefit from DAX. When in doubt, pick this mode.
  • devdax: Device-DAX mode enables similar mmap(2) DAX mapping capabilities as Filesystem-DAX. However, instead of a block-device that can support a DAX-enabled filesystem, this mode emits a single character device file (/dev/daxX.Y). Use this mode to assign PMem to a virtual-machine, register persistent memory for RDMA, or when gigantic mappings are needed.
  • sector: Use this mode to host legacy filesystems that do not checksum metadata or applications that are not prepared for torn sectors after a crash. The expected usage for this mode is for small boot volumes. This mode is compatible with other operating systems.
  • raw: Raw mode is effectively just a memory disk that does not support DAX. This mode is compatible with other operating systems, but again, does not support DAX operation.


A region is a group of one or more NVDIMMs, also known as an interleaved set. The Regions are created in interleaved or non-interleaved configurations. Interleaving is a technique that makes multiple PMem devices appear as a single logical virtual address space. It allows spreading adjacent virtual addresses within a page across multiple memory devices. This hardware-level parallelism increases the available bandwidth from the devices. Regions can only be created or changed on Intel Optane's PMem using ipmctl.

Which Operating Mode to Use

Intel Optane PMem is configured into one of three basic memory modes  (Memory Mode, App Direct Mode, and mixed-mode). It is difficult to generalize which of the two main modes (Memory Mode or App Direct Mode) is the best given the number of variables involved. That is, performance behavior is application dependent. Nevertheless, we can say that, in general, Memory Mode helps those applications constrained by main memory size, while App Direct helps in reducing I/O bottlenecks.

Optimal performance is gained when application developers determine which data structures belong in which of the memory and/or storage tiers: DRAM, PMem, and non-volatile storage (SSDs, HDDs). With the aid of profiling tools, developers can characterize application workloads and evaluate which Memory Mode best fits each application. Applications should be tested in both modes to fully determine what optimizations are necessary to achieve the maximum performance and benefits of PMem.

For an application to take advantage of App Direct Mode, the application will require some code changes and the use of PMDK.

More information about these topics:

Memory Mode

In Memory Mode, the installed Intel® Optane™ PMem modules act as system memory, and the DRAM capacity acts as an extra level of cache. The persistent memory capacity is managed by the memory controller of the CPU, which means that the operating system does not have direct access. Memory Mode works well in those situations where the application's working set fits within the DRAM size, but more capacity is needed to avoid going to disk.
Although the media is persistent, data is always volatile in Memory mode. This is achieved by cryptographically erasing all the data in every system reboot. 

App Direct Mode

In the App Direct Mode, the PMem capacity is exposed to the operating system as special block devices. These block devices are then used by applications to speed up their I/O paths, by either (1) replacing traditional non-volatile devices—such as SSDs or HDDs—for their I/O needs, or (2) by directly persisting their data structures (avoiding the I/O stack altogether, by using DAX),

Although the primary use case for App Direct Mode is persistence, using it as an additional pool of volatile memory is also possible.

Using this mode usually results in performance improvement, but not always. If I/O is done in large, sequential chunks, and the page cache is effective in keeping the most used blocks in DRAM, traditional I/O can still be the best approach. Keep in mind though that sometimes a large amount of DRAM is needed to make the page cache effective, and PMem can avoid that extra cost by not using a page cache at all. In general, PMem is better for small, random I/O. Applications can benefit from this by re-designing their I/O paths. Going from serialization, buffering, and large sequential I/O, to directly persisting their data structures and doing updates at cache line granularity.

Mixed Mode

When PMem is configured with only a portion of the capacity being assign as Memory Mode(<100%), the remaining capacity is available to be used in App Direct Mode.
Note: When part or all of PMem module capacity is allocated to Memory mode, all the DRAM capacity is hidden from the application and becomes the last-level cache.

Hardware Requirements

The following hardware components are required:

  • Main system board supporting 2nd generation Intel® Xeon® Scalable processors
  • Intel® Optane™ persistent memory modules
  • DRAM

To make purchases of Intel Optane Persistent memory, please contact your server OEM or supplier. Generally, you will need to talk to a knowledgeable sales rep as the websites frequently don't list PMEM. On intel.com, we have a page where you can request information on how to buy servers with Intel technologies.

PMem Provisioning Overview

Provisioning PMem is a one or two-step process depending on the Memory ode used.

  1. Configuring the Goal - During this process, a goal is specified and stored on the PMem modules and applied on the next reboot. A goal configures memory modules in Memory Mode, App Direct mode, or mixed-mode. The goal is set in one of two ways:
    • BIOS Provisioning - PMem modules can be provisioned using options provided in the BIOS. Please refer to the documentation provided by your system vendor.
    • ipmctl Provisioning - ipmctl, is available for the UEFI shell and as a command-line utility for both Linux and Windows
  2. Configuring namespaces - Only App Direct Mode needs namespaces configured, and this is an OS-specific operation done with the following tools. Detailed instructions are defined in part 2 and part 3 of this guide.

Software - ipmctl

ipmctl is necessary for discovering PMem module resources, creating goals and regions, updating the firmware, and debugging issues with these PMem modules. 

Note: Although with ipmctl, the same commands are used in both the UEFI as well as the operating system versions of the utility, not all functionality is available at the operating system level. For example, the secure erasure features are not implemented.

The full list of commands is available by running ipmctl help or man ipmctl from the command line. You will need root privilege to run ipmctl. 
Learn more about each of these tools and get started with PMem programming:

Using ipmctl within Unified Extensible Firmware Interface (UEFI)

ipmctl can be launched from a (UEFI) shell for management at the UEFI level. This Quick Start Guide does not cover this option.

Using ipmctl within an Operating System Environment

You can download ipmctl from its GitHub project page, where you will find the sources and the Windows binary. In addition, ipmctl Linux binaries are also available through the package manager of most Linux distributions.

Please note that all snippets and screenshots below are from a Linux example, however, the commands are the same between Windows and Linux. 

Tutorial: Provisioning

This quick start guide describes methods to provision PMem using ipmctl and operating system specific vendor-neutral utilities. ipmctl is necessary for discovering Intel Optane memory module resources, creating goals and regions, updating the firmware, and debugging issues with these PMem modules. Learn more about each of these tools and get started with PMem programming at Intel® Developer Zone (Intel® DZ) – Persistent Memory.

All the commands described in this section are demonstrated on a two-socket system with six terabytes (TiB) of configured PMem, and 384 gigabytes (GB) of DRAM installed.

This tutorial considers that an operating mode is configured already by the Original Device Manufacturer (ODM), which is common in new systems received by customers. Typically, we see systems configured in App Direct Mode or Memory Mode. 


The ipmctl utility is used to configure and manage PMem modules. 

  • To determine if ipmctl is already installed, type ipmctl into the terminal window
  • If ipmctl is not installed, please download and refer to the instructions in the ipmctl README

Step 1: Discovery

As the ODM probably configured your system, let us first determine the current operating mode. 

  1. To discover the current configuration, you will need to run the following commands (see below for examples)
    1. ipmctl show -dimm
      • The show -dimm command displays the PMem modules discovered in the system and verifies that software can communicate with them. Among other information, this command outputs each DIMM ID, capacity, health state, and firmware version. The current FW version for the DIMM and the BIOS is available from the ODM
    2. ipmctl show -memoryresources 
      • The MemoryCapacity and AppDirectCapacity values e used to determine if the system was configured in Memory mode, App Direct Mode, or mixed-mode.
  2. Analyze the data **Note metadata uses a bit of the capacity, so MemoryCapacity and AppDirectCapacity will be affected by a few Mb
    1. Memory Mode is defined when Capacity == MemoryCapacity*
    2. AppDirectMode is defined when Capacity == AppDirectCapacity*
    3. Mixed Mode is defined when  MemoryCapacity is greater than zero and not != Capacity


# ipmctl show -dimm

 DimmID| Capacity  | HealthState | ActionRequired | LockState | FWVersion
 0x0001 | 502.6 GiB | Healthy     | 0              | Disabled  |
 0x0011 | 502.6 GiB | Healthy     | 0              | Disabled  |
 0x0021 | 502.6 GiB | Healthy     | 0              | Disabled  |
 0x1121 | 502.6 GiB | Healthy     | 0              | Disabled  |
# ipmctl show -memoryresources

Capacity=6031.2 GiB
MemoryCapacity=0.0 GiB
AppDirectCapacity=6024.0 GiB
UnconfiguredCapacity=0.0 GiB
InaccessibleCapacity=7.2 GiB
ReservedCapacity=0.0 GiB

Step 2: Create a Configuration Goal

At this point, if your device is configured as you need it, consider the following step as just information. However, if you need to make changes to the configuration, this section explains the basics.

The first thing you will need to do is decide which of the three modes you will require and run the appropriate configuration command.

  1. Memory Mode - 100% of PMem capacity across sockets can be provisioned in Memory mode, as described below. In this example, 100% of the available PMem capacity is to be provisioned in Memory mode. You can always use the -f option to overwrite any existing goal, which is a destructive operation.
    • ipmctl create -goal memorymode=100
  2. App Direct Mode - PMem can be provisioned in App Direct Mode with interleaving enabled or disabled. As described above in the Persistent Memory Provisioning Concepts section above, interleaving increases the throughput of reads and writes to PMem.
    • Interleaved -The command below sets a goal to create a PMem region that is interleaved across all the modules on each CPU socket. Creating an interleaved set that spans multiple CPU sockets is not allowed. 
      • ipmctl create -goal PersistentMemoryType=AppDirectAppDirect
    • Non-interleaved
      • ipmctl create -goal PersistentMemoryType=AppDirectAppDirectNotInterleaved
  3. Memory/ Mixed Modes - Any percentage of PMem capacity across sockets can be provisioned in Memory mode, as described below. In this example, 60% of the available PMem capacity is to be provisioned in Memory mode. 
    • ipmctl create -goal memorymode=60

Example: Memory Mode configuration

In this example, 100% of the available PMem capacity is to be provisioned in Memory Mode. 

# ipmctl create -goal memorymode=100

The following configuration will be applied:
 SocketID | DimmID | MemorySize | AppDirect1Size | AppDirect2Size
 0x0000   | 0x0001 | 502.0 GiB  | 0.0 GiB        | 0.0 GiB
 0x0000   | 0x0011 | 502.0 GiB  | 0.0 GiB        | 0.0 GiB
 0x0000   | 0x0021 | 502.0 GiB  | 0.0 GiB        | 0.0 GiB
 0x0001   | 0x1111 | 502.0 GiB  | 0.0 GiB        | 0.0 GiB
 0x0001   | 0x1121 | 502.0 GiB  | 0.0 GiB        | 0.0 GiB


Example: Mixed Mode

In this example, 60% of the available PMem capacity is to be provisioned in Memory Mode.

# ipmctl create -goal Memorymode=60

The following configuration will be applied:
 SocketID | DimmID | MemorySize | AppDirect1Size | AppDirect2Size
 0x0000   | 0x0011 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
 0x0000   | 0x0021 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
 0x0000   | 0x0001 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
 0x0001   | 0x1121 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
 0x0001   | 0x1101 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
Do you want to continue? [y/n] y
Created following region configuration goal
 SocketID | DimmID | MemorySize | AppDirect1Size | AppDirect2Size
 0x0000   | 0x0011 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
 0x0000   | 0x0021 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
 0x0000   | 0x0001 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
 0x0001   | 0x1121 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
 0x0001   | 0x1101 | 310.0 GiB  | 192.0 GiB      | 0.0 GiB
A reboot is required to process new memory allocation goals.


Example: App Direct Mode Configuration

In this example, we configure the System into App Direct Mode.

# ipmctl create -goal persistentmemorytype=appdirect

The following configuration will be applied:
 SocketID | DimmID | MemorySize | AppDirect1Size | AppDirect2Size
 0x0000   | 0x0011 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
 0x0000   | 0x0021 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
 0x0000   | 0x0001 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
 0x0001   | 0x1121 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
 0x0001   | 0x1101 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
Do you want to continue? [y/n] y
Created following region configuration goal
 SocketID | DimmID | MemorySize | AppDirect1Size | AppDirect2Size
 0x0000   | 0x0011 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
 0x0000   | 0x0021 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
 0x0000   | 0x0001 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
 0x0001   | 0x1121 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
 0x0001   | 0x1101 | 0.0 GiB    | 502.0 GiB      | 0.0 GiB
A reboot is required to process new memory allocation goals.


Step 3: Reboot System

Once the firmware for the PMem module has been given a set of goals, a system reboot is required.

Next Steps

This ends the OS-agnostic portion of the tutorial. If your system is configured in Memory Mode, we have come to the end of the tutorial.

If your system is in App Direct Mode or Mixed Mode, see below for a link to other articles in this series.

  1. Quick Start Guide Part 1: Provisioning Basics for Intel® Optane™ Persistent Memory
  2. Quick Start Guide Part 2: Linux Provisioning for Intel® Optane™ Persistent Memory
  3. Quick Start Guide Part 3: Windows Provisioning for Intel® Optane™ Persistent Memory 


Frequently Asked Questions on Provisioning

When I configure in App Direct Mode, why do I see part of the capacity as "Inaccessible" and "Unconfigured"?

  • PMem reserves a certain amount of capacity for metadata. For first-generation Intel Optane PMem, it is approximately 0.5% per DIMM. Unconfigured capacity is the capacity that is not mapped into the system's physical address space. It could also be the capacity that is inaccessible because the processor does not support the entire capacity on the platform.
  • # ipmctl show -memoryresources
    Capacity=6031.2 GiB
    MemoryCapacity=0.0 GiB
    AppDirectCapacity=6024.0 GiB
    UnconfiguredCapacity=0.0 GiB
    InaccessibleCapacity=7.2 GiB
    ReservedCapacity=0.0 GiB

How do I find the firmware version on the modules?

  • # ipmctl show -dimm

My processor does not allow me to configure the entire PMem module capacity on the platform. How do I find out maximum supported capacity on the processor?

  • Run the following command to display the maximum amount of memory that is allowed to be mapped into the system physical address space for this processor based on the processor SKU. For more information on the capacity supported by the processor SKU on your platform, run the following commands:
  • # ipmctl show -d TotalMappedMemory -socket
       TotalMappedMemory=3203.0 GiB
       TotalMappedMemory=3202.5 GiB

How do I unlock the encrypted modules?

  • The ability to enable security, unlock a PMem region, and change passphrase is enabled in both the Linux kernel driver 5.0 and is also available in ndctl.

Does PMem support SMART errors?

  • Yes

How do I find a module's lifetime?

  • The remaining PMem module life as a percentage value of factory-expected life span can be found by running the following command:
  • # ipmctl show -o text -sensor percentageremaining -dimm
     DimmID | Type                | CurrentValue | CurrentState
     0x0001 | PercentageRemaining | 100%         | Normal
     0x0011 | PercentageRemaining | 100%         | Normal
     0x0021 | PercentageRemaining | 100%         | Normal

When configured in Mixed mode, is the DRAM capacity seen by the operating system and applications?

  • No. When a portion or all of the capacity is configured in Memory mode, DRAM is hidden from the operating system. The capacity configured in Memory Mode is the only capacity used as the main memory.

I am adding two new DIMMs and would like to erase all the existing configurations and safely reconfigure the hardware but was unable to delete regions.

  • To create a new configuration, you need to delete the existing goal and create a new one, as shown below. There is no need to delete regions. Create-goal -f will overwrite the existing goal, and on reboot, you will see the new goal.
  • # ndctl destroy-namespace namespace0.0
    # ndctl destroy-namespace -f all
    # ipmctl delete -goal
    Delete memory allocation goal from DIMM 0x0001: Success
    Delete memory allocation goal from DIMM 0x0011: Success
    Delete memory allocation goal from DIMM 0x0101: Success
    Delete memory allocation goal from DIMM 0x0111: Success
    # ipmctl create -f -goal persistentmemorytype=appdirect

Why do I see a certain amount of capacity shown as reserved?

  • Reserved capacity is the total PMem capacity that is reserved. This capacity is the PMem partition capacity (rounded down for alignment) less any App Direct capacity. Reserved capacity typically results from a Memory Allocation Goal request that specified the Reserved property. This capacity is not mapped to the system physical address (SPA) space.
  • For a comprehensive list of debugging and troubleshooting commands, refer to the list of debugging and troubleshooting options listed in the Appendix

What is the list of supported configurations, and what happens if I am not using one of these configurations?

  • A list of validated and popular configurations are provided in the System Requirements section of this document. Other configurations are likely to not be supported by the BIOS and may not boot.


Appendix A: List of ipmctl Commands

Memory Provisioning

  • create -goal
  • delete -goal
  • show -goal
  • dump -goal
  • load -goal
  • show -region

Health and Performance

  • show -performance
  • show -sensor
  • change -sensor


  • change -device-passphrase
  • change -device-security
  • enable -device-security
  • erase -device-data

Device Discovery

  • show –device
  • show -dimm
  • show –memoryresources
  • show –socket
  • show –system -capabilities
  • show -topology

Support and Maintenance

  • dump -support
  • show –firmware
  • show –host
  • acknowledge –event
  • update -firmware
  • change –preferences
  • show -preferences
  • help


  • dump –debug-log
  • inject -error
  • run -diagnostic
  • show -acpi
  • show -pcd
  • show –nfit
  • show –error-log
  • show –event

Appendix B: Configuration - Management

This Appendix is primarily to cover in a bit more details commands used in management, that might be required during a re-configuration

Change Configuration Goal

When creating a goal, ipmctl checks to see whether or not the NVDIMMs are already configured, if so, it prints a message that the current configuration is to be deleted before creating a new goal. The current configuration can be deleted by first disabling and destroying namespaces and then disabling the active regions.

# ipmctl create -goal MemoryMode=100
Create region configuration goal failed: Error (115) - A requested DIMM already has a configured goal. Delete this existing goal before creating a new one
Delete Configuration

If you already have a goal configured, you will need to delete it prior to applying a new goal in its place. To disable/destroy a namespace, you will need to use ndctl or PowerShell to do the management, which is covered in parts 2 and 3 of this Quick Start Guide. 

# ipmctl delete –goal
Delete allocation goal from DIMM 0x0001: Success
Delete allocation goal from DIMM 0x0011: Success
Delete allocation goal from DIMM 0x0021: Success
Delete allocation goal from DIMM 0x1101: Success
Delete allocation goal from DIMM 0x1111: Success
Delete allocation goal from DIMM 0x1211: Success

Dump Current Goal

# ipmctl dump -destination testfile -system -config
Successfully dumped system configuration to file: testfile

Create a Goal from a Configuration File

Goals can be provisioned using a configuration file with the load -source <file> -goal command. To save the current configuration to a file, use the dump -destination <file> -System –config command. This allows for the same configuration to be applied to multiple systems or restored to the same system.

# ipmctl dump -destination testfile -system -config
# ipmctl load -source myPath/testfile –goal

Show Current Goal

To see the current goal, if there is one, use the show goal command.

# ipmctl show -goal

There are no goal configs definedin the system.
Please use 'show -region' to display currently valid persistent memory regions.

Confirm Mode Change

So far, we have seen how the goal can be set for different modes. Upon reboot, run the following commands to see if the model is applied correctly. The current output shows that the goal was set to configure the entire capacity in Memory mode.

# ipmctl show –memoryresources
Capacity=6031.2 GiB
MemoryCapacity=6024.0 GiB
AppDirectCapacity=0.0 GiB
UnconfiguredCapacity=0.0 GiB
InaccessibleCapacity=7.2 GiB
ReservedCapacity=0.0 GiB

Show Regions

If the mode is changed from Memory Mode to App Direct Mode, upon reboot, a single region per socket is created. If the Memory Mode is changed from App Direct Mode to Memory Mode, there are no regions created. Use the following command to see the regions created:

# ipmctl show -region
 SocketID| ISetID             | PersistentMemoryType | Capacity   | FreeCapacity | HealthState
 0x0000   | 0xa0927f48a8112ccc | AppDirect            | 3012.0 GiB | 3012.0 GiB   | Healthy
 0x0001   | 0xf6a27f48de212ccc | AppDirect            | 3012.0 GiB | 3012.0 GiB   | Healthy


Product and Performance Information


Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.

Notice revision #20110804