some skill-based updates

Author: anupras-mohapatra-arm

content/learning-paths/servers-and-cloud-computing/performix-instruction-mix/_index.md

@@ -1,17 +1,17 @@
 ---
-title: Profile GPT-2 instruction mix with Arm Performix
+title: Profile GPT-2 inference with the Arm Performix Instruction Mix recipe
 
-description: Learn how to profile GPT-2 inference on Arm Neoverse with the Arm Performix Instruction Mix recipe, identify scalar versus vector execution patterns, and improve throughput with NEON, SVE, and KleidiAI kernels.
+description: Profile GPT-2 inference on Arm Neoverse with the Arm Performix Instruction Mix recipe, identify scalar versus vector execution patterns, and improve throughput with Neon, SVE, and KleidiAI kernels.
 
 minutes_to_complete: 45
 
 who_is_this_for: This is an introductory topic for developers who want to get started using the Arm Performix Instruction Mix recipe through a practical example.
 
 learning_objectives: 
-    - Understand how the Instruction Mix recipe combines static disassembly with runtime sampling to show execution behavior
+    - Use the Instruction Mix recipe to combine static disassembly with runtime sampling to show execution behavior
     - Build and run the GPT-2 inference example on an Arm Linux server
     - Identify why matrix multiplication dominates runtime and how vectorization changes the instruction mix
-    - Compare throughput and instruction mix across scalar, NEON, SVE, and KleidiAI implementations
+    - Compare throughput and instruction mix across scalar, Neon, SVE, and KleidiAI implementations
 
 prerequisites:
     - Access to Arm Performix configured with a remote Arm Linux target. For setup, see the [Arm Performix install guide](/install-guides/performix/).
@@ -32,7 +32,7 @@ tools_software_languages:
     - Arm Performix
     - C
     - LLM
-    - NEON
+    - Neon
     - SVE
 operatingsystems:
     - Linux
@@ -53,6 +53,10 @@ further_reading:
         title: Arm MCP Server GitHub Repository
         link: https://github.com/arm/mcp
         type: website
+    - resource:
+        title: KleidiAI GitHub Repository
+        link: https://github.com/ARM-software/kleidiai
+        type: website
     - resource:
         title: GPT-2 Example repository
         link: https://github.com/arm-education/GPT-2-Example
@@ -65,4 +69,4 @@ further_reading:
 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.
----
+---

content/learning-paths/servers-and-cloud-computing/performix-instruction-mix/how-to-1.md

@@ -16,7 +16,7 @@ The Instruction Mix recipe classifies each instruction into a group. The availab
 - memory loads and stores (including exclusive operations)
 - control flow instructions, such as branches and loops
 - specialized instructions, such as cryptographic operations
-- SIMD (Single Instruction, Multiple Data) instructions, including NEON (fixed 128-bit) and SVE (scalable vector length)
+- SIMD (Single Instruction, Multiple Data) instructions, including Neon (fixed 128-bit) and SVE (scalable vector length)
 
 The Instruction Mix result gives you two complementary views:
 
@@ -27,18 +27,18 @@ Together, these views help you verify whether architecture-specific features are
 
 Instruction Mix is useful when you need to confirm that performance-critical code uses Arm CPU features effectively. This is especially helpful when you are, for example, validating the effectiveness of compiler autovectorization.
 
-For example, if a hot function is mostly scalar at runtime when you expected NEON or SVE activity, that often indicates missed vectorization opportunities. You can then focus optimization work on compiler flags, data layout, loop structure, and kernel implementation to improve throughput where it matters most.
+For example, if a hot function is mostly scalar at runtime when you expected Neon or SVE activity, that often indicates missed vectorization opportunities. You can then focus optimization work on compiler flags, data layout, loop structure, and kernel implementation to improve throughput where it matters most.
 
 ## GPT-2 as a test workload
 
-You can run the [GPT-2 Medium](https://huggingface.co/openai-community/gpt2-medium) model on a minimal C++ inference engine to analyze instruction mix and throughput. This model is available under a [modified MIT License](https://github.com/openai/gpt-2/blob/master/LICENSE). You will confirm that matrix multiplication (`matmul`) is the hot path, then compare how scalar, NEON, and SVE implementations change instruction behavior and token generation speed. 
+You can run the [GPT-2 Medium](https://huggingface.co/openai-community/gpt2-medium) model on a minimal C++ inference engine to analyze instruction mix and throughput. This model is available under a [modified MIT License](https://github.com/openai/gpt-2/blob/master/LICENSE). You will confirm that matrix multiplication (`matmul`) is the hot path, then compare how scalar, Neon, and SVE implementations change instruction behavior and token generation speed. 
 
 You'll implement only the forward inference path, with no back propagation or training. You don't need to understand the full transformer architecture to complete this Learning Path. Familiarity with matrix multiplication is enough. For background on GPT-2, see the original 2019 paper, [Language Models are Unsupervised Multitask Learners](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf).
 
-You'll also try implementing your own `matmul` kernels that target NEON and SVE, then use instruction mix data to verify that these vector paths are active and improving throughput.
+You'll also try implementing your own `matmul` kernels that target Neon and SVE, then use instruction mix data to verify that these vector paths are active and improving throughput.
 
 ## What you've learned and what's next
 
 You now know what instruction mix represents and why it matters for LLM inference optimization on Arm.
 
-Next, you'll set up the GPT-2 example, build the binaries, and run a baseline test.
+Next, you'll set up the GPT-2 example, build the binaries, and run a baseline test.

content/learning-paths/servers-and-cloud-computing/performix-instruction-mix/how-to-2.md

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Prepare the environment
 
-Use an Arm Linux target, such as an Arm Neoverse cloud instance. The results in this Learning Path were collected on a Graviton 3-based instance based on Neoverse V1 running Ubuntu 24.04 LTS. 
+Use an Arm Linux target, such as an Arm Neoverse-based cloud instance. The results in this Learning Path were collected on a Graviton 3-based instance based on Neoverse V1 running Ubuntu 24.04 LTS. 
 
 If you've not configured Arm Performix yet, complete setup and target connection using the [Arm Performix install guide](/install-guides/performix/).
 
@@ -90,7 +90,7 @@ void matmul_ref(float *out, const float *x, const float *W, const float *b,
 }
 ```
 
-This scalar implementation can leave NEON and SVE vector units underused if the compiler cannot efficiently autovectorize it. Because `matmul` is called hundreds of times per token, explicitly optimizing this kernel guarantees SIMD execution where most of the available compute is spent.
+This scalar implementation can leave Neon and SVE vector units underused if the compiler cannot efficiently autovectorize it. Because `matmul` is called hundreds of times per token, explicitly optimizing this kernel guarantees SIMD execution where most of the available compute is spent.
 
 ## Build and run the baseline
 
@@ -115,4 +115,4 @@ The output is:
 
 You now have a working baseline binary and model files. 
 
-Next, you'll use the Instruction Mix recipe in Arm Performix to inspect static disassembly and dynamic runtime behavior.
+Next, you'll use the Instruction Mix recipe in Arm Performix to inspect static disassembly and dynamic runtime behavior.

content/learning-paths/servers-and-cloud-computing/performix-instruction-mix/how-to-3.md

@@ -1,5 +1,5 @@
 ---
-title: Profile with the Arm Performix Instruction Mix recipe
+title: Find GPT-2 hotspots and profile with the Arm Performix Instruction Mix recipe
 weight: 4
 
 ### FIXED, DO NOT MODIFY
@@ -74,4 +74,4 @@ Finally, in dynamic functions, you can break down operation types to individual
 
 You've now used Instruction Mix to confirm that baseline runtime is dominated by scalar-heavy `matmul` execution. 
 
-Next, you'll compare updated Instruction Mix and throughput across scalar, NEON, SVE, and KleidiAI variants.
+Next, you can optionally learn to optimize matmul with vector intrinsics and use the Arm MCP Server with Performix. You can also skip to [Compare Neon and SVE with the Arm Performix Instruction Mix recipe](/learning-paths/servers-and-cloud-computing/performix-instruction-mix/how-to-5/) to compare updated Instruction Mix and throughput across scalar, Neon, SVE, and KleidiAI variants.

content/learning-paths/servers-and-cloud-computing/performix-instruction-mix/how-to-4.md

@@ -10,9 +10,9 @@ layout: learningpathall
 
 In this project, `src/kernels/matmul_user.cpp` is your editable implementation file. The baseline behavior in this file is scalar, and the build uses `-O2 -g`, so compiler optimization is enabled but vector hardware is still underused in the hot loop.
 
-Use the profiling evidence from Performix to implement your own NEON or SVE intrinsics in `src/kernels/matmul_user.cpp`, then rebuild and profile `gpt2_user`.
+Use the profiling evidence from Performix to implement your own Neon or SVE intrinsics in `src/kernels/matmul_user.cpp`, then rebuild and profile `gpt2_user`.
 
-{{% notice Hint %}}
+{{% notice Note %}}
 
 Focus on the accumulation loop in `matmul_user` (`acc += row[j] * x[j];`). Think about lane utilization, loop unrolling, and handling the tail when the input width is not an exact multiple of the vector width.
 
@@ -70,4 +70,4 @@ Restart your coding assistant, then prompt it to run Performix Instruction Mix a
 
 You've now optionally implemented and profiled a custom `matmul_user` kernel using the same workflow you used for baseline analysis. 
 
-Next, you'll compare instruction mix and throughput across scalar, NEON, SVE, and KleidiAI variants.
+Next, you'll compare Instruction Mix and throughput across scalar, Neon, SVE, and KleidiAI variants.

content/learning-paths/servers-and-cloud-computing/performix-instruction-mix/how-to-5.md

@@ -30,7 +30,7 @@ Rename each run with a descriptive name, such as baseline and Neon, so you can i
 
 The baseline profile is mostly scalar instructions. After you add Neon intrinsics, the instruction mix shifts toward Advanced SIMD (Neon) instructions, showing that the code is using Arm Neon hardware more effectively.
 
-![Instruction Mix comparison view showing scalar-dominant baseline versus NEON variant with increased ASIMD instruction share in the hot matmul path.#center](./neon_scalar_instruction_mix.webp "NEON versus scalar instruction mix")
+![Instruction Mix comparison view showing scalar-dominant baseline versus Neon variant with increased ASIMD instruction share in the hot matmul path.#center](./neon_scalar_instruction_mix.webp "Neon versus scalar instruction mix")
 
 You can also compare SVE variants in the same way. The increase in SVE operations shows that this path is now utilizing SVE hardware.
 
@@ -56,11 +56,11 @@ For variable-length vectorization, compare with an explicit SVE implementation t
 
 For a full-page view, open a [Godbolt session with all three matmul kernels](https://godbolt.org/z/E4a7Wxh8K).
 
-## Measure speed up
+## Measure speedup
 
 Run the provided comparison script to measure tokens per second across all available binaries:
 
-```bash bash { command_line="ubuntu@ip | 2-30"}
+```bash { command_line="ubuntu@ip | 2-30"}
 ./compare_gpt2_variants.sh
 Model: gpt2-medium
 Prompt: Once upon a time
@@ -88,6 +88,6 @@ These results show that intrinsics increase throughput from about 3 tok/s in the
 
 ## What you've accomplished and what's next
 
-You've now verified vectorization using the Instruction Mix recipe, compared throughput across Neon and SVE, and measure tokens per second across the available binaries. 
+You've now verified vectorization using the Instruction Mix recipe, compared throughput across Neon and SVE, and measured tokens per second across the available binaries. 
 
-Next, you'll use optimized libraries to push performance further.
+Next, you'll use optimized libraries to push performance further.

content/learning-paths/servers-and-cloud-computing/performix-instruction-mix/how-to-6.md

@@ -14,7 +14,7 @@ Getting close to peak matmul performance is complex, especially in transformer i
 
 - *Tiling* breaks large matrices into smaller blocks that fit better in cache, so data is reused more often and memory bandwidth pressure is lower.
 
-Arm created [KleidiAI](https://github.com/ARM-software/kleidiai) to provide the fastest Arm CPU microkernels on packing and tiled matrix multiplication, so you can use these optimizations without writing and tuning every low-level kernel yourself.
+Arm created [KleidiAI](https://github.com/ARM-software/kleidiai) to provide accelerated Arm CPU microkernels on packing and tiled matrix multiplication, so you can use these optimizations without writing and tuning every low-level kernel yourself.
 
 ## KleidiAI integration in the GPT-2 example
 
@@ -24,7 +24,7 @@ The file `src/kernels/matmul_kai_sve.cpp` is the runtime bridge between your mod
 - `kai_get_rhs_packed_offset_matmul_clamp_f32_f32_f32p4vlx1b_6x4vl_sve_mla`
 - `kai_run_matmul_clamp_f32_f32_f32p4vlx1b_6x4vl_sve_mla`
 
-The `kai_run_matmul_clamp_f32_f32_f32p4vlx1b_6x4vl_sve_mla` is our entry. As per [the naming convention](https://github.com/ARM-software/kleidiai/blob/main/kai/ukernels/matmul/README.md), this kernel performs an FP32 matrix multiplication, computing output tiles of 6 × 4VL (six rows by four SVE vector lengths of columns) using SVE (multiply–accumulate) MLA instructions on prepacked RHS weights for efficient cache and SIMD utilization.
+`kai_run_matmul_clamp_f32_f32_f32p4vlx1b_6x4vl_sve_mla` is your entry. According to [the naming convention](https://github.com/ARM-software/kleidiai/blob/main/kai/ukernels/matmul/README.md), this kernel performs an FP32 matrix multiplication, computing output tiles of 6 × 4VL (six rows by four SVE vector lengths of columns) using SVE (multiply–accumulate) MLA instructions on prepacked RHS weights for efficient cache and SIMD utilization.
 
 For more details on KleidiAI, see the [official GitLab repository](https://gitlab.arm.com/kleidi/kleidiai).
 
@@ -105,7 +105,7 @@ Compared to the non-vectorized baseline (`gpt2`), this FP32 KleidiAI microkernel
 You can increase throughput by running the KleidiAI path with multiple matmul threads. For this 355M model, tune `--matmul-threads` heuristically on your target system to find the optimal value. For a Graviton 3-based instance, you'll observe a max token generation speed of 34.5 token/s with 4 threads.
 
 
-``` bash { command_line="ubuntu@ip | 3-50"}
+```bash { command_line="ubuntu@ip | 3-50"}
 cd build
 ./gpt2_kai_sve --model gpt2-medium "Once upon a time" -n 150 --matmul-threads 4
 Weights path: /home/ubuntu/GPT-2-DEMO/GPT-2-Example/models/gpt2-medium/weights.bin