From 4de711a3b4998d9a0b66ba676f800cfd558bcc7b Mon Sep 17 00:00:00 2001 From: Arnaud de Grandmaison Date: Fri, 28 Jun 2024 11:23:41 +0200 Subject: [PATCH 01/25] Add SME2 matrix multiplication learning path. --- .../cross-platform/sme2/1-get-started.md | 234 +++++++++++ .../sme2/2-check-your-environment.md | 174 +++++++++ .../cross-platform/sme2/3-vanilla-matmul.md | 80 ++++ .../cross-platform/sme2/4-outer-product.md | 112 ++++++ .../cross-platform/sme2/5-SME2-matmul-asm.md | 205 ++++++++++ .../cross-platform/sme2/6-SME2-matmul-intr.md | 366 ++++++++++++++++++ .../cross-platform/sme2/7-debugging.md | 119 ++++++ .../cross-platform/sme2/8-going-further.md | 62 +++ .../cross-platform/sme2/VSCode.png | Bin 0 -> 458989 bytes .../cross-platform/sme2/_index.md | 44 +++ .../cross-platform/sme2/_next-steps.md | 64 +++ .../cross-platform/sme2/_review.md | 48 +++ .../cross-platform/sme2/matmul.png | Bin 0 -> 39432 bytes .../cross-platform/sme2/outer_product.png | Bin 0 -> 55155 bytes 14 files changed, 1508 insertions(+) create mode 100644 content/learning-paths/cross-platform/sme2/1-get-started.md create mode 100644 content/learning-paths/cross-platform/sme2/2-check-your-environment.md create mode 100644 content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md create mode 100644 content/learning-paths/cross-platform/sme2/4-outer-product.md create mode 100644 content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md create mode 100644 content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md create mode 100644 content/learning-paths/cross-platform/sme2/7-debugging.md create mode 100644 content/learning-paths/cross-platform/sme2/8-going-further.md create mode 100644 content/learning-paths/cross-platform/sme2/VSCode.png create mode 100644 content/learning-paths/cross-platform/sme2/_index.md create mode 100644 content/learning-paths/cross-platform/sme2/_next-steps.md create mode 100644 content/learning-paths/cross-platform/sme2/_review.md create mode 100644 content/learning-paths/cross-platform/sme2/matmul.png create mode 100644 content/learning-paths/cross-platform/sme2/outer_product.png diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md new file mode 100644 index 0000000000..606b65fe3b --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -0,0 +1,234 @@ +--- +title: Get started +weight: 2 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +In this section, you will setup the environment needed to develop with SME2. + +SME2 hardware is not widely deployed at the time of writing of this learning +path, so you will have to use: + + - a compiler with support for SME2 instructions. [clang](https://www.llvm.org/) + version >= 18 or [gcc](https://gcc.gnu.org/) versions >= 14. This learning + path will use ``clang``. + + - an emulator to execute code with those new instructions. In this learning + path, we will use + [Arm's Fixed Virtual Platform (FVP) model](https://developer.arm.com/Tools%20and%20Software/Fixed%20Virtual%20Platforms). + + +## Prerequisites + +This learning path assumes that you have ``git`` and ``docker`` installed on your machine. + +### git + +Check that ``git`` is installed on your machine with the following command line in a terminal: + +```BASH { output_lines=2 } +git --version +git version 2.47.1 +``` + +If the above command line fails with a message similar to "``git: command not found``", then install ``git`` following the steps for your specific machine OS: + +{{< tabpane code=true >}} + {{< tab header="Linux/Ubuntu" language="bash">}} +sudo apt install git + {{< /tab >}} + {{< tab header="MacOS" language="bash">}} +brew install git + {{< /tab >}} +{{< /tabpane >}} + +### docker + +For ease of learning, without any risk of harming your computer setup, the +required compiler and FVP are provided as a docker container that you can fetch +from the internet to get instantly started. However, the ``Dockerfile`` to build +the container is available as well should you prefer to build it yourself or +study how it's built. + +{{% notice Note %}} +This learning path should also work without ``docker``, the only assumption is +that the compiler and the FVP are available on your search path. +{{% /notice %}} + +First, you should check that ``docker`` is installed by typing the following +command line in a terminal: + +```BASH { output_lines="2" } +docker --version +Docker version 27.3.1, build ce12230 +``` + +If the above command fails with a message similar to "``docker: command not found``" +then follow the steps from the [docker install guide](https://learn.arm.com/install-guides/docker/). +Note that you might have to re-login or restart your machine for the changes to be taken into account. + +Now that ``docker`` is installed on your machine, you should check that it's operating properly with: + +```BASH { output_lines="2-27" } +docker run hello-world +Unable to find image 'hello-world:latest' locally +latest: Pulling from library/hello-world +478afc919002: Pull complete +Digest: sha256:305243c734571da2d100c8c8b3c3167a098cab6049c9a5b066b6021a60fcb966 +Status: Downloaded newer image for hello-world:latest + +Hello from Docker! +This message shows that your installation appears to be working correctly. + +To generate this message, Docker took the following steps: + 1. The Docker client contacted the Docker daemon. + 2. The Docker daemon pulled the "hello-world" image from the Docker Hub. + (arm64v8) + 3. The Docker daemon created a new container from that image which runs the + executable that produces the output you are currently reading. + 4. The Docker daemon streamed that output to the Docker client, which sent it + to your terminal. + +To try something more ambitious, you can run an Ubuntu container with: + $ docker run -it ubuntu bash + +Share images, automate workflows, and more with a free Docker ID: + https://hub.docker.com/ + +For more examples and ideas, visit: + https://docs.docker.com/get-started/ +``` + +## Environment + +Now, using ``git``, clone the environment for experimenting with SME2 to a directory +named ``SME2.git``: + +```BASH +git clone https://gitlab.arm.com/learning-code-examples/TODO_SOME_PATH SME2-learning-path.git +``` + +This repository content is looking like: + +```TXT +SME2-learning-path.git/ +├── .clang-format +├── .devcontainer/ +│ └── devcontainer.json +├── .git/ +├── .gitignore +├── Makefile +├── README.rst +├── docker/ +│ ├── assets.source_me +│ ├── build-all-containers.sh +│ ├── build-my-container.sh +│   └── sme2-environment.docker +├── hello.c +├── main.c +├── matmul.h +├── matmul_asm.c +├── matmul_asm_impl.S +├── matmul_intr.c +├── matmul_vanilla.c +├── misc.c +├── misc.h +├── preprocess_l_asm.S +├── preprocess_vanilla.c +├── run-fvp.sh +└── sme2_check.c +``` + +It contains: +- the code examples used in this learning path, +- the ``Makefile`` used to build them, +- the ``run-fvp.sh`` shell script to run the FVP, +- the ``docker/`` directory contains ``docker`` related material. + ``assets.source_me`` provides the FVP and compiler toolchain references, + ``sme2-environment.docker`` is the docker receipe to build the container that + you will use, ``build-my-container.sh`` is the shell script you should use in + case you want to build the docker container (but you don't have to, ready-made + images are made available for you ). Lastly ``build-all-containers.sh`` is the + script that was used to create the multi-arch (x86_64 and aarch64 support) + image for you to download. +- ``.devcontainer/devcontainer.json`` is a configuration script for VSCode to be + able to use the container from the IDE (read below). + +Change directory to your checkout: + +```BASH +cd SME2-learning-path.git +``` + +From now on, all instructions in this learning path assume your current +directory is ``SME2-learning-path.git``. + +## Using the environment + +Docker provides you with a way to execute commands in a different environment, +where all necessary tools are available without cluttering your machine. You can: +- use docker directly from the command line, for example when you are working + from a terminal, +- configure VSCode to run all the commands in the docker environment. + +### Directly in a terminal + +When a command has to be executed in the docker container environment, you have +to prepend it with instructions on the command line so that your shell will +execute them in the container. For example, to execute ``COMMAND ARGUMENTS`` in +the SME2 docker container, the command line looks like: + +```SH +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 COMMAND ARGUMENTS +``` + +This invokes docker, using the +``armswdev/sme2-learning-path:sme2-environment-v1``container +image, and mounts the current working directory (the ``SME2-learning-path.git``) +inside the container to ``/work``, sets ``/work`` as the +working directory and run ``COMMAND ARGUMENTS`` in this environment. + +For example, to run ``make``, you would have to type: + +```SH +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make +``` + +### In VSCode + +Make sure you have the [Dev +Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) +extension installed. It should then be as easy as using the "Reopen in +Container" menu entry as in figure 1 (it will automatically find and use +``.devcontainer/devcontainer.json``): + +![example image alt-text#center](VSCode.png "Figure 1. Using the Dev Containers extension") + +All your commands will now take place in the container, so no need to prepend +them with some docker invocation, VSCode handles all this transparently for you. + +In the remainder of this learning path, the shell commands will show the docker +invocation (so readers that don't use VSCode can copy the full command line), +but you should only use the ``COMMAND ARGUMENTS`` part. + +## Suggested reading + +If you are not familiar with matrix multiplication --- or need a refresh --- +this [wikipedia article on Matrix +multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication) is a good +start. + +If you are not familiar with SVE and / or SME, it is strongly suggested that you +first read some material as this learning path assumes some basic understanding +of those technologies: + + - [Introducing the Scalable Matrix Extension for the Armv9-A + Architecture](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/scalable-matrix-extension-armv9-a-architecture) + - [Arm Scalable Matrix Extension (SME) Introduction (part + 1)](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction) + - [Arm Scalable Matrix Extension (SME) Introduction (part + 2)](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction-p2) + +You are now all set to move to the next chapter ! \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md new file mode 100644 index 0000000000..a6c253b747 --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md @@ -0,0 +1,174 @@ +--- +title: Check your environment +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +In this section, you will check that the environment needed to develop with SME2 +just works. This will also serve as your first hands on with the environment + +## Compile the examples + +First, compile the example code with: + +```BASH { output_lines="2-19" } +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -nostartfiles -lcrt0-semihost -lsemihost -Wl,--defsym=__boot_flash=0x80000000 -Wl,--defsym=__flash=0x80001000 -Wl,--defsym=__ram=0x81000000 -T picolibc.ld -o hello hello.c +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -c -o sme2_check.o sme2_check.c +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -c -o misc.o misc.c +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -nostartfiles -lcrt0-semihost -lsemihost -Wl,--defsym=__boot_flash=0x80000000 -Wl,--defsym=__flash=0x80001000 -Wl,--defsym=__ram=0x81000000 -T picolibc.ld -o sme2_check sme2_check.o misc.o +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -DIMPL=asm -c -o main_asm.o main.c +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -c -o matmul_asm.o matmul_asm.c +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -c -o matmul_asm_impl.o matmul_asm_impl.S +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -c -o preprocess_l_asm.o preprocess_l_asm.S +clang --target=aarch64-none-elf -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -c -o matmul_vanilla.o matmul_vanilla.c +clang --target=aarch64-none-elf -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -c -o preprocess_vanilla.o preprocess_vanilla.c +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -nostartfiles -lcrt0-semihost -lsemihost -Wl,--defsym=__boot_flash=0x80000000 -Wl,--defsym=__flash=0x80001000 -Wl,--defsym=__ram=0x81000000 -T picolibc.ld -o sme2_matmul_asm main_asm.o matmul_asm.o matmul_asm_impl.o preprocess_l_asm.o matmul_vanilla.o preprocess_vanilla.o misc.o +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -DIMPL=intr -c -o main_intr.o main.c +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -c -o matmul_intr.o matmul_intr.c +clang --target=aarch64-none-elf -march=armv9.4-a+sme2 -fno-exceptions -fno-rtti -mno-unaligned-access -O2 -Wall -std=c99 -nostartfiles -lcrt0-semihost -lsemihost -Wl,--defsym=__boot_flash=0x80000000 -Wl,--defsym=__flash=0x80001000 -Wl,--defsym=__ram=0x81000000 -T picolibc.ld -o sme2_matmul_intr main_intr.o matmul_intr.o matmul_vanilla.o preprocess_vanilla.o misc.o +llvm-objdump --demangle -d hello > hello.lst +llvm-objdump --demangle -d sme2_check > sme2_check.lst +llvm-objdump --demangle -d sme2_matmul_asm > sme2_matmul_asm.lst +llvm-objdump --demangle -d sme2_matmul_intr > sme2_matmul_intr.lst +``` + +The above ``make`` command (executed within the docker ``armswdev/sme2-learning-path:sme2-environment-v1`` environment) is: + +- building 4 executables: ``hello``, ``sme2_check``, ``sme2_matmul_asm`` and ``sme2_matmul_intr``, +- creating the assembly listings for the 4 executables: ``hello.lst``, ``sme2_check.lst``, ``sme2_matmul_asm.lst`` and ``sme2_matmul_intr.lst`` + +{{% notice Note %}} +At any point, you can clean the directory of all the files that have been built by invoking ``make clean`` target: + +```BASH +$ docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make clean +``` +{{% /notice %}} + +## Basic Sanity checks + +The very first program that you should run is the famous "Hello, world !" that +will let you know that the basics of your environment are in place. The source +code is in ``hello.c`` and looks like: + +```C +#include +#include + +int main(int argc, char *argv[]) { + printf("Hello, world !\n"); + return EXIT_SUCCESS; +} +``` + +Run the FVP simulation of the ``hello`` program with: + +```BASH { output_lines="2-4" } +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh hello +Hello, world ! + +Info: /OSCI/SystemC: Simulation stopped by user. +``` + +The important line is the "``Hello, world !``" one that shows that generic code +can be compiled and run on the FVP. + +## SME2 checks + +You will now run the ``sme2_check`` program, which checks that SME2 works as +expected, in the compiler and in the FVP. The source code is found in +``sme2_check.c``: + +```C +#include +#include + +#include "misc.h" + +#ifdef __ARM_FEATURE_SME2 +#include +#else +#error __ARM_FEATURE_SME2 is not defined +#endif + +#define get_cpu_ftr(regId, feat, msb, lsb) \ + ({ \ + unsigned long __val; \ + __asm__("mrs %0, " #regId : "=r"(__val)); \ + printf("%-20s: 0x%016lx\n", #regId, __val); \ + printf(" - %-10s: 0x%08lx\n", #feat, \ + (__val >> lsb) & ((1 << (msb - lsb)) - 1)); \ + }) + +int main(int argc, char *argv[]) { + get_cpu_ftr(ID_AA64PFR0_EL1, SVE, 35, 32); + get_cpu_ftr(ID_AA64PFR1_EL1, SME, 27, 24); + + int n = 0; +#ifdef __ARM_FEATURE_SME2 + setup_sme(); + n = svcntb() * 8; +#endif + if (n) { + printf("SVE is available with length %d\n", n); + } else { + printf("SVE is unavailable.\n"); + exit(EXIT_FAILURE); + } + + printf("Checking has_sme: %d\n", __arm_has_sme()); + printf("Checking in_streaming_mode: %d\n", __arm_in_streaming_mode()); + + printf("Starting streaming mode...\n"); + __asm__("smstart"); + + printf("Checking in_streaming_mode: %d\n", __arm_in_streaming_mode()); + + printf("Stopping streaming mode...\n"); + __asm__("smstop"); + + printf("Checking in_streaming_mode: %d\n", __arm_in_streaming_mode()); + + return EXIT_SUCCESS; +} +``` + +The ``sme2_check`` program will display the SVE (resp. SME) fields of the +``ID_AA64PFR0_EL1`` (resp. ``ID_AA64PFR1_EL1``) system registers from the CPU +and will then check if SVE and SME are available, and finally will switch into +streaming mode and back from streaming mode. The ``__ARM_FEATURE_SME2`` macro +is provided by the compiler when it targets an SME capable target, which is +specified with the ``-march=armv9.4-a+sme2`` command line option to ``clang`` in +file ``Makefile``. The ``arm_sme.h`` include file is part of the Arm C library +extension ([ACLE](https://arm-software.github.io/acle/main/)). The ACLE provides +types and function declarations to let C/C++ programmers exploit the Arm +architecture. We will use the SME related part of the library, but it does also +provide support for Neon or other Arm architectural extensions. + +```BASH +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh sme2_check +``` + +The output you get should be similar to: + +```TXT +ID_AA64PFR0_EL1 : 0x1101101131111112 + - SVE : 0x00000001 +ID_AA64PFR1_EL1 : 0x0000101002000001 + - SME : 0x00000002 +SVE is available with length 512 +Checking has_sme: 1 +Checking in_streaming_mode: 0 +Starting streaming mode... +Checking in_streaming_mode: 1 +Stopping streaming mode... +Checking in_streaming_mode: 0 + +Info: /OSCI/SystemC: Simulation stopped by user. +``` + +You have checked that code can be compiled and executed with full SME2 support: +you are now all set to move to the next chapter ! \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md new file mode 100644 index 0000000000..6faf405a69 --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md @@ -0,0 +1,80 @@ +--- +title: Vanilla matrix multiplication +weight: 4 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +In this chapter, you will write a by-the-book matrix multiplication in C. + +## Vanilla matrix multiplication + +### Algorithm description + +The vanilla matrix multiplication operation takes two input matrices, A [Al +rows x Ac columns] and B [Bl rows x Bc columns], to produce an output matrix C +[Cl rows x Cc columns]. The operation consists of iterating on each row of A +and each column of B, multiplying each element of the A row with its corresponding +element in the B column then summing all these products, as depicted in figure 2 below. + +![example image alt-text#center](matmul.png "Figure 2. By the book matrix multiplication") + +This implies that the A, B and C matrices have some constraints on their +dimensions: + +- A's number of columns needs to match B's number of lines: Ac == Bl +- C will have dimensions Cl == Al and Cc == Bc + +You can learn more about matrix multiplication, including its history, +properties and use, with this [wikipedia +article](https://en.wikipedia.org/wiki/Matrix_multiplication) + +In this learning path, we will use the following variable names: + +- ``matLeft`` corresponds to the left hand side argument of the matrix + multiplication, +- ``matRight``corresponds to the right-hand side of the matrix multiplication, +- ``M`` is ``matleft`` number of rows, +- ``K`` is ``matleft`` number of columns (and ``matRight`` number of rows), +- ``N`` is ``matRight`` number of columns, +- ``matResult``corresponds to the result of the matrix multiplication, with + ``M`` rows and ``N`` columns. + +### C implementation + +A literal implementation of the textbook matrix multiplication algorithm, as +described above, can be found in file ``matmul_vanilla.c``: + +```C +void matmul(uint64_t M, uint64_t K, uint64_t N, + const float *restrict matLeft, const float *restrict matRight, + float *restrict matResult) { + for (uint64_t m = 0; m < M; m++) { + for (uint64_t n = 0; n < N; n++) { + + float acc = 0.0; + + for (uint64_t k = 0; k < K; k++) + acc += matLeft[m * K + k] * matRight[k * N + n]; + + matResult[m * N + n] = acc; + } + } +} +``` + +In this learning path, the matrices are laid out in memory as contiguous +sequences of elements, in [row major +order](https://en.wikipedia.org/wiki/Row-_and_column-major_order). The +``matmul`` function performs the algorithm that was described above. The +pointers to ``matLeft``, ``matRight`` and ``matResult`` have been annotated as +``restrict``, which informs the compiler that the memory areas designated by +those pointers do not alias (i.e. they do not overlap in any way), so the +compiler does not need to insert extra instructions to deal with those cases. +The pointers to ``matLeft`` and ``matRight`` are marked as ``const`` because +none of these 2 matrices are modified by ``matmul``. + +You now have a reference matrix multiplication function. It will be used later +on in this learning path to ensure that the assembly version and the intrinsics +version of the multiplication algorithm do not contain errors. \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/4-outer-product.md b/content/learning-paths/cross-platform/sme2/4-outer-product.md new file mode 100644 index 0000000000..b9ec961956 --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/4-outer-product.md @@ -0,0 +1,112 @@ +--- +title: Outer product +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +In this section, you will learn how the outer product with the SME engine can be +used to improve matrix multiplication. + +## Matrix multiplication with the outer product + +In our textbook matrix multiplication example, the core of the computation: + +```C + acc += matLeft[m * K + k] * matRight[k * N + n]; +``` + +is 1 multiply-accumulate (a.k.a ``macc``) for 2 loads (``matLeft[m * K + k]`` +and ``matRight[k *N + n]``): it thus has 1:2 ``macc`` to ``load`` ratio. From a +memory system perspective, this is not very effective especially since this +computation is done within a triple nested loop, repeatedly loading data from +memory. And to make things worse, large matrices may not fit in cache... In +order to improve the matrix multiplication efficiency, the goal is to increase +the ``macc`` to ``load`` ratio, that is perform more multiply-accumulate +operations per load. + +Figure 3 below depicts how the matrix multiplication of ``matLeft`` (3 rows, 2 +columns) by ``matRight`` (2 rows, 3 columns) can be decomposed as the sum of the +outer products: + +![example image alt-text#center](outer_product.png "Figure 3. Outer product based matrix multiplication") + +The SME engine builds on the +[outer product](https://en.wikipedia.org/wiki/Outer_product) as matrix +multiplication can be expressed as the +[sum of column-by-row outer products](https://en.wikipedia.org/wiki/Outer_product#Connection_with_the_matrix_product). + + +## About transposition + +From the previous page, you will recall that matrices are laid out in row-major +order. This means that loading row-data from memory is efficient as the memory +system operates efficiently with contiguous data, e.g. caches are loaded line by +line, data prefetching is extremely simple (just load the data from +``current address + sizeof(data)``), ... This is not the case for loading column-data from +memory though, as it requires more work from the memory system. + +In order to further improve the effectiveness of the matrix multiplication, it +is thus desirable to change the layout in memory of the left hand side matrix +(``matLeft`` in our code examples), essentially performing a matrix +transposition so that instead of load column-data one loads row-data from +memory. + +{{% notice Important %}} +It's important to note here that this reorganizes the layout of the matrix in +memory in order for the algorithm implementation to be more efficient. The +transposition affects only the memory layout: ``matLeft`` will be transformed to +be in column-major order --- from a mathematical perspective, ``matleft`` is +*not* transposed. +{{% /notice %}} + +### Transposition in the real world + +Just as trees don't grow to the sky, the SME engine has physical +implementation limits. It operates with so called tiles in the ZA storage. Tiles +are 2D portions of the matrices being processed. SME has dedicated instructions +to load data to / store data from tiles efficiently, as well as instructions to +operate with / on tiles, e.g the +[fmopa](https://developer.arm.com/documentation/ddi0602/latest/SME-Instructions/FMOPA--non-widening---Floating-point-outer-product-and-accumulate-?lang=en) +instruction which takes 2 vectors as inputs and accumulate all the outer +products to a 2D tile. The tile in ZA storage is what allows SME to increase the +``macc`` to ``load`` ratio, as all the tile elements are loaded to the tile, to +be used with the SME outer product instructions. + +Taking into account that the ZA storage is finite, the desirable transposition +of the ``matLeft`` matrix that was discussed in the previous section needs to +adapted to the tile dimensions, so that a tile is easy to access. The +``matLeft`` preprocessing has thus some aspects of transpositions, but takes +into account the tiling as well and is referred to in the code as +``preprocess``. + +Here is at the algorithmic level what ``preprocess_l`` does in practice: + +```C +void preprocess_l(uint64_t nbr, uint64_t nbc, uint64_t SVL, + const float *restrict a, float *restrict a_mod) { + + // For all tiles of SVL x SVL data + for (uint64_t By = 0; By < nbr; By += SVL) { + for (uint64_t Bx = 0; Bx < nbc; Bx += SVL) { + // For this tile + const uint64_t dest = By * nbc + Bx * SVL; + for (uint64_t j = 0; j < SVL; j++) { + for (uint64_t i = 0; i < SVL && (Bx + i) < nbc; i++) { + if (By + j < nbr) { + a_mod[dest + i * SVL + j] = a[(By + j) * nbc + Bx + i]; + } else { + // These elements are outside of matrix a, so zero them. + a_mod[dest + i * SVL + j] = 0.0; + } + } + } + } + } +} +``` + +``preprocess_l`` will be used to check the assembly and intrinsic versions of +the matrix multiplication perform the preprocessing step correctly. This code is +located in file ``preprocess_vanilla.c``. diff --git a/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md b/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md new file mode 100644 index 0000000000..876d5bf8dd --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md @@ -0,0 +1,205 @@ +--- +title: SME2 assembly matrix multiplication +weight: 6 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +In this chapter, you will use an SME2 optimized matrix multiplication written +directly in assembly. + +## Matrix multiplication with SME2 in assembly + +### Description + +This learning path reuse the assembly version provided in the [SME programmer's +guide](https://developer.arm.com/documentation/109246/0100/matmul-fp32--Single-precision-matrix-by-matrix-multiplication) +where you will find a high level and an in-depth description of the 2 steps +performed. The assembly versions have been modified so they coexist nicely with +the intrinsic versions. In this learning path, the ``preprocess`` function is +defined in ``preprocess_l_asm.S`` and the outer-product based matrix +multiplication is in ``matmul_asm_impl.S``. Those 2 functions have been stitched +together in ``matmul_asm.c`` with the same prototype as the reference +implementation of matrix multiplication, so that a top-level ``matmul_asm`` can +be called from the ``main`` function: + +```C +void matmul_asm(uint64_t M, uint64_t K, uint64_t N, + const float *restrict matLeft, const float *restrict matRight, + float *restrict matLeft_mod, float *restrict matResult) { + __asm volatile("" + : + : + : "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8", "p9", + "p10", "p11", "p12", "p13", "p14", "p15", "z0", "z1", "z2", + "z3", "z4", "z5", "z6", "z7", "z8", "z9", "z10", "z11", + "z12", "z13", "z14", "z15", "z16", "z17", "z18", "z19", + "z20", "z21", "z22", "z23", "z24", "z25", "z26", "z27", + "z28", "z29", "z30", "z31"); + + preprocess_l_asm(M, K, matLeft, matLeft_mod); + matmul_asm_impl(M, K, N, matLeft_mod, matRight, matResult); + + __asm volatile("" + : + : + : "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8", "p9", + "p10", "p11", "p12", "p13", "p14", "p15", "z0", "z1", "z2", + "z3", "z4", "z5", "z6", "z7", "z8", "z9", "z10", "z11", + "z12", "z13", "z14", "z15", "z16", "z17", "z18", "z19", + "z20", "z21", "z22", "z23", "z24", "z25", "z26", "z27", + "z28", "z29", "z30", "z31"); +} +``` + +Note the use of the ``__asm`` statement forcing the compiler to save the SVE/SME registers. + +The high-level ``matmul_asm`` function is called from ``main.c``: + +```C +#include "matmul.h" +#include "misc.h" + +#include +#include +#include +#include + +#ifndef __ARM_FEATURE_SME2 +#error __ARM_FEATURE_SME2 is not defined +#endif + +#ifndef IMPL +#error matmul implementation selection macro IMPL is not defined +#endif + +#define STRINGIFY_(I) #I +#define STRINGIFY(I) STRINGIFY_(I) +#define FN(M, I) M##I +#define MATMUL(I, M, K, N, mL, mR, mM, m) FN(matmul_, I)(M, K, N, mL, mR, mM, m) + +// Assumptions: +// nbr in matLeft (M): any +// nbc in matLeft, nbr in matRight (K): any K > 2 (for the asm version) +// nbc in matRight (N): any + +int main(int argc, char **argv) { + + /* Size parameters */ + uint64_t M, N, K; + if (argc >= 4) { + M = strtoul(argv[1], NULL, 0); + K = strtoul(argv[2], NULL, 0); + N = strtoul(argv[3], NULL, 0); + } else { + /* Default: 125x35x70 */ + M = 125; + K = 35; + N = 70; + } + + printf("\nSME2 Matrix Multiply fp32 *%s* example with args %lu %lu %lu\n", + STRINGIFY(IMPL), M, K, N); + + setup_sme(); + + const uint64_t SVL = svcntsw(); + + /* Calculate M of transformed matLeft. */ + const uint64_t M_mod = SVL * (M / SVL + (M % SVL != 0 ? 1 : 0)); + + float *matRight = (float *)malloc(K * N * sizeof(float)); + + float *matLeft = (float *)malloc(M * K * sizeof(float)); + float *matLeft_mod = (float *)malloc(M_mod * K * sizeof(float)); + float *matLeft_mod_ref = (float *)malloc(M_mod * K * sizeof(float)); + + float *matResult = (float *)malloc(M * N * sizeof(float)); + float *matResult_ref = (float *)malloc(M * N * sizeof(float)); + +#ifdef DEBUG + initialize_matrix(matLeft, M * K, LINEAR_INIT); + initialize_matrix(matRight, K * N, LINEAR_INIT); + initialize_matrix(matLeft_mod, M_mod * K, DEAD_INIT); + initialize_matrix(matResult, M * N, DEAD_INIT); + + print_matrix(M, K, matLeft, "matLeft"); + print_matrix(K, N, matRight, "matRight"); +#else + initialize_matrix(matLeft, M * K, RANDOM_INIT); + initialize_matrix(matRight, K * N, RANDOM_INIT); +#endif + + MATMUL(IMPL, M, K, N, matLeft, matRight, matLeft_mod, matResult); + + // Compute the reference values with the vanilla implementations. + matmul(M, K, N, matLeft, matRight, matResult_ref); + preprocess_l(M, K, SVL, matLeft, matLeft_mod_ref); + + unsigned error = compare_matrices(K, M_mod, matLeft_mod_ref, matLeft_mod, + "Matrix preprocessing"); + if (!error) + error = compare_matrices(M, N, matResult_ref, matResult, + "Matrix multiplication"); + + free(matRight); + + free(matLeft); + free(matLeft_mod); + free(matLeft_mod_ref); + + free(matResult); + free(matResult_ref); + + return error ? EXIT_FAILURE : EXIT_SUCCESS; +} +``` + +The same ``main.c`` file is used for the assembly and intrinsic based versions +of the matrix multiplication. It will first set the ``M``, ``K`` and ``N`` +parameters, to either the arguments supplied on the command line or use default +value. Depending on the ``M``, ``K``, ``N`` dimension parameters, ``main`` will +allocate memory for all the matrices and initialize ``matLeft`` and +``matRight`` with random data. The actual matrix multiplication implementation +is provided through the ``IMPL`` macro. It will then run the matrix multiplication +from ``IMPL`` and compute the reference values for the preprocessed matrix as +well as the result matrix. It then compares the actual values to the reference +values and reports errors (if any). Last, all the memory is de-allocated before +exiting the program with a success or failure return code. + +### Compile and run it + +First, make sure that the ``sme2_matmul_asm`` executable is up to date: + +```BASH +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make sme2_matmul_asm +``` + +Then execute ``sme2_matmul_asm`` on the FVP: + +```BASH +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh sme2_matmul_asm +``` + +which should output something similar to: + +```TXT +SME2 Matrix Multiply fp32 *asm* example with args 125 35 70 +Matrix preprocessing: PASS ! +Matrix multiplication: PASS ! + +Info: /OSCI/SystemC: Simulation stopped by user. +``` + +{{% notice Tip %}} +The example above uses the default values for the ``M``, ``K`` and ``N`` +parameters (resp. 125, 25 and 70). You can override this and provide your own +values on the command line: + +```BASH +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh sme2_matmul_asm 7 8 9 +``` + +if you wish to execute the same code with ``M=7``, ``K=8`` and ``N=9`` instead. +{{% /notice %}} \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md new file mode 100644 index 0000000000..6ce87ea3a0 --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md @@ -0,0 +1,366 @@ +--- +title: SME2 intrinsics matrix multiplication +weight: 7 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +In this chapter, you will write an SME2 optimized matrix multiplication in C +using the intrinsics provided by the compiler. + +## Matrix multiplication with SME2 intrinsics + +*Intrinsics*, also know known as *compiler intrinsics* or *intrinsic functions* +are functions available to application developers that the compiler has an +intimate knowledge of. This enables the compiler to either translate that +function to a very specific instruction and/or to perform specific +optimizations. + +You can lean more about intrinsics in this [wikipedia +article](https://en.wikipedia.org/wiki/Intrinsic_function). + +Using intrinsics allows the programmer to use the very specific instructions +needed to achieve the required performance while writing in C all the mundane +code (loops, ...). This gives performance close to what can be reached with hand +written assembly whilst being significantly more maintainable and portable ! + +All Arm specific intrinsics are specified in the +[ACLE](https://github.com/ARM-software/acle) --- Arm C language extension. ACLE +is supported by the main compilers, most notably [GCC](https://gcc.gnu.org/) and +[clang](https://clang.llvm.org). + +## Streaming mode + +In the previous page, the assembly language gave the programmer full access to +the processor features. However, this comes at a cost in complexity and +maintenance especially when one has to manage large code bases with deeply +nested function calls. The assembly version is very low level, and does not deal +properly with the SME state. In real world large scale software, the program +will move back and forth from streaming mode, and some streaming mode routines +will call other streaming mode routines, which means that some state (including +the ZA storage) needs to be saved and restored. This is defined in the ACLE and +supported by the compiler: the programmer *just* has to annotate the function +with some keywords and set up some registers (see function ``setup_sme`` in +``misc.c`` for an example). See +[Introduction to streaming and non-streaming mode](https://arm-software.github.io/acle/main/acle.html#controlling-the-use-of-streaming-mode) +for further details. The rest of this section quotes parts from the ACLE as there is no better way to +restate the same. + +The AArch64 architecture defines a concept called “streaming mode”, controlled +by a processor state bit called ``PSTATE.SM``. At any given point in time, the +processor is either in streaming mode (``PSTATE.SM==1``) or in non-streaming mode +(``PSTATE.SM==0``). There is an instruction called ``SMSTART`` to enter streaming mode +and an instruction called ``SMSTOP`` to return to non-streaming mode. + +Streaming mode has three main effects on C and C++ code: + +- It can change the length of SVE vectors and predicates: the length of an SVE + vector in streaming mode is called the “streaming vector length” (SVL), which + might be different from the normal non-streaming vector length. See + [Effect of streaming mode on VL](https://arm-software.github.io/acle/main/acle.html#effect-of-streaming-mode-on-vl) + for more details. +- Some instructions can only be executed in streaming mode, which means that + their associated ACLE intrinsics can only be used in streaming mode. These + intrinsics are called “streaming intrinsics”. +- Some other instructions can only be executed in non-streaming mode, which + means that their associated ACLE intrinsics can only be used in non-streaming + mode. These intrinsics are called “non-streaming intrinsics”. + +The C and C++ standards define the behavior of programs in terms of an “abstract +machine”. As an extension, the ACLE specification applies the distinction +between streaming mode and non-streaming mode to this abstract machine: at any +given point in time, the abstract machine is either in streaming mode or in +non-streaming mode. + +This distinction between processor mode and abstract machine mode is mostly just +a dry specification detail. However, the usual “as if” rule applies: the +processor's actual mode at runtime can be different from the abstract machine's +mode, provided that this does not alter the behavior of the program. One +practical consequence of this is that C and C++ code does not specify the exact +placement of ``SMSTART`` and ``SMSTOP`` instructions; the source code simply places +limits on where such instructions go. For example, when stepping through a +program in a debugger, the processor mode might sometimes be different from the +one implied by the source code. + +ACLE provides attributes that specify whether the abstract machine executes statements: + +- in non-streaming mode, in which case they are called “non-streaming statements” +- in streaming mode, in which case they are called “streaming statements” +- in either mode, in which case they are called “streaming-compatible statements” + +SME provides an area of storage called ZA, of size ``SVL.B`` x ``SVL.B`` bytes. It +also provides a processor state bit called ``PSTATE.ZA`` to control whether ZA +is enabled. + +In C and C++ code, access to ZA is controlled at function granularity: a +function either uses ZA or it does not. Another way to say this is that a +function either “has ZA state” or it does not. + +If a function does have ZA state, the function can either share that ZA state +with the function's caller or create new ZA state “from scratch”. In the latter +case, it is the compiler's responsibility to free up ZA so that the function can +use it; see the description of the lazy saving scheme in +[AAPCS64](https://arm-software.github.io/acle/main/acle.html#AAPCS64) for details +about how the compiler does this. + +## Implementation + +Here again, a top level function named ``matmul_intr`` in ``matmul_intr.c`` +will be used to stitch together the preprocessing and the multiplication: + +```C "{ line_numbers = true }" +__arm_new("za") __arm_locally_streaming void matmul_intr( + uint64_t M, uint64_t K, uint64_t N, const float *restrict matLeft, + const float *restrict matRight, float *restrict matLeft_mod, + float *restrict matResult) { + uint64_t SVL = svcntsw(); + preprocess_l_intr(M, K, SVL, matLeft, matLeft_mod); + matmul_intr_impl(M, K, N, SVL, matLeft_mod, matRight, matResult); +} +``` + +Note the ``__arm_new("za")`` and ``__arm_locally_streaming`` at line 1 that will +make the compiler save the ZA storage so we can use it without destroying its +content if it was still in use by one of the callers. + +``SVL``, the dimension of the ZA storage, is requested from the underlying +hardware with the ``svcntsw()`` function call at line 5, and passed down to the +``preprocess_l_intr`` and ``matmul_intr_impl`` functions. ``svcntsw()`` is a +function provided be the ACLE library. + +### Matrix preprocessing + +```C "{ line_numbers = true }" +void preprocess_l_intr( + uint64_t M, uint64_t K, uint64_t SVL, const float *restrict a, + float *restrict a_mod) __arm_streaming __arm_inout("za") { + const uint64_t M_mod = SVL * (M / SVL + (M % SVL != 0 ? 1 : 0)); + + // The outer loop, iterating over rows (M dimension) + for (uint64_t row = 0; row < M; row += SVL) { + + svbool_t pMDim = svwhilelt_b32(row, M); + + // The inner loop, iterating on columns (K dimension). + for (uint64_t col = 0; col < K; col += 2 * SVL) { + + svcount_t pKDim = svwhilelt_c32(col, K, 2); + + // Load-as-rows + for (uint64_t trow = 0; trow < SVL; trow += 4) { + svcount_t p0 = svpsel_lane_c32(pKDim, pMDim, trow + 0); + svcount_t p1 = svpsel_lane_c32(pKDim, pMDim, trow + 1); + svcount_t p2 = svpsel_lane_c32(pKDim, pMDim, trow + 2); + svcount_t p3 = svpsel_lane_c32(pKDim, pMDim, trow + 3); + + const uint64_t tile_UL_corner = (row + trow) * K + col; + svfloat32x2_t zp0 = svld1_x2(p0, &a[tile_UL_corner + 0 * K]); + svfloat32x2_t zp1 = svld1_x2(p1, &a[tile_UL_corner + 1 * K]); + svfloat32x2_t zp2 = svld1_x2(p2, &a[tile_UL_corner + 2 * K]); + svfloat32x2_t zp3 = svld1_x2(p3, &a[tile_UL_corner + 3 * K]); + + svfloat32x4_t zq0 = svcreate4(svget2(zp0, 0), svget2(zp1, 0), + svget2(zp2, 0), svget2(zp3, 0)); + svfloat32x4_t zq1 = svcreate4(svget2(zp0, 1), svget2(zp1, 1), + svget2(zp2, 1), svget2(zp3, 1)); + svwrite_hor_za32_f32_vg4( + /* tile: */ 0, /* slice: */ trow, zq0); + svwrite_hor_za32_f32_vg4( + /* tile: */ 1, /* slice: */ trow, zq1); + } + + // Read-as-columns and store + const uint64_t dest_0 = row * K + col * SVL; + const uint64_t dest_1 = dest_0 + SVL * SVL; + for (uint64_t tcol = 0; tcol < SVL; tcol += 4) { + svcount_t p0 = svwhilelt_c32(dest_0 + tcol * SVL, K * M_mod, 4); + svcount_t p1 = svwhilelt_c32(dest_1 + tcol * SVL, K * M_mod, 4); + svfloat32x4_t zq0 = + svread_ver_za32_f32_vg4(/* tile: */ 0, /* slice: */ tcol); + svfloat32x4_t zq1 = + svread_ver_za32_f32_vg4(/* tile: */ 1, /* slice: */ tcol); + svst1(p0, &a_mod[dest_0 + tcol * SVL], zq0); + svst1(p1, &a_mod[dest_1 + tcol * SVL], zq1); + } + } + } +} +``` + +Note that ``preprocess_l_intr`` has been annotated at line 3 with: + +- ``__arm_streaming``, because this function is using streaming instructions, + +- ``__arm_inout("za")``, because ``preprocess_l_intr`` reuses the ZA storage + from its caller. + +The matrix preprocessing is performed in a double nested loop, over the ``M`` +(line 7) and ``K`` (line 12) dimensions of the input matrix ``a``. Both loops +have an ``SVL`` step increment, which corresponds to the horizontal and vertical +dimensions of the ZA storage that will be used. The dimensions of ``a`` may not +be perfect multiples of ``SVL`` though... which is why the predicates ``pMDim`` +(line 9) and ``pKDim`` (line 14) are computed in order to know which rows (resp. +columns) are valid. + +The core of ``preprocess_l_intr`` is made of two parts: + +- lines 17 - 37: load matrix tile as rows. In this part, loop unrolling has been + used at 2 different levels. At the lowest level, 4 rows are loaded at a time + (lines 24-27). But this goes much further because as SME2 has multi-vectors + operations (hence the ``svld1_x2`` intrinsic to load 2 rows in 2 vector + registers), this allows the function to load the consecutive row, which + happens to be the row from the neighbouring tile on the right : this means 2 + tiles are processed at once. At line 29-32, the pairs of vector registers are + rearranged on quads of vector registers so they can be stored horizontally in + the 2 tiles' ZA storage at lines 33-36 with the ``svwrite_hor_za32_f32_vg4`` + intrinsic. Of course, as the input matrix may not have dimensions that are + perfect multiples of ``SVL``, the ``p0``, ``p1``, ``p2`` and ``p3`` predicates + are computed with the ``svpsel_lane_c32`` intrinsic (lines 18-21) so that + elements outside of the input matrix are set to 0 when they are loaded at + lines 24-27. + +- lines 39 - 51: read the matrix tile as columns and store them. Now that the 2 + tiles have been loaded *horizontally*, they will be read *vertically* with the + ``svread_ver_za32_f32_vg4`` intrinsic to quad-registers of vectors (``zq0`` + and ``zq1``) at lines 45-48 and then stored with the ``svst1`` intrinsic to + the relevant location in the destination matrix ``a_mod`` (lines 49-50). Note + again the usage of predicates ``p0`` and ``p1`` (computed at lines 43-44) to + ``svst1`` to prevent writing out of the matrix bounds. + +As you can see, the usage of intrinsics greatly simplifies the writing of a +function once one has a good understanding of the available instructions in the +SME2 instruction set. The usage of predicates, which are at the core of SVE and +SME and allows to express an algorithm almost naturally and deal elegantly with +the corner cases (you will note that there is no explicit testing in the loops +for the cases where the rows or columns are outside of the matrix bounds). + +### Outer-product multiplication + +```C "{ line_numbers = true }" +void matmul_intr_impl( + uint64_t M, uint64_t K, uint64_t N, uint64_t SVL, + const float *restrict matLeft_mod, const float *restrict matRight, + float *restrict matResult) __arm_streaming __arm_inout("za") { + + // Build the result matrix tile by tile. + for (uint64_t row = 0; row < M; row += SVL) { + + svbool_t pMDim = svwhilelt_b32(row, M); + + for (uint64_t col = 0; col < N; col += SVL) { + + svbool_t pNDim = svwhilelt_b32(col, N); + + // Outer product + accumulation + svzero_za(); + const uint64_t matLeft_pos = row * K; + const uint64_t matRight_UL_corner = col; + for (uint64_t k = 0; k < K; k++) { + svfloat32_t zL = + svld1(pMDim, &matLeft_mod[matLeft_pos + k * SVL]); + svfloat32_t zR = + svld1(pNDim, &matRight[matRight_UL_corner + k * N]); + svmopa_za32_m(0, pMDim, pNDim, zL, zR); + } + + // Store ZA to matResult. + const uint64_t result_tile_UL_corner = row * N + col; + for (uint64_t trow = 0; trow < SVL && row + trow < M; trow += 4) { + svbool_t p0 = svpsel_lane_b32(pNDim, pMDim, row + trow + 0); + svbool_t p1 = svpsel_lane_b32(pNDim, pMDim, row + trow + 1); + svbool_t p2 = svpsel_lane_b32(pNDim, pMDim, row + trow + 2); + svbool_t p3 = svpsel_lane_b32(pNDim, pMDim, row + trow + 3); + + svst1_hor_za32( + /* tile: */ 0, /* slice: */ trow + 0, p0, + &matResult[result_tile_UL_corner + (trow + 0) * N]); + svst1_hor_za32( + /* tile: */ 0, /* slice: */ trow + 1, p1, + &matResult[result_tile_UL_corner + (trow + 1) * N]); + svst1_hor_za32( + /* tile: */ 0, /* slice: */ trow + 2, p2, + &matResult[result_tile_UL_corner + (trow + 2) * N]); + svst1_hor_za32( + /* tile: */ 0, /* slice: */ trow + 3, p3, + &matResult[result_tile_UL_corner + (trow + 3) * N]); + } + } + } +} +``` + +Note again that ``matmul_intr_impl`` function has been annotated at line 4 with: + +- ``__arm_streaming``, because the function is using streaming instructions, + +- ``__arm_inout("za")``, because the function reuses the ZA storage from its caller. + +The multiplication with the outer product is performed in a double nested loop, +over the ``M`` (line 7) and ``N`` (line 11) dimensions of the input matrices +``matLeft_mod`` and ``matRight``. Both loops have an ``SVL`` step increment, +which corresponds to the horizontal and vertical dimensions of the ZA storage +that will be used as one tile at a time will be processed. The ``M`` and ``N`` +dimensions of the inputs may not be perfect multiples of ``SVL`` so the +predicates ``pMDim`` (line 9) (resp. ``pNDim`` at line 13) are computed in order +to know which rows (resp. columns) are valid. + +The core of the multiplication is done in 2 parts: + +- outer-product and accumulation at lines 15-25. As ``matLeft`` has been + laid-out perfectly in memory with ``preprocess_l_intr``, this part becomes + straightforward. First, the tile is zeroed with the ``svzero_za`` intrinsics + at line 16 so the outer products can be accumulated in the tile. The outer + products are computed and accumulation over the ``K`` common dimension with + the loop at line 19: the column of ``matleft_mod`` and the row of ``matRight`` + are loaded with the ``svld1`` intrinsics at line 20-23 to vector registers + ``zL`` and ``zR``, which are then used at line 24 with the ``svmopa_za32_m`` + intrinsic to perform the outer product and accumulation (to tile 0). This + corresponds exactly to what you saw in figure 2 earlier in the learning path. + Note again the usage of the ``pMDim`` and ``pNDim`` predicates to deal + correctly with the rows and columns respectively which are out of bounds. + +- storing of the result matrix at lines 27-46. The previous part has computed + the result of the matrix multiplication for the current tile, which now needs + to be written back to memory. This is done with the loop at line 29 which will + iterate over all rows of the tile: the ``svst1_hor_za32`` intrinsic at lines + 35-46 stores directly from the tile to memory. Note that the loop has been + unrolled by a factor of 4 (thus the ``trow += 4`` increment, line 29) and the + 4 ``svst1_hor_za32``. Again, the ``pMDim`` and ``pNDim`` predicates deal + gracefully with the parts of the tile which are out-of-bound for the + destination matrix ``matResult``. + +Once again you will note that the usage of the intrinsics made it easy to take +advantage of the full power of SME2 --- once there is a good undestanding of the +available SME2 instructions. The predicates deal elegantly with the corner +cases. And most importanly, our code will deal with different SVL from different +hardware implementations without having to be recompiled. It's the important +concept of *compile-once* / *run-everywhere*, plus the implementations that have +larger SVL will perform the computation faster (for the same binary). + +### Compile and run + +The main function is exactly the same that was used for the assembly version, +with the ``IMPL`` macro defined to be ``intr`` in the ``Makefile``. + +First, make sure that the ``sme2_matmul_intr`` executable is up to date: + +```BASH +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make sme2_matmul_intr +``` + +Then execute ``sme2_matmul_intr`` on the FVP: + +```BASH +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh sme2_matmul_intr +``` + +which should output something similar to: + +```TXT +SME2 Matrix Multiply fp32 *intr* example with args 125 35 70 +Matrix preprocessing: PASS ! +Matrix multiplication: PASS ! + +Info: /OSCI/SystemC: Simulation stopped by user. +``` diff --git a/content/learning-paths/cross-platform/sme2/7-debugging.md b/content/learning-paths/cross-platform/sme2/7-debugging.md new file mode 100644 index 0000000000..a1bce406e3 --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/7-debugging.md @@ -0,0 +1,119 @@ +--- +title: Debugging +weight: 8 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Debugging + +### Looking at the generated code + +In some cases, it is useful to look at the code actually generated by the +compiler. In this learning path, the assembly listing have been produced and can +be inspected. For example, the inner loop with the outer product + accumulation of +the matrix multiplication with intrinsics is looking like (from listing +``sme2_matmul_intr.lst``): + +```TXT +... +80001854: a540a1c0 ld1w { z0.s }, p0/z, [x14] +80001858: a540a661 ld1w { z1.s }, p1/z, [x19] +8000185c: f10006b5 subs x21, x21, #0x1 +80001860: 8b0d0273 add x19, x19, x13 +80001864: 8b0a01ce add x14, x14, x10 +80001868: 80812000 fmopa za0.s, p0/m, p1/m, z0.s, z1.s +8000186c: 54ffff41 b.ne 0x80001854 +... +``` + +### With debuggers + +Both of the main debuggers, ``gdb`` and ``lldb`` have some support for debugging +SME2 code. Their usage is not shown in this learning path though, the main +reason being that this learning path operates the CPU in the so-called +*baremetal* mode: this is a simplistic and minimalistic environment (no +operating system for example) and debug would require to have a debug monitor +(a.k.a demon) running to interface between the debugger, the program and the +CPU. + +### With traces + +The FVP can emit an instruction trace file in text format, known as the Tarmac +trace. This provides a convenient way to understand what the program is doing. +In the excerpt shown below, one can see that the SVE register ``z0`` has been +loaded with 16 values (because predicate ``p0`` was true) with an ``LD1W`` +instruction, whereas ``z1`` was loaded with only 2 values (because of ``p1``). +``z0`` and ``z1`` are later used by the ``fmopa`` instruction to compute the +outer-product and the trace displays the content of the ZA storage. + +```TXT +923530000 ps IT (92353) 80001b08 a540a1a0 O EL3h_s : LD1W {z0.S},p0/Z,[x13] +923530000 ps MR4 81000868:000081000868 40000000 +923530000 ps MR4 8100086c:00008100086c 40800000 +923530000 ps MR4 81000870:000081000870 40c00000 +923530000 ps MR4 81000874:000081000874 41000000 +923530000 ps MR4 81000878:000081000878 41200000 +923530000 ps MR4 8100087c:00008100087c 41400000 +923530000 ps MR4 81000880:000081000880 41600000 +923530000 ps MR4 81000884:000081000884 41800000 +923530000 ps MR4 81000888:000081000888 41900000 +923530000 ps MR4 8100088c:00008100088c 41a00000 +923530000 ps MR4 81000890:000081000890 41b00000 +923530000 ps MR4 81000894:000081000894 41c00000 +923530000 ps MR4 81000898:000081000898 41d00000 +923530000 ps MR4 8100089c:00008100089c 41e00000 +923530000 ps MR4 810008a0:0000810008a0 41f00000 +923530000 ps MR4 810008a4:0000810008a4 42000000 +923530000 ps R Z0 42000000_41f00000_41e00000_41d00000_41c00000_41b00000_41a00000_41900000_41800000_41600000_41400000_41200000_41000000_40c00000_40800000_40000000 +923540000 ps IT (92354) 80001b0c a540a441 O EL3h_s : LD1W {z1.S},p1/Z,[x2] +923540000 ps MR4 81000780:000081000780 42027ae1 +923540000 ps MR4 81000784:000081000784 c16b5c29 +923540000 ps R Z1 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_c16b5c29_42027ae1 +923550000 ps IT (92355) 80001b10 f1000484 O EL3h_s : SUBS x4,x4,#1 +923550000 ps R cpsr 600003cd +923550000 ps R X4 0000000000000000 +923560000 ps IT (92356) 80001b14 8b0a0042 O EL3h_s : ADD x2,x2,x10 +923560000 ps R X2 0000000081000788 +923570000 ps IT (92357) 80001b18 8b1701ad O EL3h_s : ADD x13,x13,x23 +923570000 ps R X13 00000000810008A8 +923580000 ps IT (92358) 80001b1c 80812000 O EL3h_s : FMOPA ZA0.S,p0/M,p1/M,z0.S,z1.S +923580000 ps R ZA0H_S_0 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_4190147b_42bd23d7 +923580000 ps R ZA0H_S_1 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_42a6e668_435a7852 +923580000 ps R ZA0H_S_2 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_4314e3d7_43ab2f5c +923580000 ps R ZA0H_S_3 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_4356547c_43e92290 +923580000 ps R ZA0H_S_4 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_438be28f_44138ae2 +923580000 ps R ZA0H_S_5 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_43ac9ae1_4432847b +923580000 ps R ZA0H_S_6 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_43cd5334_44517e15 +923580000 ps R ZA0H_S_7 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_43ee0b86_447077ae +923580000 ps R ZA0H_S_8 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_440761eb_4487b8a4 +923580000 ps R ZA0H_S_9 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_4417be14_44973571 +923580000 ps R ZA0H_S_10 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_44281a3e_44a6b23e +923580000 ps R ZA0H_S_11 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_44387667_44b62f0a +923580000 ps R ZA0H_S_12 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_4448d28f_44c5abd7 +923580000 ps R ZA0H_S_13 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_44592eb8_44d528a4 +923580000 ps R ZA0H_S_14 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_44698ae1_44e4a571 +923580000 ps R ZA0H_S_15 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_4479e70a_44f4223e +``` + +You can get a Tarmac trace when invoking ``run-fvp.sh`` by adding the ``--trace`` +option as the *first* argument, e.g. : + +```BASH +docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh --trace sme2_matmul_asm +``` + +Tracing is not enabled by default because it slows down the simulation +significantly and the trace file can become very large for long run running +programs (programs with large matrices). + +{{% notice Debugging tip %}} +It can be really helpful when debugging to understand where an element in the +Tile is coming from. The current code base allows you to do that in ``debug`` +mode (when ``-DDEBUG`` is passed to the compiler in the ``Makefile``). If you +look into ``main.c``, you'll notice that the matrix initialization will no +longer be random, but will instead initialize each element with its linear +index. This makes it *easier* to find where the matrix elements are loaded in +the tile in tarmac trace for example. +{{% /notice %}} \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/8-going-further.md b/content/learning-paths/cross-platform/sme2/8-going-further.md new file mode 100644 index 0000000000..59d8c7801e --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/8-going-further.md @@ -0,0 +1,62 @@ +--- +title: Going further +weight: 9 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Generalize the algorithms + +In this learning path, in order to show how to use SME2 for matrix +multiplication, we have only covered the case for floating point multiplication. +In practice, a library or framework that supports matrix multiplication should +also be implemented it for the double type (64-bit floating point number) as +well as all kinds of integers (8-bit, 16-bit, ...). + +One can note that the algorithm structure for the matrix preprocessing as well +as the multiplication with the outer product do not change at all for other data +types --- they only need to be adapted to deal with other types. This is +perfectly suited for languages with [generic +programming](https://en.wikipedia.org/wiki/Generic_programming) like C++ with +templates. One could even make the template deal with the case where the value +accumulated during the product uses a larger type than the input matrices, as +SME2 has the instructions to deal efficiently with this common case. + +This would enable the library writer to focus on the algorithm and the testing +--- and other optimizations (see below) --- while letting the compiler generate +the many variants. + +## Unroll further + +You might have noticed that ``matmul_intr_impl`` computes only one tile at a +time --- for the sake of simplicity. SME2 supports multi vector instructions --- +and some were actually used in ``preprocess_l_intr``, e.g. ``svld1_x2``. Loading +2 vectors at a time would allow computing more tiles at the same time, and as the +input matrices have been laid out in memory in a nice way, the consecutive +loading of the data is very efficient ; implementing this would improve yet +again the ``macc`` to load ``ratio``. + +In order to check your understanding of SME2, you should try to implement this +unrolling yourself ! Fear not, your results will be compared to the expected +reference values, so you have an easy way to check your work. + +## Apply strategies + +An avenue for optimization is to use strategies depending on the matrices' +dimensions. This is especially easy to setup when working at the C or C++ level +rather than directly in assembly language. By playing with the mathematical +properties of matrix multiplication and the outer product, it is possible to +minimize data movement as well as the overall number of operations to perform. +For example, it is a very common case that one of the matrices is actually a +vector (it has a single row or column) ; it then becomes very advantageous to +transpose it... Can you see why ? (Answer: as the elements are stored +contiguously in memory, an ``Nx1`` and ``1xN`` matrices have the exact same +memory layout. The transposition becomes a no-op, the matrix elements will stay +at the same place in memory). + +An even more *degenerated* case that is very easy to deal with is when one of +the matrices is essentially a scalar, i.e. a matrix with 1 row and 1 column. +Although our current code deals with it correctly from a result point of view, a +different algorithm / use of instructions would be significantly more efficient. +Can you think of an implementation ? diff --git a/content/learning-paths/cross-platform/sme2/VSCode.png b/content/learning-paths/cross-platform/sme2/VSCode.png new file mode 100644 index 0000000000000000000000000000000000000000..b43c0030d1000b0efecf1ff199815fa1edf0a552 GIT binary patch literal 458989 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¤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

^V?3=+P*a_pI+ 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�)F+0WkY3!a7I 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

a1mz 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

OyK4+2|U(6OVPjKv(QivR?{Q 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 BKfwS1 literal 0 HcmV?d00001 diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md new file mode 100644 index 0000000000..52c37659ea --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -0,0 +1,44 @@ +--- +title: Improve matrix multiplication performance with SME2 + +minutes_to_complete: 30 + +who_is_this_for: The Scalable Matrix Extension (SME) is an extension to Armv9-A architecture. It introduces a new execution mode and new instructions to accelerate matrix operations. This learning path is an advanced topic for developers who want to learn about how they can improve the performance of matrix multiplications with SME2. + +learning_objectives: + - Implement a by-the-book reference matrix multiplication + - Use SME2 assembly instructions to improve the matrix multiplication performance + - Use SME2 intrinsics to improve the matrix multiplication performance while staying in C + - Compile and run code with SME2 instructions + +prerequisites: + - A Linux or MacOS based computer + - An intermediate understanding of C and assembly + +author_primary: Arnaud de Grandmaison + +draft: true + +### Tags +skilllevels: Advanced +subjects: Performance and Architecture +armips: + - Neoverse + - Cortex-A +tools_software_languages: + - C + - Clang +operatingsystems: + - Linux, MacOS or Windows +shared_path: true +shared_between: + - servers-and-cloud-computing + - laptops-and-desktops + - smartphones-and-mobile + +### 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/cross-platform/sme2/_next-steps.md b/content/learning-paths/cross-platform/sme2/_next-steps.md new file mode 100644 index 0000000000..c62b20298a --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/_next-steps.md @@ -0,0 +1,64 @@ +--- +next_step_guidance: PLACEHOLDER TEXT 1 + +recommended_path: /learning-paths/PLACEHOLDER_CATEGORY/PLACEHOLDER_LEARNING_PATH/ + +further_reading: + + - resource: + title: SVE programming examples + link: https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://developer.arm.com/documentation/dai0548/latest/&ved=2ahUKEwisi76m-f2GAxUDSKQEHfyWClAQFnoECA4QAQ&usg=AOvVaw1YPQ-aQsHmumnZykaFxM0b + type: documentation + + - resource: + title: Port Code to Arm Scalable Vector Extension (SVE) + link: https://learn.arm.com/learning-paths/servers-and-cloud-computing/sve + type: website + + - resource: + title: Arm Scalable Matrix Extension (SME) Introduction (part 1) + link: https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction + type: blog + + - resource: + title: Introducing the Scalable Matrix Extension for the Armv9-A Architecture + link: https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/scalable-matrix-extension-armv9-a-architecture + type: website + + - resource: + title: Arm Scalable Matrix Extension (SME) Introduction (part 2) + link: https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction-p2 + type: blog + + - resource: + title: SME Programmer’s Guide + link: https://developer.arm.com/documentation/109246/latest + type: documentation + + - resource: + title: Matrix multiplication + link: https://en.wikipedia.org/wiki/Matrix_multiplication + type: website + + - resource: + title: Compiler intrinsics + link: https://en.wikipedia.org/wiki/Intrinsic_function + type: website + + - resource: + title: ACLE --- Arm C language extension + link: https://github.com/ARM-software/acle + type: website + + - resource: + title: Application Binary Interface for the Arm Architecture + link: https://github.com/ARM-software/abi-aa + type: website + +# ================================================================================ +# FIXED, DO NOT MODIFY +# ================================================================================ +weight: 21 # set to always be larger than the content in this path, and one more than 'review' +title: "Next Steps" # Always the same +layout: "learningpathall" # All files under learning paths have this same wrapper +--- diff --git a/content/learning-paths/cross-platform/sme2/_review.md b/content/learning-paths/cross-platform/sme2/_review.md new file mode 100644 index 0000000000..bc45f3c958 --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/_review.md @@ -0,0 +1,48 @@ +--- +review: + - questions: + question: > + How does SME2 speedup matrix multiplication ? + answers: + - Outer product + - Quantum physics + correct_answer: 1 + explanation: > + The matrix multiplication operation can be expressed as a sum of outer products, + which allows the SME engine to perform many multiplication/accumulations at once. + + - questions: + question: > + Why is the ZA storage so important for SME2 ? + answers: + - It's infinite + - It holds a 2D view of matrices + correct_answer: 2 + explanation: > + The ZA storage offers a 2D view of part of a matrix, a.k.a a tile. SME can operate + on complete tiles, or on horizontal / vertical slices of the tiles, which is a useful + and often used feature in numerous algorithms. ZA storage is finite and has size SVL x SVL. + + - questions: + question: > + What are predicates ? + answers: + - Parts of a sentence or clause containing a verb and stating something about the subject + - They select the active lanes in a vector operation + - It's just another word for flags from the Processor Status Register (PSR) + correct_answer: 2 + explanation: > + SVE is a predicate centric architecture. Predicates allow Vector Length Agnosticism (VLA), + they support complex nested conditions and loops and reduce vector loop management + overhead by allowing lane predication in vector operations. Predicates have their own + dedicated registers. + + + +# ================================================================================ +# FIXED, DO NOT MODIFY +# ================================================================================ +title: "Review" # Always the same title +weight: 20 # Set to always be larger than the content in this path +layout: "learningpathall" # All files under learning paths have this same wrapper +--- diff --git a/content/learning-paths/cross-platform/sme2/matmul.png b/content/learning-paths/cross-platform/sme2/matmul.png new file mode 100644 index 0000000000000000000000000000000000000000..8a45b76307c9faa320db9317b40859d2fcf4f364 GIT binary patch literal 39432 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 literal 0 HcmV?d00001 diff --git a/content/learning-paths/cross-platform/sme2/outer_product.png b/content/learning-paths/cross-platform/sme2/outer_product.png new file mode 100644 index 0000000000000000000000000000000000000000..ed163f703d823482fd0ad426ace588b221bf381d GIT binary patch literal 55155 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 TnYk>93;t-T>Kvx4*aZCt)K;xx literal 0 HcmV?d00001 From 545237fbd6372aa7e40eda0110cf6442bba1c92c Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Fri, 17 Jan 2025 15:08:32 +0000 Subject: [PATCH 02/25] changed title --- content/learning-paths/cross-platform/sme2/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md index 52c37659ea..731a4f3b9f 100644 --- a/content/learning-paths/cross-platform/sme2/_index.md +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -1,5 +1,5 @@ --- -title: Improve matrix multiplication performance with SME2 +title: Accelerate Matrix Multiplication Performance with SME2 minutes_to_complete: 30 From 33c0fd56513237adf1f6ad0faa4f4a5f2b76f318 Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Fri, 17 Jan 2025 19:39:52 +0000 Subject: [PATCH 03/25] Continuing editorial first-pass review. --- .../cross-platform/sme2/1-get-started.md | 36 ++++++++++--------- .../cross-platform/sme2/_index.md | 15 ++++---- 2 files changed, 26 insertions(+), 25 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index 606b65fe3b..6a5260a7e8 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -6,18 +6,16 @@ weight: 2 layout: learningpathall --- -In this section, you will setup the environment needed to develop with SME2. +In this section, you will set up an environment to develop with SME2. -SME2 hardware is not widely deployed at the time of writing of this learning -path, so you will have to use: +SME2 hardware is not widely deployed at the time of writing, so you will require: - - a compiler with support for SME2 instructions. [clang](https://www.llvm.org/) - version >= 18 or [gcc](https://gcc.gnu.org/) versions >= 14. This learning - path will use ``clang``. + - A compiler with support for SME2 instructions. [clang](https://www.llvm.org/) + version >= 18 or [gcc](https://gcc.gnu.org/) versions >= 14. This Learning + Path uses ``clang``. - - an emulator to execute code with those new instructions. In this learning - path, we will use - [Arm's Fixed Virtual Platform (FVP) model](https://developer.arm.com/Tools%20and%20Software/Fixed%20Virtual%20Platforms). + - An emulator to execute code with the SME2 instructions. This Learning + Path uses [Arm's Fixed Virtual Platform (FVP) model](https://developer.arm.com/Tools%20and%20Software/Fixed%20Virtual%20Platforms). ## Prerequisites @@ -57,7 +55,7 @@ This learning path should also work without ``docker``, the only assumption is that the compiler and the FVP are available on your search path. {{% /notice %}} -First, you should check that ``docker`` is installed by typing the following +Start by checking that ``docker`` is installed on your machine by typing the following command line in a terminal: ```BASH { output_lines="2" } @@ -69,7 +67,7 @@ If the above command fails with a message similar to "``docker: command not foun then follow the steps from the [docker install guide](https://learn.arm.com/install-guides/docker/). Note that you might have to re-login or restart your machine for the changes to be taken into account. -Now that ``docker`` is installed on your machine, you should check that it's operating properly with: +Once you have confirmed that ``docker`` is installed on your machine, you can check that it is operating normally with the following: ```BASH { output_lines="2-27" } docker run hello-world @@ -82,12 +80,16 @@ Status: Downloaded newer image for hello-world:latest Hello from Docker! This message shows that your installation appears to be working correctly. -To generate this message, Docker took the following steps: +To generate this message, Docker followed these steps: + 1. The Docker client contacted the Docker daemon. + 2. The Docker daemon pulled the "hello-world" image from the Docker Hub. (arm64v8) + 3. The Docker daemon created a new container from that image which runs the executable that produces the output you are currently reading. + 4. The Docker daemon streamed that output to the Docker client, which sent it to your terminal. @@ -110,7 +112,7 @@ named ``SME2.git``: git clone https://gitlab.arm.com/learning-code-examples/TODO_SOME_PATH SME2-learning-path.git ``` -This repository content is looking like: +This repository content looks like: ```TXT SME2-learning-path.git/ @@ -142,10 +144,10 @@ SME2-learning-path.git/ ``` It contains: -- the code examples used in this learning path, -- the ``Makefile`` used to build them, -- the ``run-fvp.sh`` shell script to run the FVP, -- the ``docker/`` directory contains ``docker`` related material. +- The code examples that this Learning Path uses. +- The ``Makefile`` that builds the code examples. +- The ``run-fvp.sh`` shell script that runs the FVP. +- The ``docker/`` directory that contains ``docker``-related material. ``assets.source_me`` provides the FVP and compiler toolchain references, ``sme2-environment.docker`` is the docker receipe to build the container that you will use, ``build-my-container.sh`` is the shell script you should use in diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md index 731a4f3b9f..f0a2a73e55 100644 --- a/content/learning-paths/cross-platform/sme2/_index.md +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -3,21 +3,20 @@ title: Accelerate Matrix Multiplication Performance with SME2 minutes_to_complete: 30 -who_is_this_for: The Scalable Matrix Extension (SME) is an extension to Armv9-A architecture. It introduces a new execution mode and new instructions to accelerate matrix operations. This learning path is an advanced topic for developers who want to learn about how they can improve the performance of matrix multiplications with SME2. +who_is_this_for: This Learning Path is an advanced topic for developers who want to learn about accelerating the performance of matrix multiplications using SME2. learning_objectives: - - Implement a by-the-book reference matrix multiplication - - Use SME2 assembly instructions to improve the matrix multiplication performance - - Use SME2 intrinsics to improve the matrix multiplication performance while staying in C - - Compile and run code with SME2 instructions + - Implement a reference matrix multiplication according to standard procedure. + - Use SME2 assembly instructions to improve the matrix multiplication performance. + - Use SME2 intrinsics to improve the matrix multiplication performance using the C programming language. + - Compile and run code with SME2 instructions. prerequisites: - - A Linux or MacOS based computer - - An intermediate understanding of C and assembly + - A computer running Linux, MacOS, or Windows. + - An intermediate understanding of C and assembly language. author_primary: Arnaud de Grandmaison -draft: true ### Tags skilllevels: Advanced From b99560b4d592d7b6fd4bab5e0dc8f63843beddd5 Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Sat, 18 Jan 2025 01:24:30 +0000 Subject: [PATCH 04/25] Continuing editorial. --- .../cross-platform/sme2/1-get-started.md | 48 +++++++++---------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index 6a5260a7e8..617026b73c 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -20,7 +20,7 @@ SME2 hardware is not widely deployed at the time of writing, so you will require ## Prerequisites -This learning path assumes that you have ``git`` and ``docker`` installed on your machine. +You require ``git`` and ``docker`` installed on your machine. ### git @@ -144,19 +144,18 @@ SME2-learning-path.git/ ``` It contains: -- The code examples that this Learning Path uses. -- The ``Makefile`` that builds the code examples. -- The ``run-fvp.sh`` shell script that runs the FVP. -- The ``docker/`` directory that contains ``docker``-related material. - ``assets.source_me`` provides the FVP and compiler toolchain references, - ``sme2-environment.docker`` is the docker receipe to build the container that - you will use, ``build-my-container.sh`` is the shell script you should use in - case you want to build the docker container (but you don't have to, ready-made +- Code examples. +- A ``Makefile`` that builds the code examples. +- A shell script called ``run-fvp.sh`` that runs the FVP. +- A directory called ``docker/`` that contains materials related to ``docker``. +- A script called ``assets.source_me`` that provides the FVP and compiler toolchain references. +- A docker receipe called ``sme2-environment.docker`` to build the container that + you will use. +- A shell script called ``build-my-container.sh`` that you can use if you want to build the docker container. This is not essential however, as ready-made images are made available for you ). Lastly ``build-all-containers.sh`` is the script that was used to create the multi-arch (x86_64 and aarch64 support) image for you to download. -- ``.devcontainer/devcontainer.json`` is a configuration script for VSCode to be - able to use the container from the IDE (read below). +- A configuration script for VSCode to be able to use the container from the IDE called ``.devcontainer/devcontainer.json`` (see below). Change directory to your checkout: @@ -164,23 +163,24 @@ Change directory to your checkout: cd SME2-learning-path.git ``` -From now on, all instructions in this learning path assume your current +From this point in the Learning Path, all instructions assume your current directory is ``SME2-learning-path.git``. ## Using the environment Docker provides you with a way to execute commands in a different environment, -where all necessary tools are available without cluttering your machine. You can: -- use docker directly from the command line, for example when you are working - from a terminal, -- configure VSCode to run all the commands in the docker environment. +where all necessary tools are available without cluttering your machine. + +You can use docker in the following ways: +- You can use docker directly from the command line. For example, when you are working + from a terminal. +- You can use docker to configure VSCode to run all the commands in the docker environment. ### Directly in a terminal -When a command has to be executed in the docker container environment, you have -to prepend it with instructions on the command line so that your shell will -execute them in the container. For example, to execute ``COMMAND ARGUMENTS`` in -the SME2 docker container, the command line looks like: +When a command is executed in the docker container environment, you must prepend it with instructions on the command line so that your shell executes them in the container. + +For example, to execute ``COMMAND ARGUMENTS`` in the SME2 docker container, the command line looks like: ```SH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 COMMAND ARGUMENTS @@ -192,7 +192,7 @@ image, and mounts the current working directory (the ``SME2-learning-path.git``) inside the container to ``/work``, sets ``/work`` as the working directory and run ``COMMAND ARGUMENTS`` in this environment. -For example, to run ``make``, you would have to type: +For example, to run ``make``, you need to type: ```SH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make @@ -202,8 +202,8 @@ docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-enviro Make sure you have the [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) -extension installed. It should then be as easy as using the "Reopen in -Container" menu entry as in figure 1 (it will automatically find and use +extension installed. It should then be as easy as using the **Reopen in +Container** menu entry as Figure 1 shows (it automatically finds and uses ``.devcontainer/devcontainer.json``): ![example image alt-text#center](VSCode.png "Figure 1. Using the Dev Containers extension") @@ -211,7 +211,7 @@ Container" menu entry as in figure 1 (it will automatically find and use All your commands will now take place in the container, so no need to prepend them with some docker invocation, VSCode handles all this transparently for you. -In the remainder of this learning path, the shell commands will show the docker +In the remainder of this learning path, the shell commands show the docker invocation (so readers that don't use VSCode can copy the full command line), but you should only use the ``COMMAND ARGUMENTS`` part. From bbc746b58fa49024f6a4ee792697781ec76cdadd Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Mon, 20 Jan 2025 06:39:05 +0000 Subject: [PATCH 05/25] Continuing editorial. --- .../cross-platform/sme2/_review.md | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/_review.md b/content/learning-paths/cross-platform/sme2/_review.md index bc45f3c958..710b6b8b4a 100644 --- a/content/learning-paths/cross-platform/sme2/_review.md +++ b/content/learning-paths/cross-platform/sme2/_review.md @@ -2,34 +2,34 @@ review: - questions: question: > - How does SME2 speedup matrix multiplication ? + How does SME2 accelerate matrix multiplication? answers: - - Outer product - - Quantum physics + - The matrix multiplication operation is a sum of outer products. + - Quantum physics. correct_answer: 1 explanation: > The matrix multiplication operation can be expressed as a sum of outer products, - which allows the SME engine to perform many multiplication/accumulations at once. + which allows the SME engine to perform many multiplications at once. - questions: question: > - Why is the ZA storage so important for SME2 ? + Why is the ZA storage so important for SME2? answers: - - It's infinite - - It holds a 2D view of matrices + - It is infinite. + - It holds a 2D view of matrices. correct_answer: 2 explanation: > - The ZA storage offers a 2D view of part of a matrix, a.k.a a tile. SME can operate - on complete tiles, or on horizontal / vertical slices of the tiles, which is a useful - and often used feature in numerous algorithms. ZA storage is finite and has size SVL x SVL. + The ZA storage offers a 2D view of part of a matrix, which is also known as a tile. SME can operate + on complete tiles, or on horizontal or vertical slices of the tiles, which is a useful + and often-used feature in numerous algorithms. ZA storage is finite and has the size SVL x SVL. - questions: question: > - What are predicates ? + What are predicates? answers: - Parts of a sentence or clause containing a verb and stating something about the subject - - They select the active lanes in a vector operation - - It's just another word for flags from the Processor Status Register (PSR) + - Predicates select the active lanes in a vector operation. + - Predicates are another word for flags from the Processor Status Register (PSR). correct_answer: 2 explanation: > SVE is a predicate centric architecture. Predicates allow Vector Length Agnosticism (VLA), From f7e283c27cb791063ded2633c2b83e8994216a96 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Wed, 29 Jan 2025 16:42:36 +0000 Subject: [PATCH 06/25] Review index file. --- content/learning-paths/cross-platform/sme2/_index.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md index f0a2a73e55..c909774ab2 100644 --- a/content/learning-paths/cross-platform/sme2/_index.md +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -3,17 +3,17 @@ title: Accelerate Matrix Multiplication Performance with SME2 minutes_to_complete: 30 -who_is_this_for: This Learning Path is an advanced topic for developers who want to learn about accelerating the performance of matrix multiplications using SME2. +who_is_this_for: This Learning Path is an advanced topic for developers who want to learn about accelerating the performance of matrix multiplication using Arm's Scalable Matrix Extension Version 2 (SME2). learning_objectives: - - Implement a reference matrix multiplication according to standard procedure. + - Implement a reference matrix multiplication without SME2. - Use SME2 assembly instructions to improve the matrix multiplication performance. - Use SME2 intrinsics to improve the matrix multiplication performance using the C programming language. - Compile and run code with SME2 instructions. prerequisites: - A computer running Linux, MacOS, or Windows. - - An intermediate understanding of C and assembly language. + - An intermediate understanding of C programming language and assembly language. author_primary: Arnaud de Grandmaison From d5b517b01b573581c6f15c70108c3479ab43c710 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Wed, 29 Jan 2025 17:10:50 +0000 Subject: [PATCH 07/25] Editorial improvements. --- .../cross-platform/sme2/1-get-started.md | 19 -------- .../cross-platform/sme2/_index.md | 2 +- .../cross-platform/sme2/overview.md | 43 +++++++++++++++++++ 3 files changed, 44 insertions(+), 20 deletions(-) create mode 100644 content/learning-paths/cross-platform/sme2/overview.md diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index 617026b73c..d950afb532 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -215,22 +215,3 @@ In the remainder of this learning path, the shell commands show the docker invocation (so readers that don't use VSCode can copy the full command line), but you should only use the ``COMMAND ARGUMENTS`` part. -## Suggested reading - -If you are not familiar with matrix multiplication --- or need a refresh --- -this [wikipedia article on Matrix -multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication) is a good -start. - -If you are not familiar with SVE and / or SME, it is strongly suggested that you -first read some material as this learning path assumes some basic understanding -of those technologies: - - - [Introducing the Scalable Matrix Extension for the Armv9-A - Architecture](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/scalable-matrix-extension-armv9-a-architecture) - - [Arm Scalable Matrix Extension (SME) Introduction (part - 1)](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction) - - [Arm Scalable Matrix Extension (SME) Introduction (part - 2)](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction-p2) - -You are now all set to move to the next chapter ! \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md index c909774ab2..81bbda04da 100644 --- a/content/learning-paths/cross-platform/sme2/_index.md +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -6,7 +6,7 @@ minutes_to_complete: 30 who_is_this_for: This Learning Path is an advanced topic for developers who want to learn about accelerating the performance of matrix multiplication using Arm's Scalable Matrix Extension Version 2 (SME2). learning_objectives: - - Implement a reference matrix multiplication without SME2. + - Implement a reference matrix multiplication without using SME2. - Use SME2 assembly instructions to improve the matrix multiplication performance. - Use SME2 intrinsics to improve the matrix multiplication performance using the C programming language. - Compile and run code with SME2 instructions. diff --git a/content/learning-paths/cross-platform/sme2/overview.md b/content/learning-paths/cross-platform/sme2/overview.md new file mode 100644 index 0000000000..6b28dd985a --- /dev/null +++ b/content/learning-paths/cross-platform/sme2/overview.md @@ -0,0 +1,43 @@ +--- +title: Overview +weight: 2 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +# Overview of Arm's Scalable Matrix Extension Version 2 + +### What is SME2? + +The Scalable Matrix Extension Version 2 (SME2) extends the SME architecture by accelerating vector operations to increase the number of applications that can benefit from the computational efficiency of SME, beyond its initial focus on outer products and matrix-matrix multiplication. + +SME2 extends SME by introducing multi-vector data-processing instructions, load to and store from multi-vectors, and a multi-vector predication mechanism. + +Additional architectural features of SME2 include: + +Multi-vector multiply-accumulate instructions, with Z vectors as multiplier and multiplicand inputs and accumulating results into ZA array vectors, including widening multiplies that accumulate into more vectors than they read. + +Multi-vector load, store, move, permute, and convert instructions, that use multiple SVE Z vectors as source and destination registers to pre-process inputs and post-process outputs of the ZA-targeting SME2 instructions + +“Predicate-as-counter”, an alternative predication mechanism is added to the original SVE predication mechanism, to control operations performed on multiple vector registers + +Compressed neural network capability using dedicated lookup table instructions and outer product instructions that support binary neural networks + +SME2 adds a 512-bit architectural register ZT0, that supports the lookup table feature. + +### Suggested reading + +If you are not familiar with matrix multiplication, or need a refresh, this [wikipedia article on Matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication) is a good +start. + +If you are not familiar with SVE and / or SME, it is strongly suggested that you +first read some material as this learning path assumes some basic understanding +of those technologies: + + - [Introducing the Scalable Matrix Extension for the Armv9-A + Architecture](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/scalable-matrix-extension-armv9-a-architecture). + - [Arm Scalable Matrix Extension (SME) Introduction (Part + 1)](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction). + - [Arm Scalable Matrix Extension (SME) Introduction (Part + 2)](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction-p2). \ No newline at end of file From cb9cdf07f9e87b4c991762cb74aa04a4de79d9a3 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Thu, 30 Jan 2025 10:54:25 +0000 Subject: [PATCH 08/25] Adjusting page weightings; adding two prerequisities; adding overview with architectural information from SME Programmer's Guide. --- .../cross-platform/sme2/1-get-started.md | 2 +- .../sme2/2-check-your-environment.md | 2 +- .../cross-platform/sme2/3-vanilla-matmul.md | 2 +- .../cross-platform/sme2/4-outer-product.md | 2 +- .../cross-platform/sme2/5-SME2-matmul-asm.md | 2 +- .../cross-platform/sme2/6-SME2-matmul-intr.md | 2 +- .../cross-platform/sme2/7-debugging.md | 2 +- .../cross-platform/sme2/8-going-further.md | 2 +- .../cross-platform/sme2/_index.md | 2 ++ .../cross-platform/sme2/overview.md | 19 ++++++++----------- 10 files changed, 18 insertions(+), 19 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index d950afb532..9669a7692f 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -1,6 +1,6 @@ --- title: Get started -weight: 2 +weight: 3 ### FIXED, DO NOT MODIFY layout: learningpathall diff --git a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md index a6c253b747..1afad1db70 100644 --- a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md +++ b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md @@ -1,6 +1,6 @@ --- title: Check your environment -weight: 3 +weight: 4 ### FIXED, DO NOT MODIFY layout: learningpathall diff --git a/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md index 6faf405a69..e5da137127 100644 --- a/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md +++ b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md @@ -1,6 +1,6 @@ --- title: Vanilla matrix multiplication -weight: 4 +weight: 5 ### FIXED, DO NOT MODIFY layout: learningpathall diff --git a/content/learning-paths/cross-platform/sme2/4-outer-product.md b/content/learning-paths/cross-platform/sme2/4-outer-product.md index b9ec961956..c46607ed90 100644 --- a/content/learning-paths/cross-platform/sme2/4-outer-product.md +++ b/content/learning-paths/cross-platform/sme2/4-outer-product.md @@ -1,6 +1,6 @@ --- title: Outer product -weight: 5 +weight: 6 ### FIXED, DO NOT MODIFY layout: learningpathall diff --git a/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md b/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md index 876d5bf8dd..10a8885d3e 100644 --- a/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md +++ b/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md @@ -1,6 +1,6 @@ --- title: SME2 assembly matrix multiplication -weight: 6 +weight: 7 ### FIXED, DO NOT MODIFY layout: learningpathall diff --git a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md index 6ce87ea3a0..ade005a4f6 100644 --- a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md +++ b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md @@ -1,6 +1,6 @@ --- title: SME2 intrinsics matrix multiplication -weight: 7 +weight: 8 ### FIXED, DO NOT MODIFY layout: learningpathall diff --git a/content/learning-paths/cross-platform/sme2/7-debugging.md b/content/learning-paths/cross-platform/sme2/7-debugging.md index a1bce406e3..091f835a4f 100644 --- a/content/learning-paths/cross-platform/sme2/7-debugging.md +++ b/content/learning-paths/cross-platform/sme2/7-debugging.md @@ -1,6 +1,6 @@ --- title: Debugging -weight: 8 +weight: 9 ### FIXED, DO NOT MODIFY layout: learningpathall diff --git a/content/learning-paths/cross-platform/sme2/8-going-further.md b/content/learning-paths/cross-platform/sme2/8-going-further.md index 59d8c7801e..adccb47e50 100644 --- a/content/learning-paths/cross-platform/sme2/8-going-further.md +++ b/content/learning-paths/cross-platform/sme2/8-going-further.md @@ -1,6 +1,6 @@ --- title: Going further -weight: 9 +weight: 10 ### FIXED, DO NOT MODIFY layout: learningpathall diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md index 81bbda04da..749d9295da 100644 --- a/content/learning-paths/cross-platform/sme2/_index.md +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -12,6 +12,8 @@ learning_objectives: - Compile and run code with SME2 instructions. prerequisites: + - Basic knowledge of Arm's Scalable Matrix Extension (SME). + - Basic knowledge of Arm's Scalable Vector Extension (SVE). - A computer running Linux, MacOS, or Windows. - An intermediate understanding of C programming language and assembly language. diff --git a/content/learning-paths/cross-platform/sme2/overview.md b/content/learning-paths/cross-platform/sme2/overview.md index 6b28dd985a..61eeef06bf 100644 --- a/content/learning-paths/cross-platform/sme2/overview.md +++ b/content/learning-paths/cross-platform/sme2/overview.md @@ -10,30 +10,27 @@ layout: learningpathall ### What is SME2? -The Scalable Matrix Extension Version 2 (SME2) extends the SME architecture by accelerating vector operations to increase the number of applications that can benefit from the computational efficiency of SME, beyond its initial focus on outer products and matrix-matrix multiplication. +The Scalable Matrix Extension (SME) is an extension to the Armv9-A architecture. The Scalable Matrix Extension Version 2 (SME2) extends the SME architecture by accelerating vector operations to increase the number of applications that can benefit from the computational efficiency of SME, beyond its initial focus on outer products and matrix-matrix multiplication. SME2 extends SME by introducing multi-vector data-processing instructions, load to and store from multi-vectors, and a multi-vector predication mechanism. Additional architectural features of SME2 include: -Multi-vector multiply-accumulate instructions, with Z vectors as multiplier and multiplicand inputs and accumulating results into ZA array vectors, including widening multiplies that accumulate into more vectors than they read. +* Multi-vector multiply-accumulate instructions, with Z vectors as multiplier and multiplicand inputs and accumulating results into ZA array vectors, including widening multiplies that accumulate into more vectors than they read. -Multi-vector load, store, move, permute, and convert instructions, that use multiple SVE Z vectors as source and destination registers to pre-process inputs and post-process outputs of the ZA-targeting SME2 instructions +* Multi-vector load, store, move, permute, and convert instructions, that use multiple SVE Z vectors as source and destination registers to pre-process inputs and post-process outputs of the ZA-targeting SME2 instructions -“Predicate-as-counter”, an alternative predication mechanism is added to the original SVE predication mechanism, to control operations performed on multiple vector registers +* “Predicate-as-counter”, an alternative predication mechanism is added to the original SVE predication mechanism, to control operations performed on multiple vector registers -Compressed neural network capability using dedicated lookup table instructions and outer product instructions that support binary neural networks +* Compressed neural network capability using dedicated lookup table instructions and outer product instructions that support binary neural networks -SME2 adds a 512-bit architectural register ZT0, that supports the lookup table feature. +* A 512-bit architectural register ZT0, that supports the lookup table feature. ### Suggested reading -If you are not familiar with matrix multiplication, or need a refresh, this [wikipedia article on Matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication) is a good -start. +If you are not familiar with matrix multiplication, or would benefit from refreshing your knowledge, this [Wikipedia article on Matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication) is a good start. -If you are not familiar with SVE and / or SME, it is strongly suggested that you -first read some material as this learning path assumes some basic understanding -of those technologies: +This Learning Path assumes some basic understanding of SVE and SME. If you are not familiar with SVE or SME, these are some useful resources that you should first read: - [Introducing the Scalable Matrix Extension for the Armv9-A Architecture](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/scalable-matrix-extension-armv9-a-architecture). From 219cc56aa443210f1e099bc3ced4c376be7a9f64 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Thu, 30 Jan 2025 15:28:42 +0000 Subject: [PATCH 09/25] Added prerequisite software to prerequisites. --- content/learning-paths/cross-platform/sme2/1-get-started.md | 2 +- .../cross-platform/sme2/2-check-your-environment.md | 2 +- content/learning-paths/cross-platform/sme2/_index.md | 4 ++++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index 9669a7692f..b85f0d2a5e 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -1,5 +1,5 @@ --- -title: Get started +title: Set up your environment weight: 3 ### FIXED, DO NOT MODIFY diff --git a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md index 1afad1db70..454e6b2a31 100644 --- a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md +++ b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md @@ -1,5 +1,5 @@ --- -title: Check your environment +title: Test your environment weight: 4 ### FIXED, DO NOT MODIFY diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md index 749d9295da..1f6af1e961 100644 --- a/content/learning-paths/cross-platform/sme2/_index.md +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -15,6 +15,10 @@ prerequisites: - Basic knowledge of Arm's Scalable Matrix Extension (SME). - Basic knowledge of Arm's Scalable Vector Extension (SVE). - A computer running Linux, MacOS, or Windows. + - An installation of Git. + - An installation of Docker. + - An emulator to run code with SME2 instructions. + - Clang or GCC. - An intermediate understanding of C programming language and assembly language. author_primary: Arnaud de Grandmaison From 0c6107fba4743341066f453bfda8c7e367802814 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Thu, 30 Jan 2025 15:41:12 +0000 Subject: [PATCH 10/25] Tweaking the index file. --- content/learning-paths/cross-platform/sme2/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md index 1f6af1e961..1a37499592 100644 --- a/content/learning-paths/cross-platform/sme2/_index.md +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -18,7 +18,7 @@ prerequisites: - An installation of Git. - An installation of Docker. - An emulator to run code with SME2 instructions. - - Clang or GCC. + - A compiler with support for SME2 instructions. - An intermediate understanding of C programming language and assembly language. author_primary: Arnaud de Grandmaison From 4c680630912bbe8a8746b0bb8db3b864c60abbe7 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Thu, 30 Jan 2025 15:43:01 +0000 Subject: [PATCH 11/25] Update --- content/learning-paths/cross-platform/sme2/_index.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md index 1a37499592..6acdfd6b6d 100644 --- a/content/learning-paths/cross-platform/sme2/_index.md +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -15,8 +15,7 @@ prerequisites: - Basic knowledge of Arm's Scalable Matrix Extension (SME). - Basic knowledge of Arm's Scalable Vector Extension (SVE). - A computer running Linux, MacOS, or Windows. - - An installation of Git. - - An installation of Docker. + - Installations of Git and Docker. - An emulator to run code with SME2 instructions. - A compiler with support for SME2 instructions. - An intermediate understanding of C programming language and assembly language. From a78f7ef56bec90c53631db1fec1ba1606e143c75 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Thu, 30 Jan 2025 16:41:01 +0000 Subject: [PATCH 12/25] Further updates. --- .../cross-platform/sme2/1-get-started.md | 29 ++++++++----------- .../sme2/2-check-your-environment.md | 5 ++-- .../cross-platform/sme2/4-outer-product.md | 9 +++--- 3 files changed, 18 insertions(+), 25 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index b85f0d2a5e..71fbe697c3 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -1,14 +1,16 @@ --- -title: Set up your environment +title: Set up your Environment weight: 3 ### FIXED, DO NOT MODIFY layout: learningpathall --- -In this section, you will set up an environment to develop with SME2. +## Installing software for this Learning Path -SME2 hardware is not widely deployed at the time of writing, so you will require: +To follow this Learning Path, you will need to set up an environment to develop with SME2. + +As SME2 hardware is not widely deployed at the time of writing, you will require: - A compiler with support for SME2 instructions. [clang](https://www.llvm.org/) version >= 18 or [gcc](https://gcc.gnu.org/) versions >= 14. This Learning @@ -17,14 +19,11 @@ SME2 hardware is not widely deployed at the time of writing, so you will require - An emulator to execute code with the SME2 instructions. This Learning Path uses [Arm's Fixed Virtual Platform (FVP) model](https://developer.arm.com/Tools%20and%20Software/Fixed%20Virtual%20Platforms). +You will also require ``git`` and ``docker`` installed on your machine. -## Prerequisites - -You require ``git`` and ``docker`` installed on your machine. +### Set up Git -### git - -Check that ``git`` is installed on your machine with the following command line in a terminal: +To check if ``git`` is already installed on your machine, use the following command line in a terminal: ```BASH { output_lines=2 } git --version @@ -42,17 +41,13 @@ brew install git {{< /tab >}} {{< /tabpane >}} -### docker +### Docker + +To enable you to get started easily and with the tools that you need, you can fetch a Docker container with the required compiler and FVP to get started straight away. Alternatively, if you do wish to build the container yourself, the ``Dockerfile`` is also available. -For ease of learning, without any risk of harming your computer setup, the -required compiler and FVP are provided as a docker container that you can fetch -from the internet to get instantly started. However, the ``Dockerfile`` to build -the container is available as well should you prefer to build it yourself or -study how it's built. {{% notice Note %}} -This learning path should also work without ``docker``, the only assumption is -that the compiler and the FVP are available on your search path. +This Learning Path should also work without ``docker``, but the compiler and the FVP must be available on your search path. {{% /notice %}} Start by checking that ``docker`` is installed on your machine by typing the following diff --git a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md index 454e6b2a31..423e4b4436 100644 --- a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md +++ b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md @@ -48,7 +48,7 @@ $ docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-envi ``` {{% /notice %}} -## Basic Sanity checks +## Basic checks The very first program that you should run is the famous "Hello, world !" that will let you know that the basics of your environment are in place. The source @@ -170,5 +170,4 @@ Checking in_streaming_mode: 0 Info: /OSCI/SystemC: Simulation stopped by user. ``` -You have checked that code can be compiled and executed with full SME2 support: -you are now all set to move to the next chapter ! \ No newline at end of file +You have now checked that the code can be compiled and run with full SME2 support, so you are now all set to move to the next section. \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/4-outer-product.md b/content/learning-paths/cross-platform/sme2/4-outer-product.md index c46607ed90..5997ef8fcb 100644 --- a/content/learning-paths/cross-platform/sme2/4-outer-product.md +++ b/content/learning-paths/cross-platform/sme2/4-outer-product.md @@ -6,12 +6,11 @@ weight: 6 layout: learningpathall --- -In this section, you will learn how the outer product with the SME engine can be -used to improve matrix multiplication. +In this section, you will learn how you can use the outer product with the SME engine to improve matrix multiplication. ## Matrix multiplication with the outer product -In our textbook matrix multiplication example, the core of the computation: +In this textbook matrix multiplication example, the core of the computation: ```C acc += matLeft[m * K + k] * matRight[k * N + n]; @@ -19,14 +18,14 @@ In our textbook matrix multiplication example, the core of the computation: is 1 multiply-accumulate (a.k.a ``macc``) for 2 loads (``matLeft[m * K + k]`` and ``matRight[k *N + n]``): it thus has 1:2 ``macc`` to ``load`` ratio. From a -memory system perspective, this is not very effective especially since this +memory system perspective, this is not effective especially since this computation is done within a triple nested loop, repeatedly loading data from memory. And to make things worse, large matrices may not fit in cache... In order to improve the matrix multiplication efficiency, the goal is to increase the ``macc`` to ``load`` ratio, that is perform more multiply-accumulate operations per load. -Figure 3 below depicts how the matrix multiplication of ``matLeft`` (3 rows, 2 +Figure 3 below shows how the matrix multiplication of ``matLeft`` (3 rows, 2 columns) by ``matRight`` (2 rows, 3 columns) can be decomposed as the sum of the outer products: From 4d010102c7fe46f377c2252a496d753b9a8ee017 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Thu, 30 Jan 2025 16:53:44 +0000 Subject: [PATCH 13/25] Further improvements. --- .../cross-platform/sme2/4-outer-product.md | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/4-outer-product.md b/content/learning-paths/cross-platform/sme2/4-outer-product.md index 5997ef8fcb..108ee710b2 100644 --- a/content/learning-paths/cross-platform/sme2/4-outer-product.md +++ b/content/learning-paths/cross-platform/sme2/4-outer-product.md @@ -62,13 +62,8 @@ be in column-major order --- from a mathematical perspective, ``matleft`` is ### Transposition in the real world -Just as trees don't grow to the sky, the SME engine has physical -implementation limits. It operates with so called tiles in the ZA storage. Tiles -are 2D portions of the matrices being processed. SME has dedicated instructions -to load data to / store data from tiles efficiently, as well as instructions to -operate with / on tiles, e.g the -[fmopa](https://developer.arm.com/documentation/ddi0602/latest/SME-Instructions/FMOPA--non-widening---Floating-point-outer-product-and-accumulate-?lang=en) -instruction which takes 2 vectors as inputs and accumulate all the outer +In the same way that trees don't reach the sky, the SME engine has physical implementation limits. It operates with tiles in the ZA storage. Tiles are 2D portions of the matrices being processed. SME has dedicated instructions to load data to, and store data from tiles efficiently, as well as instructions to operate with and on tiles, for example the [fmopa](https://developer.arm.com/documentation/ddi0602/latest/SME-Instructions/FMOPA--non-widening---Floating-point-outer-product-and-accumulate-?lang=en) +instruction which takes two vectors as inputs and accumulate all the outer products to a 2D tile. The tile in ZA storage is what allows SME to increase the ``macc`` to ``load`` ratio, as all the tile elements are loaded to the tile, to be used with the SME outer product instructions. From 5d99c12165c6d83e048f54ea0dfe02c710c16a0b Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Thu, 30 Jan 2025 17:16:53 +0000 Subject: [PATCH 14/25] Further improvements. --- .../cross-platform/sme2/8-going-further.md | 33 +++++++++---------- 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/8-going-further.md b/content/learning-paths/cross-platform/sme2/8-going-further.md index adccb47e50..48583b9091 100644 --- a/content/learning-paths/cross-platform/sme2/8-going-further.md +++ b/content/learning-paths/cross-platform/sme2/8-going-further.md @@ -8,29 +8,26 @@ layout: learningpathall ## Generalize the algorithms -In this learning path, in order to show how to use SME2 for matrix -multiplication, we have only covered the case for floating point multiplication. +In this Learning Path, in order to show how to use SME2 for matrix +multiplication, only the case for floating point multiplication was covered. In practice, a library or framework that supports matrix multiplication should also be implemented it for the double type (64-bit floating point number) as well as all kinds of integers (8-bit, 16-bit, ...). -One can note that the algorithm structure for the matrix preprocessing as well -as the multiplication with the outer product do not change at all for other data -types --- they only need to be adapted to deal with other types. This is -perfectly suited for languages with [generic +You can see that the algorithm structure for matrix preprocessing as well +as multiplication with the outer product do not change at all for other data +types - they only need to be adapted. This is suitable for languages with [generic programming](https://en.wikipedia.org/wiki/Generic_programming) like C++ with -templates. One could even make the template deal with the case where the value +templates. You can even make the template deal with the case where the value accumulated during the product uses a larger type than the input matrices, as SME2 has the instructions to deal efficiently with this common case. -This would enable the library writer to focus on the algorithm and the testing ---- and other optimizations (see below) --- while letting the compiler generate -the many variants. +This enables the library writer to focus on the algorithm and the testing - and other optimizations (see below) - while allowing the compiler to generate the many variants. ## Unroll further You might have noticed that ``matmul_intr_impl`` computes only one tile at a -time --- for the sake of simplicity. SME2 supports multi vector instructions --- +time, for the sake of simplicity. SME2 supports multi vector instructions --- and some were actually used in ``preprocess_l_intr``, e.g. ``svld1_x2``. Loading 2 vectors at a time would allow computing more tiles at the same time, and as the input matrices have been laid out in memory in a nice way, the consecutive @@ -38,17 +35,17 @@ loading of the data is very efficient ; implementing this would improve yet again the ``macc`` to load ``ratio``. In order to check your understanding of SME2, you should try to implement this -unrolling yourself ! Fear not, your results will be compared to the expected -reference values, so you have an easy way to check your work. +unrolling yourself! Fear not, your results will be compared to the expected +reference values, so you have an effortless way to check your work. ## Apply strategies An avenue for optimization is to use strategies depending on the matrices' -dimensions. This is especially easy to setup when working at the C or C++ level +dimensions. This is especially easy to set up when working at the C or C++ level, rather than directly in assembly language. By playing with the mathematical properties of matrix multiplication and the outer product, it is possible to -minimize data movement as well as the overall number of operations to perform. -For example, it is a very common case that one of the matrices is actually a +minimize data movement as well as reduce the overall number of operations to perform. +For example, it is a very common that one of the matrices is actually a vector (it has a single row or column) ; it then becomes very advantageous to transpose it... Can you see why ? (Answer: as the elements are stored contiguously in memory, an ``Nx1`` and ``1xN`` matrices have the exact same @@ -56,7 +53,7 @@ memory layout. The transposition becomes a no-op, the matrix elements will stay at the same place in memory). An even more *degenerated* case that is very easy to deal with is when one of -the matrices is essentially a scalar, i.e. a matrix with 1 row and 1 column. +the matrices is essentially a scalar, which means that it is a matrix with one row and one column. Although our current code deals with it correctly from a result point of view, a different algorithm / use of instructions would be significantly more efficient. -Can you think of an implementation ? +Can you think of an implementation? From 1cb0673d02a9468a49deeeea3982d95d1f6b46b3 Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Sun, 2 Feb 2025 08:22:24 +0000 Subject: [PATCH 15/25] Editorial update. --- .../learning-paths/cross-platform/sme2/1-get-started.md | 8 ++++---- content/learning-paths/cross-platform/sme2/_index.md | 3 ++- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index 71fbe697c3..06de1b8dda 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -10,16 +10,16 @@ layout: learningpathall To follow this Learning Path, you will need to set up an environment to develop with SME2. -As SME2 hardware is not widely deployed at the time of writing, you will require: +You require: - - A compiler with support for SME2 instructions. [clang](https://www.llvm.org/) - version >= 18 or [gcc](https://gcc.gnu.org/) versions >= 14. This Learning + - A compiler with support for SME2 instructions. You can use [Clang](https://www.llvm.org/) + version 18 or later, or [GCC](https://gcc.gnu.org/), version 14, or later. This Learning Path uses ``clang``. - An emulator to execute code with the SME2 instructions. This Learning Path uses [Arm's Fixed Virtual Platform (FVP) model](https://developer.arm.com/Tools%20and%20Software/Fixed%20Virtual%20Platforms). -You will also require ``git`` and ``docker`` installed on your machine. +You also require ``git`` and ``docker`` installed on your machine. ### Set up Git diff --git a/content/learning-paths/cross-platform/sme2/_index.md b/content/learning-paths/cross-platform/sme2/_index.md index 6acdfd6b6d..8763bbba6e 100644 --- a/content/learning-paths/cross-platform/sme2/_index.md +++ b/content/learning-paths/cross-platform/sme2/_index.md @@ -14,11 +14,12 @@ learning_objectives: prerequisites: - Basic knowledge of Arm's Scalable Matrix Extension (SME). - Basic knowledge of Arm's Scalable Vector Extension (SVE). + - An intermediate understanding of C programming language and assembly language. - A computer running Linux, MacOS, or Windows. - Installations of Git and Docker. - An emulator to run code with SME2 instructions. - A compiler with support for SME2 instructions. - - An intermediate understanding of C programming language and assembly language. + author_primary: Arnaud de Grandmaison From aee63e11462f8f84269af09922e5dabe1eeb637a Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Tue, 4 Feb 2025 16:26:22 +0000 Subject: [PATCH 16/25] Next batch of editorial changes. --- .../cross-platform/sme2/1-get-started.md | 72 ++++++++++--------- .../sme2/2-check-your-environment.md | 43 +++++------ .../cross-platform/sme2/3-vanilla-matmul.md | 47 ++++++------ .../cross-platform/sme2/4-outer-product.md | 9 ++- .../cross-platform/sme2/6-SME2-matmul-intr.md | 34 ++++----- .../cross-platform/sme2/7-debugging.md | 44 ++++++------ .../cross-platform/sme2/_next-steps.md | 8 +-- .../cross-platform/sme2/_review.md | 7 +- .../cross-platform/sme2/overview.md | 8 +-- 9 files changed, 130 insertions(+), 142 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index 06de1b8dda..8b76769eff 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -19,18 +19,18 @@ You require: - An emulator to execute code with the SME2 instructions. This Learning Path uses [Arm's Fixed Virtual Platform (FVP) model](https://developer.arm.com/Tools%20and%20Software/Fixed%20Virtual%20Platforms). -You also require ``git`` and ``docker`` installed on your machine. +You also require Git and Docker installed on your machine. ### Set up Git -To check if ``git`` is already installed on your machine, use the following command line in a terminal: +To check if Git is already installed on your machine, use the following command line in a terminal: ```BASH { output_lines=2 } git --version git version 2.47.1 ``` -If the above command line fails with a message similar to "``git: command not found``", then install ``git`` following the steps for your specific machine OS: +If the above command line fails with a message similar to "``git: command not found``", then install Git following the steps for the OS of your machine: {{< tabpane code=true >}} {{< tab header="Linux/Ubuntu" language="bash">}} @@ -47,7 +47,7 @@ To enable you to get started easily and with the tools that you need, you can fe {{% notice Note %}} -This Learning Path should also work without ``docker``, but the compiler and the FVP must be available on your search path. +This Learning Path works without ``docker``, but the compiler and the FVP must be available in your search path. {{% /notice %}} Start by checking that ``docker`` is installed on your machine by typing the following @@ -59,10 +59,13 @@ Docker version 27.3.1, build ce12230 ``` If the above command fails with a message similar to "``docker: command not found``" -then follow the steps from the [docker install guide](https://learn.arm.com/install-guides/docker/). -Note that you might have to re-login or restart your machine for the changes to be taken into account. +then follow the steps from the [Docker Install Guide](https://learn.arm.com/install-guides/docker/). -Once you have confirmed that ``docker`` is installed on your machine, you can check that it is operating normally with the following: +{{% notice Note %}} +You might need to login again or restart your machine for the changes to take effect. +{{% /notice %}} + +Once you have confirmed that Docker is installed on your machine, you can check that it is operating normally with the following: ```BASH { output_lines="2-27" } docker run hello-world @@ -100,7 +103,7 @@ For more examples and ideas, visit: ## Environment -Now, using ``git``, clone the environment for experimenting with SME2 to a directory +Now, using Git, clone the environment for experimenting with SME2 to a directory named ``SME2.git``: ```BASH @@ -142,17 +145,16 @@ It contains: - Code examples. - A ``Makefile`` that builds the code examples. - A shell script called ``run-fvp.sh`` that runs the FVP. -- A directory called ``docker/`` that contains materials related to ``docker``. -- A script called ``assets.source_me`` that provides the FVP and compiler toolchain references. -- A docker receipe called ``sme2-environment.docker`` to build the container that +- A directory called ``docker`` that contains materials related to Docker: + - A script called ``assets.source_me`` that provides the FVP and compiler toolchain references. + - A docker recipe called ``sme2-environment.docker`` to build the container that you will use. -- A shell script called ``build-my-container.sh`` that you can use if you want to build the docker container. This is not essential however, as ready-made - images are made available for you ). Lastly ``build-all-containers.sh`` is the - script that was used to create the multi-arch (x86_64 and aarch64 support) - image for you to download. -- A configuration script for VSCode to be able to use the container from the IDE called ``.devcontainer/devcontainer.json`` (see below). + - A shell script called ``build-my-container.sh`` that you can use if you want to build the docker container. This is not essential however, as ready-made + images are made available for you ). + - The ``build-all-containers.sh`` is the script that was used to create the image for multi-architecture support, for both x86_64 and AArch64, for you to download. +- A configuration script for VSCode to be able to use the container from the IDE called ``.devcontainer/devcontainer.json``. -Change directory to your checkout: +Now change directory to your checkout: ```BASH cd SME2-learning-path.git @@ -163,29 +165,27 @@ directory is ``SME2-learning-path.git``. ## Using the environment -Docker provides you with a way to execute commands in a different environment, -where all necessary tools are available without cluttering your machine. +Docker provides you with the functionality of being able to execute commands in an isolated environment, where you have all the necessary tools that you require without having to clutter your machine. Docker containers runs independently, which means that they do not interfere with other containers on the same machine or server. You can use docker in the following ways: -- You can use docker directly from the command line. For example, when you are working - from a terminal. -- You can use docker to configure VSCode to run all the commands in the docker environment. +- Directly from the command line, for example when you are working from a terminal. +- In the container, once you have used Docker to configure VSCode to run all the commands within the Docker environment. -### Directly in a terminal +### Working from a terminal When a command is executed in the docker container environment, you must prepend it with instructions on the command line so that your shell executes them in the container. -For example, to execute ``COMMAND ARGUMENTS`` in the SME2 docker container, the command line looks like: +For example, to execute ``COMMAND ARGUMENTS`` in the SME2 docker container, the command line looks like this: ```SH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 COMMAND ARGUMENTS ``` -This invokes docker, using the +This invokes Docker, using the ``armswdev/sme2-learning-path:sme2-environment-v1``container image, and mounts the current working directory (the ``SME2-learning-path.git``) -inside the container to ``/work``, sets ``/work`` as the -working directory and run ``COMMAND ARGUMENTS`` in this environment. +inside the container to ``/work``, then sets ``/work`` as the +working directory and runs ``COMMAND ARGUMENTS`` in this environment. For example, to run ``make``, you need to type: @@ -193,20 +193,22 @@ For example, to run ``make``, you need to type: docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make ``` -### In VSCode +### Working from within the Docker container Make sure you have the [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) -extension installed. It should then be as easy as using the **Reopen in -Container** menu entry as Figure 1 shows (it automatically finds and uses -``.devcontainer/devcontainer.json``): +extension installed. + +It should then be as easy as using the **Reopen in +Container** menu entry as Figure 1 shows. + +It automatically finds and uses ``.devcontainer/devcontainer.json``: -![example image alt-text#center](VSCode.png "Figure 1. Using the Dev Containers extension") +![example image alt-text#center](VSCode.png "Figure 1. Setting up the Docker Container.") All your commands will now take place in the container, so no need to prepend -them with some docker invocation, VSCode handles all this transparently for you. +them with a docker invocation, VSCode handles all this transparently for you. In the remainder of this learning path, the shell commands show the docker -invocation (so readers that don't use VSCode can copy the full command line), -but you should only use the ``COMMAND ARGUMENTS`` part. +invocation so that those who do not use VSCode can copy the full command line, but if you do use VSCode, you should only use the ``COMMAND ARGUMENTS`` part. diff --git a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md index 423e4b4436..b5ba240d38 100644 --- a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md +++ b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md @@ -6,12 +6,11 @@ weight: 4 layout: learningpathall --- -In this section, you will check that the environment needed to develop with SME2 -just works. This will also serve as your first hands on with the environment +In this section, you will check that your environment is all set up and ready to develop with SME2. This will be your first hands-on experience with the environment. ## Compile the examples -First, compile the example code with: +First, compile the example code with Clang: ```BASH { output_lines="2-19" } docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make @@ -35,13 +34,13 @@ llvm-objdump --demangle -d sme2_matmul_asm > sme2_matmul_asm.lst llvm-objdump --demangle -d sme2_matmul_intr > sme2_matmul_intr.lst ``` -The above ``make`` command (executed within the docker ``armswdev/sme2-learning-path:sme2-environment-v1`` environment) is: + Executed within the docker ``armswdev/sme2-learning-path:sme2-environment-v1`` environment, the ``make`` command performs the following tasks: -- building 4 executables: ``hello``, ``sme2_check``, ``sme2_matmul_asm`` and ``sme2_matmul_intr``, -- creating the assembly listings for the 4 executables: ``hello.lst``, ``sme2_check.lst``, ``sme2_matmul_asm.lst`` and ``sme2_matmul_intr.lst`` +- It builds four executables: ``hello``, ``sme2_check``, ``sme2_matmul_asm``, and ``sme2_matmul_intr``. +- It creates the assembly listings for the four executables: ``hello.lst``, ``sme2_check.lst``, ``sme2_matmul_asm.lst`` and ``sme2_matmul_intr.lst``. {{% notice Note %}} -At any point, you can clean the directory of all the files that have been built by invoking ``make clean`` target: +At any point, you can clean the directory of all the files that have been built by invoking the ``make clean`` target: ```BASH $ docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make clean @@ -50,9 +49,10 @@ $ docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-envi ## Basic checks -The very first program that you should run is the famous "Hello, world !" that -will let you know that the basics of your environment are in place. The source -code is in ``hello.c`` and looks like: +The very first program that you should run is the famous "Hello, world !" example that +will tell you if your environment is set up correctly. + +The source code is contained in ``hello.c`` and looks like: ```C #include @@ -73,13 +73,15 @@ Hello, world ! Info: /OSCI/SystemC: Simulation stopped by user. ``` -The important line is the "``Hello, world !``" one that shows that generic code +The important line here is "``Hello, world !``" as it demonstrates that the generic code can be compiled and run on the FVP. ## SME2 checks You will now run the ``sme2_check`` program, which checks that SME2 works as -expected, in the compiler and in the FVP. The source code is found in +expected, in both the compiler and in the FVP. + +The source code is found in ``sme2_check.c``: ```C @@ -136,23 +138,22 @@ int main(int argc, char *argv[]) { } ``` -The ``sme2_check`` program will display the SVE (resp. SME) fields of the -``ID_AA64PFR0_EL1`` (resp. ``ID_AA64PFR1_EL1``) system registers from the CPU -and will then check if SVE and SME are available, and finally will switch into +The ``sme2_check`` program displays the SVE (respectively SME) fields of the +``ID_AA64PFR0_EL1`` (respectively ``ID_AA64PFR1_EL1``) system registers from the CPU +and then checks if SVE and SME are available, and finally switches into streaming mode and back from streaming mode. The ``__ARM_FEATURE_SME2`` macro is provided by the compiler when it targets an SME capable target, which is specified with the ``-march=armv9.4-a+sme2`` command line option to ``clang`` in -file ``Makefile``. The ``arm_sme.h`` include file is part of the Arm C library -extension ([ACLE](https://arm-software.github.io/acle/main/)). The ACLE provides -types and function declarations to let C/C++ programmers exploit the Arm -architecture. We will use the SME related part of the library, but it does also -provide support for Neon or other Arm architectural extensions. +file ``Makefile``. The ``arm_sme.h`` include file is part of the Arm C Library +Extension ([ACLE](https://arm-software.github.io/acle/main/)). + +The ACLE provides types and function declarations to enable C/C++ programmers to make best possible use of the Arm architecture. You can use the SME-related part of the library, but it does also provide support for Neon or other Arm architectural extensions. ```BASH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh sme2_check ``` -The output you get should be similar to: +The output should be similar to: ```TXT ID_AA64PFR0_EL1 : 0x1101101131111112 diff --git a/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md index e5da137127..91f21e4a48 100644 --- a/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md +++ b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md @@ -6,38 +6,38 @@ weight: 5 layout: learningpathall --- -In this chapter, you will write a by-the-book matrix multiplication in C. - ## Vanilla matrix multiplication +In this section, you will learn about a textbook example of matrix multiplication in C. + ### Algorithm description The vanilla matrix multiplication operation takes two input matrices, A [Al rows x Ac columns] and B [Bl rows x Bc columns], to produce an output matrix C [Cl rows x Cc columns]. The operation consists of iterating on each row of A and each column of B, multiplying each element of the A row with its corresponding -element in the B column then summing all these products, as depicted in figure 2 below. +element in the B column then summing all these products, as Figure 2 shows. -![example image alt-text#center](matmul.png "Figure 2. By the book matrix multiplication") +![example image alt-text#center](matmul.png "Figure 2. Standard Matrix Multiplication.") -This implies that the A, B and C matrices have some constraints on their +This implies that the A, B, and C matrices have some constraints on their dimensions: -- A's number of columns needs to match B's number of lines: Ac == Bl -- C will have dimensions Cl == Al and Cc == Bc +- A's number of columns must match B's number of lines: Ac == Bl. +- C has the ll have dimensions Cl == Al and Cc == Bc You can learn more about matrix multiplication, including its history, properties and use, with this [wikipedia article](https://en.wikipedia.org/wiki/Matrix_multiplication) -In this learning path, we will use the following variable names: +In this Learning Path, you will see the following variable names: -- ``matLeft`` corresponds to the left hand side argument of the matrix - multiplication, -- ``matRight``corresponds to the right-hand side of the matrix multiplication, -- ``M`` is ``matleft`` number of rows, -- ``K`` is ``matleft`` number of columns (and ``matRight`` number of rows), -- ``N`` is ``matRight`` number of columns, +- ``matLeft`` corresponds to the left-hand side argument of the matrix + multiplication. +- ``matRight``corresponds to the right-hand side of the matrix multiplication. +- ``M`` is ``matLeft`` number of rows. +- ``K`` is ``matLeft`` number of columns (and ``matRight`` number of rows). +- ``N`` is ``matRight`` number of columns. - ``matResult``corresponds to the result of the matrix multiplication, with ``M`` rows and ``N`` columns. @@ -64,17 +64,16 @@ void matmul(uint64_t M, uint64_t K, uint64_t N, } ``` -In this learning path, the matrices are laid out in memory as contiguous -sequences of elements, in [row major -order](https://en.wikipedia.org/wiki/Row-_and_column-major_order). The -``matmul`` function performs the algorithm that was described above. The +In this Learning Path, the matrices are laid out in memory as contiguous +sequences of elements, in [Row-Major +Order](https://en.wikipedia.org/wiki/Row-_and_column-major_order). The +``matmul`` function performs the algorithm described above. The pointers to ``matLeft``, ``matRight`` and ``matResult`` have been annotated as ``restrict``, which informs the compiler that the memory areas designated by -those pointers do not alias (i.e. they do not overlap in any way), so the -compiler does not need to insert extra instructions to deal with those cases. -The pointers to ``matLeft`` and ``matRight`` are marked as ``const`` because -none of these 2 matrices are modified by ``matmul``. +those pointers do not alias. This means that they do not overlap in any way, so that the +compiler does not need to insert extra instructions to deal with these cases. +The pointers to ``matLeft`` and ``matRight`` are marked as ``const`` as neither of these two matrices are modified by ``matmul``. -You now have a reference matrix multiplication function. It will be used later -on in this learning path to ensure that the assembly version and the intrinsics +You now have a reference standard matrix multiplication function. You will use it later +on in this Learning Path to ensure that the assembly version and the intrinsics version of the multiplication algorithm do not contain errors. \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/4-outer-product.md b/content/learning-paths/cross-platform/sme2/4-outer-product.md index 108ee710b2..77c5e2c80f 100644 --- a/content/learning-paths/cross-platform/sme2/4-outer-product.md +++ b/content/learning-paths/cross-platform/sme2/4-outer-product.md @@ -5,18 +5,17 @@ weight: 6 ### FIXED, DO NOT MODIFY layout: learningpathall --- +## Matrix multiplication with the outer product In this section, you will learn how you can use the outer product with the SME engine to improve matrix multiplication. -## Matrix multiplication with the outer product - -In this textbook matrix multiplication example, the core of the computation: +In this textbook matrix multiplication example, the core of the computation can be represented as: ```C acc += matLeft[m * K + k] * matRight[k * N + n]; ``` -is 1 multiply-accumulate (a.k.a ``macc``) for 2 loads (``matLeft[m * K + k]`` +Which translates to 1 multiply-accumulate, which is also known as ``macc``, for two loads (``matLeft[m * K + k]`` and ``matRight[k *N + n]``): it thus has 1:2 ``macc`` to ``load`` ratio. From a memory system perspective, this is not effective especially since this computation is done within a triple nested loop, repeatedly loading data from @@ -29,7 +28,7 @@ Figure 3 below shows how the matrix multiplication of ``matLeft`` (3 rows, 2 columns) by ``matRight`` (2 rows, 3 columns) can be decomposed as the sum of the outer products: -![example image alt-text#center](outer_product.png "Figure 3. Outer product based matrix multiplication") +![example image alt-text#center](outer_product.png "Figure 3. Outer Product-based Matrix Multiplication.") The SME engine builds on the [outer product](https://en.wikipedia.org/wiki/Outer_product) as matrix diff --git a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md index ade005a4f6..697fe403a7 100644 --- a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md +++ b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md @@ -5,30 +5,24 @@ weight: 8 ### FIXED, DO NOT MODIFY layout: learningpathall --- - -In this chapter, you will write an SME2 optimized matrix multiplication in C -using the intrinsics provided by the compiler. - ## Matrix multiplication with SME2 intrinsics -*Intrinsics*, also know known as *compiler intrinsics* or *intrinsic functions* -are functions available to application developers that the compiler has an -intimate knowledge of. This enables the compiler to either translate that -function to a very specific instruction and/or to perform specific -optimizations. +In this section, you will write an SME2 optimized matrix multiplication in C +using the intrinsics that the compiler provides. + +*Intrinsics*, also know known as *compiler intrinsics* or *intrinsic functions*, and they are functions available to application developers that the compiler has an +intimate knowledge of. This enables the compiler to either translate the function to a very specific instruction or to perform specific optimizations, or both. -You can lean more about intrinsics in this [wikipedia -article](https://en.wikipedia.org/wiki/Intrinsic_function). +You can lean more about intrinsics in this [Wikipedia +Article on Intrinsic Function](https://en.wikipedia.org/wiki/Intrinsic_function). Using intrinsics allows the programmer to use the very specific instructions -needed to achieve the required performance while writing in C all the mundane -code (loops, ...). This gives performance close to what can be reached with hand -written assembly whilst being significantly more maintainable and portable ! +required to achieve the required performance while writing in C all the typically-required standard code, such as loops. This produces performance close to what can be reached with hand-written assembly whilst being significantly more maintainable and portable. -All Arm specific intrinsics are specified in the -[ACLE](https://github.com/ARM-software/acle) --- Arm C language extension. ACLE +All Arm-specific intrinsics are specified in the +[ACLE](https://github.com/ARM-software/acle), which is the Arm C Language Extension. ACLE is supported by the main compilers, most notably [GCC](https://gcc.gnu.org/) and -[clang](https://clang.llvm.org). +[Clang](https://clang.llvm.org). ## Streaming mode @@ -210,7 +204,7 @@ The core of ``preprocess_l_intr`` is made of two parts: (lines 24-27). But this goes much further because as SME2 has multi-vectors operations (hence the ``svld1_x2`` intrinsic to load 2 rows in 2 vector registers), this allows the function to load the consecutive row, which - happens to be the row from the neighbouring tile on the right : this means 2 + happens to be the row from the neighboring tile on the right : this means 2 tiles are processed at once. At line 29-32, the pairs of vector registers are rearranged on quads of vector registers so they can be stored horizontally in the 2 tiles' ZA storage at lines 33-36 with the ``svwrite_hor_za32_f32_vg4`` @@ -331,9 +325,9 @@ The core of the multiplication is done in 2 parts: destination matrix ``matResult``. Once again you will note that the usage of the intrinsics made it easy to take -advantage of the full power of SME2 --- once there is a good undestanding of the +advantage of the full power of SME2 --- once there is a good understanding of the available SME2 instructions. The predicates deal elegantly with the corner -cases. And most importanly, our code will deal with different SVL from different +cases. And most importantly, our code will deal with different SVL from different hardware implementations without having to be recompiled. It's the important concept of *compile-once* / *run-everywhere*, plus the implementations that have larger SVL will perform the computation faster (for the same binary). diff --git a/content/learning-paths/cross-platform/sme2/7-debugging.md b/content/learning-paths/cross-platform/sme2/7-debugging.md index 091f835a4f..0051cdd287 100644 --- a/content/learning-paths/cross-platform/sme2/7-debugging.md +++ b/content/learning-paths/cross-platform/sme2/7-debugging.md @@ -10,11 +10,11 @@ layout: learningpathall ### Looking at the generated code -In some cases, it is useful to look at the code actually generated by the -compiler. In this learning path, the assembly listing have been produced and can +In some cases, it is useful to look at the code generated by the +compiler. In this Learning Path, the assembly listings have been produced and can be inspected. For example, the inner loop with the outer product + accumulation of -the matrix multiplication with intrinsics is looking like (from listing -``sme2_matmul_intr.lst``): +the matrix multiplication with intrinsics from listing +``sme2_matmul_intr.lst`` looks like: ```TXT ... @@ -31,22 +31,19 @@ the matrix multiplication with intrinsics is looking like (from listing ### With debuggers Both of the main debuggers, ``gdb`` and ``lldb`` have some support for debugging -SME2 code. Their usage is not shown in this learning path though, the main -reason being that this learning path operates the CPU in the so-called -*baremetal* mode: this is a simplistic and minimalistic environment (no -operating system for example) and debug would require to have a debug monitor -(a.k.a demon) running to interface between the debugger, the program and the -CPU. +SME2 code. Their usage is not shown in this Learning Path though, the main +reason being that this Learning Path focuses on the CPU in *baremetal* mode: this is a simplistic and minimalistic environment, without an operating system, for example, and debug mode requires a debug monitor, that is a demon, to interface between the debugger, the program, and the CPU. -### With traces +### With trace The FVP can emit an instruction trace file in text format, known as the Tarmac -trace. This provides a convenient way to understand what the program is doing. -In the excerpt shown below, one can see that the SVE register ``z0`` has been -loaded with 16 values (because predicate ``p0`` was true) with an ``LD1W`` -instruction, whereas ``z1`` was loaded with only 2 values (because of ``p1``). +trace. This provides a convenient way for you to understand what the program is doing. + +In the excerpt shown below, you can see that the SVE register ``z0`` has been +loaded with 16 values, as predicate ``p0`` was true, with an ``LD1W`` +instruction, whereas ``z1`` was loaded with only two values, because of ``p1``. ``z0`` and ``z1`` are later used by the ``fmopa`` instruction to compute the -outer-product and the trace displays the content of the ZA storage. +outer-product, and the trace displays the content of the ZA storage. ```TXT 923530000 ps IT (92353) 80001b08 a540a1a0 O EL3h_s : LD1W {z0.S},p0/Z,[x13] @@ -98,22 +95,21 @@ outer-product and the trace displays the content of the ZA storage. ``` You can get a Tarmac trace when invoking ``run-fvp.sh`` by adding the ``--trace`` -option as the *first* argument, e.g. : +option as the *first* argument, for example: ```BASH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh --trace sme2_matmul_asm ``` Tracing is not enabled by default because it slows down the simulation -significantly and the trace file can become very large for long run running -programs (programs with large matrices). +significantly and the trace file can become very large for programs with large matrices. {{% notice Debugging tip %}} -It can be really helpful when debugging to understand where an element in the +It can be helpful when debugging to understand where an element in the Tile is coming from. The current code base allows you to do that in ``debug`` -mode (when ``-DDEBUG`` is passed to the compiler in the ``Makefile``). If you -look into ``main.c``, you'll notice that the matrix initialization will no -longer be random, but will instead initialize each element with its linear +mode, when ``-DDEBUG`` is passed to the compiler in the ``Makefile``. If you +look into ``main.c``, you will notice that the matrix initialization is no +longer random, but instead initializes each element with its linear index. This makes it *easier* to find where the matrix elements are loaded in -the tile in tarmac trace for example. +the tile in tarmac trace, for example. {{% /notice %}} \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/_next-steps.md b/content/learning-paths/cross-platform/sme2/_next-steps.md index c62b20298a..1513403867 100644 --- a/content/learning-paths/cross-platform/sme2/_next-steps.md +++ b/content/learning-paths/cross-platform/sme2/_next-steps.md @@ -6,7 +6,7 @@ recommended_path: /learning-paths/PLACEHOLDER_CATEGORY/PLACEHOLDER_LEARNING_PATH further_reading: - resource: - title: SVE programming examples + title: SVE Programming Examples link: https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://developer.arm.com/documentation/dai0548/latest/&ved=2ahUKEwisi76m-f2GAxUDSKQEHfyWClAQFnoECA4QAQ&usg=AOvVaw1YPQ-aQsHmumnZykaFxM0b type: documentation @@ -36,17 +36,17 @@ further_reading: type: documentation - resource: - title: Matrix multiplication + title: Matrix Multiplication link: https://en.wikipedia.org/wiki/Matrix_multiplication type: website - resource: - title: Compiler intrinsics + title: Compiler Intrinsics link: https://en.wikipedia.org/wiki/Intrinsic_function type: website - resource: - title: ACLE --- Arm C language extension + title: ACLE --- Arm C Language Extension link: https://github.com/ARM-software/acle type: website diff --git a/content/learning-paths/cross-platform/sme2/_review.md b/content/learning-paths/cross-platform/sme2/_review.md index 710b6b8b4a..49682188ae 100644 --- a/content/learning-paths/cross-platform/sme2/_review.md +++ b/content/learning-paths/cross-platform/sme2/_review.md @@ -27,15 +27,12 @@ review: question: > What are predicates? answers: - - Parts of a sentence or clause containing a verb and stating something about the subject + - Parts of a sentence or clause containing a verb and stating something about the subject. - Predicates select the active lanes in a vector operation. - Predicates are another word for flags from the Processor Status Register (PSR). correct_answer: 2 explanation: > - SVE is a predicate centric architecture. Predicates allow Vector Length Agnosticism (VLA), - they support complex nested conditions and loops and reduce vector loop management - overhead by allowing lane predication in vector operations. Predicates have their own - dedicated registers. + SVE is a predicate-centric architecture. Predicates allow Vector Length Agnosticism (VLA), they support complex nested conditions and loops and reduce vector loop management overhead by allowing lane predication in vector operations. Predicates have their own dedicated registers. diff --git a/content/learning-paths/cross-platform/sme2/overview.md b/content/learning-paths/cross-platform/sme2/overview.md index 61eeef06bf..db395e1ff9 100644 --- a/content/learning-paths/cross-platform/sme2/overview.md +++ b/content/learning-paths/cross-platform/sme2/overview.md @@ -18,11 +18,11 @@ Additional architectural features of SME2 include: * Multi-vector multiply-accumulate instructions, with Z vectors as multiplier and multiplicand inputs and accumulating results into ZA array vectors, including widening multiplies that accumulate into more vectors than they read. -* Multi-vector load, store, move, permute, and convert instructions, that use multiple SVE Z vectors as source and destination registers to pre-process inputs and post-process outputs of the ZA-targeting SME2 instructions +* Multi-vector load, store, move, permute, and convert instructions, that use multiple SVE Z vectors as source and destination registers to pre-process inputs and post-process outputs of the ZA-targeting SME2 instructions. -* “Predicate-as-counter”, an alternative predication mechanism is added to the original SVE predication mechanism, to control operations performed on multiple vector registers +* *Predicate-as-counter*, which is an alternative predication mechanism that is added to the original SVE predication mechanism, to control operations performed on multiple vector registers. -* Compressed neural network capability using dedicated lookup table instructions and outer product instructions that support binary neural networks +* Compressed neural network capability using dedicated lookup table instructions and outer product instructions that support binary neural networks. * A 512-bit architectural register ZT0, that supports the lookup table feature. @@ -30,7 +30,7 @@ Additional architectural features of SME2 include: If you are not familiar with matrix multiplication, or would benefit from refreshing your knowledge, this [Wikipedia article on Matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication) is a good start. -This Learning Path assumes some basic understanding of SVE and SME. If you are not familiar with SVE or SME, these are some useful resources that you should first read: +This Learning Path assumes some basic understanding of SVE and SME. If you are not familiar with SVE or SME, these are some useful resources that you can read first: - [Introducing the Scalable Matrix Extension for the Armv9-A Architecture](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/scalable-matrix-extension-armv9-a-architecture). From 3514d82b2625c5f0390da6306ca644974f684015 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Tue, 4 Feb 2025 17:04:40 +0000 Subject: [PATCH 17/25] Further changes. --- .../cross-platform/sme2/6-SME2-matmul-intr.md | 24 ++++++++----------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md index 697fe403a7..e6427488b3 100644 --- a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md +++ b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md @@ -10,13 +10,13 @@ layout: learningpathall In this section, you will write an SME2 optimized matrix multiplication in C using the intrinsics that the compiler provides. -*Intrinsics*, also know known as *compiler intrinsics* or *intrinsic functions*, and they are functions available to application developers that the compiler has an +*Intrinsics*, also know known as *compiler intrinsics* or *intrinsic functions*, are the functions available to application developers that the compiler has an intimate knowledge of. This enables the compiler to either translate the function to a very specific instruction or to perform specific optimizations, or both. -You can lean more about intrinsics in this [Wikipedia +You can learn more about intrinsics in this [Wikipedia Article on Intrinsic Function](https://en.wikipedia.org/wiki/Intrinsic_function). -Using intrinsics allows the programmer to use the very specific instructions +Using intrinsics allows the programmer to use the specific instructions required to achieve the required performance while writing in C all the typically-required standard code, such as loops. This produces performance close to what can be reached with hand-written assembly whilst being significantly more maintainable and portable. All Arm-specific intrinsics are specified in the @@ -27,19 +27,15 @@ is supported by the main compilers, most notably [GCC](https://gcc.gnu.org/) and ## Streaming mode In the previous page, the assembly language gave the programmer full access to -the processor features. However, this comes at a cost in complexity and -maintenance especially when one has to manage large code bases with deeply -nested function calls. The assembly version is very low level, and does not deal -properly with the SME state. In real world large scale software, the program -will move back and forth from streaming mode, and some streaming mode routines -will call other streaming mode routines, which means that some state (including -the ZA storage) needs to be saved and restored. This is defined in the ACLE and +the processor features. However, this comes at a cost in terms of complexity and +maintenance, especially when one has to manage large code bases with deeply-nested function calls. The assembly version is very low level, and does not deal +fully with the SME state. + +In real-world large-scale software, the program moves back and forth from streaming mode, and some streaming mode routines call other streaming mode routines, which means that some state needs to be saved and restored. This includes the ZA storage. This is defined in the ACLE and supported by the compiler: the programmer *just* has to annotate the function with some keywords and set up some registers (see function ``setup_sme`` in -``misc.c`` for an example). See -[Introduction to streaming and non-streaming mode](https://arm-software.github.io/acle/main/acle.html#controlling-the-use-of-streaming-mode) -for further details. The rest of this section quotes parts from the ACLE as there is no better way to -restate the same. +``misc.c`` for an example). See [Introduction to streaming and non-streaming mode](https://arm-software.github.io/acle/main/acle.html#controlling-the-use-of-streaming-mode) +for further information. The rest of this section references information from the ACLE. The AArch64 architecture defines a concept called “streaming mode”, controlled by a processor state bit called ``PSTATE.SM``. At any given point in time, the From 7dcc7c01d53ba0b6a6446c32d7a173bcdeab0992 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Wed, 5 Feb 2025 15:14:02 +0000 Subject: [PATCH 18/25] Further editorial updates. --- .../cross-platform/sme2/1-get-started.md | 62 +++++++++---------- .../sme2/2-check-your-environment.md | 17 +++-- .../cross-platform/sme2/3-vanilla-matmul.md | 21 ++++--- .../cross-platform/sme2/4-outer-product.md | 20 +++--- 4 files changed, 60 insertions(+), 60 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index 8b76769eff..05f390e237 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -10,16 +10,16 @@ layout: learningpathall To follow this Learning Path, you will need to set up an environment to develop with SME2. -You require: +You will require: - A compiler with support for SME2 instructions. You can use [Clang](https://www.llvm.org/) - version 18 or later, or [GCC](https://gcc.gnu.org/), version 14, or later. This Learning - Path uses ``clang``. + version 18 or later, or [GCC](https://gcc.gnu.org/) version 14, or later. This Learning + Path uses ``Clang``. - An emulator to execute code with the SME2 instructions. This Learning Path uses [Arm's Fixed Virtual Platform (FVP) model](https://developer.arm.com/Tools%20and%20Software/Fixed%20Virtual%20Platforms). -You also require Git and Docker installed on your machine. +You will also require Git and Docker installed on your machine. ### Set up Git @@ -30,20 +30,20 @@ git --version git version 2.47.1 ``` -If the above command line fails with a message similar to "``git: command not found``", then install Git following the steps for the OS of your machine: +If the above command line fails with a message similar to "``git: command not found``", then install Git following the steps for your machine's OS. {{< tabpane code=true >}} {{< tab header="Linux/Ubuntu" language="bash">}} sudo apt install git {{< /tab >}} - {{< tab header="MacOS" language="bash">}} + {{< tab header="macOS" language="bash">}} brew install git {{< /tab >}} {{< /tabpane >}} ### Docker -To enable you to get started easily and with the tools that you need, you can fetch a Docker container with the required compiler and FVP to get started straight away. Alternatively, if you do wish to build the container yourself, the ``Dockerfile`` is also available. +To enable you to get started easily and with the tools that you need, you can fetch a Docker container with the required compiler and FVP. Alternatively, if you do wish to build the container yourself, the ``Dockerfile`` is also available. {{% notice Note %}} @@ -110,7 +110,7 @@ named ``SME2.git``: git clone https://gitlab.arm.com/learning-code-examples/TODO_SOME_PATH SME2-learning-path.git ``` -This repository content looks like: +This list of content in the repository should look like this : ```TXT SME2-learning-path.git/ @@ -145,37 +145,37 @@ It contains: - Code examples. - A ``Makefile`` that builds the code examples. - A shell script called ``run-fvp.sh`` that runs the FVP. -- A directory called ``docker`` that contains materials related to Docker: +- A directory called ``docker`` that contains materials related to Docker, which are: - A script called ``assets.source_me`` that provides the FVP and compiler toolchain references. - - A docker recipe called ``sme2-environment.docker`` to build the container that + - A Docker recipe called ``sme2-environment.docker`` to build the container that you will use. - - A shell script called ``build-my-container.sh`` that you can use if you want to build the docker container. This is not essential however, as ready-made - images are made available for you ). - - The ``build-all-containers.sh`` is the script that was used to create the image for multi-architecture support, for both x86_64 and AArch64, for you to download. + - A shell script called ``build-my-container.sh`` that you can use if you want to build the Docker container. This is not essential however, as ready-made images are made available for you. + - A script called ``build-all-containers.sh`` that was used to create the image for you to download to provide multi-architecture support for both x86_64 and AArch64. - A configuration script for VSCode to be able to use the container from the IDE called ``.devcontainer/devcontainer.json``. -Now change directory to your checkout: +The next step is to change directory to your checkout: ```BASH cd SME2-learning-path.git ``` +{{% notice Note %}} +From this point in the Learning Path, all instructions assume that your current +directory is ``SME2-learning-path.git``.{{% /notice %}} -From this point in the Learning Path, all instructions assume your current -directory is ``SME2-learning-path.git``. ## Using the environment -Docker provides you with the functionality of being able to execute commands in an isolated environment, where you have all the necessary tools that you require without having to clutter your machine. Docker containers runs independently, which means that they do not interfere with other containers on the same machine or server. +Docker containers provide you with the functionality to execute commands in an isolated environment, where you have all the necessary tools that you require without having to clutter your machine. The containers runs independently, which means that they do not interfere with other containers on the same machine or server. -You can use docker in the following ways: -- Directly from the command line, for example when you are working from a terminal. -- In the container, once you have used Docker to configure VSCode to run all the commands within the Docker environment. +You can use Docker in the following ways: +- Directly from the command line. For example, when you are working from a terminal. +- In the container. Once you have used Docker to configure VSCode to run all the commands within the Docker environment, you can work from within it. ### Working from a terminal -When a command is executed in the docker container environment, you must prepend it with instructions on the command line so that your shell executes them in the container. +When a command is executed in the Docker container environment, you must prepend it with instructions on the command line so that your shell executes it within the container. -For example, to execute ``COMMAND ARGUMENTS`` in the SME2 docker container, the command line looks like this: +For example, to execute ``COMMAND ARGUMENTS`` in the SME2 Docker container, the command line looks like this: ```SH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 COMMAND ARGUMENTS @@ -187,7 +187,7 @@ image, and mounts the current working directory (the ``SME2-learning-path.git``) inside the container to ``/work``, then sets ``/work`` as the working directory and runs ``COMMAND ARGUMENTS`` in this environment. -For example, to run ``make``, you need to type: +For example, to run ``make``, you need to enter: ```SH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make @@ -195,20 +195,20 @@ docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-enviro ### Working from within the Docker container -Make sure you have the [Dev +Make sure you have the [Microsoft Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) extension installed. -It should then be as easy as using the **Reopen in -Container** menu entry as Figure 1 shows. +Then select the **Reopen in Container** menu entry as Figure 1 shows. It automatically finds and uses ``.devcontainer/devcontainer.json``: -![example image alt-text#center](VSCode.png "Figure 1. Setting up the Docker Container.") +![example image alt-text#center](VSCode.png "Figure 1: Setting up the Docker Container.") -All your commands will now take place in the container, so no need to prepend -them with a docker invocation, VSCode handles all this transparently for you. +All your commands now take place in the container, so no need to prepend +them with a Docker invocation, as VSCode handles all this transparently for you. -In the remainder of this learning path, the shell commands show the docker +{{% notice Note %}} +In the remainder of this learning path, the shell commands show the Docker invocation so that those who do not use VSCode can copy the full command line, but if you do use VSCode, you should only use the ``COMMAND ARGUMENTS`` part. - +{{% /notice %}} \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md index b5ba240d38..1e2124a2e9 100644 --- a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md +++ b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md @@ -52,7 +52,7 @@ $ docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-envi The very first program that you should run is the famous "Hello, world !" example that will tell you if your environment is set up correctly. -The source code is contained in ``hello.c`` and looks like: +The source code is contained in ``hello.c`` and looks like this: ```C #include @@ -138,13 +138,12 @@ int main(int argc, char *argv[]) { } ``` -The ``sme2_check`` program displays the SVE (respectively SME) fields of the -``ID_AA64PFR0_EL1`` (respectively ``ID_AA64PFR1_EL1``) system registers from the CPU -and then checks if SVE and SME are available, and finally switches into -streaming mode and back from streaming mode. The ``__ARM_FEATURE_SME2`` macro -is provided by the compiler when it targets an SME capable target, which is -specified with the ``-march=armv9.4-a+sme2`` command line option to ``clang`` in -file ``Makefile``. The ``arm_sme.h`` include file is part of the Arm C Library +The ``sme2_check`` program displays the SVE field of the ``ID_AA64PFR0_EL1`` system register and the SME field of the ``ID_AA64PFR1_EL1`` system register and will then check if SVE and SME are available, and finally will switch into streaming mode and back from streaming mode. + +The ``__ARM_FEATURE_SME2`` macro is provided by the compiler when it targets an SME-capable target, which is specified with the ``-march=armv9.4-a+sme2`` command line option to ``clang`` in +file ``Makefile``. + +The ``arm_sme.h`` include file is part of the Arm C Library Extension ([ACLE](https://arm-software.github.io/acle/main/)). The ACLE provides types and function declarations to enable C/C++ programmers to make best possible use of the Arm architecture. You can use the SME-related part of the library, but it does also provide support for Neon or other Arm architectural extensions. @@ -171,4 +170,4 @@ Checking in_streaming_mode: 0 Info: /OSCI/SystemC: Simulation stopped by user. ``` -You have now checked that the code can be compiled and run with full SME2 support, so you are now all set to move to the next section. \ No newline at end of file +You have now checked that the code can be compiled and run with full SME2 support and are all set to move to the next section. \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md index 91f21e4a48..20cc85798b 100644 --- a/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md +++ b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md @@ -8,13 +8,13 @@ layout: learningpathall ## Vanilla matrix multiplication -In this section, you will learn about a textbook example of matrix multiplication in C. +In this section, you will learn about an example of standard matrix multiplication in C. ### Algorithm description -The vanilla matrix multiplication operation takes two input matrices, A [Al -rows x Ac columns] and B [Bl rows x Bc columns], to produce an output matrix C -[Cl rows x Cc columns]. The operation consists of iterating on each row of A +The vanilla matrix multiplication operation takes two input matrices, A [Ar +rows x Ac columns] and B [Br rows x Bc columns], to produce an output matrix C +[Cr rows x Cc columns]. The operation consists of iterating on each row of A and each column of B, multiplying each element of the A row with its corresponding element in the B column then summing all these products, as Figure 2 shows. @@ -23,12 +23,12 @@ element in the B column then summing all these products, as Figure 2 shows. This implies that the A, B, and C matrices have some constraints on their dimensions: -- A's number of columns must match B's number of lines: Ac == Bl. -- C has the ll have dimensions Cl == Al and Cc == Bc +- A's number of columns must match B's number of rows: Ac == Br. +- C has the dimensions Cr == Ar and Cc == Bc. You can learn more about matrix multiplication, including its history, -properties and use, with this [wikipedia -article](https://en.wikipedia.org/wiki/Matrix_multiplication) +properties and use, by reading this [Wikipedia +article on Matrix Multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication). In this Learning Path, you will see the following variable names: @@ -67,8 +67,9 @@ void matmul(uint64_t M, uint64_t K, uint64_t N, In this Learning Path, the matrices are laid out in memory as contiguous sequences of elements, in [Row-Major Order](https://en.wikipedia.org/wiki/Row-_and_column-major_order). The -``matmul`` function performs the algorithm described above. The -pointers to ``matLeft``, ``matRight`` and ``matResult`` have been annotated as +``matmul`` function performs the algorithm described above. + +The pointers to ``matLeft``, ``matRight`` and ``matResult`` have been annotated as ``restrict``, which informs the compiler that the memory areas designated by those pointers do not alias. This means that they do not overlap in any way, so that the compiler does not need to insert extra instructions to deal with these cases. diff --git a/content/learning-paths/cross-platform/sme2/4-outer-product.md b/content/learning-paths/cross-platform/sme2/4-outer-product.md index 77c5e2c80f..49e155a24b 100644 --- a/content/learning-paths/cross-platform/sme2/4-outer-product.md +++ b/content/learning-paths/cross-platform/sme2/4-outer-product.md @@ -9,29 +9,29 @@ layout: learningpathall In this section, you will learn how you can use the outer product with the SME engine to improve matrix multiplication. -In this textbook matrix multiplication example, the core of the computation can be represented as: +In this standard matrix multiplication example, the core of the computation can be represented as: ```C acc += matLeft[m * K + k] * matRight[k * N + n]; ``` Which translates to 1 multiply-accumulate, which is also known as ``macc``, for two loads (``matLeft[m * K + k]`` -and ``matRight[k *N + n]``): it thus has 1:2 ``macc`` to ``load`` ratio. From a -memory system perspective, this is not effective especially since this -computation is done within a triple nested loop, repeatedly loading data from -memory. And to make things worse, large matrices may not fit in cache... In -order to improve the matrix multiplication efficiency, the goal is to increase -the ``macc`` to ``load`` ratio, that is perform more multiply-accumulate -operations per load. +and ``matRight[k *N + n]``). It therefore has a 1:2 ``macc`` to ``load`` ratio. + +From a memory system perspective, this is not effective, especially since this +computation is done within a triple-nested loop, repeatedly loading data from +memory. + +To exacerbate matters, large matrices might not fit in cache. In order to improve the matrix multiplication efficiency, the goal is to increase the ``macc`` to ``load`` ratio, which means to increase the number of multiply-accumulate operations per load. Figure 3 below shows how the matrix multiplication of ``matLeft`` (3 rows, 2 columns) by ``matRight`` (2 rows, 3 columns) can be decomposed as the sum of the outer products: -![example image alt-text#center](outer_product.png "Figure 3. Outer Product-based Matrix Multiplication.") +![example image alt-text#center](outer_product.png "Figure 3: Outer Product-based Matrix Multiplication.") The SME engine builds on the -[outer product](https://en.wikipedia.org/wiki/Outer_product) as matrix +[Outer Product](https://en.wikipedia.org/wiki/Outer_product) as matrix multiplication can be expressed as the [sum of column-by-row outer products](https://en.wikipedia.org/wiki/Outer_product#Connection_with_the_matrix_product). From 5d9244e52f6949000a64e86cc221dc70517778d3 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Wed, 5 Feb 2025 15:21:01 +0000 Subject: [PATCH 19/25] Editorial update. --- .../cross-platform/sme2/4-outer-product.md | 17 ++++++----------- .../cross-platform/sme2/6-SME2-matmul-intr.md | 6 +++--- 2 files changed, 9 insertions(+), 14 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/4-outer-product.md b/content/learning-paths/cross-platform/sme2/4-outer-product.md index 49e155a24b..a550a6d449 100644 --- a/content/learning-paths/cross-platform/sme2/4-outer-product.md +++ b/content/learning-paths/cross-platform/sme2/4-outer-product.md @@ -40,22 +40,17 @@ multiplication can be expressed as the From the previous page, you will recall that matrices are laid out in row-major order. This means that loading row-data from memory is efficient as the memory -system operates efficiently with contiguous data, e.g. caches are loaded line by -line, data prefetching is extremely simple (just load the data from -``current address + sizeof(data)``), ... This is not the case for loading column-data from -memory though, as it requires more work from the memory system. +system operates efficiently with contiguous data. An example of this is where caches are loaded row by row, and data prefetching is simple - just load the data from ``current address + sizeof(data)``. This is not the case for loading column-data from memory though, as it requires more work from the memory system. In order to further improve the effectiveness of the matrix multiplication, it -is thus desirable to change the layout in memory of the left hand side matrix -(``matLeft`` in our code examples), essentially performing a matrix -transposition so that instead of load column-data one loads row-data from -memory. +is therefore desirable to change the layout in memory of the left-hand side matrix, which is called ``matLeft`` in the code examples in this Learning Path, which essentially performs a matrix +transposition so that instead of loading column-data from memory, one loads row-data. {{% notice Important %}} -It's important to note here that this reorganizes the layout of the matrix in +It is important to note here that this reorganizes the layout of the matrix in memory in order for the algorithm implementation to be more efficient. The -transposition affects only the memory layout: ``matLeft`` will be transformed to -be in column-major order --- from a mathematical perspective, ``matleft`` is +transposition affects only the memory layout. ``matLeft`` is transformed to +column-major order, but from a mathematical perspective, ``matleft`` is *not* transposed. {{% /notice %}} diff --git a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md index e6427488b3..2e455d3e74 100644 --- a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md +++ b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md @@ -75,9 +75,9 @@ one implied by the source code. ACLE provides attributes that specify whether the abstract machine executes statements: -- in non-streaming mode, in which case they are called “non-streaming statements” -- in streaming mode, in which case they are called “streaming statements” -- in either mode, in which case they are called “streaming-compatible statements” +- In non-streaming mode, in which case they are called “non-streaming statements”. +- In streaming mode, in which case they are called “streaming statements”. +- In either mode, in which case they are called “streaming-compatible statements”. SME provides an area of storage called ZA, of size ``SVL.B`` x ``SVL.B`` bytes. It also provides a processor state bit called ``PSTATE.ZA`` to control whether ZA From 0a70df3e3daef452f75e456b8f9a77366835ceda Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Wed, 5 Feb 2025 21:37:41 +0000 Subject: [PATCH 20/25] Further editorial work. --- .../cross-platform/sme2/5-SME2-matmul-asm.md | 57 ++++++++--------- .../cross-platform/sme2/7-debugging.md | 21 +++--- .../cross-platform/sme2/8-going-further.md | 64 +++++++++---------- 3 files changed, 70 insertions(+), 72 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md b/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md index 10a8885d3e..9504eff06d 100644 --- a/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md +++ b/content/learning-paths/cross-platform/sme2/5-SME2-matmul-asm.md @@ -5,23 +5,24 @@ weight: 7 ### FIXED, DO NOT MODIFY layout: learningpathall --- +## Matrix multiplication with SME2 in assembly -In this chapter, you will use an SME2 optimized matrix multiplication written +In this chapter, you will use an SME2-optimized matrix multiplication written directly in assembly. -## Matrix multiplication with SME2 in assembly - ### Description -This learning path reuse the assembly version provided in the [SME programmer's -guide](https://developer.arm.com/documentation/109246/0100/matmul-fp32--Single-precision-matrix-by-matrix-multiplication) -where you will find a high level and an in-depth description of the 2 steps -performed. The assembly versions have been modified so they coexist nicely with -the intrinsic versions. In this learning path, the ``preprocess`` function is -defined in ``preprocess_l_asm.S`` and the outer-product based matrix -multiplication is in ``matmul_asm_impl.S``. Those 2 functions have been stitched -together in ``matmul_asm.c`` with the same prototype as the reference -implementation of matrix multiplication, so that a top-level ``matmul_asm`` can +This Learning Path reuses the assembly version provided in the [SME Programmer's +Guide](https://developer.arm.com/documentation/109246/0100/matmul-fp32--Single-precision-matrix-by-matrix-multiplication) +where you will find a high-level and an in-depth description of the two steps +performed. + +The assembly versions have been modified so they coexist nicely with +the intrinsic versions. In this Learning Path, the ``preprocess`` function is +defined in ``preprocess_l_asm.S`` and the outer product-based matrix +multiplication is found in ``matmul_asm_impl.S``. + +These two functions have been stitched together in ``matmul_asm.c`` with the same prototype as the reference implementation of matrix multiplication, so that a top-level ``matmul_asm`` can be called from the ``main`` function: ```C @@ -53,7 +54,7 @@ void matmul_asm(uint64_t M, uint64_t K, uint64_t N, } ``` -Note the use of the ``__asm`` statement forcing the compiler to save the SVE/SME registers. +Note here the use of the ``__asm`` statement forcing the compiler to save the SVE/SME registers. The high-level ``matmul_asm`` function is called from ``main.c``: @@ -156,21 +157,18 @@ int main(int argc, char **argv) { } ``` -The same ``main.c`` file is used for the assembly and intrinsic based versions -of the matrix multiplication. It will first set the ``M``, ``K`` and ``N`` -parameters, to either the arguments supplied on the command line or use default -value. Depending on the ``M``, ``K``, ``N`` dimension parameters, ``main`` will -allocate memory for all the matrices and initialize ``matLeft`` and -``matRight`` with random data. The actual matrix multiplication implementation -is provided through the ``IMPL`` macro. It will then run the matrix multiplication -from ``IMPL`` and compute the reference values for the preprocessed matrix as -well as the result matrix. It then compares the actual values to the reference -values and reports errors (if any). Last, all the memory is de-allocated before -exiting the program with a success or failure return code. +The same ``main.c`` file is used for the assembly and intrinsic-based versions +of the matrix multiplication. It first sets the ``M``, ``K`` and ``N`` +parameters, to either the arguments supplied on the command line or uses the default +value. + +Depending on the ``M``, ``K``, ``N`` dimension parameters, ``main`` allocates memory for all the matrices and initializes ``matLeft`` and ``matRight`` with random data. The actual matrix multiplication implementation is provided through the ``IMPL`` macro. + +It then runs the matrix multiplication from ``IMPL`` and computes the reference values for the preprocessed matrix as well as the result matrix. It then compares the actual values to the reference values and reports errors, if there are any. Finally, all the memory is deallocated before exiting the program with a success or failure return code. ### Compile and run it -First, make sure that the ``sme2_matmul_asm`` executable is up to date: +First, make sure that the ``sme2_matmul_asm`` executable is up-to-date: ```BASH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make sme2_matmul_asm @@ -182,7 +180,7 @@ Then execute ``sme2_matmul_asm`` on the FVP: docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh sme2_matmul_asm ``` -which should output something similar to: +The output should be something similar to: ```TXT SME2 Matrix Multiply fp32 *asm* example with args 125 35 70 @@ -193,13 +191,12 @@ Info: /OSCI/SystemC: Simulation stopped by user. ``` {{% notice Tip %}} -The example above uses the default values for the ``M``, ``K`` and ``N`` -parameters (resp. 125, 25 and 70). You can override this and provide your own -values on the command line: +The example above uses the default values for the ``M`` (125), ``K``(25) and ``N``(70) +parameters. You can override this and provide your own values on the command line: ```BASH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh sme2_matmul_asm 7 8 9 ``` -if you wish to execute the same code with ``M=7``, ``K=8`` and ``N=9`` instead. +Here the values ``M=7``, ``K=8`` and ``N=9`` are used instead. {{% /notice %}} \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/7-debugging.md b/content/learning-paths/cross-platform/sme2/7-debugging.md index 0051cdd287..1cdfb41d7a 100644 --- a/content/learning-paths/cross-platform/sme2/7-debugging.md +++ b/content/learning-paths/cross-platform/sme2/7-debugging.md @@ -12,9 +12,10 @@ layout: learningpathall In some cases, it is useful to look at the code generated by the compiler. In this Learning Path, the assembly listings have been produced and can -be inspected. For example, the inner loop with the outer product + accumulation of -the matrix multiplication with intrinsics from listing -``sme2_matmul_intr.lst`` looks like: +be inspected. + +For example, the inner loop with the outer product and the accumulation of +the matrix multiplication with intrinsics from the listing file ``sme2_matmul_intr.lst`` looks like this: ```TXT ... @@ -30,9 +31,11 @@ the matrix multiplication with intrinsics from listing ### With debuggers -Both of the main debuggers, ``gdb`` and ``lldb`` have some support for debugging +Both of the main debuggers, ``gdb`` and ``lldb``, have some support for debugging SME2 code. Their usage is not shown in this Learning Path though, the main -reason being that this Learning Path focuses on the CPU in *baremetal* mode: this is a simplistic and minimalistic environment, without an operating system, for example, and debug mode requires a debug monitor, that is a demon, to interface between the debugger, the program, and the CPU. +reason for this being that this Learning Path focuses on the CPU in *baremetal* mode. + +This is a simplistic, and minimalistic environment, without an operating system, for example. Debug mode requires a debug monitor to interface between the debugger, the program, and the CPU. ### With trace @@ -41,9 +44,9 @@ trace. This provides a convenient way for you to understand what the program is In the excerpt shown below, you can see that the SVE register ``z0`` has been loaded with 16 values, as predicate ``p0`` was true, with an ``LD1W`` -instruction, whereas ``z1`` was loaded with only two values, because of ``p1``. -``z0`` and ``z1`` are later used by the ``fmopa`` instruction to compute the -outer-product, and the trace displays the content of the ZA storage. +instruction, whereas ``z1`` was loaded with only two values, as ``p1``. +``z0``, and ``z1`` are later used by the ``fmopa`` instruction to compute the +outer product, and the trace displays the content of the ZA storage. ```TXT 923530000 ps IT (92353) 80001b08 a540a1a0 O EL3h_s : LD1W {z0.S},p0/Z,[x13] @@ -101,7 +104,7 @@ option as the *first* argument, for example: docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh --trace sme2_matmul_asm ``` -Tracing is not enabled by default because it slows down the simulation +Tracing is not enabled by default. It slows down the simulation significantly and the trace file can become very large for programs with large matrices. {{% notice Debugging tip %}} diff --git a/content/learning-paths/cross-platform/sme2/8-going-further.md b/content/learning-paths/cross-platform/sme2/8-going-further.md index 48583b9091..10e5bec20b 100644 --- a/content/learning-paths/cross-platform/sme2/8-going-further.md +++ b/content/learning-paths/cross-platform/sme2/8-going-further.md @@ -9,51 +9,49 @@ layout: learningpathall ## Generalize the algorithms In this Learning Path, in order to show how to use SME2 for matrix -multiplication, only the case for floating point multiplication was covered. +multiplication, only floating point multiplication was covered. In practice, a library or framework that supports matrix multiplication should -also be implemented it for the double type (64-bit floating point number) as -well as all kinds of integers (8-bit, 16-bit, ...). +cover all kinds of integers, such as 8-bit and 16-bit. You can see that the algorithm structure for matrix preprocessing as well -as multiplication with the outer product do not change at all for other data -types - they only need to be adapted. This is suitable for languages with [generic +as multiplication with the outer product does not change at all for other data +types - they only need to be adapted. + +This is suitable for languages with [generic programming](https://en.wikipedia.org/wiki/Generic_programming) like C++ with -templates. You can even make the template deal with the case where the value -accumulated during the product uses a larger type than the input matrices, as -SME2 has the instructions to deal efficiently with this common case. +templates. You can even make the template manage a case where the value +accumulated during the product uses a larger type than the input matrices. SME2 has the instructions to deal efficiently with this common case scenario. -This enables the library writer to focus on the algorithm and the testing - and other optimizations (see below) - while allowing the compiler to generate the many variants. +This enables the library writer to focus on the algorithm, testing, and other optimizations, while allowing the compiler to generate the many variants. ## Unroll further You might have noticed that ``matmul_intr_impl`` computes only one tile at a -time, for the sake of simplicity. SME2 supports multi vector instructions --- -and some were actually used in ``preprocess_l_intr``, e.g. ``svld1_x2``. Loading -2 vectors at a time would allow computing more tiles at the same time, and as the -input matrices have been laid out in memory in a nice way, the consecutive -loading of the data is very efficient ; implementing this would improve yet -again the ``macc`` to load ``ratio``. +time, for the sake of simplicity. + +SME2 does support multi-vector instructions, and some were used in ``preprocess_l_intr``, for example, ``svld1_x2``. -In order to check your understanding of SME2, you should try to implement this -unrolling yourself! Fear not, your results will be compared to the expected -reference values, so you have an effortless way to check your work. +Loading two vectors at a time enables the simultaneous computing of more tiles, and as the +input matrices have been laid out in memory in a neat way, the consecutive +loading of the data is efficient. Implementing this approach can make improvements to the ``macc`` to load ``ratio``. + +In order to check your understanding of SME2, you can try to implement this unrolling yourself. You also have an easy way to check your work, as your results can be compared to the expected +reference values. ## Apply strategies -An avenue for optimization is to use strategies depending on the matrices' +An avenue for optimization is to use strategies that are flexible depending on the matrices' dimensions. This is especially easy to set up when working at the C or C++ level, -rather than directly in assembly language. By playing with the mathematical -properties of matrix multiplication and the outer product, it is possible to -minimize data movement as well as reduce the overall number of operations to perform. -For example, it is a very common that one of the matrices is actually a -vector (it has a single row or column) ; it then becomes very advantageous to -transpose it... Can you see why ? (Answer: as the elements are stored -contiguously in memory, an ``Nx1`` and ``1xN`` matrices have the exact same -memory layout. The transposition becomes a no-op, the matrix elements will stay -at the same place in memory). - -An even more *degenerated* case that is very easy to deal with is when one of +rather than directly in assembly language. + +By playing with the mathematical properties of matrix multiplication and the outer product, it is possible to minimize data movement as well as reduce the overall number of operations to perform. + +For example, it is a common that one of the matrices is actually a vector, in that it has a single row or column, and then it becomes very advantageous to transpose it. Can you see why? + +The answer is that as the elements are stored contiguously in memory, an ``Nx1`` and ``1xN`` matrices have the exact same memory layout. The transposition becomes a no-op, and the matrix elements stay at the same place in memory. + +An even more *degenerated* case that is easy to manage is when one of the matrices is essentially a scalar, which means that it is a matrix with one row and one column. -Although our current code deals with it correctly from a result point of view, a -different algorithm / use of instructions would be significantly more efficient. -Can you think of an implementation? + +Although our current code handles it correctly from a results point of view, a +different algorithm and use of instructions might be more efficient. Can you think of an implementation? From 78c611261e5113da9e93957583a101f5401a06df Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Thu, 6 Feb 2025 10:38:56 +0000 Subject: [PATCH 21/25] Further editorial changes. --- .../cross-platform/sme2/3-vanilla-matmul.md | 2 +- .../cross-platform/sme2/6-SME2-matmul-intr.md | 48 +++++++++---------- .../cross-platform/sme2/7-debugging.md | 26 ++++------ .../cross-platform/sme2/8-going-further.md | 23 ++++----- 4 files changed, 42 insertions(+), 57 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md index 20cc85798b..e78e399bbc 100644 --- a/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md +++ b/content/learning-paths/cross-platform/sme2/3-vanilla-matmul.md @@ -18,7 +18,7 @@ rows x Ac columns] and B [Br rows x Bc columns], to produce an output matrix C and each column of B, multiplying each element of the A row with its corresponding element in the B column then summing all these products, as Figure 2 shows. -![example image alt-text#center](matmul.png "Figure 2. Standard Matrix Multiplication.") +![example image alt-text#center](matmul.png "Figure 2: Standard Matrix Multiplication.") This implies that the A, B, and C matrices have some constraints on their dimensions: diff --git a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md index 2e455d3e74..622a400501 100644 --- a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md +++ b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md @@ -7,11 +7,10 @@ layout: learningpathall --- ## Matrix multiplication with SME2 intrinsics -In this section, you will write an SME2 optimized matrix multiplication in C -using the intrinsics that the compiler provides. +In this section, you will write an SME2 optimized matrix multiplication in C using the intrinsics that the compiler provides. *Intrinsics*, also know known as *compiler intrinsics* or *intrinsic functions*, are the functions available to application developers that the compiler has an -intimate knowledge of. This enables the compiler to either translate the function to a very specific instruction or to perform specific optimizations, or both. +intimate knowledge of. This enables the compiler to either translate the function to a specific instruction or to perform specific optimizations, or both. You can learn more about intrinsics in this [Wikipedia Article on Intrinsic Function](https://en.wikipedia.org/wiki/Intrinsic_function). @@ -26,18 +25,17 @@ is supported by the main compilers, most notably [GCC](https://gcc.gnu.org/) and ## Streaming mode -In the previous page, the assembly language gave the programmer full access to -the processor features. However, this comes at a cost in terms of complexity and +In the previous page, the assembly language gave the programmer full access to the processor features. However, this comes at a cost in terms of complexity and maintenance, especially when one has to manage large code bases with deeply-nested function calls. The assembly version is very low level, and does not deal fully with the SME state. In real-world large-scale software, the program moves back and forth from streaming mode, and some streaming mode routines call other streaming mode routines, which means that some state needs to be saved and restored. This includes the ZA storage. This is defined in the ACLE and -supported by the compiler: the programmer *just* has to annotate the function +supported by the compiler: the programmer *just* has to annotate the function with some keywords and set up some registers (see function ``setup_sme`` in ``misc.c`` for an example). See [Introduction to streaming and non-streaming mode](https://arm-software.github.io/acle/main/acle.html#controlling-the-use-of-streaming-mode) for further information. The rest of this section references information from the ACLE. -The AArch64 architecture defines a concept called “streaming mode”, controlled +The AArch64 architecture defines a concept called *streaming mode*, controlled by a processor state bit called ``PSTATE.SM``. At any given point in time, the processor is either in streaming mode (``PSTATE.SM==1``) or in non-streaming mode (``PSTATE.SM==0``). There is an instruction called ``SMSTART`` to enter streaming mode @@ -57,14 +55,14 @@ Streaming mode has three main effects on C and C++ code: means that their associated ACLE intrinsics can only be used in non-streaming mode. These intrinsics are called “non-streaming intrinsics”. -The C and C++ standards define the behavior of programs in terms of an “abstract -machine”. As an extension, the ACLE specification applies the distinction +The C and C++ standards define the behavior of programs in terms of an *abstract +machine*. As an extension, the ACLE specification applies the distinction between streaming mode and non-streaming mode to this abstract machine: at any given point in time, the abstract machine is either in streaming mode or in non-streaming mode. This distinction between processor mode and abstract machine mode is mostly just -a dry specification detail. However, the usual “as if” rule applies: the +a specification detail. However, the usual “as if” rule applies: the processor's actual mode at runtime can be different from the abstract machine's mode, provided that this does not alter the behavior of the program. One practical consequence of this is that C and C++ code does not specify the exact @@ -75,9 +73,9 @@ one implied by the source code. ACLE provides attributes that specify whether the abstract machine executes statements: -- In non-streaming mode, in which case they are called “non-streaming statements”. -- In streaming mode, in which case they are called “streaming statements”. -- In either mode, in which case they are called “streaming-compatible statements”. +- In non-streaming mode, in which case they are called *non-streaming statements*. +- In streaming mode, in which case they are called *streaming statements*. +- In either mode, in which case they are called *streaming-compatible statements*. SME provides an area of storage called ZA, of size ``SVL.B`` x ``SVL.B`` bytes. It also provides a processor state bit called ``PSTATE.ZA`` to control whether ZA @@ -190,27 +188,27 @@ The matrix preprocessing is performed in a double nested loop, over the ``M`` have an ``SVL`` step increment, which corresponds to the horizontal and vertical dimensions of the ZA storage that will be used. The dimensions of ``a`` may not be perfect multiples of ``SVL`` though... which is why the predicates ``pMDim`` -(line 9) and ``pKDim`` (line 14) are computed in order to know which rows (resp. +(line 9) and ``pKDim`` (line 14) are computed in order to know which rows (respectively columns) are valid. The core of ``preprocess_l_intr`` is made of two parts: -- lines 17 - 37: load matrix tile as rows. In this part, loop unrolling has been +- Lines 17 - 37: load matrix tile as rows. In this part, loop unrolling has been used at 2 different levels. At the lowest level, 4 rows are loaded at a time (lines 24-27). But this goes much further because as SME2 has multi-vectors operations (hence the ``svld1_x2`` intrinsic to load 2 rows in 2 vector registers), this allows the function to load the consecutive row, which - happens to be the row from the neighboring tile on the right : this means 2 + happens to be the row from the neighboring tile on the right: this means two tiles are processed at once. At line 29-32, the pairs of vector registers are rearranged on quads of vector registers so they can be stored horizontally in - the 2 tiles' ZA storage at lines 33-36 with the ``svwrite_hor_za32_f32_vg4`` + the two tiles' ZA storage at lines 33-36 with the ``svwrite_hor_za32_f32_vg4`` intrinsic. Of course, as the input matrix may not have dimensions that are perfect multiples of ``SVL``, the ``p0``, ``p1``, ``p2`` and ``p3`` predicates are computed with the ``svpsel_lane_c32`` intrinsic (lines 18-21) so that elements outside of the input matrix are set to 0 when they are loaded at lines 24-27. -- lines 39 - 51: read the matrix tile as columns and store them. Now that the 2 +- Lines 39 - 51: read the matrix tile as columns and store them. Now that the 2 tiles have been loaded *horizontally*, they will be read *vertically* with the ``svread_ver_za32_f32_vg4`` intrinsic to quad-registers of vectors (``zq0`` and ``zq1``) at lines 45-48 and then stored with the ``svst1`` intrinsic to @@ -286,18 +284,18 @@ Note again that ``matmul_intr_impl`` function has been annotated at line 4 with: - ``__arm_inout("za")``, because the function reuses the ZA storage from its caller. -The multiplication with the outer product is performed in a double nested loop, +The multiplication with the outer product is performed in a double-nested loop, over the ``M`` (line 7) and ``N`` (line 11) dimensions of the input matrices ``matLeft_mod`` and ``matRight``. Both loops have an ``SVL`` step increment, which corresponds to the horizontal and vertical dimensions of the ZA storage that will be used as one tile at a time will be processed. The ``M`` and ``N`` dimensions of the inputs may not be perfect multiples of ``SVL`` so the -predicates ``pMDim`` (line 9) (resp. ``pNDim`` at line 13) are computed in order -to know which rows (resp. columns) are valid. +predicates ``pMDim`` (line 9) (respectively ``pNDim`` at line 13) are computed in order +to know which rows (respectively columns) are valid. The core of the multiplication is done in 2 parts: -- outer-product and accumulation at lines 15-25. As ``matLeft`` has been +- Outer-product and accumulation at lines 15-25. As ``matLeft`` has been laid-out perfectly in memory with ``preprocess_l_intr``, this part becomes straightforward. First, the tile is zeroed with the ``svzero_za`` intrinsics at line 16 so the outer products can be accumulated in the tile. The outer @@ -310,7 +308,7 @@ The core of the multiplication is done in 2 parts: Note again the usage of the ``pMDim`` and ``pNDim`` predicates to deal correctly with the rows and columns respectively which are out of bounds. -- storing of the result matrix at lines 27-46. The previous part has computed +- Storing of the result matrix at lines 27-46. The previous part has computed the result of the matrix multiplication for the current tile, which now needs to be written back to memory. This is done with the loop at line 29 which will iterate over all rows of the tile: the ``svst1_hor_za32`` intrinsic at lines @@ -333,7 +331,7 @@ larger SVL will perform the computation faster (for the same binary). The main function is exactly the same that was used for the assembly version, with the ``IMPL`` macro defined to be ``intr`` in the ``Makefile``. -First, make sure that the ``sme2_matmul_intr`` executable is up to date: +First, make sure that the ``sme2_matmul_intr`` executable is up-to-date: ```BASH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 make sme2_matmul_intr @@ -345,7 +343,7 @@ Then execute ``sme2_matmul_intr`` on the FVP: docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh sme2_matmul_intr ``` -which should output something similar to: +This should output something similar to: ```TXT SME2 Matrix Multiply fp32 *intr* example with args 125 35 70 diff --git a/content/learning-paths/cross-platform/sme2/7-debugging.md b/content/learning-paths/cross-platform/sme2/7-debugging.md index 1cdfb41d7a..3d490bd8af 100644 --- a/content/learning-paths/cross-platform/sme2/7-debugging.md +++ b/content/learning-paths/cross-platform/sme2/7-debugging.md @@ -10,12 +10,10 @@ layout: learningpathall ### Looking at the generated code -In some cases, it is useful to look at the code generated by the -compiler. In this Learning Path, the assembly listings have been produced and can -be inspected. +In some cases, it is useful to look at the code generated by the compiler. In this Learning Path, the assembly listings have been produced and you can +inspect them. -For example, the inner loop with the outer product and the accumulation of -the matrix multiplication with intrinsics from the listing file ``sme2_matmul_intr.lst`` looks like this: +For example, the inner loop with the outer product and the accumulation of the matrix multiplication with intrinsics from the listing file ``sme2_matmul_intr.lst`` looks like this: ```TXT ... @@ -31,21 +29,17 @@ the matrix multiplication with intrinsics from the listing file ``sme2_matmul_in ### With debuggers -Both of the main debuggers, ``gdb`` and ``lldb``, have some support for debugging -SME2 code. Their usage is not shown in this Learning Path though, the main +Both of the main debuggers, ``gdb`` and ``lldb``, have some support for debugging SME2 code. Their usage is not shown in this Learning Path though, the main reason for this being that this Learning Path focuses on the CPU in *baremetal* mode. This is a simplistic, and minimalistic environment, without an operating system, for example. Debug mode requires a debug monitor to interface between the debugger, the program, and the CPU. ### With trace -The FVP can emit an instruction trace file in text format, known as the Tarmac -trace. This provides a convenient way for you to understand what the program is doing. +The FVP can emit an instruction trace file in text format, known as the Tarmac trace. This provides a convenient way for you to understand what the program is doing. -In the excerpt shown below, you can see that the SVE register ``z0`` has been -loaded with 16 values, as predicate ``p0`` was true, with an ``LD1W`` -instruction, whereas ``z1`` was loaded with only two values, as ``p1``. -``z0``, and ``z1`` are later used by the ``fmopa`` instruction to compute the +In the excerpt shown below, you can see that the SVE register ``z0`` has been loaded with 16 values, as predicate ``p0`` was true, with an ``LD1W`` +instruction, whereas ``z1`` was loaded with only two values, as ``p1``. ``z0``, and ``z1`` are later used by the ``fmopa`` instruction to compute the outer product, and the trace displays the content of the ZA storage. ```TXT @@ -97,15 +91,13 @@ outer product, and the trace displays the content of the ZA storage. 923580000 ps R ZA0H_S_15 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000_4479e70a_44f4223e ``` -You can get a Tarmac trace when invoking ``run-fvp.sh`` by adding the ``--trace`` -option as the *first* argument, for example: +You can get a Tarmac trace when invoking ``run-fvp.sh`` by adding the ``--trace`` option as the *first* argument, for example: ```BASH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh --trace sme2_matmul_asm ``` -Tracing is not enabled by default. It slows down the simulation -significantly and the trace file can become very large for programs with large matrices. +Tracing is not enabled by default. It slows down the simulation significantly and the trace file can become very large for programs with large matrices. {{% notice Debugging tip %}} It can be helpful when debugging to understand where an element in the diff --git a/content/learning-paths/cross-platform/sme2/8-going-further.md b/content/learning-paths/cross-platform/sme2/8-going-further.md index 10e5bec20b..0cea41d335 100644 --- a/content/learning-paths/cross-platform/sme2/8-going-further.md +++ b/content/learning-paths/cross-platform/sme2/8-going-further.md @@ -11,7 +11,7 @@ layout: learningpathall In this Learning Path, in order to show how to use SME2 for matrix multiplication, only floating point multiplication was covered. In practice, a library or framework that supports matrix multiplication should -cover all kinds of integers, such as 8-bit and 16-bit. +cover all kinds of integers. You can see that the algorithm structure for matrix preprocessing as well as multiplication with the outer product does not change at all for other data @@ -26,32 +26,27 @@ This enables the library writer to focus on the algorithm, testing, and other op ## Unroll further -You might have noticed that ``matmul_intr_impl`` computes only one tile at a -time, for the sake of simplicity. +You might have noticed that ``matmul_intr_impl`` computes only one tile at a time, for the sake of simplicity. SME2 does support multi-vector instructions, and some were used in ``preprocess_l_intr``, for example, ``svld1_x2``. -Loading two vectors at a time enables the simultaneous computing of more tiles, and as the -input matrices have been laid out in memory in a neat way, the consecutive +Loading two vectors at a time enables the simultaneous computing of more tiles, and as the input matrices have been laid out in memory in a neat way, the consecutive loading of the data is efficient. Implementing this approach can make improvements to the ``macc`` to load ``ratio``. -In order to check your understanding of SME2, you can try to implement this unrolling yourself. You also have an easy way to check your work, as your results can be compared to the expected +In order to check your understanding of SME2, you can try to implement this unrolling yourself. You can check your work by comparing your results to the expected reference values. ## Apply strategies -An avenue for optimization is to use strategies that are flexible depending on the matrices' -dimensions. This is especially easy to set up when working at the C or C++ level, +One method for optimization is to use strategies that are flexible depending on the matrices' dimensions. This is especially easy to set up when working in C or C++, rather than directly in assembly language. By playing with the mathematical properties of matrix multiplication and the outer product, it is possible to minimize data movement as well as reduce the overall number of operations to perform. -For example, it is a common that one of the matrices is actually a vector, in that it has a single row or column, and then it becomes very advantageous to transpose it. Can you see why? +For example, it is common that one of the matrices is actually a vector, meaning that it has a single row or column, and then it becomes advantageous to transpose it. Can you see why? -The answer is that as the elements are stored contiguously in memory, an ``Nx1`` and ``1xN`` matrices have the exact same memory layout. The transposition becomes a no-op, and the matrix elements stay at the same place in memory. +The answer is that as the elements are stored contiguously in memory, an ``Nx1`` and ``1xN`` matrices have the exact same memory layout. The transposition becomes a no-op, and the matrix elements stay in the same place in memory. -An even more *degenerated* case that is easy to manage is when one of -the matrices is essentially a scalar, which means that it is a matrix with one row and one column. +An even more *degenerated* case that is easy to manage is when one of the matrices is essentially a scalar, which means that it is a matrix with one row and one column. -Although our current code handles it correctly from a results point of view, a -different algorithm and use of instructions might be more efficient. Can you think of an implementation? +Although our current code handles it correctly from a results point of view, a different algorithm and use of instructions might be more efficient. Can you think of another way? From b7bca511ae1c498a6dd174a97b8cdff9457d6d28 Mon Sep 17 00:00:00 2001 From: Maddy Underwood Date: Thu, 6 Feb 2025 10:55:50 +0000 Subject: [PATCH 22/25] Further updates,. --- .../cross-platform/sme2/2-check-your-environment.md | 8 ++++---- .../cross-platform/sme2/6-SME2-matmul-intr.md | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md index 1e2124a2e9..267feb92ce 100644 --- a/content/learning-paths/cross-platform/sme2/2-check-your-environment.md +++ b/content/learning-paths/cross-platform/sme2/2-check-your-environment.md @@ -37,7 +37,7 @@ llvm-objdump --demangle -d sme2_matmul_intr > sme2_matmul_intr.lst Executed within the docker ``armswdev/sme2-learning-path:sme2-environment-v1`` environment, the ``make`` command performs the following tasks: - It builds four executables: ``hello``, ``sme2_check``, ``sme2_matmul_asm``, and ``sme2_matmul_intr``. -- It creates the assembly listings for the four executables: ``hello.lst``, ``sme2_check.lst``, ``sme2_matmul_asm.lst`` and ``sme2_matmul_intr.lst``. +- It creates the assembly listings for the four executables: ``hello.lst``, ``sme2_check.lst``, ``sme2_matmul_asm.lst``, and ``sme2_matmul_intr.lst``. {{% notice Note %}} At any point, you can clean the directory of all the files that have been built by invoking the ``make clean`` target: @@ -138,7 +138,7 @@ int main(int argc, char *argv[]) { } ``` -The ``sme2_check`` program displays the SVE field of the ``ID_AA64PFR0_EL1`` system register and the SME field of the ``ID_AA64PFR1_EL1`` system register and will then check if SVE and SME are available, and finally will switch into streaming mode and back from streaming mode. +The ``sme2_check`` program displays the SVE field of the ``ID_AA64PFR0_EL1`` system register and the SME field of the ``ID_AA64PFR1_EL1`` system register. It will then check if SVE and SME are available, then finally will switch into streaming mode and back from streaming mode. The ``__ARM_FEATURE_SME2`` macro is provided by the compiler when it targets an SME-capable target, which is specified with the ``-march=armv9.4-a+sme2`` command line option to ``clang`` in file ``Makefile``. @@ -146,7 +146,7 @@ file ``Makefile``. The ``arm_sme.h`` include file is part of the Arm C Library Extension ([ACLE](https://arm-software.github.io/acle/main/)). -The ACLE provides types and function declarations to enable C/C++ programmers to make best possible use of the Arm architecture. You can use the SME-related part of the library, but it does also provide support for Neon or other Arm architectural extensions. +The ACLE provides types and function declarations to enable C/C++ programmers to make the best possible use of the Arm architecture. You can use the SME-related part of the library, but it does also provide support for Neon or other Arm architectural extensions. ```BASH docker run --rm -v "$PWD:/work" -w /work armswdev/sme2-learning-path:sme2-environment-v1 ./run-fvp.sh sme2_check @@ -170,4 +170,4 @@ Checking in_streaming_mode: 0 Info: /OSCI/SystemC: Simulation stopped by user. ``` -You have now checked that the code can be compiled and run with full SME2 support and are all set to move to the next section. \ No newline at end of file +You have now checked that the code can be compiled and run with full SME2 support, and are all set to move to the next section. \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md index 622a400501..6fa22fbf98 100644 --- a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md +++ b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md @@ -323,7 +323,7 @@ advantage of the full power of SME2 --- once there is a good understanding of th available SME2 instructions. The predicates deal elegantly with the corner cases. And most importantly, our code will deal with different SVL from different hardware implementations without having to be recompiled. It's the important -concept of *compile-once* / *run-everywhere*, plus the implementations that have +concept of *compile-once*/*run-everywhere*, plus the implementations that have larger SVL will perform the computation faster (for the same binary). ### Compile and run From 1270ceaa3ab62b943947d885afca449a9f4d606a Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Tue, 11 Feb 2025 11:52:46 +0000 Subject: [PATCH 23/25] Corrected VSCode -> VS Code. --- .../cross-platform/sme2/1-get-started.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index 05f390e237..91f1f7d9a5 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -151,7 +151,7 @@ It contains: you will use. - A shell script called ``build-my-container.sh`` that you can use if you want to build the Docker container. This is not essential however, as ready-made images are made available for you. - A script called ``build-all-containers.sh`` that was used to create the image for you to download to provide multi-architecture support for both x86_64 and AArch64. -- A configuration script for VSCode to be able to use the container from the IDE called ``.devcontainer/devcontainer.json``. +- A configuration script for VS Code to be able to use the container from the IDE called ``.devcontainer/devcontainer.json``. The next step is to change directory to your checkout: @@ -168,8 +168,8 @@ directory is ``SME2-learning-path.git``.{{% /notice %}} Docker containers provide you with the functionality to execute commands in an isolated environment, where you have all the necessary tools that you require without having to clutter your machine. The containers runs independently, which means that they do not interfere with other containers on the same machine or server. You can use Docker in the following ways: -- Directly from the command line. For example, when you are working from a terminal. -- In the container. Once you have used Docker to configure VSCode to run all the commands within the Docker environment, you can work from within it. +- Directly from the command line. For example, when you are working from a terminal on your local machine. +- Within a containerized environment. Configure VS Code to execute run all the commands inside a Docker container, allowing you to work seamlessly within the Docker environment. ### Working from a terminal @@ -206,9 +206,9 @@ It automatically finds and uses ``.devcontainer/devcontainer.json``: ![example image alt-text#center](VSCode.png "Figure 1: Setting up the Docker Container.") All your commands now take place in the container, so no need to prepend -them with a Docker invocation, as VSCode handles all this transparently for you. +them with a Docker invocation, as VS Code handles all this transparently for you. {{% notice Note %}} In the remainder of this learning path, the shell commands show the Docker -invocation so that those who do not use VSCode can copy the full command line, but if you do use VSCode, you should only use the ``COMMAND ARGUMENTS`` part. +invocation so that those who do not use VS Code can copy the full command line, but if you do use VS Code, you should only use the ``COMMAND ARGUMENTS`` part. {{% /notice %}} \ No newline at end of file From dcef42f80b5e782226e720efdabdd89e26b2e5f2 Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Tue, 11 Feb 2025 13:22:47 +0000 Subject: [PATCH 24/25] Further improvements. --- .../cross-platform/sme2/6-SME2-matmul-intr.md | 28 ++++++------------- 1 file changed, 9 insertions(+), 19 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md index 6fa22fbf98..413f54bf48 100644 --- a/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md +++ b/content/learning-paths/cross-platform/sme2/6-SME2-matmul-intr.md @@ -25,9 +25,7 @@ is supported by the main compilers, most notably [GCC](https://gcc.gnu.org/) and ## Streaming mode -In the previous page, the assembly language gave the programmer full access to the processor features. However, this comes at a cost in terms of complexity and -maintenance, especially when one has to manage large code bases with deeply-nested function calls. The assembly version is very low level, and does not deal -fully with the SME state. +On the previous page, assembly language provided the programmer with full access to processor features. However, this comes at the cost of increased complexity and maintenance, particularly when managing large codebases with deeply nested function calls. Additionally, the assembly version operates at a very low level and does not fully handle the SME state. In real-world large-scale software, the program moves back and forth from streaming mode, and some streaming mode routines call other streaming mode routines, which means that some state needs to be saved and restored. This includes the ZA storage. This is defined in the ACLE and supported by the compiler: the programmer *just* has to annotate the function @@ -216,12 +214,9 @@ The core of ``preprocess_l_intr`` is made of two parts: again the usage of predicates ``p0`` and ``p1`` (computed at lines 43-44) to ``svst1`` to prevent writing out of the matrix bounds. -As you can see, the usage of intrinsics greatly simplifies the writing of a -function once one has a good understanding of the available instructions in the -SME2 instruction set. The usage of predicates, which are at the core of SVE and -SME and allows to express an algorithm almost naturally and deal elegantly with -the corner cases (you will note that there is no explicit testing in the loops -for the cases where the rows or columns are outside of the matrix bounds). +Using intrinsics simplifies function development significantly, provided one has a good understanding of the SME2 instruction set. +Predicates, which are fundamental to SVE and SME, enable a natural expression of algorithms while handling corner cases efficiently. +Notably, there is no explicit condition checking within the loops to account for rows or columns extending beyond matrix bounds. ### Outer-product multiplication @@ -304,12 +299,11 @@ The core of the multiplication is done in 2 parts: are loaded with the ``svld1`` intrinsics at line 20-23 to vector registers ``zL`` and ``zR``, which are then used at line 24 with the ``svmopa_za32_m`` intrinsic to perform the outer product and accumulation (to tile 0). This - corresponds exactly to what you saw in figure 2 earlier in the learning path. + is exactly what was shown in Figure 2 earlier in the Learning Path. Note again the usage of the ``pMDim`` and ``pNDim`` predicates to deal correctly with the rows and columns respectively which are out of bounds. -- Storing of the result matrix at lines 27-46. The previous part has computed - the result of the matrix multiplication for the current tile, which now needs +- Storing of the result matrix at lines 27-46. The previous section computed the matrix multiplication result for the current tile, which now needs to be written back to memory. This is done with the loop at line 29 which will iterate over all rows of the tile: the ``svst1_hor_za32`` intrinsic at lines 35-46 stores directly from the tile to memory. Note that the loop has been @@ -318,13 +312,9 @@ The core of the multiplication is done in 2 parts: gracefully with the parts of the tile which are out-of-bound for the destination matrix ``matResult``. -Once again you will note that the usage of the intrinsics made it easy to take -advantage of the full power of SME2 --- once there is a good understanding of the -available SME2 instructions. The predicates deal elegantly with the corner -cases. And most importantly, our code will deal with different SVL from different -hardware implementations without having to be recompiled. It's the important -concept of *compile-once*/*run-everywhere*, plus the implementations that have -larger SVL will perform the computation faster (for the same binary). +Once again, intrinsics makes it easy to fully leverage SME2, provided you have a solid understanding of its available instructions. +Predicates handle corner cases elegantly, ensuring robust execution. Most importantly, the code adapts to different SVL values across various hardware implementations without requiring recompilation. +This follows the key principle of compile-once, run-everywhere, allowing systems with larger SVL to execute computations more efficiently while using the same binary. ### Compile and run From 0bed429f2ce67309f31e302af5d540d66d0e0326 Mon Sep 17 00:00:00 2001 From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com> Date: Tue, 11 Feb 2025 13:58:22 +0000 Subject: [PATCH 25/25] Further improvements. --- .../learning-paths/cross-platform/sme2/1-get-started.md | 6 ++---- .../cross-platform/sme2/8-going-further.md | 9 ++++----- .../learning-paths/cross-platform/sme2/_next-steps.md | 4 ++-- 3 files changed, 8 insertions(+), 11 deletions(-) diff --git a/content/learning-paths/cross-platform/sme2/1-get-started.md b/content/learning-paths/cross-platform/sme2/1-get-started.md index 91f1f7d9a5..61031df5d2 100644 --- a/content/learning-paths/cross-platform/sme2/1-get-started.md +++ b/content/learning-paths/cross-platform/sme2/1-get-started.md @@ -205,10 +205,8 @@ It automatically finds and uses ``.devcontainer/devcontainer.json``: ![example image alt-text#center](VSCode.png "Figure 1: Setting up the Docker Container.") -All your commands now take place in the container, so no need to prepend -them with a Docker invocation, as VS Code handles all this transparently for you. +All your commands now run within the container, so there is no need to prepend them with a Docker invocation, as VS Code handles all this seamlessly for you. {{% notice Note %}} -In the remainder of this learning path, the shell commands show the Docker -invocation so that those who do not use VS Code can copy the full command line, but if you do use VS Code, you should only use the ``COMMAND ARGUMENTS`` part. +For the rest of this Learning Path, shell commands include the full Docker invocation so that users not using VS Code can copy the complete command line. However, if you are using VS Code, you only need to use the `COMMAND ARGUMENTS` part. {{% /notice %}} \ No newline at end of file diff --git a/content/learning-paths/cross-platform/sme2/8-going-further.md b/content/learning-paths/cross-platform/sme2/8-going-further.md index 0cea41d335..be2ac04bad 100644 --- a/content/learning-paths/cross-platform/sme2/8-going-further.md +++ b/content/learning-paths/cross-platform/sme2/8-going-further.md @@ -8,10 +8,9 @@ layout: learningpathall ## Generalize the algorithms -In this Learning Path, in order to show how to use SME2 for matrix -multiplication, only floating point multiplication was covered. -In practice, a library or framework that supports matrix multiplication should -cover all kinds of integers. +In this Learning Path, you focused on using SME2 for matrix +multiplication with floating point numbers. However in practice, any library or framework supporting matrix multiplication should +also handle various integer types. You can see that the algorithm structure for matrix preprocessing as well as multiplication with the outer product does not change at all for other data @@ -22,7 +21,7 @@ programming](https://en.wikipedia.org/wiki/Generic_programming) like C++ with templates. You can even make the template manage a case where the value accumulated during the product uses a larger type than the input matrices. SME2 has the instructions to deal efficiently with this common case scenario. -This enables the library writer to focus on the algorithm, testing, and other optimizations, while allowing the compiler to generate the many variants. +This enables the library developer to focus on the algorithm, testing, and optimizations, while allowing the compiler to generate multiple variants. ## Unroll further diff --git a/content/learning-paths/cross-platform/sme2/_next-steps.md b/content/learning-paths/cross-platform/sme2/_next-steps.md index 1513403867..514cabf9c7 100644 --- a/content/learning-paths/cross-platform/sme2/_next-steps.md +++ b/content/learning-paths/cross-platform/sme2/_next-steps.md @@ -16,7 +16,7 @@ further_reading: type: website - resource: - title: Arm Scalable Matrix Extension (SME) Introduction (part 1) + title: Arm Scalable Matrix Extension (SME) Introduction (Part 1) link: https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction type: blog @@ -26,7 +26,7 @@ further_reading: type: website - resource: - title: Arm Scalable Matrix Extension (SME) Introduction (part 2) + title: Arm Scalable Matrix Extension (SME) Introduction (Part 2) link: https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-scalable-matrix-extension-introduction-p2 type: blog