Updates to the MCA learning path

Author: ash-arm

content/learning-paths/cross-platform/mca-godbolt/_index.md

@@ -14,14 +14,15 @@ prerequisites:
     - Familiarity with Arm assembly.
     - LLVM version 16 or newer, which includes support for Neoverse V2.
 
-author: Rin Dobrescu
+author: Asher Dobrescu
 
 ### Tags
 skilllevels: Introductory
 subjects: Performance and Architecture
 armips:
-    - Neoverse
     - Cortex-A
+    - Cortex-X
+    - Neoverse
 tools_software_languages:
     - Assembly
     - llvm-mca

content/learning-paths/cross-platform/mca-godbolt/background.md

@@ -25,9 +25,12 @@ Machine Code Analyzer (MCA) is a performance analysis tool that uses information
 
 ### How can MCA be useful?
 
-MCA takes as input a snippet of assembly code and then simulates the execution of that code in a loop of iterations, and the default is 100. 
+MCA takes as input a snippet of assembly code and then simulates the execution of that code in a loop of iterations, and the default is 100.
 
-MCA then outputs a performance report, which contains information such as the latency and throughput of the assembly block and the resource usage for each instruction. 
+MCA then outputs a performance report, which contains information such as the latency and throughput of the assembly block and the resource usage for each instruction.
 
 Using this information, you can identify bottlenecks in performance such as resource pressure and data dependencies. There are many options you can give MCA to get performance metrics. The options are explained in the [llvm-mca documentation](https://llvm.org/docs/CommandGuide/llvm-mca.html).
 
+### How to acquire MCA
+
+MCA is available as part of most Linux distributions, however the version tends to lag behind the current LLVM release. A recent version of MCA is also shipped as part of the Arm Toolchain for Linux (ATfL). You can find more information about ATfL and installation steps in the [ATfL user guide](https://developer.arm.com/documentation/110477/211/?lang=en). The set of cores available for performance estimation in MCA is determined by the LLVM version. You can check the version you are currently using by running `llvm-mca --version`. Using a recent version of LLVM is recommended in order to take advantage of improvements made to MCA. The most recent release can be obtained directly from LLVM, by downloading one of their [release packages](https://github.com/llvm/llvm-project/releases/). LLVM also makes nightly builds available to [download for Debian/Ubuntu](https://apt.llvm.org) based systems.

content/learning-paths/cross-platform/mca-godbolt/mca_on_godbolt.md

@@ -7,19 +7,19 @@ layout: learningpathall
 
 ### What is Compiler Explorer?
 
-Compiler Explorer is an interactive online compiler that is compatible with code in C/C++, Java, Python, and many other programming languages. It allows you to see what the code looks like after being compiled in real time. 
+Compiler Explorer is an interactive online compiler that is compatible with code in C/C++, Java, Python, and many other programming languages. It allows you to see what the code looks like after being compiled in real time. This is helpful when you want to try different compiler versions without installing them.
 
 Compiler Explorer supports multiple compilers and has many tools available, including `llvm-mca`.
 
 ### Running MCA in Compiler Explorer
 
-To access Compiler Explorer, open a browser and go to https://godbolt.org. 
+To access Compiler Explorer, open a browser and go to https://godbolt.org.
 
-This leads you to the page shown below in Figure 1. Your view might be slightly different. 
+This leads you to the page shown below in Figure 1. Your view might be slightly different.
 
-![godbolt open alt-text#center](open.webp "Figure 1. Compiler Explorer")
+![godbolt open alt-text#center](open.png "Figure 1. Compiler Explorer")
 
-The left side of the page contains the source code. In Figure 1, the language is set to C++, but you can click on the programming language to select a different language for the source code. 
+The left side of the page contains the source code. In Figure 1, the language is set to C++, but you can click on the programming language to select a different language for the source code.
 
 Copy the code below and paste it into Compiler Explorer as C++ source code:
 
@@ -34,28 +34,28 @@ int func(int a, int b, int c, int d, int e, int f) {
 }
 ```
 
-The right side of the page contains the disassembly output from the compiler. 
+The right side of the page contains the disassembly output from the compiler.
 
-You can change the compiler by clicking on it and selecting a different one. 
+You can change the compiler by clicking on it and selecting a different one.
 
-Select `armv8-a clang(trunk)` as the compiler to see Arm instructions. 
+Select `armv8-a clang(trunk)` as the compiler to see Arm instructions.
 
-Next, update the compiler flags by typing `-O3` in the `Compiler options` box. 
+Next, update the compiler flags by typing `-O3` in the `Compiler options` box.
 
-You can view the full set of options passed to the compiler by clicking on the green tick next to the compiler. 
+You can view the full set of options passed to the compiler by clicking on the green tick next to the compiler.
 
 Click the `Add tool` drop-down button to add `llvm-mca` as a tool as shown in Figure 2 below:
 
 ![tool mca alt-text#center](tool-mca.png "Figure 2. Assembly in Compiler Explorer")
 
-To add more flags to `llvm-mca`, click on the `Arguments` button and type them in. 
+To add more flags to `llvm-mca`, click on the `Arguments` button and type them in.
 
-Add `-mcpu=neoverse-v2`, as well as any other flags you choose to pass to `llvm-mca`. 
+Add `-mcpu=neoverse-v2`, as well as any other flags you choose to pass to `llvm-mca`.
 
-To find what CPUs are supported you can check the [clang documentation](https://clang.llvm.org/docs/CommandGuide/clang.html#cmdoption-print-supported-cpus). 
+To find what CPUs are supported you can check the [clang documentation](https://clang.llvm.org/docs/CommandGuide/clang.html#cmdoption-print-supported-cpus).
 
 The right side of the page now contains the output from running `llvm-mca` on the disassembly of the source code, as shown in Figure 3 below:
 
 ![argument mca alt-text#center](mca-arguments.png "Figure 3. MCA in Compiler Explorer")
 
-You are now able to run `llvm-mca` using Compiler Explorer. This is helpful when you want to try different compiler versions without installing them. 
+You are now able to run `llvm-mca` using Compiler Explorer.

content/learning-paths/cross-platform/mca-godbolt/running_mca.md

@@ -6,11 +6,11 @@ layout: learningpathall
 ---
 ### MCA example with Arm assembly
 
-You have learned what MCA is and what kind of information it provides. Now you are going to use MCA to identify a performance issue and improve a snippet of Arm assembly. 
+You have learned what MCA is and what kind of information it provides. Now you are going to use MCA to identify a performance issue and improve a snippet of Arm assembly.
 
 The example below demonstrates how to run `llvm-mca`, what the expected output is, and the conclusions you can draw using the performance metrics MCA provides.
 
-The example below computes the sum of 6 numbers. 
+The example below computes the sum of 6 numbers.
 
 Use a text editor to save the program below in a file named `sum_test1.s`:
 
@@ -389,8 +389,10 @@ Average Wait times (based on the timeline view):
        10    3.6    1.9    0.7       <total>
 ```
 
-You can see by looking at the timeline view that instructions no longer depend on each other and can execute in parallel. 
+You can see by looking at the timeline view that instructions no longer depend on each other and can execute in parallel.
 
-Instructions also spend less time waiting in the scheduler's queue. This explains why the performance of `sum_test2.s`  is so much better than `sum_test1.s`.
+Instructions also spend less time waiting in the scheduler's queue. This explains why the performance of `sum_test2.s` is so much better than `sum_test1.s`.
+
+Note the use of the flag `-mcpu=neoverse-v2` throughout all of those examples. This flag tells MCA to simulate the performance of the code in `sum_test1.s` and `sum_test2.s` on a Neoverse V2 core. This flag can be changed to any core supported in MCA. You can find what cores are supported in MCA by running `llvm-mca -mcpu=help <<<''`. You can also look at the LLVM sources in [llvm-project](https://github.com/llvm/llvm-project/tree/main/llvm/test/tools/llvm-mca/AArch64), which will give you more detailed examples. For instance, when looking at the Neoverse cores, there is currently support for the N1, N2, N3 and the V1, V2, V3 cores.
 
 In the next section, you can try running `llvm-mca` with Compiler Explorer.