diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/_index.md b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/_index.md new file mode 100644 index 0000000000..69a3246220 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/_index.md @@ -0,0 +1,73 @@ +--- +title: Enable Arm SPE for Performix memory access analysis + +draft: true +cascade: + draft: true + +description: Learn how to verify and enable Arm Statistical Profiling Extension (SPE) on Arm Linux machines, including systems hosted through cloud service providers, so the Memory Access recipe in Arm Performix can run on supported environments. + +minutes_to_complete: 30 + +who_is_this_for: This is an introductory topic for software developers and performance engineers who want to prepare Arm Linux machines, including cloud-hosted systems, for Arm Performix memory access profiling. + +learning_objectives: + - Check whether Arm Statistical Profiling Extension (SPE) is already available on an Arm Linux system using Sysreport and kernel-level checks. + - Explain the hardware, platform, and kernel requirements that allow Linux to expose the SPE driver. + - Apply Linux-side changes such as loading the SPE PMU module, installing matching kernel modules, or selecting an OS/kernel with SPE support. + - Identify when a cloud instance does not expose SPE to the guest OS and choose a suitable system for Arm Performix memory access analysis. + +prerequisites: + - Access to a Linux-based Arm system, such as an Arm cloud instance or bare-metal server, with sudo or root access. + - Access to Arm Performix on your host machine and SSH access to the target system. See the [Arm Performix install guide](/install-guides/performix/) for setup instructions. + - Familiarity with the Linux command line and SSH. + +author: Kieran Hejmadi + +### Tags +skilllevels: Introductory +subjects: Performance and Architecture +cloud_service_providers: + - AWS + - Google Cloud + - Microsoft Azure +armips: + - Neoverse +tools_software_languages: + - Arm Performix + - Sysreport + - Linux kernel + - perf +operatingsystems: + - Linux + +further_reading: + - resource: + title: Arm Performix install guide + link: https://learn.arm.com/install-guides/performix/ + type: documentation + - resource: + title: Arm Statistical Profiling Extension documentation + link: https://developer.arm.com/documentation/100616/0401/?lang=en + type: documentation + - resource: + title: Arm Performix + link: https://developer.arm.com/servers-and-cloud-computing/arm-performix + type: website + - resource: + title: Get ready for performance analysis with Sysreport + link: https://learn.arm.com/learning-paths/servers-and-cloud-computing/sysreport/ + type: documentation + - resource: + title: Analyze cache behavior with Perf C2C on Arm + link: https://learn.arm.com/learning-paths/servers-and-cloud-computing/false-sharing-arm-spe/ + type: learning-path + + + +### FIXED, DO NOT MODIFY +# ================================================================================ +weight: 1 # _index.md always has weight of 1 to order correctly +layout: "learningpathall" # All files under learning paths have this same wrapper +learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. +--- diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/_next-steps.md new file mode 100644 index 0000000000..727b395ddd --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/_next-steps.md @@ -0,0 +1,8 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 # The weight controls the order of the pages. _index.md always has weight 1. +title: "Next Steps" # Always the same, html page title. +layout: "learningpathall" # All files under learning paths have this same wrapper for Hugo processing. +--- diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/enabled_support.png b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/enabled_support.png new file mode 100644 index 0000000000..cfbd7eb63e Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/enabled_support.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/grub_config_change.png b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/grub_config_change.png new file mode 100644 index 0000000000..1df02712ed Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/grub_config_change.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-1.md b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-1.md new file mode 100644 index 0000000000..5d2e23aa14 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-1.md @@ -0,0 +1,55 @@ +--- +title: Get started +weight: 2 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## What is Arm Statistical Profiling Extension + +Arm Statistical Profiling Extension (SPE) is a hardware-assisted profiling feature in the Arm A-profile architecture. It was introduced with Armv8.2-A and extended in later architecture revisions. Most modern Arm-based cloud systems support SPE. + +Unlike traditional interrupt-driven sampling, SPE records rich metadata for sampled operations, including instruction context, memory address information, and latency-related attributes. This improves attribution accuracy and helps reduce drift (also called skid) when mapping instructions to sampled counts. For more background, see the [performance analysis white paper](https://developer.arm.com/documentation/109429/latest/). + +For Arm Performix, this matters because SPE must be enabled to use the `Memory Access` recipe. + +## Understand the platform layers that enable SPE + +On Linux, SPE is available only when all required layers are aligned: + +- **Architecture layer**: the CPU must implement SPE (common on Arm Neoverse systems and the Arm AGI CPU). +- **Firmware layer**: platform firmware must advertise the SPE PMU and its interrupt path through ACPI or Device Tree. This is usually already enabled, so this check is often skipped. +- **Kernel layer**: the running kernel must be built with Arm SPE PMU support through the `CONFIG_ARM_SPE_PMU` kernel build option. +- **Driver layer**: the `arm_spe_pmu` driver must initialize successfully (built-in or loaded as a module). This requires all the above layers to have Arm SPE support. + +If any of these layers are missing, Linux cannot expose SPE to profiling tools. Additionally, cloud-based applications usually run on top of a hypervisor which typically disables SPE. + +{{% notice Please Note %}} + +Cloud providers often disable low-level profiling features on shared (multi-tenant) instances. To use Performix memory access profiling, run your application on an Arm-based **bare-metal instance** with full hardware access. These instances are typically named `metal` instances. + +Be aware that this instance type typically has a higher cost. + +{{% /notice %}} + + +## What is usually already present + +On Neoverse-based systems, architecture support is already present, and firmware support is usually present. + +This Learning Path helps you determine which case applies to your system and what action to take next. Because Linux distributions and kernel versions vary widely, this Learning Path provides practical guidance rather than an exhaustive set of steps. + +## Check if Arm SPE is enabled + +Open Performix from your local machine. If this is your first time using or installing Performix, see the [install guide](https://learn.arm.com/install-guides/performix/). + +Connect to your instance, select the `Recipes` tab, and then select the `Memory Access` recipe. This automatically runs a precheck and prints the status at the bottom of the page. If you receive the **SPE is not configured** status shown below, you need to enable SPE before you can run the recipe. + +![Screenshot of the Arm Performix Memory Access recipe showing a red status notification at the bottom of the page indicating that SPE has not been configured for the target system. This is the expected message when the arm_spe_pmu driver is missing or not loaded.#center](./memory-access-no-spe.png "Arm Performix Memory Access recipe reporting that SPE is not configured") + +If you receive a different error message, SPE is likely **not** the cause of your issue. See the [Performix user guide](https://developer.arm.com/documentation/110163/latest). + + + + diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-2.md b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-2.md new file mode 100644 index 0000000000..69b9f223b9 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-2.md @@ -0,0 +1,159 @@ +--- +title: Assess OS kernel +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +### Step 1.0) Check whether the OS kernel is built with SPE + +From the Getting Started section, you know you need to verify both the kernel and driver layers. Start by checking the kernel version: + +```bash +uname -r +``` +The output will be similar to: + +```output +6.17.0-1010-aws +``` + +This AWS instance is running the standard Ubuntu 24.04 LTS Amazon Machine Image (AMI) provided through AWS Quick Start. The command output shows a Linux 6.17 kernel, and the `1010-aws` suffix indicates an AWS-specific build customized for the AWS environment. + +Now check whether this kernel was built with SPE support enabled: + +```bash +grep CONFIG_ARM_SPE_PMU /boot/config-$(uname -r) 2>/dev/null || true +``` + +The possible outputs are `y`, `m`, or `n`, meaning built-in support, module support, or no support. + +- `y` indicates that the kernel was built with SPE support. +- `m` indicates that SPE is available as a loadable kernel module. This is the typical output for cloud instances. +- `n` means the kernel was **not** built with SPE support. + +If the output from the previous command is `CONFIG_ARM_SPE_PMU = n`, **skip directly to Step 3.0**. + +If the output from the previous command is `CONFIG_ARM_SPE_PMU = y`, **you can skip directly to step 1.2.** + +### Step 1.1) Check whether the kernel module is available + +If your output was `CONFIG_ARM_SPE_PMU = m`, as shown below, the OS kernel includes SPE support. However, you still need to confirm that the driver layer is present and can be loaded. + +```output +CONFIG_ARM_SPE_PMU = m +``` + +Run the following command to check whether the loadable kernel module (driver) is available on the target: + +```bash +modinfo arm_spe_pmu 2>/dev/null || echo "arm_spe_pmu not present for this kernel" +``` + +If you see output similar to the following, `arm_spe_pmu` is built as a module. If you see `arm_spe_pmu not present for this kernel`, continue to step 1.2. We will attempt to find and install the module for our specific kernel in later steps. + +```output +filename: /lib/modules/6.17.0-1010-aws/kernel/drivers/perf/arm_spe_pmu.ko.zst +license: GPL v2 +author: Will Deacon +description: Perf driver for the ARMv8.2 Statistical Profiling Extension +srcversion: 3B6FCB5AD9B37B8BB9FF4A9 +... +``` + +Next, run the following command to load the driver: + +```bash +sudo modprobe arm_spe_pmu +lsmod | grep arm_spe_pmu +``` + +If it loads correctly, the output will be similar to: + +```output +arm_spe_pmu 24576 0 +``` + +In Step 1.2, use Sysreport to review system-level metrics, including SPE status. + +### Step 1.2) Run Sysreport + +Follow the steps in the [Get ready for performance analysis with Sysreport guide](https://learn.arm.com/learning-paths/servers-and-cloud-computing/sysreport/) and run `sysreport` on your system: + +```bash +python /src/sysreport.py +``` + +This prints information about your system, including whether SPE is enabled. The `perf sampling` label shows SPE status. It also provides useful details for further debugging. + +```output +System feature report: + Collected: 2026-04-13 09:40:16.344396 + Script version: 2026-04-08 08:08:28.656402 + Running as root: False +System hardware: + Architecture: ARMv8.4 + CPUs: 64 + CPU types: 64 x Arm Neoverse V1 r1p1 + cache info: size, associativity, sharing + cache line size: 64 + Caches: + 64 x L1D 64K 4-way 64b-line + 64 x L1I 64K 4-way 64b-line + 64 x L2U 1M 8-way 64b-line + 1 x L3U 32M 16-way 64b-line + System memory: 126G + Atomic operations: True + interconnect: CMN-650 x 1 + NUMA nodes: 1 + Sockets: 1 +OS configuration: + Kernel: 6.17.0 + config: /boot/config-6.17.0-1010-aws + build dir: /lib/modules/6.17.0-1010-aws/build + uses atomics: True + page size: 4K + huge pages: 2048kB: 0, 32768kB: 0, 64kB: 0, 1048576kB: 0 + transparent HP: madvise + MPAM configured: False + resctrl: False + Distribution: Ubuntu 24.04.4 LTS + libc version: glibc 2.39 + boot info: ACPI + KPTI enforced: False + Lockdown: landlock, lockdown, yama, integrity, apparmor + Mitigations: spectre_v2:CSV2, BHB; spec_store_bypass:Speculative Store Bypass disabled via prctl; spectre_v1:__user pointer sanitization +Performance features: + perf tools: True + perf installed at: /usr/lib/linux-tools/6.17.0-1010-aws/perf + perf with OpenCSD: False + perf counters: 6 + perf sampling: None + perf HW trace: None + perf paranoid: 0 + CAP_PERFMON: disabled + kptr_restrict: 1 + perf in userspace: disabled + interconnect perf: True + /proc/kcore: True + /dev/mem: True + eBPF: + kernel configured for BPF: True + bpftool installed: True + bpftool v7.7.0 using libbpf v1.7 features: + bpftrace installed: bpftrace v0.20.2 + + +Actions that can be taken to improve performance tools experience: + perf tools cannot decode hardware trace + build with CORESIGHT=1 + non-invasive sampling (SPE) not enabled + ensure APIC table describes SPE interrupt + kernel module arm_spe_pmu.ko must be built + hardware trace not enabled + rebuild kernel with CONFIG_CORESIGHT + ensure ACPI describes CoreSight trace fabric +``` + +In this example, the output shows `perf sampling: None`, so continue to the next step. diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-3.md b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-3.md new file mode 100644 index 0000000000..80fc70a527 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-3.md @@ -0,0 +1,131 @@ +--- +title: Install and load driver +weight: 4 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +### Step 2.0) Install Linux kernel extra modules + +To keep kernel images smaller and tuned for different platforms, many distributions ship extra kernel modules in a separate package. If your system returned the following from step 1.1, complete this step. Else skip to step 2.1 + +```output +arm_spe_pmu not present for this kernel +``` + +Run the following commands, replacing `apt` with your distribution's package manager if needed. This searches your package index for the extra modules package that matches your kernel version: + +```bash +sudo apt update +apt search "linux-modules-extra-$(uname -r)" +``` + +This example shows two prebuilt packages: a default version and one with `64 KB` page sizes. + +```output +Sorting... Done +Full Text Search... Done +linux-modules-extra-6.17.0-1010-aws/noble-security,noble-updates,now 6.17.0-1010.10~24.04.1 arm64 [installed] + Linux kernel extra modules for version 6.17.0 on DESC + +linux-modules-extra-6.17.0-1010-aws-64k/noble-security,noble-updates 6.17.0-1010.10~24.04.1 arm64 + Linux kernel extra modules for version 6.17.0 on DESC +``` + +Install the package that matches your system. In this example, regular page sizes are used. + +```bash +sudo apt install linux-modules-extra-6.17.0-1010-aws -y +``` + +Run the check again to confirm that the kernel module is installed: + +```bash +modinfo arm_spe_pmu 2>/dev/null || echo "arm_spe_pmu module not present" +``` + +The output should be similar to: + +```output +filename: /lib/modules/6.17.0-1010-aws/kernel/drivers/perf/arm_spe_pmu.ko.zst +license: GPL v2 +author: Will Deacon +description: Perf driver for the ARMv8.2 Statistical Profiling Extension +... +``` + +### Step 2.1) Load the kernel module + +Run the following commands to load the kernel module and confirm it is running: + +```bash +sudo modprobe arm_spe_pmu +lsmod | grep arm_spe_pmu +``` + +If it loads correctly, the output is similar to: + +```output +arm_spe_pmu 24576 0 +``` + +{{% notice Tip %}} + +To load the `arm_spe_pmu` kernel module during boot, create the `arm_spe_pmu.conf` file with the following command. This means you no longer need to manually load the module each time the system is restarted. + +```bash +echo arm_spe_pmu | sudo tee /etc/modules-load.d/arm_spe_pmu.conf +sudo systemctl restart systemd-modules-load.service +``` + + +You do not need to reboot now, but after the next reboot the module should load automatically. You can confirm with: + +```bash +sudo dmesg | grep "arm_spe_pmu" +[ 2.261719] arm_spe_pmu arm,spe-v1: probed SPEv1.1 for CPUs 0-63 [max_record_sz 64, align 64, features 0x17] +``` + +{{% /notice %}} + +When you rerun `sysreport`, you should see: + +```output + perf sampling: SPE +``` + +Return to Performix. The `Memory Access` recipe should now show `All checks passing!`. + +![Screenshot of the Arm Performix memory access recipe showing all prerequisite checks passing, confirming that SPE is correctly enabled and the arm_spe_pmu module is loaded#center](./memory-access-passing.png "Arm Performix memory access recipe with all checks passing") + +If not, there is a known limitation when running SPE on Neoverse V1 systems. + +#### For Neoverse V1-based systems: adjust Kernel Page Table Isolation (KPTI) + +On some Neoverse V1 systems (for example AWS Graviton3), SPE buffer mapping can fail when Kernel Page Table Isolation (KPTI) is enabled. This issue has been observed on Neoverse V1 and is not known to affect other Neoverse cores. Use the `CPU types:` line in `sysreport.py` to confirm whether your instance is Neoverse V1. + +If all of the following conditions are met: + +- The system is based on Neoverse V1. +- The kernel includes SPE PMU support. +- The platform exposes the SPE PMU. +- `sysreport` still reports `perf sampling: None`. + + +Use your preferred editor to update `GRUB_CMDLINE_LINUX` in `/etc/default/grub` and add `kpti=off`, as shown below. + +![Screenshot of a terminal text editor showing /etc/default/grub with GRUB_CMDLINE_LINUX updated to include kpti=off, the change required to allow SPE buffer mapping to succeed on Neoverse V1 systems#center](./grub_config_change.png "GRUB_CMDLINE_LINUX set to kpti=off in /etc/default/grub") + +{{% notice Please Note %}} + +**Please Note:** Disabling KPTI has security implications and should only be done on trusted systems. + +{{% /notice %}} + +Run the following command to reboot the system. + +```bash +sudo update-grub +sudo reboot +``` \ No newline at end of file diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-4.md b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-4.md new file mode 100644 index 0000000000..c523b94442 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/how-to-4.md @@ -0,0 +1,118 @@ +--- +title: Alternative solutions +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +### Step 3.0) Try another Operating System / Kernel + +Many applications spend most execution time in user space, with relatively little time in kernel mode for tasks such as file handling. Even when an application spends meaningful time in kernel mode, switching to a newer or different kernel usually does not create a large performance change unless you are intentionally using a newer kernel feature. + +Because of that, it is usually faster to try a different OS or kernel image before rebuilding your current kernel with SPE enabled. If you specifically need to rebuild your current kernel, continue to Step 3.1. + +{{% notice Tip %}} +If you are unsure where your application is spending time, a basic command such as the one below can give you a high-level estimate of the ratio of user to kernel (also known as system) time. + +```bash +/usr/bin/time -v 2>&1 | grep -e "User time" -e "System time" +``` + +In the [Mandelbrot example](https://learn.arm.com/learning-paths/servers-and-cloud-computing/cpu_hotspot_performix/how-to-3/), about 0.3% of execution time is in kernel space. + +```output + User time (seconds): 47.52 + System time (seconds): 0.14 +``` +{{% /notice %}} + +The quickest way to run the memory access recipe is often to test on a different operating system image. On cloud platforms, this is usually straightforward. + +The information below is accurate at the time of writing, but SPE support can change over time. If you have access to the following cloud providers, use the recommended operating systems below. + +{{< tabpane code=true >}} +{{< tab header="Amazon Web Services (AWS)" >}} +Amazon Linux 2023 AMI + +Run on a metal instance (for example, `cg.metal`, where `` matches the required Graviton generation). +{{< /tab >}} +{{< tab header="Google Cloud Services (GCP)" >}} +Ubuntu 25.10 Public Image + +Google Axion C4A metal instances enable SPE at the OS level and include the `arm_spe_pmu.ko` kernel module in the base Ubuntu 25.10 public image. +{{< /tab >}} +{{< /tabpane >}} + +### Step 3.1) (Advanced) Rebuild kernel from source with Arm SPE + +If your current system does not provide a kernel with Statistical Profiling Extension (SPE) enabled, you can rebuild the kernel with the required configuration. This approach is more involved than switching operating systems and should only be used if necessary. + +#### Distribution-specific considerations + +Most Linux distributions (for example Ubuntu or Debian) ship kernels with their own patches and configuration defaults. As a result, you should follow your distribution’s official kernel build guide rather than using a generic upstream process, for example the [Ubuntu](https://wiki.ubuntu.com/Kernel/BuildYourOwnKernel) and [Debian](https://wiki.debian.org/BuildingTutorial) guides. In some environments (e.g. cloud platforms), you may also need to build against a provider-specific kernel variant. + + +#### Enable Arm SPE in the kernel configuration + +The key requirement is to ensure that the `CONFIG_ARM_SPE_PMU` option is enabled in the kernel `.config`. + +If you already have a configured kernel tree, you can enable it directly using: + +```bash +scripts/config --enable ARM_SPE_PMU +``` + +This modifies the `.config` file programmatically and sets: +``` +CONFIG_ARM_SPE_PMU=y +``` + +After modifying the config, run: + +```bash +make olddefconfig +``` + +to resolve any dependencies and ensure the configuration is consistent. + +### Use the interactive configuration menu + +Alternatively, you can enable the option via the interactive terminal UI from the root of the kernel directory: + +```bash +make menuconfig +``` + +- Press `/` to search. +- Enter `ARM_SPE_PMU`. +- Select the option when it appears. +- Press: + - `y` to build it into the kernel (`=y`) + - `m` to build it as a module (`=m`) + +In most cases, building it into the kernel (`y`) is preferred for profiling. + +![Screenshot of the kernel menuconfig interface with ARM_SPE_PMU selected and enabled, confirming the Statistical Profiling Extension will be built into the kernel#center](./enabled_support.png "Kernel menuconfig with ARM_SPE_PMU enabled") + +Once the kernel has been built, set your system to boot from the new kernel. + +{{% notice Warning %}} +Before rebooting into a custom kernel, take the following precautions to avoid being locked out of your system: + +- **Take a snapshot or backup** of your instance before rebooting. On cloud platforms, create a machine image or disk snapshot so you can restore quickly if the new kernel fails to boot. +- **Keep the original kernel as a fallback.** Most bootloaders (for example GRUB) retain previous kernel entries. Confirm the original kernel is still listed before you reboot. +- **Verify the bootloader configuration.** Check `/etc/default/grub` and confirm `GRUB_DEFAULT` points to your new kernel entry, then run `update-grub` to apply the change. +- **Test the new kernel without changing the default boot entry.** Use `grub-reboot` to boot into the new kernel exactly once, so the system automatically reverts to the previous kernel on the next reboot if something goes wrong: + +```bash +sudo grub-reboot "Advanced options for Ubuntu>Ubuntu, with Linux " +sudo reboot +``` + +Replace `` with the version string of your newly built kernel. You can list available entries with `grep menuentry /boot/grub/grub.cfg`. +{{% /notice %}} + +## What you've accomplished + +You verified the full SPE enablement path across earlier steps by checking kernel support with `CONFIG_ARM_SPE_PMU`, validating module availability, and using Sysreport to confirm whether `perf sampling` reports `SPE` or `None`. You then applied the appropriate remediation path for your environment, from loading or installing `arm_spe_pmu` to selecting a supported cloud image or rebuilding the kernel with `CONFIG_ARM_SPE_PMU` enabled, so your system is ready to run the Arm Performix memory access recipe. \ No newline at end of file diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/memory-access-no-spe.png b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/memory-access-no-spe.png new file mode 100644 index 0000000000..72a06eff7c Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/memory-access-no-spe.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/spe-on-performix/memory-access-passing.png b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/memory-access-passing.png new file mode 100644 index 0000000000..e7147aedee Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/spe-on-performix/memory-access-passing.png differ