Update learning path content for SME2 and KleidiAI integration on Android

- Revised titles and descriptions for clarity and consistency
- Enhanced learning objectives to reflect performance measurement focus
- Improved prerequisite details for building and running llama.cpp
- Updated figures and alt-text for better accessibility and understanding
- Added summaries and next steps to guide users through the learning path

Author: madeline-underwood

content/learning-paths/mobile-graphics-and-gaming/performance_llama_cpp_sme2/_index.md

@@ -1,24 +1,20 @@
 ---
-title: Profile SME2 with llama.cpp and KleidiAI on Android
-
-draft: true
-cascade:
-    draft: true
+title: Measure LLM inference performance with KleidiAI and SME2 on Android
 
 minutes_to_complete: 40
 
 who_is_this_for: This is an advanced topic for software developers, performance engineers, and AI practitioners 
 
-learning_objectives: 
-    - Build llama.cpp library with KleidiAI and SME2 support
-    - Profile performance of LLMs running on llama-cli
-    - Learn how KleidiAI and SME2 accelerates LLM operators
+learning_objectives:
+    - Build llama.cpp with KleidiAI and SME2 support
+    - Profile LLM inference performance on Android
+    - Understand how KleidiAI and SME2 accelerate LLM operators
 
 prerequisites:
     - Knowledge of KleidiAI and SME2
-    - A Linux host machine (x86_64 or aarch64) for building llama.cpp with the Arm GNU Toolchain used in this Learning Path
-    - Git, CMake and Android Debug Bridge (ADB) installed on the host machine
-    - An Android device with Arm SME2 support for running and profiling the built executable
+    - A Linux host machine (x86_64 or aarch64) for building llama.cpp with the Arm GNU Toolchain
+    - Git, CMake, and Android Debug Bridge (ADB) installed on your host machine
+    - An Android device with Arm SME2 support for running and profiling the executable
 
 author: Zenon Zhilong Xiu
 
@@ -39,21 +35,21 @@ operatingsystems:
 
 further_reading:
     - resource:
-        title: part 1 Arm Scalable Matrix Extension Introduction 
+        title: Arm Scalable Matrix Extension introduction, part 1
         link: https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction
         type: blog
     - resource:
-        title: part 2 Arm Scalable Matrix Extension Instructions 
+        title: Arm Scalable Matrix Extension instructions, part 2
         link: https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction-p2
         type: blog
     - resource:
-        title: part4 Arm SME2 Introduction 
+        title: Arm SME2 introduction, part 4
         link: https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/part4-arm-sme2-introduction
         type: blog
     - resource:
         title: Profile llama.cpp performance with Arm Streamline and KleidiAI LLM kernels
         link: https://learn.arm.com/learning-paths/servers-and-cloud-computing/llama_cpp_streamline/
-        type: blog
+        type: website
 
 
 

content/learning-paths/mobile-graphics-and-gaming/performance_llama_cpp_sme2/introduction.md

@@ -10,11 +10,13 @@ layout: learningpathall
 In this section, you get a quick mental model of SME2, KleidiAI, and what llama.cpp is doing when it runs LLM inference on an Arm CPU.
 Arm’s latest Client CPU processors such as Arm C1 include Scalable Matrix Extension 2 (SME2). SME2 accelerates the matrix-heavy AI operations behind large language models (LLMs), media processing, speech recognition, computer vision, real-time apps and multimodal apps.
 
-llama.cpp provides extensive support for many LLMs, including Phi, Llama, DeepSeek, Gemma and Qwen. Llama.cpp is designed for efficient CPU-based inference. It enables on-device LLM execution, reducing latency and enhancing privacy.
+llama.cpp provides extensive support for many LLMs, including Phi, Llama, DeepSeek, Gemma and Qwen. It's designed for efficient CPU-based inference, enabling on-device LLM execution that reduces latency and enhances privacy.
 
-By default llama.cpp integrates with Arm KleidiAI, a suite of optimized microkernels for Arm CPUs. KleidiAI includes SME2 optimized microkernels to get more performance benefits. 
+By default, llama.cpp integrates with Arm KleidiAI, a suite of optimized microkernels for Arm CPUs. KleidiAI includes SME2-optimized microkernels to deliver additional performance benefits.
 
-In this learning path, llama.cpp and Llama-3.2-3B-Instruct-Q4_0.gguf model with 3 Billion parameters is used for the tutorial. 
+This Learning Path uses the `Llama-3.2-3B-Instruct-Q4_0.gguf` model with 3 billion parameters.
+
+Move on to the next section to see how KleidiAI microkernels integrate into llama.cpp's CPU backend.
 
 
 

content/learning-paths/mobile-graphics-and-gaming/performance_llama_cpp_sme2/kleidiai_integration.md

@@ -13,7 +13,7 @@ In this section, you look at how SME2 connects into the Arm software ecosystem b
 
 The KleidiAI library provides optimized matrix multiplication (matmul) kernels tailored for hardware features such as SME, I8MM, and Dot Product (DotProd) acceleration. In llama.cpp this feature is enabled with the build option `GGML_CPU_KLEIDIAI`.
 
-![Figure showing components of llama.cpp alt-text#center](images/llama_components.jpg "Components of llama.cpp")
+![Block diagram showing the llama.cpp architecture with the ggml-cpu backend layer highlighted, and KleidiAI integrated as a CPU trait that dispatches SME2, I8MM, and DotProd microkernels alt-txt#center](images/llama_components.jpg "Components of llama.cpp")
 
 KleidiAI is integrated as a trait of `ggml-cpu` in the llama.cpp CPU backend.
 The integration source code is located in the following directory of llama.cpp:
@@ -43,7 +43,7 @@ More operators and data types are being supported by KleidiAI microkernels.
 
 The figure below shows how KleidiAI microkernels are used for `matmul` with `GGML_TYPE_Q4_0` or `GGML_TYPE_Q8_0` RHS(weight).
 
-![Figure showing how kleidiai microkernel is used for quantization, packing and matrix multiply llama.cpp alt-text#center](images/kai_matmul_kernel.jpg "Quantization, packing and matrix multiply microkernels")
+![Diagram showing the KleidiAI microkernel pipeline for a quantized matmul operation: the RHS weight tensor is packed once at model load, the LHS activation is quantized and packed each inference step, and the selected SME2, I8MM, or DotProd GEMM kernel executes the matrix multiply alt-txt#center](images/kai_matmul_kernel.jpg "Quantization, packing and matrix multiply microkernels")
 
 The packing of `GGML_TYPE_Q4_0` or `GGML_TYPE_Q8_0` weight (RHS) only needs to be performed one time when llama.cpp loads the model and weight tensor data, because the weight never changes during inference. For performance, it repacks the original GGUF weights into a layout optimized for cache-friendly access and DotProd, I8MM, and SME2 operations with the KleidiAI microkernels.
 
@@ -131,4 +131,10 @@ llama_context::decode
                                             kai_run_matmul_clamp_f32_qsi8d32p1x4_qsi4c32p4vlx4_1x4vl_sme2_sdot								 
 ```
 
-Now that you know where the KleidiAI SME2 path lives in llama.cpp and what it accelerates, move on to the next section to build the binary for inference.
+## What you've accomplished and what's next
+
+In this section:
+- You traced the KleidiAI SME2 path through the llama.cpp CPU backend, from model load through prefill and token decode
+- You identified the specific microkernels that handle each stage and the priority order (SME2 → I8MM → DotProd) used for microkernel selection
+
+In the next section, you'll set up the cross-compile toolchain and build a statically linked `llama-cli` binary with SME2 and KleidiAI enabled.

content/learning-paths/mobile-graphics-and-gaming/performance_llama_cpp_sme2/run_llm.md

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Run the Llama-3.2-3B-Instruct-Q4_0.gguf model with llama-cli 
 
-In this section, you run the model on an SME2-capable Android device. You will compare performance with SME2 enabled and disabled.
+In this section, you run the model on an SME2-capable Android device and compare performance with SME2 enabled and disabled.
 
 Put the built `llama-cli` executable and the `Llama-3.2-3B-Instruct-Q4_0.gguf` model file on your Android target that supports SME2. Using Android Debug Bridge (ADB) is usually the easiest way to transfer files and open a shell on the device.
 
@@ -44,17 +44,17 @@ adb shell
 cd /data/local/tmp/llama_sme2
 ```
 
-The figure below shows the architecture of Llama-3.2-3B model,
-![Figure showing Llama-3.2-3B architecture alt-text#center](images/llama-3.2-3b_architecture.jpg "Architecture of Llama-3.2-3B")
+The figure below shows the architecture of the Llama-3.2-3B model:
+![Architecture diagram of the Llama-3.2-3B model showing the transformer block structure, including attention heads, feed-forward layers, and the overall token embedding and output projection flow alt-txt#center](images/llama-3.2-3b_architecture.jpg "Architecture of Llama-3.2-3B")
 
 ## Inference with SME2 enabled
 
-You run the model by binding it to a single Arm C1-Pro core with CPU affinity. To enable SME2 microkernels, you must set the `GGML_KLEIDIAI_SME` environment variable before running the application.
+To enable SME2 microkernels, set the `GGML_KLEIDIAI_SME` environment variable before running the application. The flags used here are: `taskset 2` pins the process to CPU core 2 (the Arm C1-Pro core), `-st` enables single-token generation mode to report per-token performance stats, `-C 0x2 -Cb 0x2` sets CPU affinity for operator execution, and `-t 1` limits inference to one thread. If `taskset` is not available on your device, run the command without it.
 
 Run an inference on your target device:
 
 ```bash
-env GGML_KLEIDIAI_SME="1" taskset 2 ./llama-cli -m ./Llama-3.2-3B-Instruct-Q4_0.gguf -st -C 0x2 -Cb 0x2 -t 1 -p "input your prompt"
+env GGML_KLEIDIAI_SME="1" taskset 2 ./llama-cli -m ./Llama-3.2-3B-Instruct-Q4_0.gguf -st -C 0x2 -Cb 0x2 -t 1 -p "What is Arm SME2 and how does it accelerate AI workloads?"
 ```
 
 Here `env GGML_KLEIDIAI_SME="1"` enables SME2 microkernels, `taskset 2` binds the `llama-cli` process to CPU core 2 (the Arm C1-Pro core in our case), `-C 0x2 -Cb 0x2` sets the CPU affinity for operator execution, and `-t 1` sets the number of threads to one. If `taskset` is not available on your target device, run the same command without it.
@@ -65,15 +65,17 @@ With the SME2 kernels enabled, you'll notice the following performance output:
 [ Prompt: 12.3 t/s | Generation: 9.1 t/s ]
 ```
 
-## Inference without SME2 enabled
+Your results will vary depending on the device and the SME2 streaming vector length available.
 
-For a performance comparison, you can run the model with SME2 microkernels disabled. In this scenario, I8MM and Dotprod microkernels are used instead.
+## Baseline performance without SME2
+
+For a performance comparison, run the model with SME2 microkernels disabled. In this scenario, I8MM and DotProd microkernels are used instead.
 
 ```bash
-env GGML_KLEIDIAI_SME="0" taskset 2 ./llama-cli -m ./Llama-3.2-3B-Instruct-Q4_0.gguf -st -C 0x2 -Cb 0x2  -t 1 -p "input your prompt"
+env GGML_KLEIDIAI_SME="0" taskset 2 ./llama-cli -m ./Llama-3.2-3B-Instruct-Q4_0.gguf -st -C 0x2 -Cb 0x2 -t 1 -p "What is Arm SME2 and how does it accelerate AI workloads?"
 ```
 
-With the resulting performance:
+The output is similar to:
 
 ```output
 [ Prompt: 7.9 t/s | Generation: 5.9 t/s ]
@@ -85,15 +87,15 @@ You can profile the model execution with the approach introduced in [Profile lla
 
 The Streamline Timeline view and Annotate Markers in the figure below show that the token generation speeds up significantly at both Prefill and Decode stage. The PMU event counters show that many SME2 instructions, especially SME2 Integer Outer Product Accumulate instructions at the Prefill stage and SME2 Integer Outer Product instructions at the Decode stage, are used for acceleration.
 
-![Figure showing Streamline Timeline view alt-text#center](images/streamline_timeline_combined.jpg "Combined Streamline Timeline view with and without SME2")
+![Arm Streamline Timeline view showing side-by-side token generation runs with SME2 enabled and disabled, with Annotate markers highlighting Prefill and Decode stages and PMU counters showing SME2 Integer Outer Product instructions alt-txt#center](images/streamline_timeline_combined.jpg "Combined Streamline Timeline view with and without SME2")
 
 The Streamline Call Paths view below indicates similar speedup, it also shows that DotProd and I8MM KleidiAI microkernels are used instead when SME2 is not enabled. 
 
-![Figure showing Streamline Call Paths view alt-text#center](images/streamline_call_paths_combined.jpg "Combined Streamline Call Paths view with and without SME2")
+![Arm Streamline Call Paths view comparing inference with SME2 enabled against DotProd and I8MM fallback paths, showing the KleidiAI microkernel selected in each case alt-txt#center](images/streamline_call_paths_combined.jpg "Combined Streamline Call Paths view with and without SME2")
 
 ## Optional: Print the kernel names at runtime
 
-To investigate which operators in the model graph are delegated to KleidiAI microkernels, you can add some code as below to *./ggml/src/ggml-cpu/kleidiai/kleidiai.cpp* and recompile the binary. When you run the inference, the names of operators that make use of KleidiAI microkernels will be printed. This is only for debugging purposes.
+To investigate which operators in the model graph are delegated to KleidiAI microkernels, you can add some code as below to `./ggml/src/ggml-cpu/kleidiai/kleidiai.cpp` and recompile the binary. When you run the inference, the names of operators that make use of KleidiAI microkernels will be printed. This is only for debugging purposes.
 
 ```cpp
     bool compute_forward(struct ggml_compute_params * params, struct
@@ -127,8 +129,8 @@ kai matmul Q4_0 ffn_out-27
 
 ## Summary
 
-KleidiAI support in llama.cpp is still evolving, more operators will be accelerated by KleidiAI microkernels, unleashing greater potential of SME2. 
+You've run a quantized LLM on an SME2-capable Android device and measured the throughput difference with KleidiAI SME2 microkernels enabled and disabled. The results demonstrate meaningful gains at both the Prefill and Decode stages, making on-device LLM inference faster and more power-efficient on Arm hardware.
 
-With out-of-box KleidiAI and SME2 support in llama.cpp, you can get significant performance uplift at both Prefill and Decode stage, which enhances the experience of running LLM locally on device. 
+With out-of-the-box KleidiAI and SME2 support in llama.cpp, you can achieve significant performance improvements without any changes to the model or application code.
 
-Now that you have validated the runtime behavior with SME2 on your target device, move on to the Next Steps section to explore profiling and related Arm on-device AI performance resources.
+Move on to the Next Steps section to explore profiling and related Arm on-device AI performance resources.