diff --git a/.htmltest.yml b/.htmltest.yml index 0b6d0a2f7..cbcc6d446 100644 --- a/.htmltest.yml +++ b/.htmltest.yml @@ -9,3 +9,4 @@ IgnoreURLs: - "localhost" - "127.0.0.1" - "192.168.64.39" +- "/livereload.js" \ No newline at end of file diff --git a/.wordlist.txt b/.wordlist.txt index d3f3044ee..0256033b7 100644 --- a/.wordlist.txt +++ b/.wordlist.txt @@ -1386,7 +1386,6 @@ vht fszI youtu NDK -instrinsics dotProduct uint TextView @@ -3087,4 +3086,19 @@ WebsiteHosting flexbox getAverageTemperature libaom -writeTemperatures \ No newline at end of file +writeTemperatures +ACCP +AES +ArmCompilerforEmbedded +JMeter +LocalAppData +Microsystems +ProgramFiles +ThreadStackSize +UseTransparentHugePages +UserProfile +configurability +darwin +dmg +madvise +osKernelInitialize \ No newline at end of file diff --git a/assets/css/content.css b/assets/css/content.css index 4ee660dc1..8bac14910 100644 --- a/assets/css/content.css +++ b/assets/css/content.css @@ -175,6 +175,45 @@ div.answer label { white-space: normal; } +/* Horizontal Tabs */ +/**********************/ +.normal-tabpane { + box-sizing: border-box; + margin-left: 16px; + margin-top: 8px; + margin-bottom: 8px; + + padding-left: 16px; + padding-right: 16px; + padding-bottom: 16px; + + background-color: var(--arm-color-surface); + --ads-horizontal-tabs-navigation-background-color: var(--arm-color-surface); +} +.normal-horizontal-tabs { + --ads-horizontal-tabs-tab-color: white; + --ads-horizontal-tabs-tab-color-active: var(--arm-orange); + --ads-horizontal-tabs-underline-color: var(--arm-orange); + + --ads-horizontal-tabs-tab-color-hover: var(--arm-green); + --ads-horizontal-tabs-tab-content-background-color: var(--arm-color-footing); +} + +.normal-horizontal-tabs table, .normal-horizontal-tabs p { + padding-top: 16px; + padding-left: 16px; + padding-right: 16px; +} +.normal-horizontal-tabs table{ + padding-bottom: 8px; +} +.normal-horizontal-tabs table thead th { + background-color: var(--arm-color-footing); + color: var(--arm-light-grey); +} +.normal-horizontal-tabs table thead th, .normal-horizontal-tabs table tbody td { + border: 1px solid var(--arm-black); +} diff --git a/content/install-guides/ambaviz.md b/content/install-guides/ambaviz.md index c3e5e770a..242f19256 100644 --- a/content/install-guides/ambaviz.md +++ b/content/install-guides/ambaviz.md @@ -41,7 +41,7 @@ It is available to download at the [Arm Product Download Hub](https://developer. You can download AMBA Viz as an individual standalone component, or you can download the complete Success Kits. -For more information on the Download Hub, refer to the [Arm Product Download Hub install guide](../pdh). +For more information on the Download Hub, refer to the [Arm Product Download Hub install guide](/install-guides/pdh/). ## Installation @@ -73,7 +73,7 @@ docs/public/assets/pdfs/ambaviz-release-note.pdf AMBA Viz is license-managed. A Hardware Success Kit license is necessary. -License set up instructions are available in the [Arm License install guide](../license/). +License set up instructions are available in the [Arm License install guide](/install-guides/license/). ## Get started diff --git a/content/install-guides/armclang.md b/content/install-guides/armclang.md index 6388e5bf8..d0667b94f 100644 --- a/content/install-guides/armclang.md +++ b/content/install-guides/armclang.md @@ -57,7 +57,7 @@ These can either be used standalone or [integrated](#armds) into your Arm Develo See also: [What should I do if I want to download a legacy release of Arm Compiler?](https://developer.arm.com/documentation/ka005184) -See [Arm Product Download Hub](../pdh) for additional information on usage. +See [Arm Product Download Hub](/install-guides/pdh/) for additional information on usage. ### Install compiler packages @@ -102,7 +102,7 @@ armclang --version ### Arm Tools Artifactory {#artifactory} -The Arm Compiler for Embedded, as well as other tools and utilities are available in the [Arm Tools Artifactory](https://www.keil.arm.com/artifacts/). The Keil Studio VS Code [Extensions](../keilstudio_vs) use the artifactory to fetch and install and the necessary components. +The Arm Compiler for Embedded, as well as other tools and utilities are available in the [Arm Tools Artifactory](https://www.keil.arm.com/artifacts/). The Keil Studio VS Code [Extensions](/install-guides/keilstudio_vs/) use the artifactory to fetch and install and the necessary components. Available packages can also be fetched directly from the artifactory. This is particularly useful for automated CI/CD flows. @@ -121,7 +121,7 @@ export AC6_TOOLCHAIN_6_22_0=/home/$USER/ArmCompilerforEmbedded6.22/bin ## Set up the product license -Arm Compiler for Embedded and Arm Compiler for Embedded FuSa are license managed. License setup instructions are available in the [Arm Licensing install guide](../license/). +Arm Compiler for Embedded and Arm Compiler for Embedded FuSa are license managed. License setup instructions are available in the [Arm Licensing install guide](/install-guides/license/). ## Verify installation diff --git a/content/install-guides/armds.md b/content/install-guides/armds.md index b5754de88..a202917ff 100644 --- a/content/install-guides/armds.md +++ b/content/install-guides/armds.md @@ -44,7 +44,7 @@ You can download the Development Studio installer from the [Product Download Hub Versions of Arm Development Studio denoted by `year.index`, where `index` is a letter (for example `2023.a`) are only available to certain Arm licensees, as they contain support for non publicly announced IP (at time of release). -For more information about the Product Download Hub, refer to the [Product Download Hub guide](../pdh). +For more information about the Product Download Hub, refer to the [Product Download Hub guide](/install-guides/pdh/). ## Install Arm Development Studio @@ -136,7 +136,7 @@ Arm Development Studio is license managed. When you launch the IDE for the first A free 30 day evaluation license for Arm Development Studio is also available. You can generate this in `Arm License Manager`. Click on `Add`, and follow instructions therein to obtain the evaluation license (requires Arm login). -Full license setup instructions are available in the [Arm Software Licensing install guide](../license/). +Full license setup instructions are available in the [Arm Software Licensing install guide](/install-guides/license/). ## Get started diff --git a/content/install-guides/aws-greengrass-v2.md b/content/install-guides/aws-greengrass-v2.md index 5b779ab07..370ea7560 100644 --- a/content/install-guides/aws-greengrass-v2.md +++ b/content/install-guides/aws-greengrass-v2.md @@ -112,13 +112,13 @@ Log in to the AWS console, set the AWS region you want to use in upper right cor You can find your account ID by clicking on your user name in the top-right corner of the AWS console. -![Role Permissions Editor #center](../_images/gg-role-permissions.png) +![Role Permissions Editor #center](/install-guides/_images/gg-role-permissions.png) 6. Name the new policy `GGDeploymentAccess` 7. Back on the group creation page, click the refresh button then search for and select `GGDeploymentAccess` -![Group Policy Selection #center](../_images/gg-group-policy.png) +![Group Policy Selection #center](/install-guides/_images/gg-group-policy.png) 8. Click `Create user group` @@ -132,7 +132,7 @@ You can find your account ID by clicking on your user name in the top-right corn 13. Copy your `Access key` and `Secret access key`. -![Access Keys #center](../_images/gg-access-keys.png) +![Access Keys #center](/install-guides/_images/gg-access-keys.png) You will use the credentials in the next section. @@ -210,6 +210,6 @@ You will see the new device listed in the Greengrass core devices. Click on the device name to see more device details. -![Greengrass Devices #center](../_images/greengrass-devices.png) +![Greengrass Devices #center](/install-guides/_images/greengrass-devices.png) You are now ready to use AWS IoT Greengrass v2 on your device. \ No newline at end of file diff --git a/content/install-guides/aws_access_keys.md b/content/install-guides/aws_access_keys.md index f4aa0a988..f620de97b 100644 --- a/content/install-guides/aws_access_keys.md +++ b/content/install-guides/aws_access_keys.md @@ -65,4 +65,4 @@ Default output format [json]: json Replace the value of `Access Key ID`, `Secret Access Key`, `region name` and `output format` with your unique values. -After a successful configuration, you will be able to use the AWS CLI and automation tools like [Terraform](../terraform) from the terminal. +After a successful configuration, you will be able to use the AWS CLI and automation tools like [Terraform](/install-guides/terraform/) from the terminal. diff --git a/content/install-guides/azure-cli.md b/content/install-guides/azure-cli.md index c3fa55190..64ece50ec 100644 --- a/content/install-guides/azure-cli.md +++ b/content/install-guides/azure-cli.md @@ -105,4 +105,4 @@ You should see an output similar to below } ``` -After a successful log in, you can use the [Azure CLI](../azure-cli) and automation tools like [Terraform](../terraform) from the terminal. +After a successful log in, you can use the [Azure CLI](/install-guides/azure-cli/) and automation tools like [Terraform](/install-guides/terraform/) from the terminal. diff --git a/content/install-guides/azure_login.md b/content/install-guides/azure_login.md index bc8cf7342..bc0286b3a 100644 --- a/content/install-guides/azure_login.md +++ b/content/install-guides/azure_login.md @@ -51,4 +51,4 @@ You will see the command line details as shown below after you log in. ![azure #center](https://github.com/ArmDeveloperEcosystem/arm-learning-paths/assets/40816837/1b11ecbe-0e70-48c3-a9bf-6712ad2fba4a) -After a successful log in, you will be able to use the [Azure CLI](../azure-cli) and automation tools like [Terraform](../terraform) from the terminal. +After a successful log in, you will be able to use the [Azure CLI](/install-guides/azure-cli/) and automation tools like [Terraform](/install-guides/terraform/) from the terminal. diff --git a/content/install-guides/browsers/_index.md b/content/install-guides/browsers/_index.md index f8ab003a1..55ee06e34 100644 --- a/content/install-guides/browsers/_index.md +++ b/content/install-guides/browsers/_index.md @@ -43,7 +43,7 @@ Here is a quick summary to get you started: | Brave | native | yes | | Chrome | native | no | | Edge | native | no | -| Vivaldi | native (snapshot) | yes | +| Vivaldi | native | yes | Windows on Arm runs native ARM64 applications, but can also emulate 32-bit x86 and 64-bit x64 applications. Emulation is slower than native and shortens battery life, but may provide functionality you need. diff --git a/content/install-guides/browsers/vivaldi.md b/content/install-guides/browsers/vivaldi.md index 9cf007f0b..c11b946d8 100644 --- a/content/install-guides/browsers/vivaldi.md +++ b/content/install-guides/browsers/vivaldi.md @@ -30,7 +30,6 @@ Vivaldi is available for Arm Linux and Windows on Arm. Visit [Download Vivaldi](https://vivaldi.com/download/) to obtain packages for various operating systems. - ### Linux Vivaldi is available for Arm Linux. @@ -66,19 +65,12 @@ sudo dnf install vivaldi-stable -y ### Windows -The stable release of Vivaldi runs on Windows using emulation, but there is a snapshot release for ARM64. - -Stable Vivaldi runs on Windows on Arm using emulation. +The stable release of Vivaldi is an Arm native application. -Emulation is slower than native and shortens battery life, but may provide required functionality. +To install Vivaldi on Windows on Arm: -1. Download the 32-bit Windows version from [Download Vivaldi](https://vivaldi.com/download/). +1. Go to the [download page](https://vivaldi.com/download/) and click the Download for Windows button. -2. Run the downloaded `.exe` file +2. Run the downloaded `.exe` file 3. Find and start Vivaldi from the applications menu - - -The [snapshot release](https://downloads.vivaldi.com/snapshot/Vivaldi.6.9.3425.3.arm64.exe) is available as a native ARM64 application. Install the snapshot release using the same 3 steps above. - - diff --git a/content/install-guides/cmsis-build.md b/content/install-guides/cmsis-build.md index bc39b611a..74deb8e21 100644 --- a/content/install-guides/cmsis-build.md +++ b/content/install-guides/cmsis-build.md @@ -36,7 +36,7 @@ CMSIS-Build is a component of the CMSIS-Toolbox. For most users, it is recommended to install the complete toolbox package. -See the [CMSIS-Toolbox Install Guide](../cmsis-toolbox). +See the [CMSIS-Toolbox Install Guide](/install-guides/cmsis-toolbox/). {{% /notice %}} [CMSIS-Build](https://open-cmsis-pack.github.io/devtools/buildmgr/latest/index.html) is a set of tools to enable IDEs and command-line tools to share the same projects. diff --git a/content/install-guides/cmsis-toolbox.md b/content/install-guides/cmsis-toolbox.md index 1afe9f5f8..5a4fb0e66 100644 --- a/content/install-guides/cmsis-toolbox.md +++ b/content/install-guides/cmsis-toolbox.md @@ -38,11 +38,17 @@ It is also used for the creation and maintenance of such packs. Windows, Linux, and macOS host platforms are supported. -The below assumes Ubuntu Linux on an Arm based host. Instructions are similar for other platforms. +{{% notice Note %}} +This install guide is for manual installation of `CMSIS-Toolbox`. + +For automation instructions using `vcpkg` see [Install tools on the command line using vcpkg](/learning-paths/microcontrollers/vcpkg-tool-installation/). + +`CMSIS-Toolbox` is also installed as part of a Keil MDK installation (Windows only). +{{% /notice %}} ## Dependencies -You will need to install `cmake` and `ninja`: +You will need to install `CMake` and `Ninja`: ```command sudo apt update sudo apt install cmake ninja-build -y @@ -52,38 +58,62 @@ Check the versions of each tool: cmake --version ninja --version ``` -If `cmake` is earlier than 3.25.2, or `ninja` is earlier than 1.10.2, you will need to uninstall that version and install by other means: +Ensure version of `CMake` is at least `3.25.2`, and `Ninja` is at least `1.10.2`. -#### cmake -```command -sudo apt remove -y cmake -sudo snap install cmake --classic -``` -#### ninja -```command -sudo apt remove -y ninja-build -wget http://mirror.archlinuxarm.org/aarch64/extra/ninja-1.11.1-3-aarch64.pkg.tar.xz -sudo tar -xf ninja-1.11.1-3-aarch64.pkg.tar.xz -C / -``` +You can also download installers for all supported hosts from the below: +* [CMake](https://cmake.org/download/) +* [Ninja](https://github.com/ninja-build/ninja/releases) -## Download +## Download CMSIS-Toolbox -Download and unpack the latest install file from GitHub. Downloads are provided in the [Releases area](https://github.com/Open-CMSIS-Pack/cmsis-toolbox/releases) of the repository. +Download and unpack the latest version of `CMSIS-Toolbox` from the [Arm Tools Artifactory](https://artifacts.tools.arm.com/cmsis-toolbox/). -```console -wget https://github.com/Open-CMSIS-Pack/cmsis-toolbox/releases/download/2.2.0/cmsis-toolbox-linux-arm64.tar.gz -tar -xf cmsis-toolbox-linux-arm64.tar.gz -``` +Full details of the contents is given in the [Releases area](https://github.com/Open-CMSIS-Pack/cmsis-toolbox/releases) of the GitHub repository. -## Install the appropriate compiler toolchain +### Arm64 hosts -Projects can be built with Arm Compiler for Embedded, Arm GNU Toolchain, or IAR tools. +{{< tabpane code=true >}} + {{< tab header="Windows" language="shell">}} +wget https://artifacts.tools.arm.com/cmsis-toolbox/2.5.0/cmsis-toolbox-windows-arm64.zip +tar -xf cmsis-toolbox-windows-arm64.zip + {{< /tab >}} + {{< tab header="Linux" language="shell">}} +wget https://artifacts.tools.arm.com/cmsis-toolbox/2.5.0/cmsis-toolbox-linux-arm64.tar.gz +tar -xf cmsis-toolbox-linux-arm64.tar.gz + {{< /tab >}} + {{< tab header="macOS" language="shell">}} +curl -L -o cmsis-toolbox-darwin-arm64.tar.gz https://artifacts.tools.arm.com/cmsis-toolbox/2.5.0/cmsis-toolbox-darwin-arm64.tar.gz +tar -xf cmsis-toolbox-darwin-arm64.tar.gz + {{< /tab >}} +{{< /tabpane >}} + +### x86_64 hosts + +{{< tabpane code=true >}} + {{< tab header="Windows" language="shell">}} +wget https://artifacts.tools.arm.com/cmsis-toolbox/2.5.0/cmsis-toolbox-windows-amd64.zip +tar -xf cmsis-toolbox-windows-amd64.zip + {{< /tab >}} + {{< tab header="Linux" language="shell">}} +wget https://artifacts.tools.arm.com/cmsis-toolbox/2.5.0/cmsis-toolbox-linux-amd64.tar.gz +tar -xf cmsis-toolbox-linux-amd64.tar.gz + {{< /tab >}} + {{< tab header="macOS" language="shell">}} +curl -L -o cmsis-toolbox-darwin-amd64.tar.gz https://artifacts.tools.arm.com/cmsis-toolbox/2.5.0/cmsis-toolbox-darwin-amd64.tar.gz +tar -xf cmsis-toolbox-darwin-amd64.tar.gz + {{< /tab >}} +{{< /tabpane >}} + +## Install an appropriate compiler toolchain + +Projects can be built with Arm Compiler for Embedded 6, Arm GNU Toolchain, LLVM Embedded Toolchain, or IAR tools. For further setup instructions see these Install Guides: -* [Arm Compiler for Embedded](../armclang) -* [Arm GNU Toolchain](../gcc/arm-gnu) +* [Arm Compiler for Embedded](/install-guides/armclang) +* [Arm GNU Toolchain](/install-guides/gcc/arm-gnu) +* [LLVM Embedded Toolchain for Arm](/install-guides/llvm-embedded/) -Arm Compiler for Embedded is installed below. +`Arm Compiler for Embedded` is used in the example below. ## Set up environment variables @@ -97,19 +127,37 @@ Set environment variables as below. Note the exact name of the `TOOLCHAIN` varia | `PATH` | Add CMSIS-Toolbox `bin` to path | Also path to `CMake` and `Ninja` if necessary | For example: -```command -export AC6_TOOLCHAIN_6_21=$HOME/ArmCompilerforEmbedded6.21/bin +{{< tabpane code=true >}} + {{< tab header="Windows" language="shell">}} +set AC6_TOOLCHAIN_6_22_0=%ProgramFiles%/ArmCompilerforEmbedded6.22/bin +set CMSIS_PACK_ROOT=%LocalAppData%/Arm/Packs +set CMSIS_COMPILER_ROOT=%UserProfile%/cmsis-toolbox-windows-amd64/etc +set PATH=%PATH%;%UserProfile%/cmsis-toolbox-windows-amd64/bin + {{< /tab >}} + {{< tab header="Linux/macOS" language="shell">}} +export AC6_TOOLCHAIN_6_22_0=$HOME/ArmCompilerforEmbedded6.22/bin export CMSIS_PACK_ROOT=$HOME/packs export CMSIS_COMPILER_ROOT=$HOME/cmsis-toolbox-linux-arm64/etc export PATH=$HOME/cmsis-toolbox-linux-arm64/bin:$PATH + {{< /tab >}} +{{< /tabpane >}} + +Exact paths will depend on version installed and the install directory. + +## Initialize CMSIS-Pack directory + +Run the following command to initialize the directory specified by `CMSIS_PACK_ROOT` above. +```command cpackget init https://www.keil.com/pack/index.pidx ``` +`CMSIS-Toolbox` should now be ready for use. + ## Test setup {#test} Example projects are provided on the [GitHub repository](https://github.com/Open-CMSIS-Pack/csolution-examples). -Clone the repository to your build machine: +Clone the following repository to your build machine: ```command git clone https://github.com/Open-CMSIS-Pack/csolution-examples ``` @@ -119,46 +167,42 @@ Navigate to the `Hello` example: cd csolution-examples/Hello ``` -### Set up the build +### Build the solution -Determine and install the necessary CMSIS-Packs for the project: -```command -csolution list packs -s Hello.csolution.yml -m >packs.txt -cpackget add -f packs.txt -``` +Use the [cbuild](https://github.com/Open-CMSIS-Pack/cbuild) utility (a component of `CMSIS-Toolbox`) to build. -### Generate .cprj project file(s) +Add `--packs` to the command line to download and install any necessary software packs not currently installed. -Generate `cprj` project files for build targets within the solution project. ```command -csolution convert -s Hello.csolution.yml +cbuild Hello.csolution.yml --packs ``` -### Build a generated project -Use the `cbuild` utility to build a project. -```command -cbuild Hello.Release+AVH.cprj -``` -The build will proceed and generate an executable image: +The build will proceed and generate an executable image(s). You will see output similar to: + ```output -info cbuild: Build Invocation 2.2.0 (C) 2023 Arm Ltd. and Contributors - -M650: Command completed successfully. - -M652: Generated file for project build: '/home/ubuntu/csolution-examples/Hello/tmp/Hello/AVH/Release/CMakeLists.txt' --- The ASM compiler identification is ARMClang --- Found assembler: /home/ubuntu/ArmCompilerforEmbedded6.21/bin/armclang --- The C compiler identification is ARMClang 6.21 --- Detecting C compiler ABI info --- Detecting C compiler ABI info - done --- Check for working C compiler: /home/ubuntu/ArmCompilerforEmbedded6.21/bin/armclang - skipped --- Detecting C compile features --- Detecting C compile features - done --- Configuring done (0.6s) --- Generating done (0.0s) --- Build files have been written to: /home/ubuntu/csolution-examples/Hello/tmp/Hello/AVH/Release -[1/27] Building ASM object CMakeFiles/Hello.dir/home/ubuntu/packs/ARM/CMSIS/5.9.0/CMSIS/RTOS2/RTX/Source/GCC/irq_armv8mml.o +ARM::CMSIS@6.0.0 +ARM::CMSIS-Compiler@2.0.0 +ARM::CMSIS-RTX@5.8.0 +ARM::V2M_MPS3_SSE_300_BSP@1.5.0 +I: Downloading ARM.CMSIS.pdsc... +I: Adding pack "ARM::CMSIS@6.0.0" +I: Downloading ARM.CMSIS.6.0.0.pack... +... +... +(1/2) Building context: "Hello.Debug+AVH" +Building CMake target 'Hello.Debug+AVH' +[1/31] Building C object CMakeFiles/Group_Main.dir/home/ubuntu/csolution-examples/Hello/main.o +... +[31/31] Linking C executable /home/ubuntu/csolution-examples/Hello/out/Hello/AVH/Debug/Hello.axf +Program Size: Code=29968 RO-data=1584 RW-data=244 ZI-data=37072 ++------------------------------------------ +(2/2) Building context: "Hello.Release+AVH" +Building CMake target 'Hello.Release+AVH' +[1/31] Building C object CMakeFiles/Group_App.dir/home/ubuntu/csolution-examples/Hello/hello.o ... -[27/27] Linking C executable /home/ubuntu/csolution-examples/Hello/out/AVH/Hello.axf -info cbuild: build finished successfully! +[31/31] Linking C executable /home/ubuntu/csolution-examples/Hello/out/Hello/AVH/Release/Hello.axf +Program Size: Code=17664 RO-data=988 RW-data=196 ZI-data=37112 ++------------------------------------------------------------ +Build summary: 2 succeeded, 0 failed - Time Elapsed: 00:00:03 ++============================================================ ``` diff --git a/content/install-guides/gcc/arm-gnu.md b/content/install-guides/gcc/arm-gnu.md index fb5ffdcfc..cafebc2d0 100644 --- a/content/install-guides/gcc/arm-gnu.md +++ b/content/install-guides/gcc/arm-gnu.md @@ -72,9 +72,9 @@ export PATH=/path/to/install/dir/bin:$PATH Here is a specific example for an Arm Linux host and the AArch32 bare-metal target. ```bash { target="ubuntu:latest" } -wget https://developer.arm.com/-/media/Files/downloads/gnu/12.3.rel1/binrel/arm-gnu-toolchain-12.3.rel1-aarch64-arm-none-eabi.tar.xz -tar xJf arm-gnu-toolchain-12.3.rel1-aarch64-arm-none-eabi.tar.xz -C $HOME -echo 'export PATH="$PATH:$HOME/arm-gnu-toolchain-12.3.rel1-aarch64-arm-none-eabi/bin"' >> ~/.bashrc +wget https://developer.arm.com/-/media/Files/downloads/gnu/13.3.rel1/binrel/arm-gnu-toolchain-13.3.rel1-aarch64-arm-none-eabi.tar.xz +tar xJf arm-gnu-toolchain-13.3.rel1-aarch64-arm-none-eabi.tar.xz -C $HOME +echo 'export PATH="$PATH:$HOME/arm-gnu-toolchain-13.3.rel1-aarch64-arm-none-eabi/bin"' >> ~/.bashrc source ~/.bashrc ``` @@ -98,7 +98,7 @@ Use a text editor to add the `bin` directory as a new line in `/etc/paths`. ```console sudo nano /etc/paths ``` -For example the path could be: `/Applications/ArmGNUToolchain/12.3.rel1/arm-none-eabi/bin` +For example the path could be: `/Applications/ArmGNUToolchain/13.3.rel1/arm-none-eabi/bin` The `/etc/paths` file is a list of paths to search. @@ -109,15 +109,15 @@ The `/etc/paths` file is a list of paths to search. /bin /usr/sbin /sbin -/Applications/ArmGNUToolchain/12.3.rel1/arm-none-eabi/bin +/Applications/ArmGNUToolchain/13.3.rel1/arm-none-eabi/bin ``` ### Apple Silicon Here is a specific example for macOS with Apple Silicon and the AArch32 bare-metal target. ```console -wget https://developer.arm.com/-/media/Files/downloads/gnu/12.3.rel1/binrel/arm-gnu-toolchain-12.3.rel1-darwin-arm64-arm-none-eabi.pkg -sudo installer -pkg arm-gnu-toolchain-12.3.rel1-darwin-arm64-arm-none-eabi.pkg -target / -echo '/Applications/ArmGNUToolchain/12.3.rel1/arm-none-eabi/bin' | sudo tee -a /etc/paths +wget https://developer.arm.com/-/media/Files/downloads/gnu/13.3.rel1/binrel/arm-gnu-toolchain-13.3.rel1-darwin-arm64-arm-none-eabi.pkg +sudo installer -pkg arm-gnu-toolchain-13.3.rel1-darwin-arm64-arm-none-eabi.pkg -target / +echo '/Applications/ArmGNUToolchain/13.3.rel1/arm-none-eabi/bin' | sudo tee -a /etc/paths ``` ## Installing on Windows @@ -150,5 +150,5 @@ arm-none-eabi-gcc -v Additional examples are included in the toolchain installation at: ```console -${install_dir}/_version_/share/gcc-arm-none-eabi/samples +${install_dir}/share/gcc-arm-none-eabi/samples ``` diff --git a/content/install-guides/gcc/cross.md b/content/install-guides/gcc/cross.md index 09fc07f59..f34269894 100644 --- a/content/install-guides/gcc/cross.md +++ b/content/install-guides/gcc/cross.md @@ -52,29 +52,31 @@ sudo apt install gcc-arm-linux-gnueabihf -y sudo apt install gcc-aarch64-linux-gnu -y ``` -### Installing on Red Hat / Fedora / Amazon Linux +### Installing on Fedora -These Linux distributions use `yum` as the package manager. +Fedora uses the `dnf` package manager. -To install the most common development tools use the commands below. If the machine has `sudo` you can use it or run `yum` as _root_. +To install the most common development tools use the commands below. -```bash { target="fedora:latest" } -sudo yum update -y -sudo yum install arm-none-eabi-gcc-cs -y -sudo yum install arm-none-eabi-newlib -y -sudo yum install gcc-aarch64-linux-gnu -y -sudo yum install gcc-arm-linux-gnu -y -``` +- If the machine has `sudo` you can use it: -If `sudo` is not available become _root_ and omit the `sudo`. + ```bash { target="fedora:latest" } + sudo dnf update -y + sudo dnf install arm-none-eabi-gcc-cs -y + sudo dnf install arm-none-eabi-newlib -y + sudo dnf install gcc-aarch64-linux-gnu -y + sudo dnf install gcc-arm-linux-gnu -y + ``` -```console -yum update -yum install arm-none-eabi-gcc-cs -y -yum install arm-none-eabi-newlib -y -yum install gcc-aarch64-linux-gnu -y -yum install gcc-arm-linux-gnu -y -``` +- If `sudo` is not available become _root_ and omit the `sudo` from the above commands: + + ```console + dnf update -y + dnf install arm-none-eabi-gcc-cs -y + dnf install arm-none-eabi-newlib -y + dnf install gcc-aarch64-linux-gnu -y + dnf install gcc-arm-linux-gnu -y + ``` ## Setting up product license {#license} diff --git a/content/install-guides/gcc/native.md b/content/install-guides/gcc/native.md index b6f28520b..d8aa825d9 100644 --- a/content/install-guides/gcc/native.md +++ b/content/install-guides/gcc/native.md @@ -54,7 +54,7 @@ sudo apt update sudo apt install gcc g++ -y ``` -Another meta-package on Ubuntu is ``build-essential``. This will install the most common tools libraries with a single command. +Another meta-package on Ubuntu is ``build-essential``. This will install the most common tools and libraries with a single command. ```bash { target="ubuntu:latest" } sudo apt install build-essential -y @@ -62,18 +62,18 @@ sudo apt install build-essential -y ### Installing on Red Hat / Fedora / Amazon Linux -These Linux distributions use `yum` as the package manager. +These Linux distributions use `dnf` as the package manager. To install the most common development tools use the commands below. If the machine has `sudo` you can use it. ```bash { target="fedora:latest" } -sudo yum update -y -sudo yum groupinstall 'Development Tools' -y +sudo dnf update -y +sudo dnf groupinstall 'Development Tools' -y ``` If `sudo` is not available become _root_ and omit the `sudo`. ```console -yum update -yum groupinstall 'Development Tools' -y +dnf update -y +dnf groupinstall 'Development Tools' -y ``` ## Setting up product license diff --git a/content/install-guides/gcloud.md b/content/install-guides/gcloud.md index 39b56ddec..5e93110f0 100644 --- a/content/install-guides/gcloud.md +++ b/content/install-guides/gcloud.md @@ -109,4 +109,4 @@ Credentials saved to file: [/home/ubuntu/.config/gcloud/application_default_cred These credentials will be used by any library that requests Application Default Credentials (ADC). ``` -After a successful log in, you will be able to use the `Google Cloud CLI` and automation tools like [Terraform](../terraform) from the terminal. +After a successful log in, you will be able to use the `Google Cloud CLI` and automation tools like [Terraform](/install-guides/terraform/) from the terminal. diff --git a/content/install-guides/ipexplorer.md b/content/install-guides/ipexplorer.md index 94c21b32d..f760bbf8a 100644 --- a/content/install-guides/ipexplorer.md +++ b/content/install-guides/ipexplorer.md @@ -72,7 +72,7 @@ A `SoC Concept` is the first step towards the architectural design of your devic You can select any of the Arm IPs that you wish to use, including those configured previously, and define how they can be connected. -![SoC Concept #center](../_images/soc_concept.png "SoC Concept") +![SoC Concept #center](/install-guides/_images/soc_concept.png "SoC Concept") You can invite other users to help review your design. These could be others from your organization, contacts within Arm that you are engaged with, or from a different organization that you are working with on the project. diff --git a/content/install-guides/java.md b/content/install-guides/java.md new file mode 100644 index 000000000..343a870d3 --- /dev/null +++ b/content/install-guides/java.md @@ -0,0 +1,327 @@ +--- +title: Java +author_primary: Jason Andrews +minutes_to_complete: 15 +official_docs: https://docs.oracle.com/en/java/ + +additional_search_terms: +- linux +- cloud + +multi_install: false +multitool_install_part: false + +test_images: +- ubuntu:latest +test_maintenance: false + +tool_install: true +weight: 1 +layout: installtoolsall +--- + +Java is a high-level, object-oriented programming language first released by Sun Microsystems in 1995. + +It is designed to have as few implementation dependencies as possible, making it a versatile and widely-used language. + +## Is Java available for Arm Linux? + +Yes, there are numerous ways to install Java on Arm Linux distributions. + +Below are some of the common methods to install Java. This includes both the Java runtime environment (JRE), which is used to run Java applications and the Java development kit (JDK) which is used to create Java applications. + +Pick the one that works best for you. + +## Install Java using the Linux package manager + +For distributions using `apt` - including Debian and Ubuntu: + +```console +sudo apt update +sudo apt install default-jre -y +sudo apt install default-jdk -y +``` + +For distributions using `dnf` - including Fedora and Red Hat: + +```console +sudo dnf install java-latest-openjdk +``` + +For distributions using `pacman` - including Arch and Manjaro: + +```console +sudo pacman -S jdk-openjdk +sudo pacman -S jre-openjdk +``` + +## Install Java using Amazon Corretto + +Amazon Corretto is a no-cost distribution of the Open Java Development Kit (OpenJDK). It is maintained and supported by Amazon Web Services (AWS). + +You can install Corretto using `apt` with the commands: + +```console +wget -O - https://apt.corretto.aws/corretto.key | sudo gpg --dearmor -o /usr/share/keyrings/corretto-keyring.gpg && \ +echo "deb [signed-by=/usr/share/keyrings/corretto-keyring.gpg] https://apt.corretto.aws stable main" | sudo tee /etc/apt/sources.list.d/corretto.list +sudo apt-get update; sudo apt-get install -y java-21-amazon-corretto-jdk +``` + +More installation options for Corretto are available in the [Amazon Corretto 21 Guide for Linux](https://docs.aws.amazon.com/corretto/latest/corretto-21-ug/linux-info.html) + +## Install Java using Snap + +For Linux distributions with `snap` you can install Java using: + +```console +sudo snap install openjdk +``` + +## Is there a way to install Java from the official website? + +You can download Java from the [Oracle website](https://www.oracle.com/java/technologies/javase-downloads.html) and install it manually. Look for the files with ARM64 in the description. + +Download a [tar.gz](https://download.oracle.com/java/22/latest/jdk-22_linux-aarch64_bin.tar.gz) file from the website. + +Extract the contents of the file: + +```console +tar xvf jdk-22_linux-aarch64_bin.tar.gz +``` + +Move the contents to a directory of your choice: + +```console +sudo mv jdk-22.0.2 /usr/local/ +``` + +Set up environment variables to locate your installation: + +```console +export JAVA_HOME=/usr/local/jdk-22.0.2 +export PATH=$JAVA_HOME/bin:$PATH +``` + +Add the environment variables to your `~/.bashrc` file to set them permanently. + +## Can I change the default Java version if multiple versions are installed? + +Yes, you can change the default version. For systems with `apt` use: + +```console +sudo update-alternatives --config java +``` + +You will be given the option to select a new version. The options are depend on the software currently installed on your computer. + +```output +There are 3 choices for the alternative java (providing /usr/bin/java). + + Selection Path Priority Status +------------------------------------------------------------ +* 0 /usr/lib/jvm/java-21-amazon-corretto/bin/java 12100004 auto mode + 1 /usr/lib/jvm/java-17-openjdk-arm64/bin/java 1711 manual mode + 2 /usr/lib/jvm/java-21-amazon-corretto/bin/java 12100004 manual mode + 3 /usr/lib/jvm/java-21-openjdk-arm64/bin/java 2111 manual mode + +Press to keep the current choice[*], or type selection number: +``` + +For this case, if you select option 1, Java 17 becomes the default. + +## How do I print the Java version? + +Print the version of the Java runtime: + +```console +java -version +``` + +The output will be similar to: + +```output +openjdk version "21.0.4" 2024-07-16 +OpenJDK Runtime Environment (build 21.0.4+7-Ubuntu-1ubuntu224.04) +OpenJDK 64-Bit Server VM (build 21.0.4+7-Ubuntu-1ubuntu224.04, mixed mode, sharing) +``` + +Print the version of the Java compiler: + +```console +javac -version +``` + +The output will be similar to: + +```output +javac 21.0.4 +``` + +## Which version of Java should I use for Arm Linux systems? + +It’s important to ensure that your version of Java is at least 11.0.9. There are large performance improvements starting from version 11.0.9. Since then, Java performance has steadily increased over time and newer versions will provide better performance. + +## Which flags are available for tuning the JVM? + +The Java virtual machine (JVM) includes a number of flags which are available to tune performance and aid in debugging. Some of the flags are general purpose and some are Arm architecture specific. + +To print the final values of the flags after the JVM has been initialized run: + +```console +java -XX:+PrintFlagsFinal -version +``` + +## Are there other tools commonly used in Java projects? + +There are a number of Java related tools you may want to install. + +### Apache Maven + +Apache Maven is a powerful build automation tool primarily used for Java projects. + +It simplifies the build process by providing a uniform build system, dependency management, and project management capabilities. + +You can install it from the `apt` package manager: + +```console +sudo apt-get install -y maven +``` + +Print the version: + +```console +mvn -v +``` + +The output is similar to: + +```output +Apache Maven 3.8.7 +Maven home: /usr/share/maven +Java version: 22.0.2, vendor: Oracle Corporation, runtime: /usr/local/jdk-22.0.2 +Default locale: en, platform encoding: UTF-8 +OS name: "linux", version: "6.8.0-41-generic", arch: "aarch64", family: "unix" +``` + +### Gradle + +Gradle is another build automation tool that is widely used for Java projects. + +It is designed to be highly customizable and flexible, making it suitable for a wide range of projects. + +You can install it from the `apt` package manager: + +```console +sudo apt install gradle -y +``` + +You can also install specific versions by downloading and extracting a zip file: + +```console +wget https://services.gradle.org/distributions/gradle-8.10-bin.zip -O gradle-8.10-bin.zip +unzip gradle-8.10-bin.zip +sudo mv gradle-8.10 /opt/gradle +sudo ln -s /opt/gradle/bin/gradle /usr/local/bin/gradle +``` + +Print the version: + +```console +gradle -v +``` + +The output is similar to: + +```output +Welcome to Gradle 8.10! + +Here are the highlights of this release: + - Support for Java 23 + - Faster configuration cache + - Better configuration cache reports + +For more details see https://docs.gradle.org/8.10/release-notes.html + + +------------------------------------------------------------ +Gradle 8.10 +------------------------------------------------------------ + +Build time: 2024-08-14 11:07:45 UTC +Revision: fef2edbed8af1022cefaf44d4c0514c5f89d7b78 + +Kotlin: 1.9.24 +Groovy: 3.0.22 +Ant: Apache Ant(TM) version 1.10.14 compiled on August 16 2023 +Launcher JVM: 22.0.2 (Oracle Corporation 22.0.2+9-70) +Daemon JVM: /usr/local/jdk-22.0.2 (no JDK specified, using current Java home) +OS: Linux 6.8.0-41-generic aarch64 +``` + +### Apache Ant + +Apache Ant is a Java-based build tool used to automate the build process for Java projects. It is similar to Make but is designed specifically for Java projects. + +Ant uses XML to describe the build process and dependencies. + +You can install it from the `apt` package manager: + +```console +sudo apt install ant -y +``` + +You can also install specific versions by downloading and extracting a zip file: + +```console +wget https://downloads.apache.org/ant/binaries/apache-ant-1.10.13-bin.zip -O apache-ant-1.10.13-bin.zip +unzip apache-ant-1.10.13-bin.zip +sudo mv apache-ant-1.10.13 /opt/ant +sudo ln -s /opt/ant/bin/ant /usr/local/bin/ant +``` + +Print the version: + +```console +ant -version +``` + +The output is similar to: + +```output +Apache Ant(TM) version 1.10.13 compiled on January 4 2023 +``` + +### Apache JMeter + +JMeter is an open-source tool designed for performance and load testing Java applications. + +You can install it using: + +```console +wget https://downloads.apache.org/jmeter/binaries/apache-jmeter-5.6.3.tgz +tar xzf apache-jmeter-5.6.3.tgz +sudo mv apache-jmeter-5.6.3 /opt/jmeter +sudo ln -s /opt/jmeter/bin/jmeter /usr/local/bin/jmeter +``` + +Print the version: + +```console +jmeter --version +``` + +The output is similar to: + +```output +Aug 27, 2024 9:01:58 PM java.util.prefs.FileSystemPreferences$1 run +INFO: Created user preferences directory. + _ ____ _ ____ _ _ _____ _ __ __ _____ _____ _____ ____ + / \ | _ \ / \ / ___| | | | ____| | | \/ | ____|_ _| ____| _ \ + / _ \ | |_) / _ \| | | |_| | _| _ | | |\/| | _| | | | _| | |_) | + / ___ \| __/ ___ \ |___| _ | |___ | |_| | | | | |___ | | | |___| _ < +/_/ \_\_| /_/ \_\____|_| |_|_____| \___/|_| |_|_____| |_| |_____|_| \_\ 5.6.3 + +Copyright (c) 1999-2024 The Apache Software Foundation +``` + +You are ready to use Java on your Arm Linux system. \ No newline at end of file diff --git a/content/install-guides/keilstudio_vs.md b/content/install-guides/keilstudio_vs.md index 0c471de45..5b80a50ea 100644 --- a/content/install-guides/keilstudio_vs.md +++ b/content/install-guides/keilstudio_vs.md @@ -33,7 +33,7 @@ layout: installtoolsall # DO NOT MODIFY. Always true for tool install ar --- [Arm Keil Studio](https://keil.arm.com/) is the next generation software development environment for Arm Cortex-M based microcontroller devices. The desktop version is available as a set of [Visual Studio Code](https://code.visualstudio.com/) extensions. -Alternatively, [Keil Studio Cloud](/install-guides/keilstudiocloud/) provides the same functionality, but runs in a browser and requires no installation. +Alternatively, [Keil Studio Cloud](/install-guides/keilstudiocloud/) provides similar functionality, but runs in a browser and requires no installation. ## Before you begin @@ -53,7 +53,7 @@ Install the Keil Studio extensions: Visual Studio Code installs the extensions. The extensions are now available in the `Activity Bar`. -You will be prompted to enable an [MDK Community License](https://www.keil.arm.com/community/) for non-commercial use. Accept this option if you do not have a license and agree to non-commercial use. +You will be prompted to enable an [MDK Community License](https://www.keil.arm.com/mdk-community/) for non-commercial use. Accept this option if you do not have a license and agree to non-commercial use. If you have a commercial license for `Keil MDK` installed, decline this option. diff --git a/content/install-guides/license/_index.md b/content/install-guides/license/_index.md index e9710cc0c..3aeaf7ebd 100644 --- a/content/install-guides/license/_index.md +++ b/content/install-guides/license/_index.md @@ -16,7 +16,7 @@ multitool_install_part: false # Set to true if a sub-page of a multi-page arti layout: installtoolsall # DO NOT MODIFY. Always true for tool install articles --- -Most Arm commercial tools are license managed. Arm is migrating to user-based licensing (UBL) which greatly simplifies license configuration. It is available for [Arm Success Kits](../successkits/) as well as [Arm Development Studio](../armds). +Most Arm commercial tools are license managed. Arm is migrating to user-based licensing (UBL) which greatly simplifies license configuration. It is available for [Arm Success Kits](/install-guides/successkits/) as well as [Arm Development Studio](/install-guides/armds). Success kits are available as `Hardware Success Kits` (`HSK`) or `Software Success Kits` (`SSK`). See the table below for tooling provided. SSK is a subset of HSK. diff --git a/content/install-guides/license/cloud.md b/content/install-guides/license/cloud.md index ba91851a3..491f259b2 100644 --- a/content/install-guides/license/cloud.md +++ b/content/install-guides/license/cloud.md @@ -3,7 +3,7 @@ title: UBL Cloud server setup minutes_to_complete: 15 official_docs: https://developer.arm.com/documentation/107573 author_primary: Ronan Synnott -weight: 4 +weight: 4 ### FIXED, DO NOT MODIFY tool_install: false # Set to true to be listed in main selection page, else false @@ -38,7 +38,7 @@ armlm activate --code xxxxxxxx-xxxx-xxxx-xxxxxxxx The license can also be activated in the various Arm tool IDEs. -For example [Arm Development Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Development%20Studio)), via `Help` > `Arm License Manager` > `Manage Arm User-Based Licenses`. +For example [Arm Development Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Development%20Studio), via `Help` > `Arm License Manager` > `Manage Arm User-Based Licenses`. Select `Activate with` > `Activation Code`, and enter your product activation code. Click `Activate`. diff --git a/content/install-guides/license/flexnet.md b/content/install-guides/license/flexnet.md index b8eab28cb..c6c88ed63 100644 --- a/content/install-guides/license/flexnet.md +++ b/content/install-guides/license/flexnet.md @@ -3,7 +3,7 @@ title: FlexNet Publisher Floating license setup minutes_to_complete: 15 official_docs: https://developer.arm.com/documentation/dui0209 author_primary: Ronan Synnott -weight: 5 +weight: 5 ### FIXED, DO NOT MODIFY tool_install: false # Set to true to be listed in main selection page, else false @@ -57,7 +57,7 @@ export ARMLMD_LICENSE_FILE=port@server The license can also be activated in the various Arm tool IDEs. -For example [Arm Development Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Development%20Studio)), via `Help` > `Arm License Manager`. +For example [Arm Development Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Development%20Studio), via `Help` > `Arm License Manager`. If `ARMLMD_LICENSE_FILE` is not set, use `Add` > `Add product license`, and specify `port` and `server` information for your license server. diff --git a/content/install-guides/license/ubl_license_admin.md b/content/install-guides/license/ubl_license_admin.md index b6e0c8ad2..b9bf69d1b 100644 --- a/content/install-guides/license/ubl_license_admin.md +++ b/content/install-guides/license/ubl_license_admin.md @@ -130,7 +130,7 @@ You will see the following output when successful. ```output Licenses have been successfully updated. No confirmation is required. ``` -The licenses are now ready to use by the [end-users](../ubl_license_enduser). +The licenses are now ready to use by the [end-users](/install-guides/license/ubl_license_enduser/). ## Changing installed licenses per server diff --git a/content/install-guides/license/ubl_license_enduser.md b/content/install-guides/license/ubl_license_enduser.md index a6faca569..3c9e7f6a7 100644 --- a/content/install-guides/license/ubl_license_enduser.md +++ b/content/install-guides/license/ubl_license_enduser.md @@ -3,7 +3,7 @@ title: UBL LLS End-user setup minutes_to_complete: 15 official_docs: https://developer.arm.com/documentation/102516 author_primary: Ronan Synnott -weight: 3 +weight: 3 ### FIXED, DO NOT MODIFY tool_install: false # Set to true to be listed in main selection page, else false @@ -13,7 +13,7 @@ layout: installtoolsall # DO NOT MODIFY. Always true for tool install ar --- ## Local License Server -A [Local License Server (LLS)](../ubl_license_admin) must first be set up by your license administration team. +A [Local License Server (LLS)](/install-guides/license/ubl_license_admin/) must first be set up by your license administration team. {{% notice Notice%}} A Software Success Kit is a subset of a Hardware Success Kit. @@ -52,7 +52,7 @@ You can now [confirm your license has been checked out](#confirm). The license can also be activated in the various Arm tool IDEs. -For example [Arm Development Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Development%20Studio)), via `Help` > `Arm License Manager` > `Manage Arm User-Based Licenses`. +For example [Arm Development Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Development%20Studio), via `Help` > `Arm License Manager` > `Manage Arm User-Based Licenses`. Select `Activate with` > `License Server`, and enter the appropriate license server address. Click `Query` to see what license types are available, and select the appropriate one from the pull down. Click `Activate`. diff --git a/content/install-guides/llvm-embedded.md b/content/install-guides/llvm-embedded.md index 14af758c1..9279c839f 100644 --- a/content/install-guides/llvm-embedded.md +++ b/content/install-guides/llvm-embedded.md @@ -36,7 +36,7 @@ The [LLVM Embedded Toolchain for Arm](https://github.com/ARM-software/LLVM-embed Copy and paste the URL below into your browser to download the latest release from GitHub: ```url -https://github.com/ARM-software/LLVM-embedded-toolchain-for-Arm/releases/download/release-16.0.0/LLVMEmbeddedToolchainForArm-16.0.0-Windows-x86_64.zip +https://github.com/ARM-software/LLVM-embedded-toolchain-for-Arm/releases/download/release-18.1.3/LLVM-ET-Arm-18.1.3-Windows-x86_64.zip ``` Unzip the download to a location of your choice on your host machine. @@ -50,25 +50,21 @@ Open a `Command Prompt` and [test your installation](#test). Copy and paste the URL below into your browser to download the latest release from GitHub: ```url -https://github.com/ARM-software/LLVM-embedded-toolchain-for-Arm/releases/download/release-16.0.0/LLVMEmbeddedToolchainForArm-16.0.0-Darwin.tar.gz +https://github.com/ARM-software/LLVM-embedded-toolchain-for-Arm/releases/download/release-18.1.3/LLVM-ET-Arm-18.1.3-Darwin-universal.dmg ``` -Open a terminal application and use `tar` to extract the file: - -```command -tar -xf ~/Downloads/LLVMEmbeddedToolchainForArm-16.0.0-Darwin.tar.gz -C $HOME -``` +Install the toolchain by clicking on the dmg file and following the instructions. Add the LLVM `bin` directory to your `PATH`: ```command -export PATH=$HOME/LLVMEmbeddedToolchainForArm-16.0.0-Darwin/bin:$PATH +export PATH=/Applications/LLVM-ET-Arm-18.1.3-Darwin-universal/bin:$PATH ``` The toolchain binaries may be quarantined. Navigate to the `bin` directory and use the `xattr` command to remove the quarantine: ``` command -cd $HOME/LLVMEmbeddedToolchainForArm-16.0.0-Darwin/bin +cd /Applications/LLVM-ET-Arm-18.1.3-Darwin-universal/bin find . -type f -perm +0111 | xargs xattr -d com.apple.quarantine ``` @@ -81,25 +77,19 @@ The information below assumes `Ubuntu Linux` on an `AArch64` host. Modify the fi Download the latest release using `wget`: ```command -wget https://github.com/ARM-software/LLVM-embedded-toolchain-for-Arm/releases/download/release-16.0.0/LLVMEmbeddedToolchainForArm-16.0.0-Linux-AArch64.tar.gz +wget https://github.com/ARM-software/LLVM-embedded-toolchain-for-Arm/releases/download/release-18.1.3/LLVM-ET-Arm-18.1.3-Linux-AArch64.tar.xz ``` Open a terminal application and use `tar` to extract the file: ```command -tar -xf LLVMEmbeddedToolchainForArm-16.0.0-Linux-AArch64.tar.gz -C $HOME +tar xfJ LLVM-ET-Arm-18.1.3-Linux-AArch64.tar.xz -C $HOME ``` Add the LLVM `bin` directory to your `PATH`: ```command -export PATH=$HOME/LLVMEmbeddedToolchainForArm-16.0.0-Linux-AArch64/bin:$PATH -``` - -Install the required library `libtinfo5`: - -``` command -sudo apt install -y libtinfo5 +export PATH=$HOME/LLVM-ET-Arm-18.1.3-Linux-AArch64/bin:$PATH ``` You can now [test your installation](#test). @@ -117,10 +107,10 @@ clang --version You should observe output similar to: ```output -clang version 16.0.0 +clang version 18.1.3 Target: aarch64-unknown-linux-gnu Thread model: posix -InstalledDir: /home/ubuntu/LLVMEmbeddedToolchainForArm-16.0.0-Linux-AArch64/bin +InstalledDir: /home/ubuntu/LLVM-ET-Arm-18.1.3-Linux-AArch64/bin ``` ### Build a simple application diff --git a/content/install-guides/mdk.md b/content/install-guides/mdk.md index e874f01cd..ae03119eb 100644 --- a/content/install-guides/mdk.md +++ b/content/install-guides/mdk.md @@ -1,7 +1,7 @@ --- ### Title the install tools article with the name of the tool to be installed ### Include vendor name where appropriate -title: Arm Keil MDK +title: Arm Keil μVision ### Optional additional search terms (one per line) to assist in finding the article additional_search_terms: @@ -46,7 +46,7 @@ Follow the installation instructions provided in the [µVision User's Guide](htt Arm Keil MDK is license managed. Follow the [license setup instructions](https://developer.arm.com/documentation/101454/latest/License-Management). -The MDK-Community license is free for non-commercial use. Visit [keil.arm.com](https://keil.arm.com/mdk-community) to cut your personal license (requires Arm login). +The MDK-Community license is free for non-commercial use. Visit [Arm Keil MDK-Community Edition](https://keil.arm.com/mdk-community) for set up instructions. A free 30 day evaluation license for MDK-Professional is also available by completing the [request form](https://www.keil.com/MDKEvaluationRequest/). diff --git a/content/install-guides/oci-cli.md b/content/install-guides/oci-cli.md index b2a992263..984c64407 100644 --- a/content/install-guides/oci-cli.md +++ b/content/install-guides/oci-cli.md @@ -94,4 +94,4 @@ To locate your API KEYS open your profile and click API KEYS: ![oci2 #center](https://github.com/ArmDeveloperEcosystem/arm-learning-paths/assets/40816837/7844c9fa-7307-450e-82f4-90116fab6ece "Click add API key, from there generate your API key pair") -After a successful log in, you can use the OCI CLI and automation tools like [Terraform](../terraform) from the terminal. +After a successful log in, you can use the OCI CLI and automation tools like [Terraform](/install-guides/terraform/) from the terminal. diff --git a/content/install-guides/py-woa.md b/content/install-guides/py-woa.md index 4bd8c9c67..dddd5fd5c 100644 --- a/content/install-guides/py-woa.md +++ b/content/install-guides/py-woa.md @@ -29,9 +29,9 @@ layout: installtoolsall # DO NOT MODIFY. Always true for tool install ar Python has native support for [Windows on Arm](https://learn.microsoft.com/en-us/windows/arm/overview). Starting with version 3.11, an official installer is available. The latest version at time of writing is 3.12.0. -A number of developer ready Windows on Arm [devices](../../learning-paths/laptops-and-desktops/intro/find-hardware/) are available. +A number of developer ready Windows on Arm [devices](/learning-paths/laptops-and-desktops/intro/find-hardware/) are available. -Windows on Arm instances are available with Microsoft Azure. For more information, see [Deploy a Windows on Arm virtual machine on Microsoft Azure](../../learning-paths/cross-platform/woa_azure/). +Windows on Arm instances are available with Microsoft Azure. For more information, see [Deploy a Windows on Arm virtual machine on Microsoft Azure](/learning-paths/cross-platform/woa_azure/). ## Download and install diff --git a/content/install-guides/rust.md b/content/install-guides/rust.md index 791c0b2af..9f1d846f4 100644 --- a/content/install-guides/rust.md +++ b/content/install-guides/rust.md @@ -23,7 +23,7 @@ layout: installtoolsall # DO NOT MODIFY. Always true for tool install ar This install guide is for Linux application developers wishing to use Rust. -If you wish to use Rust to build embedded applications for Arm, refer to [Rust for Embedded Applications](../rust_embedded) instead. +If you wish to use Rust to build embedded applications for Arm, refer to [Rust for Embedded Applications](/install-guides/rust_embedded/) instead. ## Before you begin diff --git a/content/install-guides/rust_embedded.md b/content/install-guides/rust_embedded.md index d7a276d57..b36c43bb9 100644 --- a/content/install-guides/rust_embedded.md +++ b/content/install-guides/rust_embedded.md @@ -19,7 +19,7 @@ layout: installtoolsall # DO NOT MODIFY. Always true for tool install ar This install guide is for developers using Rust for their embedded applications. -If you are using Rust to build Linux applications on an Arm Linux platform, refer to [Rust for Linux Applications](../rust) instead. +If you are using Rust to build Linux applications on an Arm Linux platform, refer to [Rust for Linux Applications](/install-guides/rust/) instead. This install guide describes a setup using an Ubuntu Linux host. diff --git a/content/install-guides/socrates.md b/content/install-guides/socrates.md index fb00fea12..710dc1997 100644 --- a/content/install-guides/socrates.md +++ b/content/install-guides/socrates.md @@ -39,7 +39,7 @@ It is available to download via the [Arm Product Download Hub](https://developer You can download Socrates as an individual standalone component, or you can download the complete success kits. -For more information on the Download Hub, refer to the [Arm Product Download Hub install guide](../pdh). +For more information on the Download Hub, refer to the [Arm Product Download Hub install guide](/install-guides/pdh/). ## Installation @@ -63,7 +63,7 @@ See also the output of: ## Set up the product license -Arm Socrates is license managed. License setup instructions are available in the [Arm License install guide](../license/). +Arm Socrates is license managed. License setup instructions are available in the [Arm License install guide](/install-guides/license/). Configuration of some Arm IP products require a corresponding license for that IP. diff --git a/content/install-guides/streamline.md b/content/install-guides/streamline.md index 83627fbd3..af5c0f9ad 100644 --- a/content/install-guides/streamline.md +++ b/content/install-guides/streamline.md @@ -62,7 +62,7 @@ Arm Development Studio supports Windows and Linux hosts. Full install instructions are given in section 3 of the Performance Studio [Release Notes](https://developer.arm.com/documentation/107649). -See also the Arm Performance Studio [install guide](../ams/). +See also the Arm Performance Studio [install guide](/install-guides/ams/). If working with an Android target, you must also install Android Debug Bridge (`adb`) available with [Android SDK platform tools](https://developer.android.com/studio/releases/platform-tools). @@ -72,11 +72,11 @@ Add the Android SDK platform tools directory to your `PATH` environment variable Install Arm Development Studio using the instructions in the [Arm Development Studio Getting Started Guide](https://developer.arm.com/documentation/101469/latest/Installing-and-configuring-Arm-Development-Studio). -See also the Arm Development Studio [install guide](../armds/). +See also the Arm Development Studio [install guide](/install-guides/armds/). ## Setting up product license -Arm Development Studio is license managed. License setup instructions are available in the Arm Software Licensing [install guide](../license/). +Arm Development Studio is license managed. License setup instructions are available in the Arm Software Licensing [install guide](/install-guides/license/). Arm Performance Studio is free of charge and is not license managed. @@ -96,4 +96,4 @@ Depending on your type of application, choose the appropriate guide below to get For Android users, a thorough [tutorial](https://developer.arm.com/documentation/102477) is also available. -See also the [Get started with Arm Performance Studio](../../learning-paths/smartphones-and-mobile/ams/) learning path. +See also the [Get started with Arm Performance Studio](/learning-paths/smartphones-and-mobile/ams/) learning path. diff --git a/content/install-guides/successkits.md b/content/install-guides/successkits.md index 3a11c5d24..e2d6976f6 100644 --- a/content/install-guides/successkits.md +++ b/content/install-guides/successkits.md @@ -43,7 +43,7 @@ Arm Success Kits are a component of [Arm Flexible Access](https://www.arm.com/en All downloads are provided via the [Arm Product Download Hub](https://developer.arm.com/downloads). -For more information on the Download Hub, refer to the [Arm Product Download Hub install guide](../pdh). +For more information on the Download Hub, refer to the [Arm Product Download Hub install guide](/install-guides/pdh). You can download individual components, or the complete Success Kits. @@ -51,15 +51,15 @@ Bundles are provided for Windows, Linux, or Mac OS. Not all components are suppo ## Component installation and setup -[User license setup](../license/) +[User license setup](/install-guides/license/) -[Install Arm Development Studio](../armds/) +[Install Arm Development Studio](/install-guides/armds/) -[Install Arm Compiler for Embedded](../armclang/) +[Install Arm Compiler for Embedded](/install-guides/armclang/) -[Install Arm Fast Models](../fm_fvp/) +[Install Arm Fast Models](/install-guides/fm_fvp/) -[Install Arm Socrates](../socrates/) +[Install Arm Socrates](/install-guides/socrates/) -[Install Arm AMBA Viz](../ambaviz/) +[Install Arm AMBA Viz](/install-guides/ambaviz/) diff --git a/content/install-guides/topdown-tool.md b/content/install-guides/topdown-tool.md index d91304f53..0358941a9 100644 --- a/content/install-guides/topdown-tool.md +++ b/content/install-guides/topdown-tool.md @@ -29,11 +29,11 @@ layout: installtoolsall # DO NOT MODIFY. Always true for tool install ar The Arm Telemetry Solution provides tools and data for performance analysis. -The Arm Topdown Methodology specifies a set of metrics and steps to measure them using the Telemetry Solution. +The Arm Topdown Methodology specifies a set of metrics and steps to measure them using the Telemetry Solution. -The Telemetry Solution requires Linux Perf to collect metrics. +The Telemetry Solution requires Linux Perf to collect metrics. -The Telemetry Solution also includes data for defining PMU events, a test suite to stress CPU resources, and a tool to parse Statistical Profiling Extension (SPE) data for analysis. +The Telemetry Solution also includes data for defining PMU events, a test suite to stress CPU resources, and a tool to parse Statistical Profiling Extension (SPE) data for analysis. ## Before you begin @@ -57,15 +57,16 @@ If you see a different result, you are not using an Arm computer running 64-bit Install Perf using the [Perf for Linux on Arm install guide](/install-guides/perf). -3. Install Python 3 and pip +3. Install Python 3 and pip -Python 3.7 or later and pip are required. +Python 3.7 or later and pip are required. -Install these on your Linux distribution. +Install these on your Linux distribution. For Debian based distributions (including Ubuntu) run: ```bash { target="ubuntu:latest" } +sudo apt update sudo apt install python3-pip python-is-python3 -y ``` @@ -80,12 +81,22 @@ cd telemetry-solution/tools/topdown_tool 2. Install the `topdown-tool` executable: -Install `topdown-tool` in `/usr/local/bin` using: +Install `topdown-tool` in `/usr/local/bin` using: ```console -sudo pip3 install . +pip3 install -e . ``` +{{% notice Note %}} +If you are getting errors on the environment being externally managed, try creating a virtual environment. +``` +sudo apt install python3-venv +python3 -m venv topdown-venv +source topdown-venv/bin/activate +pip3 install -e . +``` +{{% /notice %}} + 3. Confirm you can run `top-down` using the `version` command: ```bash { target="ubuntu:latest" } @@ -151,7 +162,7 @@ output options: --debug enable debug output ``` -4. Test `topdown-tool` +4. Test `topdown-tool` {{% notice Note %}} You may need to enable access to the counters. More information about the options is in the [Linux Perf install guide](/install-guides/perf/). @@ -178,4 +189,14 @@ Frontend Stalled Cycles 57.67% cycles Backend Stalled Cycles. 21.06% cycles ``` +{{% notice Note %}} +If you encounter the error `Could not detect CPU. Specify via --cpu`, you can check what CPUs are available, and pass it to the command. + +```console +topdown-tool --list-cpus +topdown-tool --cpu -m Cycle_Accounting -a sleep 5 + +``` +{{% /notice %}} + Your output may be different, but if values are printed you are ready to apply the Arm Top Down methodology. diff --git a/content/install-guides/windows-sandbox-woa.md b/content/install-guides/windows-sandbox-woa.md index d8a72afcb..7c0416430 100644 --- a/content/install-guides/windows-sandbox-woa.md +++ b/content/install-guides/windows-sandbox-woa.md @@ -30,7 +30,7 @@ Windows Sandbox is a lightweight, desktop environment from Microsoft that enable You can install Windows Sandbox on an Arm device running Windows 11, version 22H2, and later. -A number of developer-ready [Windows on Arm devices](../../learning-paths/laptops-and-desktops/intro/find-hardware/) are available. +A number of developer-ready [Windows on Arm devices](/learning-paths/laptops-and-desktops/intro/find-hardware/) are available. ## Enable Virtualization diff --git a/content/learning-paths/cross-platform/_example-learning-path/questions.md b/content/learning-paths/cross-platform/_example-learning-path/questions.md index a6be93ec4..8d3618962 100644 --- a/content/learning-paths/cross-platform/_example-learning-path/questions.md +++ b/content/learning-paths/cross-platform/_example-learning-path/questions.md @@ -10,7 +10,7 @@ layout: "learningpathall" The search index is not automatically generated, but you can add it to enable the search box. -Refer to the information about the search box in the [Learning Path setup](../setup/#search) section. +Refer to the information about the search box in the [Learning Path setup](/learning-paths/cross-platform/_example-learning-path/setup/#search) section. ### Why are my Learning Path pages in the wrong order? diff --git a/content/learning-paths/cross-platform/_example-learning-path/write-2-metadata.md b/content/learning-paths/cross-platform/_example-learning-path/write-2-metadata.md index f24050e2a..c6b4f9cd7 100644 --- a/content/learning-paths/cross-platform/_example-learning-path/write-2-metadata.md +++ b/content/learning-paths/cross-platform/_example-learning-path/write-2-metadata.md @@ -34,11 +34,11 @@ The following metadata is defined in the `_index.md` file: Look at other Learning Paths for inspiration about how to write a good title, learning objectives, and prerequisites. {{% notice Note%}} -To specify a prerequisite Learning Path, do so with a relative path. For example: +To specify a prerequisite Learning Path, do so with an absolute path from the root of the website. For example: -- The Learning Path [Learn how to use Docker](../../docker) should be completed first +- The Learning Path [Learn how to use Docker](/learning-paths/cross-platform/docker/) should be completed first -Note the relative path of `../../docker` +Note the absolute path of `/learning-paths/cross-platform/docker/` {{% /notice %}} ### Author information @@ -145,7 +145,7 @@ This is where you provide a specific next step for a reader, and provide further | Next Steps Metadata | Explanation | |-----------------------|-------------| | next_step_guidance | A 1-3 sentence description of how the reader can generally keep learning about these topics, and a specific explanation of why the next step is being recommended. | -| recommended_path | Link to the next learning path being recommended (For example, this could be [Learn How to Use Docker](../../docker)) | +| recommended_path | Link to the next learning path being recommended (For example, this could be [Learn How to Use Docker](/learning-paths/cross-platform/docker/)) | | further_reading | Links to references related to information covered | | resource > title | The displayed title of the provided further_reading resource | | resource > link | The website link to the specific resource | diff --git a/content/learning-paths/cross-platform/avh_cicd2/_index.md b/content/learning-paths/cross-platform/avh_cicd2/_index.md index 7992afbf0..4f71d8eb0 100644 --- a/content/learning-paths/cross-platform/avh_cicd2/_index.md +++ b/content/learning-paths/cross-platform/avh_cicd2/_index.md @@ -10,7 +10,7 @@ learning_objectives: - Integrate Arm Virtual Hardware into CI/CD flow with GitHub Actions prerequisites: - - This learning path builds on [Integrate Arm Virtual Hardware into CI/CD workflow 1](../avh_cicd/). + - This learning path builds on [Integrate Arm Virtual Hardware into CI/CD workflow 1](/learning-paths/cross-platform/avh_cicd/). - Valid AWS and GitHub accounts are required author_primary: Pareena Verma diff --git a/content/learning-paths/cross-platform/avh_cicd2/automate.md b/content/learning-paths/cross-platform/avh_cicd2/automate.md index 9d8cecf9e..849a9183c 100644 --- a/content/learning-paths/cross-platform/avh_cicd2/automate.md +++ b/content/learning-paths/cross-platform/avh_cicd2/automate.md @@ -7,7 +7,7 @@ weight: 3 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -Your AWS account is now [ready](../prep_aws) to be integrated into the CI/CD flow. +Your AWS account is now [ready](/learning-paths/cross-platform/avh_cicd2/prep_aws/) to be integrated into the CI/CD flow. ## Define AWS settings to repository diff --git a/content/learning-paths/cross-platform/dynamic-memory-allocator/1_dynamic_memory_allocation.md b/content/learning-paths/cross-platform/dynamic-memory-allocator/1_dynamic_memory_allocation.md index 539ceb5b0..7bb22265a 100644 --- a/content/learning-paths/cross-platform/dynamic-memory-allocator/1_dynamic_memory_allocation.md +++ b/content/learning-paths/cross-platform/dynamic-memory-allocator/1_dynamic_memory_allocation.md @@ -58,15 +58,16 @@ The C library looks for a chunk of memory with a size of at least X bytes within parameter passed to `malloc`. For instance, on Ubuntu Linux, this is done by GLIBC. The example at the top of the page is trivial, of course. As it is we could just -statically allocate both integers like this: +initialize both `a` and `b` at compilation time like this: ```C void fn() { - int a, b = 0; + int a = 0; + int *b = NULL; } ``` -Variables `a` and `b` work fine if they are not needed outside of the function. In other +This works fine as `a` and `b` are not needed outside of the function or in other words, if the lifetime of the data is equal to that of the function. A more complex example (shown below) demonstrates when this is not the case, and the values diff --git a/content/learning-paths/cross-platform/dynamic-memory-allocator/2_designing_a_dynamic_memory_allocator.md b/content/learning-paths/cross-platform/dynamic-memory-allocator/2_designing_a_dynamic_memory_allocator.md index 1bf5153d4..40e6740ad 100644 --- a/content/learning-paths/cross-platform/dynamic-memory-allocator/2_designing_a_dynamic_memory_allocator.md +++ b/content/learning-paths/cross-platform/dynamic-memory-allocator/2_designing_a_dynamic_memory_allocator.md @@ -12,7 +12,7 @@ To begin, decide which functions your memory allocator will provide. We have already described `malloc` and `free` but there are more provided by the [C library](https://en.cppreference.com/w/c/memory). -This demo assumes you just need `malloc` and `free`. The new implementations will +This learning path assumes you just need `malloc` and `free`. The new implementations will be called `simple_malloc` and `simple_free`. Start with just these two functions and write out their behaviors. @@ -96,7 +96,7 @@ range = 0x0 + 4 = 0x4; Pointer: 0x4 Size: N-4 Allocated: False -range = 0x4 + (N-4) = 1 beyond the end of the heap, so the walk is finished. +range = 0x4 + (N-4) = N beyond the end of the heap, so the walk is finished. ``` `simple_free` uses the pointer given to it to find the range it needs to de-allocate. diff --git a/content/learning-paths/cross-platform/integer-vs-floats/integer-float-conversions.md b/content/learning-paths/cross-platform/integer-vs-floats/integer-float-conversions.md index bc5e08eb4..8387dde4c 100644 --- a/content/learning-paths/cross-platform/integer-vs-floats/integer-float-conversions.md +++ b/content/learning-paths/cross-platform/integer-vs-floats/integer-float-conversions.md @@ -145,7 +145,7 @@ The second type of conversions are called implicit and are harder to track. When a conversion is not explicitly stated it is called implicit. In general, it's a conversion that the compiler issues when there is an operation involving two (or more) elements of different data types. -In that case, the compiler has to convert one of the values to the same datatype as the other, as most operations require elements of the same size. +In that case, the compiler has to convert one of the values to the same datatype as the other, as most operations require elements of the same type. {{% notice Note %}} There are some conversion exceptions, for example, the `SADDW`/`UADDW` Advanced SIMD instructions which add elements of different widths. Such instructions do not require any kind of conversion. diff --git a/content/learning-paths/cross-platform/integer-vs-floats/type-demotion-problems.md b/content/learning-paths/cross-platform/integer-vs-floats/type-demotion-problems.md index d8b0ac5ea..054604192 100644 --- a/content/learning-paths/cross-platform/integer-vs-floats/type-demotion-problems.md +++ b/content/learning-paths/cross-platform/integer-vs-floats/type-demotion-problems.md @@ -80,7 +80,7 @@ e1 = 2147483647, e2 = 2147483647 Obviously `w` is a huge value and it does not fit in a `float` (remember that the largest positive float is `3.4e+38`), but the compiler only complains about `z` which uses bracket initialization and not `y` which uses assignment. -Similarly, `d1` an `int16_t` uses assignment and does not generate a warning but `d2`, also an `int16_t`, uses bracket initialization and triggers a compiler warning. +Similarly `d1`, with type `int16_t`, uses assignment and does not generate a warning but `d2`, also an `int16_t`, uses bracket initialization and triggers a compiler warning. The same happens with the demotion/conversion of the `double w` to the `int32_t` variables `e1`, `e2`. diff --git a/content/learning-paths/cross-platform/memory-latency/_next-steps.md b/content/learning-paths/cross-platform/memory-latency/_next-steps.md index ac9ed606b..6d8780f7e 100644 --- a/content/learning-paths/cross-platform/memory-latency/_next-steps.md +++ b/content/learning-paths/cross-platform/memory-latency/_next-steps.md @@ -4,6 +4,10 @@ next_step_guidance: You now have a good understanding of the impact memory laten recommended_path: /learning-paths/servers-and-cloud-computing/top-down-n1/ further_reading: + - resource: + title: Write a Dynamic Memory Allocator + link: https://learn.arm.com/learning-paths/cross-platform/dynamic-memory-allocator/ + type: website - resource: title: Memory Latency link: https://en.algorithmica.org/hpc/cpu-cache/latency/ diff --git a/content/learning-paths/cross-platform/memory-latency/how-latency-impacts-performance-2.md b/content/learning-paths/cross-platform/memory-latency/how-latency-impacts-performance-2.md index c36d7a534..b78b206b2 100644 --- a/content/learning-paths/cross-platform/memory-latency/how-latency-impacts-performance-2.md +++ b/content/learning-paths/cross-platform/memory-latency/how-latency-impacts-performance-2.md @@ -130,4 +130,4 @@ This method of using a custom allocator is popular in performance-critical appli A linear allocator like the one used here is one of the simplest memory allocators, and is popular in systems with known fixed size objects or known constrained size limits. -There are many more memory allocators for different sizes and quite a few of them are much faster than the default `malloc()`. +There are many more memory allocators for different sizes and quite a few of them are much faster than the default `malloc()`. To learn more about how a memory allocator works and write one yourself, please have a look at the [dynamic memory allocator learning path](/learning-paths/cross-platform/dynamic-memory-allocator/). diff --git a/content/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part4.md b/content/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part4.md index af0b8a000..969ce2ae2 100644 --- a/content/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part4.md +++ b/content/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part4.md @@ -225,7 +225,7 @@ fff6 0000 0000 0000 A 4x4 matrix `a` is initialized and a `fDCT` function is called on it. The function carries out 2 passes of the same algorithm on the elements of the array, calls the 2 butterfly functions (for one and two coefficients respectively) and transposes the results in between the calculations. The result is rounded and stored in the output buffer `dct`. -The assembly output is linked [here](../butterfly1.asm) instead of being displayed due to its size. +The assembly output is linked [here](/learning-paths/cross-platform/simd-on-rust/butterfly1.asm) instead of being displayed due to its size. Now create a Rust version of this algorithm and save the contents below in a file called `butterfly2.rs`: @@ -393,7 +393,7 @@ ff71 0000 0000 0000 fff6 0000 0000 0000 ``` -The disassembly output is linked [here](../butterfly2.asm) for size reasons. You will see that it is very similar to the C version, apart from the cpu feature check at the start. +The disassembly output is linked [here](/learning-paths/cross-platform/simd-on-rust/butterfly2.asm) for size reasons. You will see that it is very similar to the C version, apart from the cpu feature check at the start. ### Comments diff --git a/content/learning-paths/cross-platform/sme/matrix-multiply-example.md b/content/learning-paths/cross-platform/sme/matrix-multiply-example.md index 079d000cc..68a1c9a93 100644 --- a/content/learning-paths/cross-platform/sme/matrix-multiply-example.md +++ b/content/learning-paths/cross-platform/sme/matrix-multiply-example.md @@ -51,7 +51,7 @@ Execution can be controlled by the `Debug Control` pane icon bar (eg `Step Instr ## Understand the example -![example image alt-text#center](armds_sme2.png "Figure 2. Debugging the SME2 example in Arm Development Studio") +![example image alt-text#center](/learning-paths/cross-platform/sme/armds_sme2.png "Figure 2. Debugging the SME2 example in Arm Development Studio") 1. In the Registers view, expand AArch64 > System > ID > ID_AA64PFR1_EL1. Notice the SME bits are set to 2, meaning the SME2 architectural state and programmers model are implemented on this target. 2. This bit can also be inspected in the Commands view, by entering `output $AArch64::$System::$ID::$ID_AA64PFR1_EL1.SME`. Other bits in other registers may be inspected similarly. diff --git a/content/learning-paths/cross-platform/sme/sme-intro.md b/content/learning-paths/cross-platform/sme/sme-intro.md index 760ac8ac8..759455360 100644 --- a/content/learning-paths/cross-platform/sme/sme-intro.md +++ b/content/learning-paths/cross-platform/sme/sme-intro.md @@ -27,7 +27,7 @@ Similarly, when accessing 32-bit elements, tiles would have height and width bot You can read or write a ZA tile slice, which is a one-dimensional vector representing a complete row or column within a tile slice. -![example image alt-text#center](ZA.png "Figure 1. The ZA storage, accessed by 32-bit elements, shown for SVL = 256 bits, and showing the mapping to horizontal and vertical slices of the four ZA0-3 tiles.") +![example image alt-text#center](/learning-paths/cross-platform/sme/ZA.png "Figure 1. The ZA storage, accessed by 32-bit elements, shown for SVL = 256 bits, and showing the mapping to horizontal and vertical slices of the four ZA0-3 tiles.") The Scalable Matrix Extension version 2 (SME2) extends the SME architecture 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 adds: * Data processing instructions with multi-vector operands and a multi-vector predication mechanism. diff --git a/content/learning-paths/cross-platform/vectorization-friendly-data-layout/a-more-complex-problem.md b/content/learning-paths/cross-platform/vectorization-friendly-data-layout/a-more-complex-problem.md index db0088109..129eecda6 100644 --- a/content/learning-paths/cross-platform/vectorization-friendly-data-layout/a-more-complex-problem.md +++ b/content/learning-paths/cross-platform/vectorization-friendly-data-layout/a-more-complex-problem.md @@ -105,9 +105,9 @@ elapsed time: 28.926221 Using `-O3` reduces the execution time by about 21%. This is good, but you might be expecting more. Checking the assembly output will tell you that it's not as good as you expected. -Check the [assembly output for -O2](../simulate_objects_O2.s). It doesn't show any SIMD instructions, which is expected with `-O2`. +Check the [assembly output for -O2](/learning-paths/cross-platform/vectorization-friendly-data-layout/simulate_objects_O2.s). It doesn't show any SIMD instructions, which is expected with `-O2`. -Now observe the [assembly output for -O3](../simulate_objects_O3.s) and in particular these lines: +Now observe the [assembly output for -O3](/learning-paths/cross-platform/vectorization-friendly-data-layout/simulate_objects_O3.s) and in particular these lines: ```simulate2_objects_O3.s c48: 6ea0e4ea fcmgt v10.4s, v7.4s, v0.4s diff --git a/content/learning-paths/embedded-systems/avh_balena/2setup.md b/content/learning-paths/embedded-systems/avh_balena/2setup.md index 9994b289d..01827d323 100644 --- a/content/learning-paths/embedded-systems/avh_balena/2setup.md +++ b/content/learning-paths/embedded-systems/avh_balena/2setup.md @@ -44,7 +44,7 @@ When the download is finished, you can convert the Balena OS device image into a The conversion can be done using a Linux shell script. -[Download the script](../mkbalenaosimg.sh) and save it as `mkbalenaosimg.sh` on your computer. +[Download the script](/learning-paths/embedded-systems/avh_balena/mkbalenaosimg.sh) and save it as `mkbalenaosimg.sh` on your computer. {{% notice Note %}} The conversion script requires a Linux environment with root access. If needed, copy the script and the Balena OS image .zip file to a Linux machine and log in to the machine. The `zip` and `unzip` commands are also required. Install them using your Linux package manager. diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/_index.md b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/_index.md similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/_index.md rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/_index.md diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/_next-steps.md b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/_next-steps.md similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/_next-steps.md rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/_next-steps.md diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/_review.md b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/_review.md similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/_review.md rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/_review.md diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh-setup.md b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh-setup.md similarity index 96% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh-setup.md rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh-setup.md index e69385d8d..c87bd1eb3 100644 --- a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh-setup.md +++ b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh-setup.md @@ -68,7 +68,7 @@ Extract the files to /usr/local/bin using: tar -C /usr/local/bin/ -xvf hybrid.tar.gz ``` {{% notice Note %}} -If you want to build the hybrid-runtime on your own, instructions can be found in the section of this learning path called [Building the hybrid-runtime and container image](../build-runtime/). +If you want to build the hybrid-runtime on your own, instructions can be found in the section of this learning path called [Building the hybrid-runtime and container image](/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/build-runtime/). {{% /notice %}} ## Download Firmware container image diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh1.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh1.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh1.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh1.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh2.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh2.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh2.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh2.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh3.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh3.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh3.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh3.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh4.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh4.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh4.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh4.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh5.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh5.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh5.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh5.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh6.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh6.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh6.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh6.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh7.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh7.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh7.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh7.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh8.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh8.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/avh_images/avh8.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/avh_images/avh8.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/build-runtime.md b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/build-runtime.md similarity index 96% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/build-runtime.md rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/build-runtime.md index 29377b468..fbc66fee8 100644 --- a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/build-runtime.md +++ b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/build-runtime.md @@ -69,4 +69,4 @@ make image ``` This should build a docker image with the name `ghcr.io/smarter-project/hybrid-runtime/hello_world_imx8mp:latest`. -The `image.dockerfile` file pulls the NXP SDK and builds the hello world example present in the NXP SDK. Finally, the Dockerfile creates a new image, copies the hello world binary into it, sets the entrypoint and adds the correct labels. You can use this Dockerfile to run the example as shown in the section [Deploy firmware container using containerd](../containerd/). +The `image.dockerfile` file pulls the NXP SDK and builds the hello world example present in the NXP SDK. Finally, the Dockerfile creates a new image, copies the hello world binary into it, sets the entrypoint and adds the correct labels. You can use this Dockerfile to run the example as shown in the section [Deploy firmware container using containerd](/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/containerd/). diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/containerd.md b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/containerd.md similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/containerd.md rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/containerd.md diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/containerd1.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/containerd1.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/containerd1.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/containerd1.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/containerd2.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/containerd2.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/containerd2.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/containerd2.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/hybrid.jpg b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/hybrid.jpg similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/hybrid.jpg rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/hybrid.jpg diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/k3s.md b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/k3s.md similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/k3s.md rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/k3s.md diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/k3s.png b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/k3s.png similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/k3s.png rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/k3s.png diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/motivation.md b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/motivation.md similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/motivation.md rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/motivation.md diff --git a/content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/runtime-overview.md b/content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/runtime-overview.md similarity index 100% rename from content/learning-paths/embedded-systems/Cloud-Native-deployment-on-hybrid-edge-systems/runtime-overview.md rename to content/learning-paths/embedded-systems/cloud-native-deployment-on-hybrid-edge-systems/runtime-overview.md diff --git a/content/learning-paths/embedded-systems/migration/6_run_evaluate.md b/content/learning-paths/embedded-systems/migration/6_run_evaluate.md index 0143c9e1f..8a2cfe775 100644 --- a/content/learning-paths/embedded-systems/migration/6_run_evaluate.md +++ b/content/learning-paths/embedded-systems/migration/6_run_evaluate.md @@ -45,4 +45,4 @@ Emulation does not give a representative view of how efficiently the algorithms You have now ported an `x86_64` application to `aarch64`, built and run the ported application on `aarch64` using emulation, well done! -If you have access to Arm hardware, continue to the next section [Evaluating real hardware](../7_alternative). If you don't have access to Arm hardware you can jump straight to the [Review](../_review) and test your knowledge. \ No newline at end of file +If you have access to Arm hardware, continue to the next section [Evaluating real hardware](/learning-paths/embedded-systems/migration/7_alternative). If you don't have access to Arm hardware you can jump straight to the [Review](/learning-paths/embedded-systems/migration/_review) and test your knowledge. \ No newline at end of file diff --git a/content/learning-paths/embedded-systems/migration/7_alternative.md b/content/learning-paths/embedded-systems/migration/7_alternative.md index 590bce349..aa07a74e4 100644 --- a/content/learning-paths/embedded-systems/migration/7_alternative.md +++ b/content/learning-paths/embedded-systems/migration/7_alternative.md @@ -10,7 +10,7 @@ layout: "learningpathall" In this section you will learn alternative ways to build the development environment and compile with a different compiler, on Arm hardware. -The changes you made in `main.cpp` and `CMakeLists.txt` in [Application porting](../5_application_porting) stay the same when running on actual Arm hardware. +The changes you made in `main.cpp` and `CMakeLists.txt` in [Application porting](/learning-paths/embedded-systems/migration/5_application_porting) stay the same when running on actual Arm hardware. ## Arm hardware @@ -60,7 +60,7 @@ Refer to [Get started with the Raspberry Pi 4](/learning-paths/embedded-systems/ ## Development environment and application porting -Use the same Dockerfile as before, see [Development environment](../4_development_environment#gcc-container). +Use the same Dockerfile as before, see [Development environment](/learning-paths/embedded-systems/migration/4_development_environment#gcc-container). You can build the development environment natively on Arm using `docker build` instead of `docker buildx`. @@ -76,7 +76,7 @@ Run the container: docker run --rm -ti --net=host -e DISPLAY=$DISPLAY -v /tmp/.X11-unix/:/tmp/.X11-unix/ -v $HOME/.Xauthority:/home/ubuntu/.Xauthority sobel_gcc_example ``` -Follow the same steps to port the application as described in [Application porting](../5_application_porting) to build and run the application. +Follow the same steps to port the application as described in [Application porting](/learning-paths/embedded-systems/migration/5_application_porting/) to build and run the application. ### ACfL @@ -103,7 +103,7 @@ Install OpenCV by running the command: sudo apt-get update && sudo apt-get install -y libopencv-dev ``` -Follow the same steps to port the application as described in [Application porting](../5_application_porting). +Follow the same steps to port the application as described in [Application porting](/learning-paths/embedded-systems/migration/5_application_porting). To use Arm Compiler for Linux you need to change the compiler in `CMakeLists.txt` as shown below: diff --git a/content/learning-paths/laptops-and-desktops/_index.md b/content/learning-paths/laptops-and-desktops/_index.md index a1d7947a0..5445e1195 100644 --- a/content/learning-paths/laptops-and-desktops/_index.md +++ b/content/learning-paths/laptops-and-desktops/_index.md @@ -13,11 +13,11 @@ operatingsystems_filter: - ChromeOS: 1 - Linux: 22 - macOS: 2 -- Windows: 30 +- Windows: 31 subjects_filter: - CI-CD: 3 - Containers and Virtualization: 5 -- Migration to Arm: 24 +- Migration to Arm: 25 - Performance and Architecture: 16 subtitle: Create and migrate apps for power efficient performance title: Laptops and Desktops @@ -50,7 +50,7 @@ tools_software_languages_filter: - MTE: 1 - Neon: 1 - Neovim: 1 -- Node.js: 2 +- Node.js: 3 - perf: 1 - Python: 2 - Qt: 2 @@ -60,7 +60,7 @@ tools_software_languages_filter: - SVE2: 1 - Trusted Firmware: 1 - Visual Studio: 9 -- Visual Studio Code: 8 +- Visual Studio Code: 9 - VS Code: 2 - Windows Forms: 1 - Windows Presentation Foundation: 1 diff --git a/content/learning-paths/laptops-and-desktops/win_sandbox_dot_net_cicd/win_sandbox_net_2.md b/content/learning-paths/laptops-and-desktops/win_sandbox_dot_net_cicd/win_sandbox_net_2.md index 9b4a05598..80906b7d2 100644 --- a/content/learning-paths/laptops-and-desktops/win_sandbox_dot_net_cicd/win_sandbox_net_2.md +++ b/content/learning-paths/laptops-and-desktops/win_sandbox_dot_net_cicd/win_sandbox_net_2.md @@ -75,7 +75,7 @@ To check that your application has been published correctly in the last step, yo The application should be published in your runner folder under **actions-runner\_work\sandbox-ci-cd-net\sandbox-ci-cd-net\TSP.WPF\bin\Release\net8.0-windows7.0\win-arm64\publish\**. Double-click TSP.WPF to run the application. The application starts as shown: -![img6](../win_net/net12.png) +![img6](net12.png) This process demonstrates how you can seamlessly integrate Windows Sandbox with GitHub Actions to automate the build and deployment of your application. diff --git a/content/learning-paths/microcontrollers/_index.md b/content/learning-paths/microcontrollers/_index.md index f4a594bb7..d3da84497 100644 --- a/content/learning-paths/microcontrollers/_index.md +++ b/content/learning-paths/microcontrollers/_index.md @@ -10,14 +10,14 @@ operatingsystems_filter: - Baremetal: 25 - Linux: 3 - macOS: 2 -- RTOS: 9 +- RTOS: 10 - Windows: 2 subjects_filter: - CI-CD: 3 - Libraries: 3 - ML: 6 - Performance and Architecture: 11 -- RTOS Fundamentals: 3 +- RTOS Fundamentals: 4 - Security: 2 - Virtual Hardware: 2 subtitle: Learn best practices for microcontroller development @@ -25,23 +25,23 @@ title: Microcontrollers tools_software_languages_filter: - Arduino: 1 - Arm Compiler for Embedded: 5 -- Arm Development Studio: 3 +- Arm Development Studio: 4 - Arm Virtual Hardware: 11 - CMSIS: 5 - CMSIS-Toolbox: 3 -- Coding: 21 +- Coding: 22 - Fixed Virtual Platform: 8 - FVP: 1 - GCC: 4 - GitHub: 2 - IP Explorer: 2 - Keil: 7 -- Keil MDK: 2 +- Keil MDK: 3 - MDK: 2 - MPS3: 1 - Paddle: 1 - Raspberry Pi: 1 -- RTX: 1 +- RTX: 2 - STM32: 2 - TensorFlow: 2 - Trusted Firmware: 2 diff --git a/content/learning-paths/microcontrollers/arduino-pico/arduino_sketch.md b/content/learning-paths/microcontrollers/arduino-pico/arduino_sketch.md index 85000c68a..97283ebf2 100644 --- a/content/learning-paths/microcontrollers/arduino-pico/arduino_sketch.md +++ b/content/learning-paths/microcontrollers/arduino-pico/arduino_sketch.md @@ -20,7 +20,7 @@ This Learning Path provides a complete sketch that you can upload onto your Rasp First, open the sketch in the Arduino IDE: -1. Right click and select `Save Link As` to save the [pir_sensor.ino](../pir_sensor_1.ino) sketch to your computer +1. Right click and select `Save Link As` to save the [pir_sensor.ino](/learning-paths/microcontrollers/arduino-pico/pir_sensor_1.ino) sketch to your computer 2. In the Arduino IDE, go to `File -> Open` 3. Find and select the `pir_sensor.ino` file that you just downloaded to your computer and click `Open` diff --git a/content/learning-paths/microcontrollers/arduino-pico/refactoring.md b/content/learning-paths/microcontrollers/arduino-pico/refactoring.md index ed11b4702..c4384afe1 100644 --- a/content/learning-paths/microcontrollers/arduino-pico/refactoring.md +++ b/content/learning-paths/microcontrollers/arduino-pico/refactoring.md @@ -57,4 +57,4 @@ That's it! You have learned how to use interrupts. You can see how much smaller Not only that but using interrupts makes other improvements possible. For example, you could stop the `loop()` and put the device into a very low-power state while no motion is detected, and let the interrupt power it back up to respond. -You can download the complete [pir_sensor.ino](../pir_sensor_2.ino) and try it out yourself. +You can download the complete [pir_sensor.ino](/learning-paths/microcontrollers/arduino-pico/pir_sensor_2.ino) and try it out yourself. diff --git a/content/learning-paths/microcontrollers/asm/_index.md b/content/learning-paths/microcontrollers/asm/_index.md index 2ee3e24ca..6bc45fe0c 100644 --- a/content/learning-paths/microcontrollers/asm/_index.md +++ b/content/learning-paths/microcontrollers/asm/_index.md @@ -15,7 +15,7 @@ learning_objectives: prerequisites: - Some familiarity with C/Assembly. - - A Windows computer to run Keil MDK. + - An installation of Keil MDK ### Tags skilllevels: Introductory diff --git a/content/learning-paths/microcontrollers/asm/coding.md b/content/learning-paths/microcontrollers/asm/coding.md index 98aa26c5f..49a8ca550 100644 --- a/content/learning-paths/microcontrollers/asm/coding.md +++ b/content/learning-paths/microcontrollers/asm/coding.md @@ -2,7 +2,7 @@ # User change title: Writing assembly functions -weight: 3 # 1 is first, 2 is second, etc. +weight: 6 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" @@ -11,7 +11,9 @@ You will create a C application, but add assembly language subroutines to perfor ## Create main.c -Right-click `Source Group 1` and select `Add New Item`. Select `C file (.c)` and name it `main.c'. +If using μVision, Right-click `Source Group 1` and select `Add New Item`. Select `C file (.c)` and name it `main.c`. + +If using Keil Studio, open `main.c` within the `Source Files` group. ## The main Function @@ -120,12 +122,14 @@ To use the conditional `BLS` branch instruction, reduce by one the value `r1` is ## Build the example -Save all files, and click the `Build` button (`F7`). +Save all files, and click the `Build` icon. ## Debug the example -Click the `Debug` button (`Ctrl+F5`) to load the example to the FVP. The code will stop at `main()`. +Click the `Debug` icon to load the example to the FVP. The code will stop at `main()`. + +Observe the values of `a` and `b` in the μVision `Call Stack + Locals` tab, or the Keil Studio `Watch` pane (click `+` to add to this view). -The `Call Stack + Locals` tab show the value of `a` and `b`. Initially they will have no meaningful data. +Initially they will have no meaningful data. -`Step` (`F11`) through the code and notice how the values of `a` and `b` change. You should see the string `Hello world!` copy to `b` and then capitalize. +`Step` through the code and notice how the values of `a` and `b` change. Observe the string `Hello world!` copy to `b` and then capitalize. diff --git a/content/learning-paths/microcontrollers/asm/intro.md b/content/learning-paths/microcontrollers/asm/intro.md new file mode 100644 index 000000000..315610ba7 --- /dev/null +++ b/content/learning-paths/microcontrollers/asm/intro.md @@ -0,0 +1,27 @@ +--- +# User change +title: Keil MDK versions + +weight: 2 # 1 is first, 2 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- + +Though Cortex-M processors have been designed so that all operations can be programmed with C/C++ code, it can be useful to also understand how to create assembler level code, which can be more efficient than compiler generated code. + +## Efficient Embedded Systems Education Kit + +This Learning Path is based on examples from the [Efficient Embedded Systems Education Kit](https://github.com/arm-university/Efficient-Embedded-Systems-Design-Education-Kit), which uses the [Nucleo-F401RE](https://www.st.com/en/evaluation-tools/nucleo-f401re.html) development board. + +In this learning path the Cortex-M4 Fixed Virtual Platform provided with MDK will be used. + +The assembly level functions will conform to the [Arm Procedure Call Standard](https://github.com/ARM-software/abi-aa/blob/main/aapcs32/aapcs32.rst). + +## Keil MDK + +[Keil MDK](https://www.keil.arm.com/) can support a number of different environments. + +Keil Studio is a collection of `Visual Studio Code` Extensions to provide a complete development IDE. For installation instructions, refer to the [Arm Keil Studio for VS Code](/install-guides/keilstudio_vs/) install guide. Windows, Linux, and MacOS are supported hosts. + +You can also use the legacy μVision IDE. For installation instructions, refer to the [Keil μVision](/install-guides/mdk/) install guide. Note that only Windows is a supported host. diff --git a/content/learning-paths/microcontrollers/asm/setup.md b/content/learning-paths/microcontrollers/asm/setup_mdk5.md similarity index 58% rename from content/learning-paths/microcontrollers/asm/setup.md rename to content/learning-paths/microcontrollers/asm/setup_mdk5.md index 18eabdb62..5b4ef44aa 100644 --- a/content/learning-paths/microcontrollers/asm/setup.md +++ b/content/learning-paths/microcontrollers/asm/setup_mdk5.md @@ -1,27 +1,16 @@ --- # User change -title: "Setting Up A Project In Keil MDK" +title: "Setting up a Project in Keil MDK (μVision)" -weight: 2 # 1 is first, 2 is second, etc. +weight: 5 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -Though Cortex-M processors have been designed so that all operations can be programmed with C/C++ code, it can be useful to also understand how to create assembler level code, which can be more efficient than compiler generated code. - -You will write assembly level functions conforming to the [Arm Procedure Call Standard](https://github.com/ARM-software/abi-aa/blob/main/aapcs32/aapcs32.rst). - -[Keil MDK](https://www2.keil.com/mdk5) is used as the toolchain. For installation instructions, refer to the [Keil MDK install guide](/install-guides/mdk/). - -## Efficient Embedded Systems Education Kit - -This Learning Path is based on examples from the [Efficient Embedded Systems Education Kit](https://github.com/arm-university/Efficient-Embedded-Systems-Design-Education-Kit), which uses the [Nucleo-F401RE](https://www.st.com/en/evaluation-tools/nucleo-f401re.html) development board. - -You will use the Cortex-M4 Fixed Virtual Platform provided with MDK. ## Create MDK Project -The first thing to do is set up a new project. Go to 'Project' > 'New uVision Project'. +The first thing to do is set up a new project. Go to 'Project' > 'New μVision Project'. Select an appropriate place and name for the project. @@ -41,20 +30,28 @@ Keil_v5/ARM/avh-fvp/bin/models/FVP_MPS2_Cortex-M4_MDK.exe ``` {{% notice Note%}} -MDK versions before 5.37 will find the FVP at +MDK versions 5.37 and earlier will find the FVP at: `Keil_v5/ARM/FVP/MPS2_Cortex-M/FVP_MPS2_Cortex-M4_MDK.exe` -and in 5.38, 5.39 it is available at +In 5.38 and 5.39 the FVP is installed at: `Keil_v5/ARM/VHT/VHT_MPS2_Cortex-M4_MDK.exe` + +In 5.40 and later the FVP is installed at: + +`Keil_v5/ARM/avh-fvp/bin/models/FVP_MPS2_Cortex-M4_MDK.exe` {{% /notice %}} ### Configure build settings In the `C/C++` tab, set the `Optimization` level to `-O1`. -In the `Linker` tab, deselect `Use Memory Layout from Target Dialog`. and a `Scatter File` will be created. Click the `Edit` button to open in the background. Click `OK` to save all `Options`. +In the `Linker` tab, deselect `Use Memory Layout from Target Dialog`. and a `Scatter File` will be created. + +Click the `Edit` button to open in the background. + +Click `OK` to save all `Options`. In this scatter file, add a region `ARM_LIB_STACK`. The C library initialization code will initialize the stack at the top of this region. ```text @@ -74,3 +71,17 @@ LR_IROM1 0x00000000 0x00040000 { ; load region size_region ### Rename Project items (optional) Rename `Target 1` and `Source Group 1` to more meaningful names, via the `Project > Manage... > Project Items` menu. + +## Basic functionality + +### New C source file + +Right-click `Source Group 1` and select `Add New Item`. Select `C file (.c)`. + +### Build + +Save all files, and click the `Build` button (`F7`). + +### Debug + +Click the `Debug` button (`Ctrl+F5`) to load the example to the FVP. The code will stop at `main()`. diff --git a/content/learning-paths/microcontrollers/asm/setup_mdk6.md b/content/learning-paths/microcontrollers/asm/setup_mdk6.md new file mode 100644 index 000000000..96e46df49 --- /dev/null +++ b/content/learning-paths/microcontrollers/asm/setup_mdk6.md @@ -0,0 +1,105 @@ +--- +# User change +title: "Setting up a Project in Keil Studio (VS Code)" + +weight: 4 # 1 is first, 2 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- +{{% notice Note%}} +If using Keil μVision, go to [Setting up a Project in Keil MDK (μVision)](/learning-paths/microcontrollers/asm/setup_mdk5/). +{{% /notice %}} + +## Create a new project (csolution) + +Keil Studio projects are based on the [CMSIS Solution](https://github.com/Open-CMSIS-Pack/cmsis-toolbox/blob/main/docs/YML-Input-Format.md) standard. + +Open the `VS Code` IDE, and select `File` > `New File` from the `File` menu. (`Ctrl`+`Alt`+`Windows`+`N`). You will be prompted for the type of file. Select `New Solution` (`Arm CMSIS Solution`). + +The `Create New Solution` window will open. Click the `Target Device` pulldown, and search for `ARMCM4`. + +From the `Templates, Reference Applications, and Examples` pulldown, select `Blank Solution`. + +Ensure `Arm Compiler 6` is the selected compiler. + +Enter an appropriate `Solution Name`. This will define the folder name that the project will be created into. You can also change the folder location if necessary. + +Click `Create`. You will be prompted to open the solution in the current window, or open a new window. + +## Configure solution environment + +VS Code allows complete configurability of all aspects of the project. + +Locate `vcpkg-configuration.json` within the project. This file defines the components used. + +Right-click on this file, and select `Configure Arm Tools Environment` to open the configuration panel. + +From the various pull-downs, ensure that the most up to date versions of the following are selected: + +* Arm CMSIS-Toolbox +* Arm Compiler for Embedded +* Arm Debugger +* Arm Virtual Hardware for Cortex-M based on Fast Models +* Kitware's cmake tool +* Ninja Build + +Others can be set as `None` as they are not needed for this example. + +If you open `vcpkg-configuration.json` in the text editor you will see these set as selected. Close the file to save. + +All necessary components will be downloaded and installed as necessary (if not already installed). + +## Configure CMSIS options + +Select `CMSIS` from the Extensions icon list. You will see the project structure. + +Move cursor over the top-level `Project`, and click on `Manage Software Components`. This is the view to add CMSIS Software Packs to your project. + +Select `CMSIS > Core` and `Device > Startup` (these are likely selected by default). + +Close this view to save. + +## Configure debug with the FVP + +Select `Run and Debug` from the Extensions icon list. + +Click the gear icon to open `launch.json`. This is the file that defines the debug instance. + +Right-click on `launch.json` and select `Open Run and Debug Configuration`. + +From the `Selected Configuration` pull-down, select `New Configuration` > `Launch FVP`. Edit the `Configuration Name` if desired. + +From the `Target` > `Configuration Database Entry` pull-down, select `MPS2_Cortex_M4` > `Cortex-M4`. + +Other fields can be left as default. Close the file to save. Observe that `launch.json` has been updated. + +## Configure scatter file + +Return to the `CMSIS` extension. The project is configured to use the `ARMCM4_ac6.sct` file as the scatter description file. + +Click the file to create it with the following: + +```text +LR_IROM1 0x00000000 0x00040000 { ; load region size_region + ER_IROM1 0x00000000 0x00040000 { ; load address = execution address + *.o (RESET, +First) + *(InRoot$$Sections) + .ANY (+RO) + .ANY (+XO) + } + RW_IRAM1 0x20000000 0x00020000 { ; RW data + .ANY (+RW +ZI) + } + ARM_LIB_STACK 0x20020000 EMPTY 0x4000 {} +} +``` +Close to save. + +## main.c + +The project automatically creates `main.c` within the `Source Files` group. We will modify this in the [Writing assembly functions](/learning-paths/microcontrollers/asm/coding/) section. + +{{% notice Note%}} +`Next` button below goes to μVision settings. Go to [Writing assembly functions](/learning-paths/microcontrollers/asm/coding/) to skip this section. +{{% /notice %}} diff --git a/content/learning-paths/microcontrollers/cmsis-dsp/_index.md b/content/learning-paths/microcontrollers/cmsis-dsp/_index.md index 6fb578f6f..666e1eed5 100644 --- a/content/learning-paths/microcontrollers/cmsis-dsp/_index.md +++ b/content/learning-paths/microcontrollers/cmsis-dsp/_index.md @@ -8,10 +8,11 @@ who_is_this_for: This is an introductory topic for software developers new to CM learning_objectives: - Build a simple application using CMSIS-DSP library - Compare relative performance on different processors - - Build a CMSIS-DSP test suite on the Corstone-300 FVP +# - Build a CMSIS-DSP test suite on the Corstone-300 FVP prerequisites: - Some familiarity with embedded programming + - A host machine to run Keil MDK development tools author_primary: Ronan Synnott diff --git a/content/learning-paths/microcontrollers/cmsis-dsp/_next-steps.md b/content/learning-paths/microcontrollers/cmsis-dsp/_next-steps.md index 90cbea4c7..259ca35ba 100644 --- a/content/learning-paths/microcontrollers/cmsis-dsp/_next-steps.md +++ b/content/learning-paths/microcontrollers/cmsis-dsp/_next-steps.md @@ -21,10 +21,10 @@ further_reading: title: CMSIS-DSP Documentation link: https://arm-software.github.io/CMSIS_5/DSP/html/modules.html type: documentation - - resource: - title: CMSIS-DSP Testing Framework - link: https://github.com/ARM-software/CMSIS-DSP/tree/main/Testing - type: documentation +# - resource: +# title: CMSIS-DSP Testing Framework +# link: https://github.com/ARM-software/CMSIS-DSP/tree/main/Testing +# type: documentation # ================================================================================ diff --git a/content/learning-paths/microcontrollers/cmsis-dsp/_review.md b/content/learning-paths/microcontrollers/cmsis-dsp/_review.md index 857f2dfc6..85c9a8c58 100644 --- a/content/learning-paths/microcontrollers/cmsis-dsp/_review.md +++ b/content/learning-paths/microcontrollers/cmsis-dsp/_review.md @@ -30,6 +30,16 @@ review: correct_answer: 1 explanation: > The library is provides vectorized versions of most algorithms for Helium and of most f32 algorithms for Neon. + - questions: + question: > + How is CMSIS-DSP library provided? + answers: + - Within a CMSIS-Pack + - In source code on Github + - Both + correct_answer: 3 + explanation: > + CMSIS-DSP is distributed in source form on Github and within the CMSIS-Core software pack. It is licensed under Apache License 2.0. # ================================================================================ diff --git a/content/learning-paths/microcontrollers/cmsis-dsp/cmsis-dsp-tests.md b/content/learning-paths/microcontrollers/cmsis-dsp/cmsis-dsp-tests.md index bc448c481..d321c0c8d 100644 --- a/content/learning-paths/microcontrollers/cmsis-dsp/cmsis-dsp-tests.md +++ b/content/learning-paths/microcontrollers/cmsis-dsp/cmsis-dsp-tests.md @@ -1,15 +1,15 @@ --- # User change title: "Build and run CMSIS-DSP tests on Corstone-300 FVP" - -weight: 3 # 1 is first, 2 is second, etc. +draft: true +weight: 5 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- The [CMSIS-DSP tests](https://github.com/ARM-software/CMSIS-DSP/blob/main/Testing) are publicly available, and are used for validation of the library. They can be run on the [Corstone-300](https://developer.arm.com/Processors/Corstone-300) Fixed Virtual Platform (FVP). -These tests are primarily for Arm internal use, but users can replicate if they wish. Else proceed to the [next step](../../cmsis-dsp/_review/). +These tests are primarily for Arm internal use, but users can replicate if they wish. Else proceed to the [next step](/learning-paths/microcontrollers/cmsis-dsp/_review/). These instructions assume an Ubuntu Linux host machine, or use of [Arm Virtual Hardware](https://www.arm.com/products/development-tools/simulation/virtual-hardware). diff --git a/content/learning-paths/microcontrollers/cmsis-dsp/example.md b/content/learning-paths/microcontrollers/cmsis-dsp/example.md deleted file mode 100644 index d2c8d9710..000000000 --- a/content/learning-paths/microcontrollers/cmsis-dsp/example.md +++ /dev/null @@ -1,83 +0,0 @@ ---- -# User change -title: Build an example application using CMSIS-DSP - -weight: 2 # 1 is first, 2 is second, etc. - -# Do not modify these elements -layout: "learningpathall" ---- -The [CMSIS-DSP](https://arm-software.github.io/CMSIS-DSP/latest/) software library is an open-source suite of common compute processing functions optimized for Arm Cortex-A and Cortex-M processors. - -The source code is available in [this GitHub repository](https://github.com/ARM-software/CMSIS-DSP). - -The library is easiest to use with Development tool IDEs such as `Keil MDK` and `Arm Development Studio`. The library is installed as a [CMSIS-Pack](https://open-cmsis-pack.github.io/Open-CMSIS-Pack-Spec/main/html/index.html). A number of example projects are also provided. - -Keil MDK will be used for this learning path. - -## Build example with Keil MDK - -Install and launch [Keil MDK](/install-guides/mdk/). - -Open the `Pack Installer`, select `ARM` as the device, and locate `DSP_Lib DotProduct example` from the `Examples` tab. - -Click `Copy`, and save the project to an appropriate location on your host. - -![Pack Installer #center](images/pack_installer.png) - -The project contains build targets for different Cortex-M processors. - -Open the `Project` > `Batch Setup` pane from the menu bar, and select all targets. Click `Rebuild` to build all. - -![Batch Setup #center](images/batch.png) - -## Run example on Cortex-M3 FVP - -From the `Select Target` pulldown, highlight the `ARMCM3` target (build for Cortex-M3). - -The project is already configured for the supplied Fixed Virtual Platforms (`FVPs`). See the `Options` > `Debug` pane. - -Start a debug session (`Ctrl+F5`) to load the image to the Cortex-M3 FVP, and run to `main`. - -Note the number of instructions executed to this point, as shown in the FVP display (`184` in the example below): - -![FVP Display #center](images/fvp.png) - -If not already set, place a breakpoint at the `while(1);` statement at the end of the `main` function. - -Click `Run` (or press `F5`) to run the example to this breakpoint, and stop. - -Note the number of instructions executed, and subtract the initialization cycle count. - -Terminate the debug session. - -## Run example on Cortex-M55 FVP - -From the `Select Target` pulldown, highlight the `ARMCM55_FP_MVE` target (build for Cortex-M55). This build makes use of the [Helium](https://www.arm.com/technologies/helium) vectorizing extensions that Cortex-M55 supports. - -Repeat the steps above to run on the Cortex-M55 FVP, and note the number of instructions executed, which should be a dramatic improvement over Cortex-M3. - -{{% notice Note%}} -The FVPs are instruction accurate but not cycle accurate. - -The instruction count is used here to illustrate relative performance to a high granularity. -{{% /notice %}} - -## Understand the example - -To make any function from the `CMSIS-DSP` library available to your code, simply include the `arm_math.h` header file in any relevant source: -```C -#include "arm_math.h" -``` -This file resides in the `Include` folder of the library installation, and so you should add this to the Include path (`-I`) for your compiler. - -For a Keil MDK project, this is done by selecting `CMSIS` > `DSP` in the `Manage Run-Time Environment` pane. - -![Manage Run-Time Environment #center](images/rte.png) - -The [example project](https://www.keil.com/pack/doc/CMSIS/DSP/html/group__DotproductExample.html) makes use of two functions from the library: - - * `arm_mult_f32()` - * `arm_add_f32()` - -The appropriate implementation is selected at build time, based on the processor. Hence the Helium optimized implementations can greatly accelerate the algorithm. diff --git a/content/learning-paths/microcontrollers/cmsis-dsp/mdk5.md b/content/learning-paths/microcontrollers/cmsis-dsp/mdk5.md new file mode 100644 index 000000000..cbf887bc4 --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis-dsp/mdk5.md @@ -0,0 +1,81 @@ +--- +# User change +title: Build example with Keil μVision + +weight: 4 # 1 is first, 2 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- +{{% notice Note%}} +Screenshots below are from older versions of Keil μVision, and are for illustrative purposes only. + +There may be slight differences with latest versions of tools and/or software packs. +{{% /notice %}} + +## Build example with Keil μVision + +Open the `Pack Installer`, select `ARM` as the device, and locate `CMSIS-DSP DotProduct example` from the `Examples` tab. + +Click `Copy`, and save the project to an appropriate location on your host. + +![Pack Installer #center](images/pack_installer.png) + +The project contains build targets for different Cortex-M processors. + +### CMSIS-DSP Software Pack + +The example is already configured to use the CMSIS-DSP software pack. To see this, open the `Manage Run-Time Environment` pane, and see `CMSIS` > `DSP`. + +![Manage Run-Time Environment #center](images/rte.png) + +### Rebuild + +Open the `Project` > `Batch Setup` pane from the menu bar, and select (at least) `ARMCM3` and `ARMCM55_FP_MVE` targets. Click `Rebuild`. + +![Batch Setup #center](images/batch.png) + +## Run example on Cortex-M3 FVP + +From the `Select Target` pulldown, highlight the `ARMCM3` target (build for Cortex-M3). + +The project is already configured for the supplied Fixed Virtual Platforms (`FVPs`). See the `Options` > `Debug` pane. + +{{% notice Note%}} +Depending on the version of MDK you have installed the path to FVP executable may need to be updated. + +* MDK versions before 5.37: `Keil_v5/ARM/FVP` + +* MDK versions 5.38, 5.39: `Keil_v5/ARM/VHT` + +* MDK version 5.40 or later: `Keil_v5/ARM/avh-fvp/bin/models` + +{{% /notice %}} + +Start a debug session (`Ctrl+F5`) to load the image to the Cortex-M3 FVP, and run to `main`. + +Note the number of instructions executed to this point, as shown in the FVP display (`184` in the example below): + +![FVP Display #center](images/fvp.png) + +If not already set, place a breakpoint at the `while(1);` statement at the end of the `main` function. + +Click `Run` (or press `F5`) to run the example to this breakpoint, and stop. + +Note the number of instructions executed, and subtract the initialization cycle count. + +Terminate the debug session. + +## Run example on Cortex-M55 FVP + +From the `Select Target` pulldown, highlight the `ARMCM55_FP_MVE` target (build for Cortex-M55). + +This build makes use of the [Helium](https://www.arm.com/technologies/helium) vectorizing extensions that Cortex-M55 supports. + +Repeat the steps above to run on the Corstone-300 FVP, and note the number of instructions executed, which should be a dramatic improvement over Cortex-M3. + +{{% notice Note%}} +The FVPs are instruction accurate but not cycle accurate. + +The instruction count is used here to illustrate relative performance to a high granularity. +{{% /notice %}} diff --git a/content/learning-paths/microcontrollers/cmsis-dsp/mdk6.md b/content/learning-paths/microcontrollers/cmsis-dsp/mdk6.md new file mode 100644 index 000000000..3cb68b27d --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis-dsp/mdk6.md @@ -0,0 +1,148 @@ +--- +# User change +title: Build example with Keil Studio (VS Code) + +weight: 3 # 1 is first, 2 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- +{{% notice Note%}} +If using Keil μVision, go to [Build example with Keil μVision](/learning-paths/microcontrollers/cmsis-dsp/mdk5/). +{{% /notice %}} + +## Clone the repository to get the example code + +The source code of the example is available within the `CMSIS-DSP` Github repository. + +Open a command prompt, and navigate to an appropriate folder. + +Clone the repository. + +``` command +git clone https://github.com/ARM-software/CMSIS-DSP +``` + +## Import example into Keil Studio + +Keil Studio projects are based on the [CMSIS Solution](https://github.com/Open-CMSIS-Pack/cmsis-toolbox/blob/main/docs/YML-Input-Format.md) standard. + +The example provided is in μVision `.uvprojx` format. The Keil Studio VS Code Extensions include functionality to import such projects. + +Launch VS Code IDE, and start a New Window (`Ctrl` + `Shift` + `N`). + +Select the `CMSIS` extension, and click on `Convert a μVision Project`. + +Browse to the above cloned repository, and locate the `CMSIS-DSP/Examples/ARM/arm_dotproduct_example` folder. + +Select the `arm_dotproduct_example.uvprojx` file, and open the newly created `csolution`. + +## Configure solution environment + +VS Code allows complete configurability of all aspects of the project. + +Locate `vcpkg-configuration.json` within the project. This file defines the components used. + +Right-click on this file, and select `Configure Arm Tools Environment` to open the configuration panel. + +From the various pull-downs, ensure that the most up to date versions of the following are selected: + +* Arm CMSIS-Toolbox +* Arm Compiler for Embedded +* Arm Debugger +* Arm Virtual Hardware for Cortex-M based on Fast Models +* Kitware's cmake tool +* Ninja Build + +Others can be set as `None` as they are not needed for this example. + +If you open `vcpkg-configuration.json` in the text editor you will see these set as selected. Close the file to save. + +All necessary components will be downloaded and installed as necessary (if not already installed). + +## Configure CMSIS options + +Select `CMSIS` from the Extensions icon list. You will see the project structure. + +Move cursor over the top-level, and click on `Manage Software Components`. This is the view to add CMSIS Software Packs to your project. + +Select `CMSIS > Core`, `CMSIS > DSP`, and `Device > Startup` (these are likely selected by default). + +Close this view to save. + +## Configure build options + +Move cursor over the top level project, and click `Open File` to open the `cproject.yml` file, which defines the build options for the different targets. + +Locate the `Link` settings for the `ARMCM4FP` and `ARMCM55FPMVE` targets (and any other targets you wish to build), and add the following to the linker options list if not already present: +```command + - --entry=Reset_Handler +``` + +## Configure build context {#build} + +The imported example includes build targets for various Arm processors. + +Click on the `Manage Solution Settings` gear icon to open the `csolution.yml` file that defines the project. + +Set `ARMCM3` as the `Active Target`. + +Click the `Build` hammer icon to build for Cortex-M3. + +## Run example on Cortex-M3 FVP {#run} + +Select `Run and Debug` from the Extensions icon list. + +Click the gear icon to open `launch.json`. This is the file that defines the debug instance. + +Right-click on `launch.json` and select `Open Run and Debug Configuration`. + +From the `Selected Configuration` pull-down, select `New Configuration` > `Launch FVP`. Edit the `Configuration Name` if desired. + +From the `Target` > `Configuration Database Entry` pull-down, select `MPS2_Cortex_M3` > `Cortex-M3`. + +Other fields can be left as default. Close the file to save. Observe that `launch.json` has been updated. + +Select this configuration from the `Run and Debug` pulldown, and `Start Debugging` (`F5`). + +The FVP will launch with the example code, and stop at `main()`. + +Set breakpoint(s) at the `while(1);` terminations at the end of `main()`. + +Note the number of instructions executed to this point, as shown in the FVP display (`184` in the example below): + +![FVP Display #center](images/fvp.png) + +Click `Continue` (or press `F5`) to run the example to this breakpoint, and stop. + +Note the number of instructions executed, and subtract the initialization cycle count. + +Terminate the debug session (`Stop` button, `Ctrl`+`F5`). + +## Run example on Cortex-M55 FVP + +We will now build for the `ARMCM55_FP_MVE` target (build for Cortex-M55). This build makes use of the [Helium](https://www.arm.com/technologies/helium) vectorizing extensions that Cortex-M55 supports. + +Repeat the steps above to [build](#build) for `ARMCM55FPMVE`. + +Repeat the steps above to [run](#run) on `Corstone-300 FVP`. + +If the `Corstone-300 FVP` is not available in the pulldown, you will need to manually configure in `launch.json`. Note the `cdbEntry` line in the below. +```json + "configurations": [ + { + "name": "M55", + "type": "arm-debugger.fvp", + "request": "launch", + "program": "${command:arm-debugger.getApplicationFile}", + "cdbEntry": "Arm SubSystem FVP::Corstone SSE-300 Ethos-U55 (MPS3)::Bare Metal Debug::Bare Metal Debug::Cortex-M55" + }, + ] +``` +You should be a dramatic performance improvement over Cortex-M3. + +{{% notice Note%}} +The FVPs are instruction accurate but not cycle accurate. + +The instruction count is used here to illustrate relative performance to a high granularity. +{{% /notice %}} diff --git a/content/learning-paths/microcontrollers/cmsis-dsp/whatis.md b/content/learning-paths/microcontrollers/cmsis-dsp/whatis.md new file mode 100644 index 000000000..1ffec837c --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis-dsp/whatis.md @@ -0,0 +1,47 @@ +--- +# User change +title: What is CMSIS-DSP? + +weight: 2 # 1 is first, 2 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- +The [CMSIS-DSP](https://arm-software.github.io/CMSIS-DSP/latest/) software library is an open-source suite of common compute processing functions optimized for Arm Cortex-A and Cortex-M processors. + +The source code is available in [this GitHub repository](https://github.com/ARM-software/CMSIS-DSP). + +The library is easiest to use with Development tool IDEs such as `Keil MDK` and `Arm Development Studio`. + +The library can be installed as a [CMSIS-Pack](https://open-cmsis-pack.github.io/Open-CMSIS-Pack-Spec/main/html/index.html). + +A number of example projects are also provided. + + +## Development Tools + +[Arm Keil MDK](https://www.keil.arm.com/) will be used for this learning path. You can use `Keil Studio Visual Studio Code Extensions` or (legacy) `Keil μVision` IDE. + +See the below install guides for set up instructions: + +* [Keil Studio VS Code Extensions](/install-guides/keilstudio_vs/) +* [Keil μVision](/install-guides/mdk/) + +Install the appropriate IDE you wish to use. + +## Using the CMSIS-DSP library + +To make any function from the `CMSIS-DSP` library available to your code, simply include the `arm_math.h` header file in any relevant source: +```C +#include "arm_math.h" +``` +This file resides in the `Include` folder of the library installation. + +The [Dot Product example](https://www.keil.com/pack/doc/CMSIS/DSP/html/group__DotproductExample.html) used makes use of two functions from the library: + + * `arm_mult_f32()` + * `arm_add_f32()` + +The appropriate implementation is selected at build time based on the processor. + +For more information refer to the [CMSIS-DSP library documentation](https://arm-software.github.io/CMSIS-DSP/latest/index.html). diff --git a/content/learning-paths/microcontrollers/cmsis_rtx/_index.md b/content/learning-paths/microcontrollers/cmsis_rtx/_index.md index b0932a9ff..ae4373201 100644 --- a/content/learning-paths/microcontrollers/cmsis_rtx/_index.md +++ b/content/learning-paths/microcontrollers/cmsis_rtx/_index.md @@ -1,5 +1,6 @@ --- -title: Build an RTX5 RTOS application +title: Build an RTX5 RTOS application with Keil μVision + minutes_to_complete: 30 @@ -9,7 +10,7 @@ learning_objectives: - Implement a basic RTOS-based application prerequisites: - - Arm [Keil MDK](/install-guides/mdk) or [Arm Development Studio](/install-guides/armds) (MDK recommended) + - An installation of [Arm Keil MDK](/install-guides/mdk) or [Arm Development Studio](/install-guides/armds) (MDK recommended) - Some familiarity with CMSIS is assumed author_primary: Ronan Synnott diff --git a/content/learning-paths/microcontrollers/cmsis_rtx/create.md b/content/learning-paths/microcontrollers/cmsis_rtx/create.md index 4d1dff265..f60287344 100644 --- a/content/learning-paths/microcontrollers/cmsis_rtx/create.md +++ b/content/learning-paths/microcontrollers/cmsis_rtx/create.md @@ -11,7 +11,11 @@ This learning path will introduce the steps to create a basic RTX based RTOS app For more information on the latest update, see the [CMSIS v6 is here](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/cmsis-v6-is-here) blog. -You will primarily use [Keil MDK](/install-guides/mdk) through this Learning Path. If you are using [Arm Development Studio](/install-guides/armds) refer to the appropriate comments. +You will use [Keil MDK](/install-guides/mdk) through this Learning Path. If you are using [Arm Development Studio](/install-guides/armds) refer to the appropriate comments. + +{{% notice Note%}} +If using `Arm Keil Studio for Visual Studio Code` please go to [Build an RTX5 RTOS application with Keil Studio (VS Code)](/learning-paths/microcontrollers/cmsis_rtx_vs/). +{{% /notice %}} ## Install (update) to latest CMSIS Packs @@ -19,7 +23,7 @@ Open the 'Pack installer' and install the latest CMSIS packs. At a minimum the f * `ARM::CMSIS` * `ARM::CMSIS-RTX` -* 'ARM::CMSIS-View +* `ARM::CMSIS-View` {{% notice Arm Development Studio%}} Add required `CMSIS-Packs` via the `CMSIS Pack Manager` perspective. @@ -79,9 +83,27 @@ Click `Options for Target`, to open that dialog. This is where build and other s ### Set FVP as debug target -Navigate to the `Debug` tab, and select `Models Cortex-M Debugger` from the `Use` pull-down list. -Click `Settings`, then the `Command` browse (`...`) button, to locate `VHT_MPS2_Cortex-M4.exe` within your Keil MDK installation (`ARM\VHT\` folder). Click `OK`. +### Configure the FVP + +In the `Debug` tab, select `Models Cortex-M Debugger`. Click `Settings`, and browse for the FVP provided with MDK in the `Command` pane. +``` +Keil_v5/ARM/avh-fvp/bin/models/FVP_MPS2_Cortex-M4_MDK.exe +``` + +{{% notice Note%}} +MDK versions 5.37 and earlier will find the FVP at: + +`Keil_v5/ARM/FVP/MPS2_Cortex-M/FVP_MPS2_Cortex-M4_MDK.exe` + +In 5.38 and 5.39 the FVP is installed at: + +`Keil_v5/ARM/VHT/VHT_MPS2_Cortex-M4_MDK.exe` + +In 5.40 and later the FVP is installed at: + +`Keil_v5/ARM/avh-fvp/bin/models/FVP_MPS2_Cortex-M4_MDK.exe` +{{% /notice %}} {{% notice Arm Development Studio%}} Ignore this step for now. Debug configuration will be set up later. diff --git a/content/learning-paths/microcontrollers/cmsis_rtx/threads.md b/content/learning-paths/microcontrollers/cmsis_rtx/threads.md index 777f1d110..108e3aa12 100644 --- a/content/learning-paths/microcontrollers/cmsis_rtx/threads.md +++ b/content/learning-paths/microcontrollers/cmsis_rtx/threads.md @@ -7,11 +7,11 @@ weight: 4 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -Implement the main RTOS thread (`app_main()`), whose role is primarily to start and manage the other threads of the system. +Implement the main RTOS thread (`app_main`), whose role is primarily to start and manage the other threads of the system. In this example you shall create 3 threads. The number and naming of the threads is arbitrary. -## Create app_main() +## Create app_main Right click on the `Source` folder under the `FVP` target, and `Add a new item`. Select `C file (.c)`, and create the `app_main.c` file with the contents below: diff --git a/content/learning-paths/microcontrollers/cmsis_rtx_vs/_index.md b/content/learning-paths/microcontrollers/cmsis_rtx_vs/_index.md new file mode 100644 index 000000000..aa9a64197 --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis_rtx_vs/_index.md @@ -0,0 +1,38 @@ +--- +title: Build an RTX5 RTOS application with Keil Studio (VS Code) + + +minutes_to_complete: 30 + +who_is_this_for: This is an introductory topic for software developers new to RTOS development. + +learning_objectives: + - Understand the basics of RTX-based RTOS application development + - Configure and manage an RTOS project in Keil Studio, including defining the memory map, selecting software components, and setting up debugging configurations for Cortex-M processors + - Create and manage multiple threads within an RTX5 RTOS application + +prerequisites: + - Installation of [Arm Keil Studio for VS Code](/install-guides/keilstudio_vs) + - Some familiarity with CMSIS is assumed + +author_primary: Ronan Synnott + +### Tags +skilllevels: Introductory +subjects: RTOS Fundamentals +armips: + - Cortex-M +operatingsystems: + - RTOS +tools_software_languages: + - Coding + - RTX + - Keil MDK + - Arm Development Studio + +### 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/microcontrollers/cmsis_rtx_vs/_next-steps.md b/content/learning-paths/microcontrollers/cmsis_rtx_vs/_next-steps.md new file mode 100644 index 000000000..372d55ad7 --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis_rtx_vs/_next-steps.md @@ -0,0 +1,35 @@ +--- +# ================================================================================ +# Edit +# ================================================================================ + +next_step_guidance: > + You have created a simple RTOS application using Keil RTX5. If you are interested in running Zephyr RTOS on Corstone-300 FVP, follow this recommended learning path: +# 1-3 sentence recommendation outlining how the reader can generally keep learning about these topics, and a specific explanation of why the next step is being recommended. + +recommended_path: "/learning-paths/microcontrollers/zephyr" +# Link to the next learning path being recommended(For example this could be /learning-paths/servers-and-cloud-computing/mongodb). + + +# further_reading links to references related to this path. Can be: + # Manuals for a tool / software mentioned (type: documentation) + # Blog about related topics (type: blog) + # General online references (type: website) + +further_reading: + - resource: + title: CMSIS-RTOS2 Documentation + link: https://www.keil.com/pack/doc/CMSIS/RTOS2/html/index.html + type: documentation + - resource: + title: Event Recorder and Component Viewer + link: https://www.keil.com/pack/doc/compiler/EventRecorder/html/index.html + type: documentation + +# ================================================================================ +# 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/microcontrollers/cmsis_rtx_vs/_review.md b/content/learning-paths/microcontrollers/cmsis_rtx_vs/_review.md new file mode 100644 index 000000000..4a51a4d5d --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis_rtx_vs/_review.md @@ -0,0 +1,51 @@ +--- +# ================================================================================ +# Edit +# ================================================================================ + +# Always 3 questions. Should try to test the reader's knowledge, and reinforce the key points you want them to remember. + # question: A one sentence question + # answers: The correct answers (from 2-4 answer options only). Should be surrounded by quotes. + # correct_answer: An integer indicating what answer is correct (index starts from 0) + # explanation: A short (1-3 sentence) explanation of why the correct answer is correct. Can add additional context if desired + + +review: + - questions: + question: > + Which function is used to invoke an OS thread? + answers: + - "osKernelInitialize()" + - "osKernelStart()" + - "osThreadNew()" + correct_answer: 3 + explanation: > + osThreadNew() is called before osKernelStart() to define the main thread, and then by the main thread to start other threads. + - questions: + question: > + What is the purpose of the `osKernelStart()` function? + answers: + - "To create the main application thread" + - "To start the RTOS kernel and begins thread switching" + - "To update the system clock" + correct_answer: 2 + explanation: > + `osKernelStart()` starts the RTOS kernel and enables thread switching, making it essential for multitasking. + - questions: + question: > + What happens if the code execution reaches the infinite while(1) loop in the main function? + answers: + - "All threads are successfully started." + - "Something went wrong, likely with the platform initialization." + - "The RTOS has successfully initialized the kernel." + correct_answer: 2 + explanation: > + Reaching the infinite `while(1)` loop in the main function suggests an error occurred during platform initialization. + +# ================================================================================ +# 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/microcontrollers/cmsis_rtx_vs/build_and_run.md b/content/learning-paths/microcontrollers/cmsis_rtx_vs/build_and_run.md new file mode 100644 index 000000000..613955d02 --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis_rtx_vs/build_and_run.md @@ -0,0 +1,40 @@ +--- +# User change +title: "Build and run the application" + +weight: 5 # 1 is first, 2 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- +You are now ready to build and run your application. + +## Build + +In the CMSIS Extension view, save all your files. Then, click the hammer icon to build the example. + +## Debug + +To start debugging, click the `Debug` icon, or enter the `Run and Debug` extension view. + +Choose the debug connection you configured earlier to launch the FVP (Fixed Virtual Platform). + +Use the debugging controls to step through your code. + +Once the OS is initialized, you will see the output from the threads displayed in the `Debug Console`. + +``` +[model] hello from thread 1 +[model] hello from thread 2 +[model] hello from thread 3 +[model] hello from thread 1 +[model] hello from thread 2 +... +``` +To end the debug session, click `Stop` or press `Ctrl`+`F5`. + +{{% notice Note%}} +For a more feature-rich debugging environment, consider using the `Arm Keil μVision IDE`. + +For more details, see [Build an RTX5 RTOS application with Keil μVision](/learning-paths/microcontrollers/cmsis_rtx/). +{{% /notice %}} diff --git a/content/learning-paths/microcontrollers/cmsis_rtx_vs/create.md b/content/learning-paths/microcontrollers/cmsis_rtx_vs/create.md new file mode 100644 index 000000000..deddd6c6b --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis_rtx_vs/create.md @@ -0,0 +1,110 @@ +--- +# User change +title: "Create csolution project" + +weight: 2 # 1 is first, 2 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- +This learning path will introduce the steps to create a basic RTX-based RTOS application using the latest features of [CMSIS](https://www.keil.arm.com/cmsis). + +For more information on the latest update, see the [CMSIS v6 is here](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/cmsis-v6-is-here) blog. + +You will use **[Keil Studio for VS Code](/install-guides/keilstudio_vs)** in this Learning Path. + +This Learning Path is written for the supplied **Cortex-M4 Fixed Virtual Platform (FVP)**, but you can run it on any of the 10,000+ devices supported by [CMSIS-Pack](https://www.open-cmsis-pack.org/). + +{{% notice Note%}} +If using `Arm Keil μVision IDE` or Arm Development Studio, refer to the [Build an RTX5 RTOS application with Keil μVision](/learning-paths/microcontrollers/cmsis_rtx/) guide. +{{% /notice %}} + +## Create a New Project + +Keil Studio projects are based on the [CMSIS Solution](https://github.com/Open-CMSIS-Pack/cmsis-toolbox/blob/main/docs/YML-Input-Format.md) standard. + +1. Open the VS Code IDE, and select `File` > `New File` from the `File` menu. You will be prompted for the type of file. Select `New Solution` (`Arm CMSIS Solution`). +2. The `Create New Solution` window will open. Click the `Target Device` pulldown, and search for `ARMCM4`. +3. From the `Templates, Reference Applications, and Examples` pulldown, select `Blank Solution`. +4. Ensure `Arm Compiler 6` is the selected compiler. +5. Enter an appropriate `Solution Name`. This will define the folder name that the project will be created into. You can also change the folder location if necessary. +6. Click `Create`. You will be prompted to open the solution in the current window, or open a new window. + +## Configure the Solution Environment + +VS Code allows complete configurability of all aspects of the project. + +- Locate `vcpkg-configuration.json` within the project. This file defines the components used. +- Right-click on this file, and select `Configure Arm Tools Environment` to open the configuration panel. + +From the dropdown menus, make sure to select the most up-to-date versions of the following: + +- Arm CMSIS-Toolbox +- Arm Compiler for Embedded +- Arm Debugger +- Arm Virtual Hardware for Cortex-M based on Fast Models +- Kitware's CMake tool +- Ninja Build + +Set all other tools to **None** as they are not needed for this example. + +If you open `vcpkg-configuration.json` in the text editor, you’ll see these selections reflected. Close the file to save your changes. + +All necessary components will be downloaded and installed as necessary (if not already installed). + +## Configure CMSIS Options + +1. Select **CMSIS** from the Extensions icon list in VS Code. You will see the project structure. +2. Hover over the top-level project and click **Manage Software Components** to add CMSIS Software Packs to your project. + +Enable the following components: +* `CMSIS > Core` +* `CMSIS > OSTick > SysTick` +* `CMSIS > RTOS2 > Keil RTX` +* `Device > Startup` + +You may need to select `Software packs: All packs` from the pull down. + +If prompted in the `Validation` pane, select the latest available version for each. Use the `CMSIS-RTX` pack if others are shown. + +Close this view to save. + +## Define the Memory Map + +Use [scatter-loading](https://developer.arm.com/documentation/101754/latest/armlink-Reference/Scatter-loading-Features/The-scatter-loading-mechanism/Overview-of-scatter-loading) to define the memory map to the linker. + +The memory map for the FVP is given in the [documentation](https://developer.arm.com/documentation/100964/latest/Microcontroller-Prototyping-System-2/MPS2---memory-maps/MPS2---memory-map-for-models-without-the-Armv8-M-additions). + +The project should be configured to use `ARMCM4_ac6.sct` as the scatter file. Locate this file in the CMSIS Extension view, and click to create. + +Populate with the following. + +```text +LOAD 0x0 0x400000 { + ROOT 0x0 0x400000 { + *.o (RESET, +First) + *(InRoot$$Sections) + .ANY (+RO) } + + RAM 0x20000000 0x40000 { + .ANY (+RW +ZI) } + + ARM_LIB_HEAP 0x20040000 EMPTY 0x10000 {} + + ARM_LIB_STACK 0x20050000 EMPTY 0x10000 {} +} +``` + +## Configure Debug with the FVP + +1. Select `Run and Debug` from the Extensions icon list. +2. Click the gear icon to open `launch.json`. This is the file that defines the debug instance. +3. Right-click on `launch.json` and select `Open Run and Debug Configuration`. + +From the `Selected Configuration` pull-down, select `New Configuration` > `Launch FVP`. Edit the `Configuration Name` if desired. + +From the `Target` > `Configuration Database Entry` pull-down, select `MPS2_Cortex_M4` > `Cortex-M4`. + +Leave other fields as default. Observe that `launch.json` has been updated. + +Close the file to save your configuration. diff --git a/content/learning-paths/microcontrollers/cmsis_rtx_vs/initialize.md b/content/learning-paths/microcontrollers/cmsis_rtx_vs/initialize.md new file mode 100644 index 000000000..4b15b001e --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis_rtx_vs/initialize.md @@ -0,0 +1,59 @@ +--- +# User change +title: "Initialize the Operating System" + +weight: 3 # 1 is first, 2 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- +[Keil RTX5](https://www2.keil.com/mdk5/cmsis/rtx) is a feature-rich real-time operating system (RTOS). CMSIS and the [CMSIS-RTOS2](https://arm-software.github.io/CMSIS_5/RTOS2/html/index.html) API makes it easy to work with. + +When setting up the project's Run-Time Environment, ensure you add the appropriate system initialization code (`C Startup`). + +Once this is done, the `RTX5` initialization code is typically the same. It involves setting up the `SysTick` timer with the [SystemCoreClockUpdate()](https://www.keil.com/pack/doc/CMSIS/Core/html/group__system__init__gr.html#gae0c36a9591fe6e9c45ecb21a794f0f0f) function, then initializing and starting the RTOS. + +## Create `main()` + +Return to the `CMSIS` view. + +Within the `Source Files` group, a `main.c` is automatically created. Click on the file to open it in the text editor. + +Delete any auto-generated code and replace it with the following: + +```C +#include "RTE_Components.h" +#include CMSIS_device_header +#include "cmsis_os2.h" + +void app_main(void *); + +int __attribute__((noreturn)) main (void) { + SystemCoreClockUpdate(); // initialize clocks etc + + osKernelInitialize(); // initialize RTOS + + osThreadNew(app_main, NULL, NULL); // Create application main thread + + if (osKernelGetState() == osKernelReady) // If all OK... + osKernelStart(); // Start thread execution + + while(1); // If you get to here, something has gone wrong! +} +``` + +## Understanding the Code + +The function [osKernelStart()](https://arm-software.github.io/CMSIS_6/latest/RTOS2/group__CMSIS__RTOS__KernelCtrl.html#ga9ae2cc00f0d89d7b6a307bba942b5221) is designed to never return. + +If your code reaches the infinite `while()` loop, something has gone wrong - most likely with the platform initialization code. + +All threads should follow a prototype like this: +```C +void thread(void *); +``` +The argument for this function is provided as the second parameter of the [osThreadNew()](https://arm-software.github.io/CMSIS_6/latest/RTOS2/group__CMSIS__RTOS__ThreadMgmt.html#ga48d68b8666d99d28fa646ee1d2182b8f) function. Use `NULL` if no argument to pass. + +In the example above, `app_main` is used as the main application thread, but this naming is arbitrary. From here, you will spawn all other threads in the RTOS. + +{{% notice %}} Tip: Naming the main application thread is flexible. Choose a name that clearly reflects its function. {{% /notice %}} diff --git a/content/learning-paths/microcontrollers/cmsis_rtx_vs/threads.md b/content/learning-paths/microcontrollers/cmsis_rtx_vs/threads.md new file mode 100644 index 000000000..15ebb7ba5 --- /dev/null +++ b/content/learning-paths/microcontrollers/cmsis_rtx_vs/threads.md @@ -0,0 +1,61 @@ +--- +# User change +title: "Create RTOS Threads" + +weight: 4 # 1 is first, 2 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- +In this step, you will implement the main RTOS thread (`app_main`), which is primarily responsible for starting and managing the other threads in the system. + +You will create three threads. The number and naming of the threads are flexible, so feel free to adjust as needed. + +## Create `app_main` + +Click on the `+` icon within the `Source Files` Group, and add a new file `app_main.c`. Populate with the below. + +```C +#include "cmsis_os2.h" + +void thread1(void *); +void thread2(void *); +void thread3(void *); + +void app_main (void *argument) { + osThreadNew(thread1, NULL, NULL); // Create thread1 + osThreadNew(thread2, NULL, NULL); // Create thread2 + osThreadNew(thread3, NULL, NULL); // Create thread3 +} +``` +## Create Threads + +Now you can implement the functionality of the threads themselves. Start with a simple example. Each thread will say hello, and then pause for a period, forever. + +Click on the `+` icon within the `Source Files` Group, and add a new file `threads.c`. Populate with the contents below. + +```C +#include "cmsis_os2.h" +#include + +void __attribute__((noreturn)) thread1(void *argument){ + for(;;){ + printf("hello from thread 1\n"); + osDelay(1000); + } +} + +void __attribute__((noreturn)) thread2(void *argument){ + for(;;){ + printf("hello from thread 2\n"); + osDelay(1000); + } +} + +void __attribute__((noreturn)) thread3(void *argument){ + for(;;){ + printf("hello from thread 3\n"); + osDelay(1000); + } +} +``` diff --git a/content/learning-paths/microcontrollers/coverage_mdk/images/b_target_options.png b/content/learning-paths/microcontrollers/coverage_mdk/images/b_target_options.png new file mode 100644 index 000000000..065144d48 Binary files /dev/null and b/content/learning-paths/microcontrollers/coverage_mdk/images/b_target_options.png differ diff --git a/content/learning-paths/microcontrollers/coverage_mdk/images/b_uv4_packinst.png b/content/learning-paths/microcontrollers/coverage_mdk/images/b_uv4_packinst.png new file mode 100644 index 000000000..2da72ebaa Binary files /dev/null and b/content/learning-paths/microcontrollers/coverage_mdk/images/b_uv4_packinst.png differ diff --git a/content/learning-paths/microcontrollers/coverage_mdk/mdk.md b/content/learning-paths/microcontrollers/coverage_mdk/mdk.md index 930f48e51..f823e8384 100644 --- a/content/learning-paths/microcontrollers/coverage_mdk/mdk.md +++ b/content/learning-paths/microcontrollers/coverage_mdk/mdk.md @@ -15,7 +15,7 @@ Code coverage can be performed on any project that runs on a suitable target. Yo ## Import and build the example project -Open the uVision IDE, and then the Pack Installer. +Open the uVision IDE, and click to open the Pack Installer ![Pack Installer Icon](images/b_uv4_packinst.png) In the `Devices` tree, select `ARM` > `ARM Cortex M3` > `ARMCM3` (use search text box if necessary). @@ -27,7 +27,7 @@ Open the project in MDK, and build. By default, this project uses the legacy simulator provided with MDK, which does not support code coverage. -To run on the FVP, open 'Options for Target...', navigate to `Debug` pane, and select `Models Cortex-M Debugger` from the `Use:` pull-down. Click `Settings`, and under `Command`, browse for one of the supplied FVPS in the `ARM\FVP\` folder of your MDK installation (eg `FVP_MPS2_Cortex-M3_MDK,exe`). +To run on the FVP, open Options for Target ![Options for Target Icon](images/b_target_options.png), navigate to `Debug` pane, and select `Models Cortex-M Debugger` from the `Use:` pull-down. Click `Settings`, and under `Command`, browse for one of the supplied FVPS in the `ARM\FVP\` folder of your MDK installation (eg `FVP_MPS2_Cortex-M3_MDK.exe`). Specify a `Coverage File`, and enable `Load` and `Store` of that file. Because of the way that the data is created, code coverage cannot be updated in real-time. diff --git a/content/learning-paths/microcontrollers/mix_c_asm/_index.md b/content/learning-paths/microcontrollers/mix_c_asm/_index.md index ab2991583..8e1669532 100644 --- a/content/learning-paths/microcontrollers/mix_c_asm/_index.md +++ b/content/learning-paths/microcontrollers/mix_c_asm/_index.md @@ -13,6 +13,11 @@ learning_objectives: - Use Arm register calling conventions when writing subroutines in assembly language.  - Use the debugger to view and analyse the processor state.  +## Setting to draft = true to hide this LP. Can it be deleted? Replication of content in //asm. +draft: true +cascade: + draft: true + prerequisites: - Keil MDK IDE - Some familiarity with C/Assembly diff --git a/content/learning-paths/microcontrollers/mix_c_asm/setup.md b/content/learning-paths/microcontrollers/mix_c_asm/setup.md index a4c5d7af0..f175c7914 100644 --- a/content/learning-paths/microcontrollers/mix_c_asm/setup.md +++ b/content/learning-paths/microcontrollers/mix_c_asm/setup.md @@ -12,7 +12,7 @@ In this exercise, you will execute assembly code using the `Keil MDK`, and exami This exercise is adapted from the [Efficient Embedded Systems Education Kit](https://github.com/arm-university/Efficient-Embedded-Systems-Design-Education-Kit). -Please make sure to read and go through the [Getting Started with MDK](https://developer.arm.com/documentation/KGS1/latest/) documentation or [Learning Path](../../uv_debug/) if you are unfamiliar with its usage. +Please make sure to read and go through the [Getting Started with MDK](https://developer.arm.com/documentation/KGS1/latest/) documentation or [Learning Path](/learning-paths/microcontrollers/uv_debug/) if you are unfamiliar with its usage. The example can run on any supported development platform. Instructions are provided for the `Nucleo-F401RE` development board from ST Microelectronics as well as the Cortex-M3 Virtual Hardware Target (`VHT`) supplied with MDK Professional Edition. diff --git a/content/learning-paths/microcontrollers/uvprojx-conversion/_index.md b/content/learning-paths/microcontrollers/uvprojx-conversion/_index.md index a15aaaa21..d4f0d67fe 100644 --- a/content/learning-paths/microcontrollers/uvprojx-conversion/_index.md +++ b/content/learning-paths/microcontrollers/uvprojx-conversion/_index.md @@ -11,8 +11,8 @@ learning_objectives: - Convert and build uvprojx-based projects on the command line. prerequisites: - - Install [Keil Studio](../../../install-guides/keilstudio_vs/) on your machine. - - Install [µVision](../../../install-guides/mdk/) on your machine. + - Install [Keil Studio](/install-guides/keilstudio_vs/) on your machine. + - Install [µVision](/install-guides/mdk/) on your machine. - Install [vcpkg](https://vcpkg.io/en/getting-started.html) for the command line flow. - The µVision project must use Arm Compiler 6 as the default toolchain. Arm Compiler 5 is not supported. diff --git a/content/learning-paths/microcontrollers/vcpkg-tool-installation/config_creation.md b/content/learning-paths/microcontrollers/vcpkg-tool-installation/config_creation.md index 5219d56c2..b3ecb1292 100644 --- a/content/learning-paths/microcontrollers/vcpkg-tool-installation/config_creation.md +++ b/content/learning-paths/microcontrollers/vcpkg-tool-installation/config_creation.md @@ -36,7 +36,7 @@ Create a new file called `vcpkg-configuration.json`. The following template give ``` {{% notice Note %}} -If you are using the [conversion flow for MDK v5 uvprojx files](../../uvprojx-conversion/), a configuration file is automatically created. +If you are using the [conversion flow for MDK v5 uvprojx files](/learning-paths/microcontrollers/uvprojx-conversion/), a configuration file is automatically created. {{% /notice %}} ### Anatomy of the JSON file @@ -47,7 +47,7 @@ If you are using the [conversion flow for MDK v5 uvprojx files](../../uvprojx-co {{% notice Tip %}} - Refer to the [vcpkg-configuration.json reference](https://learn.microsoft.com/en-gb/vcpkg/reference/vcpkg-configuration-json) for more information. -- You can also use vcpkg commands to work with the configuration file. Refer to [Working with the vcpkg-configuration.json file](../usage#working-with-the-vcpkg-configurationjson-file) +- You can also use vcpkg commands to work with the configuration file. Refer to [Working with the vcpkg-configuration.json file](/learning-paths/microcontrollers/vcpkg-tool-installation/usage#working-with-the-vcpkg-configurationjson-file) {{% /notice %}} You can now start using the vcpkg environment. diff --git a/content/learning-paths/servers-and-cloud-computing/_index.md b/content/learning-paths/servers-and-cloud-computing/_index.md index ec67da604..943423726 100644 --- a/content/learning-paths/servers-and-cloud-computing/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/_index.md @@ -9,9 +9,9 @@ maintopic: true operatingsystems_filter: - Android: 1 - Baremetal: 1 -- Linux: 92 -- macOS: 2 -- Windows: 5 +- Linux: 94 +- macOS: 3 +- Windows: 7 pinned_modules: - module: name: Recommended getting started learning paths @@ -22,11 +22,11 @@ subjects_filter: - CI-CD: 2 - Containers and Virtualization: 23 - Databases: 15 -- Libraries: 5 +- Libraries: 6 - ML: 8 - Performance and Architecture: 34 - Storage: 1 -- Web: 7 +- Web: 9 subtitle: Optimize cloud native apps on Arm for performance and cost title: Servers and Cloud Computing tools_software_languages_filter: @@ -96,6 +96,7 @@ tools_software_languages_filter: - NEON: 1 - Nexmark: 1 - Nginx: 3 +- Node.js: 2 - PAPI: 1 - perf: 3 - PostgreSQL: 4 @@ -120,14 +121,15 @@ tools_software_languages_filter: - Trusted Firmware: 1 - TypeScript: 1 - Vectorscan: 1 +- Visual Studio Code: 2 - WordPress: 3 - x265: 1 - zlib: 1 - Zookeeper: 1 weight: 1 cloud_service_providers_filter: -- AWS: 9 -- Google Cloud: 6 +- AWS: 11 +- Google Cloud: 8 - Microsoft Azure: 7 - Oracle: 2 --- diff --git a/content/learning-paths/servers-and-cloud-computing/arm_pmu/_index.md b/content/learning-paths/servers-and-cloud-computing/arm_pmu/_index.md index c178d5546..988795cea 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm_pmu/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/arm_pmu/_index.md @@ -11,7 +11,7 @@ learning_objectives: - Use PAPI to instrument event counters in code - Use the Linux perf_event_open system call to instrument event counters in code prerequisites: - - An Arm computer running Linux. A bare metal or cloud metal instance is best because they expose more counters. You can use a virtual machine (VM), but fewer counters may be available. + - An Arm computer running Linux. A bare metal or cloud metal instance is best because they expose more counters. You can use a virtual machine (VM), but fewer counters may be available. These instructions have been tested on the `a1.metal` instance type. author_primary: Julio Suarez diff --git a/content/learning-paths/servers-and-cloud-computing/arm_pmu/assembly.md b/content/learning-paths/servers-and-cloud-computing/arm_pmu/assembly.md index 681d4e621..c305af325 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm_pmu/assembly.md +++ b/content/learning-paths/servers-and-cloud-computing/arm_pmu/assembly.md @@ -8,7 +8,7 @@ There are two Arm instructions that allow access to system registers. These are ## Using assembly for system counter access -If you only need to count time/cycles, then the [system counter](https://developer.arm.com/documentation/102379/0102/System-Counter?lang=en)] can be used. You can do this from user space. An example of measuring system counter ticks across a function is shown below: +If you only need to count time/cycles, then the [system counter](https://developer.arm.com/documentation/102379/0102/System-Counter?lang=en) can be used. You can do this from user space. An example of measuring system counter ticks across a function is shown below: Use a text editor to create a file named `syscnt.c` with the code below: diff --git a/content/learning-paths/servers-and-cloud-computing/arm_pmu/perf_event_open.md b/content/learning-paths/servers-and-cloud-computing/arm_pmu/perf_event_open.md index d907c71e3..7ac96479d 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm_pmu/perf_event_open.md +++ b/content/learning-paths/servers-and-cloud-computing/arm_pmu/perf_event_open.md @@ -30,7 +30,7 @@ void code_to_measure(){ } } -// Executes perf_event_open syscall and makes sure it is succesful or exit +// Executes perf_event_open syscall and makes sure it is successful or exit static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu, int group_fd, unsigned long flags){ int fd; fd = syscall(SYS_perf_event_open, hw_event, pid, cpu, group_fd, flags); @@ -135,7 +135,7 @@ void code_to_measure(){ } } -// Executes perf_event_open syscall and makes sure it is succesful or exit +// Executes perf_event_open syscall and makes sure it is successful or exit static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu, int group_fd, unsigned long flags){ int fd; fd = syscall(SYS_perf_event_open, hw_event, pid, cpu, group_fd, flags); diff --git a/content/learning-paths/servers-and-cloud-computing/bolt/faq.md b/content/learning-paths/servers-and-cloud-computing/bolt/faq.md index b690b6a73..19b93381b 100644 --- a/content/learning-paths/servers-and-cloud-computing/bolt/faq.md +++ b/content/learning-paths/servers-and-cloud-computing/bolt/faq.md @@ -14,7 +14,7 @@ If you can record ETM on your Arm Linux system you should use it. It will genera ### What can I do about the large perf.data files ETM generates? -You can use ETM AutoFDO which uses trace strobing to record small slices and will output much smaller files compared to ETM. See [Using ETM AutoFDO](../bolt-etm/#using-etm-autofdo) section for more details. Otherwise you can use SPE or Samples. SPE also generates large files. +You can use ETM AutoFDO which uses trace strobing to record small slices and will output much smaller files compared to ETM. See [Using ETM AutoFDO](/learning-paths/servers-and-cloud-computing/bolt/bolt-etm/#using-etm-autofdo) section for more details. Otherwise you can use SPE or Samples. SPE also generates large files. ### What should I run when collecting performance profile? diff --git a/content/learning-paths/servers-and-cloud-computing/codec1/_index.md b/content/learning-paths/servers-and-cloud-computing/codec1/_index.md index 96eb18398..a6a930a84 100644 --- a/content/learning-paths/servers-and-cloud-computing/codec1/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/codec1/_index.md @@ -23,6 +23,9 @@ prerequisites: - An Arm Linux system or an [Arm based instance](/learning-paths/servers-and-cloud-computing/csp/) from a cloud service provider. +operatingsystems: + - Linux + skilllevels: Introductory subjects: Libraries diff --git a/content/learning-paths/servers-and-cloud-computing/django/_index.md b/content/learning-paths/servers-and-cloud-computing/django/_index.md index ee9ca5300..217557fd3 100644 --- a/content/learning-paths/servers-and-cloud-computing/django/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/django/_index.md @@ -11,10 +11,10 @@ learning_objectives: - Verify that the Django application is working correctly prerequisites: - - At least either an [Arm based instance](../csp/) from a cloud service provider, on-premises Arm server, or a Linux virtual machine on your Arm device. + - At least either an [Arm based instance](/learning-paths/servers-and-cloud-computing/csp/) from a cloud service provider, on-premises Arm server, or a Linux virtual machine on your Arm device. - Sudo access to install dependencies and to modify system configuration files. - Be comfortable with SSH/Linux terminal and basic system administration tasks. - - To install both [Nginx](../nginx/) and [PostgreSQL](../postgresql/) + - To install both [Nginx](/learning-paths/servers-and-cloud-computing/nginx/) and [PostgreSQL](/learning-paths/servers-and-cloud-computing/postgresql/) author_primary: Diego Russo diff --git a/content/learning-paths/servers-and-cloud-computing/java-on-axion/2-deploy-java.md b/content/learning-paths/servers-and-cloud-computing/java-on-axion/2-deploy-java.md index 4dc7f2b40..65c89d4af 100644 --- a/content/learning-paths/servers-and-cloud-computing/java-on-axion/2-deploy-java.md +++ b/content/learning-paths/servers-and-cloud-computing/java-on-axion/2-deploy-java.md @@ -93,4 +93,4 @@ Once the application is running, you can open the web app in a web browser by vi http://[EXTERNAL IP]:8080 ``` -Where `[EXTERNAL IP]` is the value you obtained in the [last section](../1-create-instance/#obtain-the-ip-of-your-instance). +Where `[EXTERNAL IP]` is the value you obtained in the [last section](/learning-paths/servers-and-cloud-computing/java-on-axion/1-create-instance/#obtain-the-ip-of-your-instance). diff --git a/content/learning-paths/servers-and-cloud-computing/migration/c-c++.md b/content/learning-paths/servers-and-cloud-computing/migration/c-c++.md index 37a1825fb..23f84b5b7 100644 --- a/content/learning-paths/servers-and-cloud-computing/migration/c-c++.md +++ b/content/learning-paths/servers-and-cloud-computing/migration/c-c++.md @@ -44,7 +44,7 @@ Neoverse-N2 | `-mcpu=neoverse-n2` | GCC-11+ | Clang/LLVM 12+ The Neoverse-N1 option `-mcpu=neoverse-n1` is available in GCC-7 on Amazon Linux2. -There are other options like `-march` (ISA version) and `-mtune` (specific processor implementation). These are discussed in the [GCC Arm options documentation](https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html). However, in general, only `-mcpu` should be used. `-mcpu` is basically a single option that combines `-march` and `-mcpu` together. Last, keep in mind that if an application targets an older processor, it will likely be able to execute on a newer processor (less some optimizations for the newer processor). However, if the application targets a newer processor, it might not execute on an older processor. This is true for any processor architecture, not just Arm. +There are other options like `-march` (ISA version) and `-mtune` (specific processor implementation). These are discussed in the [GCC Arm options documentation](https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html). However, in general, only `-mcpu` should be used. `-mcpu` is basically a single option that combines `-march` and `-mtune` together. Last, keep in mind that if an application targets an older processor, it will likely be able to execute on a newer processor (less some optimizations for the newer processor). However, if the application targets a newer processor, it might not execute on an older processor. This is true for any processor architecture, not just Arm. If `-mcpu` (and `-march` and `-mtune` for that matter) are not used, GCC will use a default value for `-march` (ISA version). This default for a given version of GCC can be viewed by running the following command. diff --git a/content/learning-paths/servers-and-cloud-computing/migration/golang.md b/content/learning-paths/servers-and-cloud-computing/migration/golang.md index a321711f6..e56c6dd9f 100644 --- a/content/learning-paths/servers-and-cloud-computing/migration/golang.md +++ b/content/learning-paths/servers-and-cloud-computing/migration/golang.md @@ -2,7 +2,7 @@ # User change title: "Migrating Go applications" -weight: 4 +weight: 5 layout: "learningpathall" diff --git a/content/learning-paths/servers-and-cloud-computing/migration/isv.md b/content/learning-paths/servers-and-cloud-computing/migration/isv.md index cafb51564..4442ffb76 100644 --- a/content/learning-paths/servers-and-cloud-computing/migration/isv.md +++ b/content/learning-paths/servers-and-cloud-computing/migration/isv.md @@ -2,7 +2,7 @@ # User change title: "List of software products supporting Arm" -weight: 5 +weight: 6 layout: "learningpathall" --- diff --git a/content/learning-paths/servers-and-cloud-computing/migration/java.md b/content/learning-paths/servers-and-cloud-computing/migration/java.md new file mode 100644 index 000000000..68b3362cf --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/migration/java.md @@ -0,0 +1,171 @@ +--- +# User change +title: "Migrating Java applications" + +weight: 4 + +layout: "learningpathall" + +--- + +# Java on Arm Neoverse processors + +Java is a general-purpose, high-level programming language used in a wide variety of applications. + +Java code is typically compiled to bytecode that runs on a Java virtual machine (JVM) making it portable across computer architectures. + +There are many ways to install Java on Arm Linux distributions. Refer to the [Java install guide](/install-guides/java/) for information about how to install Java. + +# How can I increase Java performance on Arm? + +Java runs well on Arm, but there are some things to investigate to make sure you are getting the best performance. + +## Which JVM flags impact performance? + +The JVM includes a number of flags which are available to tune performance and aid in debugging. Some of the flags are general purpose and some are Arm architecture specific. + +To print the final values of the flags after the JVM has been initialized run: + +```console +java -XX:+PrintFlagsFinal -version +``` + +Use the output from the above command to see the current values before making any changes. + +For example, to check the value of `CICompilerCount` run: + +```console +java -XX:+PrintFlagsFinal -version | grep CICompilerCount +``` + +The value of the flag is printed: + +```output + intx CICompilerCount = 3 {product} {ergonomic} +``` + +### Flags to review + +The `-XX:-TieredCompilation -XX:ReservedCodeCacheSize -XX:InitialCodeCacheSize` flags provide significant performance improvement for some applications. + +The `-XX:-TieredCompilation` flag turns off intermediate compilation tiers. This may help long-running, predictable applications especially when the warmup period doesn't significantly impact overall performance. + +You can increase the code cache sizes using the `-XX:ReservedCodeCacheSize` and `-XX:InitialCodeCacheSize` flags. Increasing them may improve performance. You can also decrease them in a memory constrained environment. + +The `-XX:CICompilerCount` flag specifies the number of compiler threads for the just-in-time (JIT) compiler. This can be useful to tune performance on multi-core systems. + +The `-XX:CompilationMode` flag instructs the JIT compiler to to use highest optimization level (`high-only`) or the quick optimization level (`quick-only`). + +The best way to determine optimal values for your application is to test your application with different values. + +### Architecture flags + +There are flags that are specific to the Arm architecture and indicate if a particular hardware feature is used. You can see all the flags by running: + +```console +java -XX:+PrintFlagsFinal -version | grep ARCH +``` + +The output is similar to: + +```output +bool AvoidUnalignedAccesses = false {ARCH product} {default} +intx BlockZeroingLowLimit = 256 {ARCH product} {default} +bool NearCpool = true {ARCH product} {default} + int SoftwarePrefetchHintDistance = 192 {ARCH product} {default} +bool TraceTraps = false {ARCH product} {default} +bool UseBlockZeroing = true {ARCH product} {default} +cstr UseBranchProtection = none {ARCH product} {default} +bool UseCRC32 = true {ARCH product} {default} +bool UseCryptoPmullForCRC32 = false {ARCH product} {default} +bool UseLSE = true {ARCH product} {default} +bool UseNeon = false {ARCH product} {default} +bool UseSIMDForArrayEquals = true {ARCH product} {default} +bool UseSIMDForBigIntegerShiftIntrinsics = true {ARCH product} {default} +bool UseSIMDForMemoryOps = false {ARCH product} {default} +uint UseSVE = 0 {ARCH product} {default} +bool UseSimpleArrayEquals = false {ARCH product} {default} +``` + +Depending on your application, you may want to investigate the vector processing flags for SIMD, NEON, SVE, and CRC. + +You can try [Process Watch](https://learn.arm.com/learning-paths/servers-and-cloud-computing/processwatch/) to monitor the usage of SIMD and CRC instructions. + +Refer to the [Java documentation](https://docs.oracle.com/en/java/javase/17/docs/specs/man/java.html) for more information about the flags. + +## Crypto + +AES encryption/decryption has been optimized for Arm, and the optimizations are enabled by default in newer versions of Java. + +You can also look at [Amazon Corretto Crypto Provider (ACCP) 2](https://aws.amazon.com/blogs/security/accelerating-jvm-cryptography-with-amazon-corretto-crypto-provider-2/) to get the best performance on Arm. + +## Stack size + +The default stack size for Java threads (ThreadStackSize) is 2 MB on aarch64 compared to 1 MB on x86_64. You can check the default with: + +```console +java -XX:+PrintFlagsFinal -version | grep ThreadStackSize +``` + +The output is: + +```output + intx CompilerThreadStackSize = 2048 {pd product} {default} + intx ThreadStackSize = 2048 {pd product} {default} + intx VMThreadStackSize = 2048 {pd product} {default} +``` + +The default can be changed on the command line with either `-XX:ThreadStackSize=` or `-Xss`. Note that the first option is in kilobytes and the second is in bytes. + +Usually, there's no need to change the default stack size, because the thread stack will be committed as it grows. + +There is one situation to be aware of. If Transparent Huge Pages (THP) are set to always, the page size matches the default stack size. In this case the full stack size is commit to memory. If you have a very high number of threads the memory usage will be large. + +To mitigate this issue, you can either manually change the stack size using the flags or change the THP setting to madvise. + +To view the THP value run: + +```console +cat /sys/kernel/mm/transparent_hugepage/enabled +``` + +If you see the output shows the current value in brackets: + +```output +[always] madvise never +``` + +You can change to madvise by running: + +```console +echo madvise | sudo tee /sys/kernel/mm/transparent_hugepage/enabled +``` + +Even if you change from always to madvise, the JVM can still use THP for the Java heap and code cache if you use the -XX:+UseTransparentHugePages flag. + +## Native code in shared objects + +A Java JAR (Java Archive) file is a package file format used to aggregate multiple Java class files, along with associated metadata and resources (like text, images, etc.), into a single file for distribution. + +JAR files can include compiled native code. The Java Native Interface (JNI) is used to interact with native code. For Linux, this means shared libraries (.so files) are included in the JAR. + +Java JARs can include shared-objects that are architecture specific. Some Java libraries check if these shared objects are found and if they are they use a JNI to call to the native library instead of relying on a generic Java implementation of the function. While the code might work, without the JNI the performance can suffer. + +A quick way to check if a JAR contains such shared objects is to simply unzip it and check if any of the resulting files are shared-objects and if an aarch64 (arm64) shared-object is missing: + +Unzip and search for share objects in the JAR: + +```console +unzip foo.jar +find . -name "*.so" -exec file {} \; +``` + +For each x86-64 ELF file, check there is a corresponding aarch64 ELF file in the binaries. With some common packages (e.g. commons-crypto) we've seen that even though a JAR can be built supporting Arm manually, artifact repositories such as Maven don't have updated versions. To see if a certain artifact version may have Arm support, consult the [Common JARs with native code Table](https://github.com/aws/aws-graviton-getting-started/blob/main/CommonNativeJarsTable.md). + +## Are there other Java on Arm blogs? + +Here are a few resources: +- [Improving Java performance on Neoverse N1 systems](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/java-performance-on-neoverse-n1) +- [Arm resources show how to optimize your Java applications for AArch64](https://blogs.oracle.com/javamagazine/post/java-arm-runtime-switches-benchmarks) +- [Unlocking Java Performance on Ampere Altra Family Processors](https://amperecomputing.com/tuning-guides/unlocking-java-performance-tuning-guide) + diff --git a/content/learning-paths/servers-and-cloud-computing/mysql_benchmark/setup_sysbench.md b/content/learning-paths/servers-and-cloud-computing/mysql_benchmark/setup_sysbench.md index bcdcb5f36..fa035179a 100644 --- a/content/learning-paths/servers-and-cloud-computing/mysql_benchmark/setup_sysbench.md +++ b/content/learning-paths/servers-and-cloud-computing/mysql_benchmark/setup_sysbench.md @@ -16,7 +16,7 @@ Because MySQL libraries are needed by Sysbench, you will need to build and insta You do not need to configure and run MySQL, just the build and install steps. -Refer to [Setup, configure, and run MySQL server](../setup_mysql_server) to build and install MySQL server and provide the required libraries to Sysbench on the client system. +Refer to [Setup, configure, and run MySQL server](/learning-paths/servers-and-cloud-computing/mysql_benchmark/setup_mysql_server) to build and install MySQL server and provide the required libraries to Sysbench on the client system. ## Build and install Sysbench diff --git a/content/learning-paths/servers-and-cloud-computing/nginx/reverse_proxy_and_api_gateway.md b/content/learning-paths/servers-and-cloud-computing/nginx/reverse_proxy_and_api_gateway.md index 5ab696e5c..b1e5c2ebd 100644 --- a/content/learning-paths/servers-and-cloud-computing/nginx/reverse_proxy_and_api_gateway.md +++ b/content/learning-paths/servers-and-cloud-computing/nginx/reverse_proxy_and_api_gateway.md @@ -6,7 +6,7 @@ layout: "learningpathall" ## Before you begin -You will need to setup two [file servers](../basic_static_file_server) using the instructions in the previous section before moving forward. +You will need to setup two [file servers](/learning-paths/servers-and-cloud-computing/nginx/basic_static_file_server/) using the instructions in the previous section before moving forward. In this section, a third node is setup that will run a Reverse Proxy & API Gateway (this will also be referred to a RP/APIGW). This RP/APIGW will use the two file servers as the upstream servers it will load balance across. The configuration shown here is a bare minimum. Tuning will be explored in the advanced [Learn how to Tune Nginx](/learning-paths/servers-and-cloud-computing/nginx_tune) learning path. Once you complete this section, you should review the [Nginx documentation](https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/) on Reverse Proxies. There are also some [Nginx blogs](https://www.nginx.com/blog/deploying-nginx-plus-as-an-api-gateway-part-1/) that discuss the deployment of API Gateways. @@ -88,7 +88,7 @@ The third location block simply forwards all other requests that don't start wit ### Creating ECDSA key and certificate for the RP/APIGW file server -Refer to the section [Setup a static file server](../basic_static_file_server) to generate the keys and certificate that will be used by the RP/APIGW. +Refer to the section [Setup a static file server](/learning-paths/servers-and-cloud-computing/nginx/basic_static_file_server) to generate the keys and certificate that will be used by the RP/APIGW. ### Checking Nginx configuration and starting the server @@ -106,7 +106,7 @@ nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful ``` -Start Nginx, refer to [Install Nginx via a package manager and check the build configuration](../install_from_package) for a sample service file: +Start Nginx, refer to [Install Nginx via a package manager and check the build configuration](/learning-paths/servers-and-cloud-computing/nginx/install_from_package/) for a sample service file: ```console sudo service nginx start diff --git a/content/learning-paths/servers-and-cloud-computing/nginx_tune/test_optimizations.md b/content/learning-paths/servers-and-cloud-computing/nginx_tune/test_optimizations.md index d4f24a380..2be058b44 100644 --- a/content/learning-paths/servers-and-cloud-computing/nginx_tune/test_optimizations.md +++ b/content/learning-paths/servers-and-cloud-computing/nginx_tune/test_optimizations.md @@ -37,7 +37,7 @@ shown below is an image of a typical multi-node test setup. On the left, there i ## Running a wrk2 test -The Nginx file servers should have files to serve. If you are using the configuration files discussed in [Tune a static file server](../tune_static_file_server) or [Tune a Reverse Proxy or API Gateway](../tune_revprox_and_apigw), the following commands can be run to create some samples files to serve. You do not need to create these files in Reverse Proxies or API Gateways, because these do not serve files directly. +The Nginx file servers should have files to serve. If you are using the configuration files discussed in [Tune a static file server](/learning-paths/servers-and-cloud-computing/nginx_tune/tune_static_file_server/) or [Tune a Reverse Proxy or API Gateway](/learning-paths/servers-and-cloud-computing/nginx_tune/tune_revprox_and_apigw), the following commands can be run to create some samples files to serve. You do not need to create these files in Reverse Proxies or API Gateways, because these do not serve files directly. ``` # Create 1kb file in RP use case directory @@ -66,4 +66,4 @@ Below is a sample command for testing an API Gateway. ./wrk --rate 10000000000 -t 64 -c 640 -d 60s https:///api_old/1kb ``` -The API Gateway shown in [Tune a Reverse Proxy or API Gateway](../tune_revprox_and_apigw) will rewrite `api_old` to `api_new`. This is why the sample files are stored in `/usr/share/nginx/html/10kb /usr/share/nginx/html/api_new` on the file servers. +The API Gateway shown in [Tune a Reverse Proxy or API Gateway](/learning-paths/servers-and-cloud-computing/nginx_tune/tune_revprox_and_apigw) will rewrite `api_old` to `api_new`. This is why the sample files are stored in `/usr/share/nginx/html/10kb /usr/share/nginx/html/api_new` on the file servers. diff --git a/content/learning-paths/servers-and-cloud-computing/nginx_tune/tune_revprox_and_apigw.md b/content/learning-paths/servers-and-cloud-computing/nginx_tune/tune_revprox_and_apigw.md index 09217d9bd..f534c7c5a 100644 --- a/content/learning-paths/servers-and-cloud-computing/nginx_tune/tune_revprox_and_apigw.md +++ b/content/learning-paths/servers-and-cloud-computing/nginx_tune/tune_revprox_and_apigw.md @@ -12,11 +12,11 @@ In the [Setup Reverse Proxy and API Gateway](/learning-paths/servers-and-cloud-c ### Top Level nginx.conf -The same top level config used in [Tune a static file server](../tune_static_file_server) is suggested. +The same top level config used in [Tune a static file server](/learning-paths/servers-and-cloud-computing/nginx_tune/tune_static_file_server) is suggested. ### Reverse Proxy and API Gateway configuration -A tuned configuration (`/etc/nginx/conf.d/loadbalancer.conf`) is shown below. Only performance relevant directives that were not discussed in the [file server section](../tune_static_file_server) are explained here. +A tuned configuration (`/etc/nginx/conf.d/loadbalancer.conf`) is shown below. Only performance relevant directives that were not discussed in the [file server section](/learning-paths/servers-and-cloud-computing/nginx_tune/tune_static_file_server) are explained here. ``` # Upstreams for https upstream ssl_file_server_com { diff --git a/content/learning-paths/servers-and-cloud-computing/nginx_tune/tune_static_file_server.md b/content/learning-paths/servers-and-cloud-computing/nginx_tune/tune_static_file_server.md index 3dc5f1aa4..1553b0206 100644 --- a/content/learning-paths/servers-and-cloud-computing/nginx_tune/tune_static_file_server.md +++ b/content/learning-paths/servers-and-cloud-computing/nginx_tune/tune_static_file_server.md @@ -110,4 +110,4 @@ server { * This directive sets up a cache that stores information on open file descriptors. This can significantly increase performance. * [`ssl_ciphers`](https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_ciphers): * The cipher suite used for HTTPS can greatly impact performance. It is important to understand both the security and performance implications of the chosen cipher suite. - * The version of OpenSSL and how it was compiled can also impact the performance of the cipher suite. This was discussed in the [Kernel, compiler, and OpenSSL](../kernel_comp_lib) section of this learning path. + * The version of OpenSSL and how it was compiled can also impact the performance of the cipher suite. This was discussed in the [Kernel, compiler, and OpenSSL](/learning-paths/servers-and-cloud-computing/nginx_tune/kernel_comp_lib/) section of this learning path. diff --git a/content/learning-paths/servers-and-cloud-computing/serverless-framework-aws-intro/_index.md b/content/learning-paths/servers-and-cloud-computing/serverless-framework-aws-intro/_index.md index 7526e52d0..7ae2fd32f 100644 --- a/content/learning-paths/servers-and-cloud-computing/serverless-framework-aws-intro/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/serverless-framework-aws-intro/_index.md @@ -17,8 +17,8 @@ author_primary: Dawid Borycki ### Tags skilllevels: Introductory -subjects: Cloud -cloud_service_providers: Amazon Web Services +subjects: Web +cloud_service_providers: AWS armips: - Neoverse diff --git a/content/learning-paths/servers-and-cloud-computing/serverless-framework-aws-lambda-dynamodb/_index.md b/content/learning-paths/servers-and-cloud-computing/serverless-framework-aws-lambda-dynamodb/_index.md index 0a48c52d8..451f94dc8 100644 --- a/content/learning-paths/servers-and-cloud-computing/serverless-framework-aws-lambda-dynamodb/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/serverless-framework-aws-lambda-dynamodb/_index.md @@ -18,8 +18,8 @@ author_primary: Dawid Borycki ### Tags skilllevels: Introductory -subjects: Cloud Computing -cloud_service_providers: Amazon Web Services +subjects: Web +cloud_service_providers: AWS armips: - Neoverse @@ -31,7 +31,7 @@ tools_software_languages: operatingsystems: - Linux - Windows - - MacOS + - macOS ### FIXED, DO NOT MODIFY diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/_index.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/_index.md index bac87a331..6686abc46 100644 --- a/content/learning-paths/servers-and-cloud-computing/top-down-n1/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/_index.md @@ -12,7 +12,7 @@ learning_objectives: - Make an application code change and see improved performance prerequisites: - - An Arm Neoverse N1 computer running Linux. A bare metal or cloud metal instance is best because they expose more counters. You can use a virtual machine (VM), but it may offer fewer counters and some commands might not succeed. + - An Arm Neoverse N1 computer running Linux. A bare metal or cloud metal instance is best because they expose more counters. You can use a virtual machine (VM), but it may offer fewer counters and some commands might not succeed. These instructions have been tested on the `a1.metal` instance type. author_primary: Jason Andrews @@ -23,8 +23,8 @@ armips: - Neoverse tools_software_languages: - perf - - Telemetry - + - Telemetry + operatingsystems: - Linux diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/analysis-1.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/analysis-1.md index 56acfb51c..98bfd8b1e 100644 --- a/content/learning-paths/servers-and-cloud-computing/top-down-n1/analysis-1.md +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/analysis-1.md @@ -5,14 +5,14 @@ layout: "learningpathall" --- {{% notice Note %}} -The hardware used in the white paper is the [Neoverse N1 Software Development Platform (N1SDP)](https://developer.arm.com/Tools%20and%20Software/Neoverse%20N1%20SDP). This hardware is different from Neoverse N1 servers and cloud instances so your results will be different. +The hardware used in the white paper is the [Neoverse N1 Software Development Platform (N1SDP)](https://developer.arm.com/Tools%20and%20Software/Neoverse%20N1%20SDP). This hardware is different from Neoverse N1 servers and cloud instances so your results will be different. You can also run this Learning Path on single board computers with the Cortex-A76 processors and the results will be closer to those in the white paper. Example boards include the [Raspberry Pi 5](https://www.raspberrypi.com/products/raspberry-pi-5/), [Khadas Edge2](https://www.khadas.com/edge2), and [Orange Pi 5](http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/details/Orange-Pi-5.html). The example output provided is from the Khadas Edge2, but yours will be different with different hardware. {{% /notice %}} -The white paper explains the definitions of the metrics and the performance analysis results for the stride benchmark in more detail. The section below provides the collection commands and interpretation of the metrics in the same order as the white paper. +The white paper explains the definitions of the metrics and the performance analysis results for the stride benchmark in more detail. The section below provides the collection commands and interpretation of the metrics in the same order as the white paper. ## Workload characterization using counting @@ -59,7 +59,7 @@ Instructions Per Cycle 0.224 per cycle ##### Front end and back end stall rate -The next metrics are front end and back end stall rate. +The next metrics are front end and back end stall rate. To collect the stall information using `perf` run: @@ -93,7 +93,7 @@ Frontend Stalled Cycles 0.00% cycles Backend Stalled Cycles. 84.38% cycles ``` -The metrics indicate the application is back end bound. +The metrics indicate the application is back end bound. According to the methodology the next step is to investigate L1 data cache and unified L2 and last level caches, instruction mix, and data TLB. @@ -179,9 +179,9 @@ Branch Operations Percentage........ 20.00% operations Crypto Operations Percentage........ 0.00% operations ``` -The instruction mix shows 60% integer operations, 20% load operations, and 20% branches. +The instruction mix shows 60% integer operations, 20% load operations, and 20% branches. -This suggests that the application is memory bound and would benefit from improved caching. +This suggests that the application is memory bound and would benefit from improved caching. The workload is not front end bound, but it is still useful to check the branch effectiveness as the instruction mix shows 20% branches. @@ -203,7 +203,7 @@ Branch MPKI............... 0.002 misses per 1,000 instructions Branch Misprediction Ratio 0.000 per branch ``` -As expected, mispredicted branches are very low. +As expected, mispredicted branches are very low. ### Translation lookaside buffer (TLB) @@ -251,9 +251,9 @@ L2 Unified TLB Miss Ratio 0.891 per TLB access Instruction TLB misses are very low as expected. Data TLB misses are higher. This suggests data-side page misses resulting in page table walks for some memory accesses. -## Hot spot analysis using sampling +## Hot spot analysis using sampling -To identify execution bottlenecks, use `perf record` to run with sampling. +To identify execution bottlenecks, use `perf record` to run with sampling. There are two ways to control the sampling rate: - counting events: record a sample every n number of events for a given event list @@ -277,7 +277,7 @@ To record a sample every 100 last level cache misses run: perf record -e ll_cache_rd -c 100 ./stride ``` -Because the application runs in a tight loop the sampling frequency doesn't have any impact. +Because the application runs in a tight loop the sampling frequency doesn't have any impact. To view the recorded data use `perf report`: @@ -297,7 +297,7 @@ You will see the source code of the `main` function with the percent of samples ![main #center](report-3.png) -All the samples are on `subs` instruction which is right after the load instruction which reads the array and causes the high cache miss rate. +All the samples are on `subs` instruction which is right after the load instruction which reads the array and causes the high cache miss rate. Press the `q` key to exit the report. The next section demonstrates an optimization to increase performance. diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/application-1.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/application-1.md index b96344712..09e6f1904 100644 --- a/content/learning-paths/servers-and-cloud-computing/top-down-n1/application-1.md +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/application-1.md @@ -10,7 +10,7 @@ The white paper presents a micro-benchmark from the DynamoRIO project. The strid The original source code is at https://github.com/DynamoRIO/dynamorio/blob/master/clients/drcachesim/tests/stride_benchmark.cpp -The code below is slightly modified to increase the number of iterations so that it runs longer for performance analysis. +The code below is slightly modified to increase the number of iterations so that it runs longer for performance analysis. 1. Use a text editor to copy the code below into a text file named `stride.cpp`: @@ -119,4 +119,4 @@ The program runs for about 10-20 seconds, depending on your hardware, and the ex Value = 12779520 ``` -The next section demonstrates how to collect metrics for performance analysis. \ No newline at end of file +The next section demonstrates how to collect metrics for performance analysis. \ No newline at end of file diff --git a/content/learning-paths/smartphones-and-mobile/ams/fa.md b/content/learning-paths/smartphones-and-mobile/ams/fa.md index 08959c6f9..0408cd173 100644 --- a/content/learning-paths/smartphones-and-mobile/ams/fa.md +++ b/content/learning-paths/smartphones-and-mobile/ams/fa.md @@ -11,7 +11,7 @@ layout: "learningpathall" ## Prerequisites -Build your application, and setup the Android device as described in the [Streamline](../streamline) instructions. +Build your application, and setup the Android device as described in the [Streamline](/learning-paths/smartphones-and-mobile/ams/streamline/) instructions. ## Connect to the device diff --git a/content/learning-paths/smartphones-and-mobile/ams/ga.md b/content/learning-paths/smartphones-and-mobile/ams/ga.md index 7aeade2b8..3e3ff26f3 100644 --- a/content/learning-paths/smartphones-and-mobile/ams/ga.md +++ b/content/learning-paths/smartphones-and-mobile/ams/ga.md @@ -13,7 +13,7 @@ The tool allows you to observe API call arguments and return values, and interac ## Prerequisites -Build your application, and setup your Android device as described in [Setup tasks](../setup_tasks). +Build your application, and setup your Android device as described in [Setup tasks](/learning-paths/smartphones-and-mobile/ams/setup_tasks/). ## Capture data from the device diff --git a/content/learning-paths/smartphones-and-mobile/ams/pa.md b/content/learning-paths/smartphones-and-mobile/ams/pa.md index e0f46d94e..61ab5ae1f 100644 --- a/content/learning-paths/smartphones-and-mobile/ams/pa.md +++ b/content/learning-paths/smartphones-and-mobile/ams/pa.md @@ -19,7 +19,7 @@ This script does the following: Performance Advisor uses a Python script to connect to your device. You will need `Python 3.6` or later installed on your host machine. -Build your application, and setup the Android device as described in [Setup tasks](../setup_tasks). +Build your application, and setup the Android device as described in [Setup tasks](/learning-paths/smartphones-and-mobile/ams/setup_tasks/). ## Connect to the device diff --git a/content/learning-paths/smartphones-and-mobile/ams/pa_example.md b/content/learning-paths/smartphones-and-mobile/ams/pa_example.md index 345924e69..2793bc0c1 100644 --- a/content/learning-paths/smartphones-and-mobile/ams/pa_example.md +++ b/content/learning-paths/smartphones-and-mobile/ams/pa_example.md @@ -11,7 +11,7 @@ Performance Advisor creates an easy-to-read report from a Streamline capture. Th ## Generate a performance report -The supplied [Arm Streamline example capture](../streamline_example) can be used to generate a `Performance Advisor` report. +The supplied [Arm Streamline example capture](/learning-paths/smartphones-and-mobile/ams/streamline_example/) can be used to generate a `Performance Advisor` report. 1. Open a terminal, and navigate to the location of the imported capture. diff --git a/content/learning-paths/smartphones-and-mobile/ams/streamline.md b/content/learning-paths/smartphones-and-mobile/ams/streamline.md index dd7838dae..ed96d8670 100644 --- a/content/learning-paths/smartphones-and-mobile/ams/streamline.md +++ b/content/learning-paths/smartphones-and-mobile/ams/streamline.md @@ -7,7 +7,7 @@ weight: 5 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -Now that you have seen an [Arm Streamline example capture](../streamline_example), you can use it to capture data from your own application. +Now that you have seen an [Arm Streamline example capture](/learning-paths/smartphones-and-mobile/ams/streamline_example/), you can use it to capture data from your own application. ## Select the device and application in Streamline diff --git a/content/learning-paths/smartphones-and-mobile/android_neon/_index.md b/content/learning-paths/smartphones-and-mobile/android_neon/_index.md index 9cba03b1e..fc1354f8a 100644 --- a/content/learning-paths/smartphones-and-mobile/android_neon/_index.md +++ b/content/learning-paths/smartphones-and-mobile/android_neon/_index.md @@ -3,7 +3,7 @@ title: Get started with Neon Intrinsics on Android minutes_to_complete: 40 -who_is_this_for: This is an introductory topic for software developers interested in learning how to use Neon instrinsics on Arm powered mobile devices running Android. +who_is_this_for: This is an introductory topic for software developers interested in learning how to use Neon Intrinsics on Arm powered mobile devices running Android. learning_objectives: - Enable Neon intrinsics support in Android Studio. diff --git a/content/learning-paths/smartphones-and-mobile/android_neon/hello_neon.md b/content/learning-paths/smartphones-and-mobile/android_neon/hello_neon.md index 9012eccb9..44f35a7a4 100644 --- a/content/learning-paths/smartphones-and-mobile/android_neon/hello_neon.md +++ b/content/learning-paths/smartphones-and-mobile/android_neon/hello_neon.md @@ -23,7 +23,7 @@ To further improve performance, you need to use assembly code. However, with Arm ## Enable Neon Intrinsics support in Android Studio -In this section, you will setup your Android development environment to use Neon instrinsics. +In this section, you will setup your Android development environment to use Neon Intrinsics. 1. Open Android Studio on your development machine. diff --git a/content/learning-paths/smartphones-and-mobile/using_unity_machine_learning_agents/03-Install.md b/content/learning-paths/smartphones-and-mobile/using_unity_machine_learning_agents/03-Install.md index 8ce3aacfd..cff75e924 100644 --- a/content/learning-paths/smartphones-and-mobile/using_unity_machine_learning_agents/03-Install.md +++ b/content/learning-paths/smartphones-and-mobile/using_unity_machine_learning_agents/03-Install.md @@ -56,7 +56,7 @@ The installation instructions in the next section go through the steps shown abo ## Download and open the Dr Arm Unity project -1. Download and extract the accompanying Unity project from the [supporting zip file](../files/MLAgentsWorkshopSupportingFiles.zip). +1. Download and extract the accompanying Unity project from the [supporting zip file](/learning-paths/smartphones-and-mobile/using_unity_machine_learning_agents/files/MLAgentsWorkshopSupportingFiles.zip). 1. Open Unity Hub diff --git a/content/migration/Arm-migration-overview.png b/content/migration/Arm-migration-overview.png new file mode 100644 index 000000000..337519f31 Binary files /dev/null and b/content/migration/Arm-migration-overview.png differ diff --git a/content/migration/Bottom-up.png b/content/migration/Bottom-up.png new file mode 100644 index 000000000..938e27ccc Binary files /dev/null and b/content/migration/Bottom-up.png differ diff --git a/content/migration/Top-down.png b/content/migration/Top-down.png new file mode 100644 index 000000000..40bc75305 Binary files /dev/null and b/content/migration/Top-down.png differ diff --git a/content/migration/_index.md b/content/migration/_index.md index 281928c94..6426d79f5 100644 --- a/content/migration/_index.md +++ b/content/migration/_index.md @@ -1,111 +1,245 @@ --- -title: "How can I migrate my applications to Arm?" +title: "How can I migrate applications to Arm Neoverse?" layout: "migration" # Easier for dynamic content loading, keep the same +description: Software developers are embracing the Arm architecture for its superior price performance and energy efficiency across a wide range of applications, including containerized workloads, cloud managed services, and Linux applications. To achieve higher performance and lower cost, you can migrate your self-managed workloads to Arm virtual machines and make sure to select Arm for managed services. A three step migration process covers the most common scenarios, and provides links to additional resources. --- -Software developers are embracing the Arm architecture for its superior price performance and energy efficiency across a wide range of applications, including containerized workloads, cloud managed services, and Linux applications. +## PREFACE: Learn and explore -To achieve higher performance and lower cost, you can migrate your self-managed workloads to Arm virtual machines and make sure to select Arm for managed services. +Arm Neoverse is a family of processor cores designed for servers and cloud data centers. There are 2 families currently available, Neoverse V-series and Neoverse N-series. -This three step migration guide covers the most common scenarios for adopting Arm. It also provides links to additional resources. +### What is Arm Neoverse? -## STEP 1: Learn and explore +Neoverse V-series offers the highest overall performance, and Neoverse N-series offers industry-leading performance-per-watt and serves a broad set of server and cloud use cases. Each Neoverse CPU implements a version of the [Arm architecture](https://www.arm.com/architecture/cpu). Arm continually works with partners to advance the architecture and increase computing capability. Neoverse cores focus on predictable per-socket performance and do not rely on multithreading or extreme clock speeds. -Before you start migrating applications, some background on Arm Neoverse is helpful. +Below is a list of Neoverse CPUs, the architecture versions, and the key additions for each. -### What is Arm Neoverse? +| CPU | Architecture version | Key additions | +| ----------- | -------------------- | --------------------------------------------------------- | +| Neoverse-N1 | Armv8.2-A | LSE - Large System Extensions improves multi-threaded performance. | +| Neoverse-V1 | Armv8.4-A | SVE - Scalable Vector Extension adds high performance vector processing for HPC and AI workloads. | +| Neoverse-N2 | Armv9.0-A | SVE2 and Arm CCA - Extends SVE and adds Arm Confidential Compute Architecture for hardware isolation and security. | +| Neoverse-V2 | Armv9.0-A | SVE2 and Arm CCA - Targets high single threaded performance for HPC and AI workloads. | + +### What cloud hardware is available today? + +Review each cloud service provider below to learn about Arm-based servers. + +{{< tabpane-normal >}} + {{< tab header="AWS">}} + +AWS offers more than [150 instance types with Graviton processors](https://aws.amazon.com/ec2/graviton/). The largest instance has 192 vCPUs and 1.5 TB of memory. A wide variety of instance sizes are available, including bare-metal (look for '.metal'). To find instances with Graviton processors look for 'g' in the name (C7g, M7g, and R7g). + +| Generation | Arm CPU | Instance types | Comments | +|---------------|--------------|----------------|-----------------------------------------------------------------------------| +| Graviton | Cortex-A72 | A1 | First Arm-based instance. +| Graviton2 | Neoverse-N1 | C6g, M6g, R6g | 600% performance and efficiency increases. | +| Graviton3 | Neoverse-V1 | C7g, M7g, R7g | 25% performance increase, DDR5 memory added, 50% more memory bandwidth. | +| Graviton4 | Neoverse-V2 | R8g | 75% more memory bandwidth, up to 40% faster for databases and 30% faster for web applications. | + + {{< /tab >}} + {{< tab header="Google GCP">}} +Google GCP offers a varity of [virtual machine instances with Arm processors](https://cloud.google.com/compute/docs/instances/arm-on-compute). The largest instance has 80 vCPUs and 640 Gb of RAM in the 'c3a-highmem' format. It does not offer bare-metal instances. It offers compute for general-purpose workloads (standard) and memory-optimized workloads (highmem). + +| Generation | Arm CPU | Instance types | Comments | +| --------------|--------------|--------------------|-----------| +| T2A | Neoverse-N1 | T2A-standard | Optimized for general-purpose workloads - web servers, and microservices. | +| C3A | AmpereOne | c3a-standard, c3a-highmem | Compute-optimized - large-scale databases, media transcoding, and HPC. | + + + {{< /tab >}} + {{< tab header="Microsoft Azure">}} +Microsoft Azure offers a varity of [virtual machine instances with Arm Neoverse processors](https://learn.microsoft.com/en-us/azure/virtual-machines/dpsv5-dpdsv5-series). The largest instance has 64 vCPUs and 208 Gb of RAM in the 'D64ps_v5' format. It does not offer bare-metal instances. It offers compute for general-purpose workloads (Dps), memory-optimized workloads (Eps), compute-intensive workloads (Fsv), and high-performance (Cobalt). + +| Generation | Arm CPU | Instance types | Comments | +| --------------|--------------|--------------------|-----------| +| psv5 | Neoverse-N1 | Dpsv5, Epsv5 | General purpose and memory optimized intstances. | +| psv6 | Neoverse-N2 | Dpsv6, Epsv6, Fsv6 | Cobalt processor improves performance, Dpsv6 (general purpose 4:1 mem:cpu ratio), Dplsv6 (general purpose, 2:1 mem:cpu ratio), Epsv6 (memory-optimized). | + + {{< /tab >}} + {{< tab header="Oracle OCI">}} +Oracle Cloud Infrastructure (OCI) Ampere [Arm-based compute](https://www.oracle.com/cloud/compute/arm/) provides market-leading price-performance for AI, containers, big data, web services, and related workloads. The largest intsance has 160 vCPUs and 1024 Gb of RAM in the 'BM.Standard.A1' format. It offers bare-metal instances (look for 'BM' as opposed to 'VM'). + +| Generation | Arm CPU | Instance types | Comments | +| --------------|--------------|--------------------|-----------| +| A1 | Neoverse-N1 | VM.Standard.A1 | Offers predefined (.#CPUs) or dynamic OCPU and memory allocation (.Flex) | +| A2 | AmpereOne | VM.Standard.A2, VM.Optimized3.A2 | Tailored for high-performance and memory-intensive workloads. | + + {{< /tab >}} + +{{< /tabpane-normal >}} + +Read [Get started with Servers and Cloud Computing](https://learn.arm.com/learning-paths/servers-and-cloud-computing/intro) to learn more and find additional cloud service providers. + +## STEP 1: Plan your transition -Arm Neoverse is a family of processor cores designed for servers and cloud data centers. There are 2 families of processors currently available, Neoverse V-series and Neoverse N-series. +Newer software is generally easier to migrate because Arm support continues to improve and performance optimizations are typically better in newer versions. Interpreted languages and Jit compilers, such as Python, Java, PHP, and Node.js are easiest to migrate. Compiled languages such as C/C++, Go, and Rust are slightly more difficult because they need to be recompiled. The most difficult situations involve a language, runtime, operating system, or something else which is not available on Arm or would be difficult to run on Arm. -Neoverse V-series offers the highest overall performance, and Neoverse N-series offers industry-leading performance-per-watt and serves a broad set of server and cloud use cases. Each Neoverse CPU implements a version of the [Arm architecture](https://www.arm.com/architecture/cpu). Arm continually works with partners to advance the architecture and increase computing capability. -Below is a list of Neoverse CPUs, the architecture versions, and examples of systems which use them. +### 1.1 Survey your software stack -| CPU | Architecture version | Example Cloud processors | -| ----------- | -------------------- | --------------------------------------------- | -| Neoverse V1 | Armv8.4-A | AWS Graviton3 | -| Neoverse V2 | Armv9.0-A | NVIDIA Grace, AWS Graviton4, Google Axion | -| Neoverse N1 | Armv8.2-A | Ampere Altra, Oracle A1, AWS Graviton2 | -| Neoverse N2 | Armv9.0-A | Microsoft Cobalt | +Step one in a typical migration journey is understanding the software stack. Make notes about operating system versions, programming languages, development tools, container tools, performance analysis tools, and any other important scripts included in the project. You can reference **Migrating applications to Arm servers** below for tips on how to get started - setting up a development machine, common challenges, and tips to proceed at pace. -Neoverse cores generally focus on high per-socket performance and do not rely on multithreading or extreme clock speeds to provide predictable performance. +[Migrating applications to Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/migration/) -Read [Get started with Servers and Cloud Computing](https://learn.arm.com/learning-paths/servers-and-cloud-computing/intro) to learn more where you can find Arm hardware in the cloud. +### 1.2 Discover Arm compatibility -## STEP 2: Plan your transition +Step two is to look through your scripts and build files and see if you spot architecture specific files. Software migration typically falls into 3 categories: +1. **Automatic:** The Linux package manager installs software from the main repositories without any changes, totally seamless. +2. **Small modifications:** Software installed using scripts or binary downloads requires minor changes to strings, such as changing “x86_64” and “amd64” to “arm64” or “aarch64”. +3. **Challenging:** A few software projects still don't support Arm Linux, some are well known projects like the Edge browser, and the others are smaller projects that haven't added Arm support, yet. Some could be blockers and others may be easy to compile yourself. -Start your transition by researching your software requirements and identifying possible challenges. +You can quickly find out if software dependencies are available for Arm using the **Software Ecosystem Dashboard for Arm** link below - search for your package and find out which versions work on Arm and review the getting started tips. The dashboard is actively growing, and is a good place to understand if your software stack will run on Arm servers. -### Survey your software +[Software Ecosystem Dashboard for Arm.](https://www.arm.com/developer-hub/ecosystem-dashboard/) -[Migrating applications to Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/migration/) is a good place to start your migration journey. It explains how to set up a development machine, some migration challenges, and other tips for different programming languages. +### 1.3 Find resources to help -Make notes about operating system versions, programming languages, development tools, container tools, performance analysis tools, deployment tools, and any other important scripts included in the project. +The below resources are curated to address migration challenges on specific cloud providers. Look through them for additional context. +- [Porting architecture specific intrinsics](https://learn.arm.com/learning-paths/cross-platform/intrinsics/) - perfect for porting intrinsics from another architecture. +- [Arm software install guides](https://learn.arm.com/install-guides) - good for quickly installing common tools and software. +- [Arm Infrastructure Solutions blog](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/) - an Arm-specific technical blog. +- [Arm Learning Paths for Servers and Cloud](https://learn.arm.com/learning-paths/servers-and-cloud-computing/) - general tutorials for Arm servers. You can search for specific cloud service providers, including [AWS](https://learn.arm.com/learning-paths/servers-and-cloud-computing/?cloud-service-providers-filter=aws/#), [Google Cloud](https://learn.arm.com/learning-paths/servers-and-cloud-computing/?cloud-service-providers-filter=google-cloud/#), [Microsoft Azure](https://learn.arm.com/learning-paths/servers-and-cloud-computing/?cloud-service-providers-filter=microsoft-azure/#), and [Oracle](https://learn.arm.com/learning-paths/servers-and-cloud-computing/?cloud-service-providers-filter=oracle/#). + -Newer software is generally easier to migrate because Arm support continues to improve and performance optimizations are typically better in newer versions of software. +- AWS has additional resources such as the [Porting Advisor for Graviton](https://learn.arm.com/install-guides/porting-advisor/) and [AWS Graviton Technical Guide](https://github.com/aws/aws-graviton-getting-started). -Interpreted languages and Jit compilers, such as Python, Java, PHP, and Node.js are easiest to migrate. +Lastly, below are some specific migration helpers for various types of software: -Compiled languages such as C/C++, Go, and Rust are slightly more difficult because they need to be recompiled. +{{< tabpane-normal >}} -The most difficult situations involve a language, runtime, operating system, or something else which is not available on Arm and would be difficult to run on Arm. + {{< tab header="Containers">}} -Depending on your situation, you may want to try the migration using a bottom-up approach or a top-down approach. A top-down example is to change the virtual machine instance types in your infrastructure-as-code to Arm instances, run the code, and debug as things fail. A bottom-up example is to to manually create an Arm virtual machine, pick out a part of your application or some of the dependencies, try to build and run on Arm, and slowly work up to running the complete application. +Which tools are available for building and running containers on Arm servers? -### Research dependencies +| Tool | Learning Paths | Other Content (Blogs/Videos) | +|-----------|----------------|----------------------------------------| +| Docker | [Learn how to use Docker](https://learn.arm.com/learning-paths/cross-platform/docker/) | [How to build cloud-native applications for multi-architecture infrastructure](https://stackoverflow.blog/2024/02/05/how-to-build-cloud-native-applications-for-multi-architecture-infrastructure/) +| AWS CodeBuild | [Build and share Docker images using AWS CodeBuild](https://learn.arm.com/learning-paths/servers-and-cloud-computing/codebuild/) | | +| Docker Build Cloud | [Build multi-architecture container images with Docker Build Cloud](https://learn.arm.com/learning-paths/cross-platform/docker-build-cloud/) | [Supercharge your Arm builds with Docker Build Cloud: Efficiency meets performance](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/supercharge-arm-builds-with-docker-build-cloud) | +| GitHub Actions | [Build multi-architecture container images with GitHub Arm-hosted runners](https://learn.arm.com/learning-paths/cross-platform/github-arm-runners/) | | -Look through your scripts and Makefiles to see if you spot architecture specific files. + {{< /tab >}} -Migration typically falls into 3 categories: -1. The Linux package manager installs software from the main repositories without any changes, totally seamless. -2. Software installed using scripts or binary downloads requires minor changes to strings, such as changing “x86_64” and “amd64” to “arm64” or “aarch64”. -3. A few software projects still don't support Arm Linux, some are well known projects like the Edge browser, and the others are smaller projects that haven't added Arm support, yet. Some could be blockers and others may be easy to compile yourself. + {{< tab header="Programming Languages">}} -The [Software Ecosystem Dashboard for Arm](https://www.arm.com/developer-hub/ecosystem-dashboard/) is a resource to identify if your software dependencies are available for Arm. +Which programming languages work on Arm servers? - Nearly all of them. -Use the Ecosystem Dashboard to find software and understand if everything you need runs on Arm. If you don't find software listed, please raise an issue in the [GitHub project](https://github.com/ArmDeveloperEcosystem/ecosystem-dashboard-for-arm/) or submit a pull request. +| Languages | Learning Paths | Other Content (Blogs/Videos) | +|-----------|----------------|----------------------------------------| +| C/C++ | [C/C++ on Arm Neoverse processors](https://learn.arm.com/learning-paths/servers-and-cloud-computing/migration/c-c++/) | [What is new in LLVM 18?](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/p1-whats-new-in-llvm-18) | +| Rust | [Rust Install Guide](https://learn.arm.com/install-guides/rust/) | [Neon Intrinsics in Rust](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/rust-neon-intrinsics) | +| Java | | [Improving Java performance on Neoverse N1 systems](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/java-performance-on-neoverse-n1) | +| | | [Java Vector API on AArch64](https://community.arm.com/arm-community-blogs/b/high-performance-computing-blog/posts/java-vector-api-on-aarch64) | +| | | AWS: [Java on Graviton](https://github.com/aws/aws-graviton-getting-started/blob/main/java.md) | +| | | Azure: [Optimizing Java Workloads on Azure General Purpose D-series v5 VMs with Microsoft’s Build of OpenJDK](https://techcommunity.microsoft.com/t5/azure-compute-blog/optimizing-java-workloads-on-azure-general-purpose-d-series-v5/ba-p/3827610) | +| | | Ampere: [Improving Java performance on OCI Ampere A1 compute instances](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/performance-of-specjbb2015-on-oci-ampere-a1-compute-instances) | +| Go | [Go Install Guide](https://learn.arm.com/install-guides/go/) | AWS: [Making your Go workloads up to 20% faster with Go 1.18 and AWS Graviton](https://aws.amazon.com/blogs/compute/making-your-go-workloads-up-to-20-faster-with-go-1-18-and-aws-graviton/)| +| .NET | [.NET Install Guide](https://learn.arm.com/install-guides/dotnet/) | [Arm64 Performance Improvements in .NET 7](https://devblogs.microsoft.com/dotnet/arm64-performance-improvements-in-dotnet-7/) | +| Python | | [Python on Arm](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/python-on-arm)| +| PHP | | [Improving performance of PHP for Arm64 and impact on AWS Graviton2 based EC2 instances](https://aws.amazon.com/blogs/compute/improving-performance-of-php-for-arm64-and-impact-on-amazon-ec2-m6g-instances/) | -### Migration helpers + {{< /tab >}} + {{< tab header="Optimized Libraries">}} -If you face specific issues with porting software you can try [Porting Advisor for Graviton](https://learn.arm.com/install-guides/porting-advisor/), a source code analysis tool which identifies incompatibilities. +Which key libraries are optimized for Arm servers? -If your code uses intrinsics from another architecture, you can use the libraries covered in [Porting architecture specific intrinsics](https://learn.arm.com/learning-paths/cross-platform/intrinsics/) +| Library/Framework | Learn More | Blogs | +|-------------------|------------|-------| +| x264/x265 | [Run x265 (H.265 codec) on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/codec/) | AWS: [Improve video encoding price/performance by up to 36% with Arm Neoverse based Amazon EC2 C6g instances](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/thirty-six-percent-better-video-encoding-with-aws-graviton2_2d00_based-c6g) | +| | | AWS: [Reduce H.265 High-Res Encoding Costs by over 80% with AWS Graviton2](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/reduce-h-265-high-res-encoding-costs-by-over-80-with-aws-graviton2-1207706725) | +| | | Ampere: [Ampere Altra Max Delivers Sustainable High-Resolution H.265 Encoding](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/ampere-altra-max-delivers-sustainable-high-resolution-h-265-video-encoding-without-compromise) | +| | | Ampere: [OCI Ampere A1 Compute instances can significantly reduce video encoding costs versus modern CPUs](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/oracle-cloud-infrastructure-arm-based-a1) | +| ArmPL | [Arm Performance Libraries install guide](https://learn.arm.com/install-guides/armpl/) | [Arm Compiler for Linux and Arm Performance Libraries 24.04](https://community.arm.com/arm-community-blogs/b/high-performance-computing-blog/posts/arm-compiler-for-linux-and-arm-performance-libraries-24-04) | +| ArmRAL | [Get started with the Arm 5G RAN Acceleration Library (ArmRAL)](https://learn.arm.com/learning-paths/servers-and-cloud-computing/ran/) | [The next chapter for Arm RAN Acceleration Library: Open-sourcing the code base & accelerating adoption](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/arm-ral-is-now-open-source) | +| OpenSSL | | | +| VP9 | | AWS: [Arm-based cloud instances outperform x86 instances by up to 64% on VP9 encoding](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/arm-outperforms-x86-by-up-to-64-percent-on-vp9) | +| ISA-L | | | +| IPSEC-MB | | | +| AV1 | | | +| SLEEF | | | +| AES | | AWS: [AWS Graviton3 delivers leading AES-GCM encryption performance](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/aes-gcm-optimizations-for-armv8-4-on-neoverse-v1-graviton3) | +| Snappy | [Measure performance of compression libraries on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/snappy/) | AWS: [Comparing data compression algorithm performance on AWS Graviton2](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/comparing-data-compression-algorithm-performance-on-aws-graviton2-342166113) | +| Cloudflare zlib | [Learn how to build and use Cloudflare zlib on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/zlib/) | | -There are additional resources which may help you find answers to your migration questions: + {{< /tab >}} -- [All Arm Learning Paths for Servers and Cloud](https://learn.arm.com/learning-paths/servers-and-cloud-computing/) - - [AWS Learning Paths](https://learn.arm.com/learning-paths/servers-and-cloud-computing/?cloud-service-providers-filter=aws/#) - - [Google Cloud Learning Paths](https://learn.arm.com/learning-paths/servers-and-cloud-computing/?cloud-service-providers-filter=google-cloud/#) - - [Microsoft Azure Learning Paths](https://learn.arm.com/learning-paths/servers-and-cloud-computing/?cloud-service-providers-filter=microsoft-azure/#) - - [Oracle Learning Paths](https://learn.arm.com/learning-paths/servers-and-cloud-computing/?cloud-service-providers-filter=oracle/#) -- [Infrastructure Solutions blog](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/) -- [Arm software install guides](https://learn.arm.com/install-guides) -- [AWS Graviton Technical Guide](https://github.com/aws/aws-graviton-getting-started) contains a wealth of information. + {{< tab header="Databases">}} -Additional migration resources: - - [Programming Languages](/migration/languages/) - - [Optimized Libraries](/migration/libraries/) - - [Containers](/migration/containers/) - - [Databases](/migration/databases/) - - [Web applications](/migration/web/) - - [Networking](/migration/networking/) +Which databases are available on Arm servers? +| Database | Learning Paths | Other Content (Blogs/Videos) | +|-----------|----------------|----------------------------------------| +| MySQL | AWS: [Deploy WordPress with MySQL on Elastic Kubernetes Service (EKS)](https://learn.arm.com/learning-paths/servers-and-cloud-computing/eks/) | | +| MySQL | [Learn how to deploy MySQL](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mysql/) | | +| MySQL | [Benchmarking MySQL with Sysbench](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mysql_benchmark/) | | +| MySQL | [Learn how to Tune MySQL](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mysql_tune/) | | +| PostgreSQL | [Learn how to deploy PostgreSQL](https://learn.arm.com/learning-paths/servers-and-cloud-computing/postgresql/) | | +| Flink | [Benchmark the performance of Flink on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/flink/) | +| Clickhouse | [Measure performance of ClickHouse on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/clickhouse/) | AWS: [Improve ClickHouse Performance up to 26% by using AWS Graviton3](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/improve-clickhouse-performance-up-to-26-by-using-aws-graviton3) | +| MongoDB | [Test the performance of MongoDB on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mongodb/) | [MongoDB performance on Arm Neoverse based AWS Graviton2 processors](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/mongodb-performance-on-aws-with-the-arm-graviton2) | +| Redis | [Deploy Redis on Arm](https://learn.arm.com/learning-paths/servers-and-cloud-computing/redis/) | Alibaba: [Improve Redis performance up to 36% by deploying on Alibaba Cloud Yitian 710 instances](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/improve-redis-performance-by-deploying-on-alibaba-cloud-yitian-710-instances) | +| Spark | AWS: [Learn how to deploy Spark on AWS Graviton2](https://learn.arm.com/learning-paths/servers-and-cloud-computing/spark/) | AWS: [Spark on AWS Graviton2 best practices: K-Means clustering case study](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/optimize-spark-on-aws-graviton2-best-practices-k-means-clustering) | +| MariaDB | [Deploy MariaDB on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mariadb/) | +| Elasticsearch/Opensearch | | +| Spark+Gluten+Velox | | +| Pinecone | | -## Build and run + {{< /tab >}} -Based on your initial research, decide how to proceed with trying your software on Arm. + {{< tab header="Web applications">}} +Which software helps me build web applications on Arm servers? +| Software | Learning Paths | Other Content (Blogs/Videos) | +|-----------|----------------|----------------------------------------| +| Nginx | [Learn how to deploy Nginx](https://learn.arm.com/learning-paths/servers-and-cloud-computing/nginx/) | AWS: [Nginx Performance on AWS Graviton3](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/nginx-performance-on-graviton-3) | +| | [Learn how to tune Nginx](https://learn.arm.com/learning-paths/servers-and-cloud-computing/nginx_tune/) | | +| Django | [Learn how to deploy a Django application](https://learn.arm.com/learning-paths/servers-and-cloud-computing/django/) | | -Use the resources above to build and run your application on Arm. -Make sure to watch for any test tools or saved test results so you can plan for them on Arm. + {{< /tab >}} -## STEP 3: Test and Optimize + {{< tab header="Networking">}} +Which networking software works on Arm servers? -### Measure performance +| Software | Learning Paths | Other Content (Blogs/Videos) | +|-----------|----------------|----------------------------------------| +| Vectorscan | [Install Vectorscan (Hyperscan on Arm) and use it with Snort 3](https://learn.arm.com/learning-paths/servers-and-cloud-computing/vectorscan/) | | +| DPDK | | [DPDK Tuning Guide](https://developer.arm.com/documentation/109701/1-0/?lang=en) | + {{< /tab >}} -Once the application is running you can measure performance. This can be as simple as timing an application or may involve using performance analysis tools +{{< /tabpane-normal >}} -Additional performance analysis and benchmarking resources: +## STEP 2: Test, build, and run + +Based on your initial research, decide how to proceed with trying your software on Arm. In general, you can use a top-down or bottom-up strategy to migrate to Arm. Select a methodology and use the resources above to build and run your application. + +### 2.1 Top-down methodology + +Top-down porting involves moving the complete software stack to an Arm machine and trying to build and run it straightaway. You will almost certainly face errors, which you can address one at a time until the full application runs on Arm. + +![Top-down porting methodology](Top-down.png) + +This methodology is great for simpler stacks, when breaking down the problem would take more time than fixing errors iteratively. + +### 2.2 Bottom-up methodology + +Bottom-up porting is more systematic. Here, you break apart your software stack, starting with the foundations of your app to get those running on an Arm server first. Then add back one or two software packages at a time, and recompile and run to ensure it works on Arm. If errors arise, fix them or replace the incompatible package with an Arm compatible version. Continue building back your stack until it is fully formed on an Arm server. + +![Bottom-up porting methodology](Bottom-up.png) + +This methodology is sensible for large stacks, where running the whole app on Arm immediately would cause too many errors to effectively work through. + +## STEP 3: Optimize your application + +If you've reached this step, congratulations! Your application is running on Arm. The next action is to ensure it is running optimally. + +### 3.1 Measure performance + +Once the application is running you can measure performance. This can be as simple as timing an application or may involve using performance analysis tools. + +You may have some performance analysis methodologies you already follow, continue to use those. + +Below are some additional performance analysis tips and methodologies specific to Arm-based servers: - [Learn the Arm Neoverse N1 performance analysis methodology](https://learn.arm.com/learning-paths/servers-and-cloud-computing/top-down-n1/) - [Profiling for Neoverse with Streamline CLI Tools](https://learn.arm.com/learning-paths/servers-and-cloud-computing/profiling-for-neoverse/) - [Learn how to optimize an application with BOLT](https://learn.arm.com/learning-paths/servers-and-cloud-computing/bolt/) @@ -113,18 +247,19 @@ Additional performance analysis and benchmarking resources: - [NVIDIA Grace CPU Benchmarking Guide](https://nvidia.github.io/grace-cpu-benchmarking-guide/index.html) - [Learn about Large System Extensions (LSE)](https://learn.arm.com/learning-paths/servers-and-cloud-computing/lse/) +### 3.2 Ask for help -Your goal is to understand if the performance you see will translate into the expected price performance advantages. If you are unsure or need additional help you can submit an issue on GitHub. +Your goal is to understand if the performance you see will translate into the expected price performance advantages. If you are unsure or need additional help you can ask the Arm developer community for help. Join the [Arm Developer Program](https://www.arm.com/resources/developer-program) and talk directly to other developers and Arm Experts on Discord. -### Deploy +### DELIVER: Deploy your application to users Once the price performance gains are confirmed, you can plan for a larger deployment. -This may involve a variety of steps: -- Experimenting with different virtual machine sizes or instance types to find the best fit for your application -- Adding some Arm notes to your Kubernetes cluster and running a subset of workloads on Arm -- Directing some of your web traffic to an Arm version of the application -- Creating a complete version of your application in a dev environment for additional testing +Deployment is outside the scope of this guide, but here are some concepts to keep in mind: +- Experiment with different virtual machine sizes and instance types to find the best fit for your application. +- Add some Arm nodes to your Kubernetes cluster and run a subset of workloads on Arm. +- Direct some of your web traffic to an Arm version of the application. +- Create a complete version of your application in a dev environment for additional testing. Make sure to research the details needed for these tasks by checking any places you use infrastructure as code or other places you store details about virtual machine types and sizes, as well as parameters for managed services. @@ -132,6 +267,4 @@ You can also check [Works on Arm](https://www.arm.com/markets/computing-infrastr ## Summary -The 3 step process combined with the available resources help you migrate applications to Arm. - - +With this 3 step process and the provided resources, you are well positioned to migrate your applications to Arm. Happy porting! diff --git a/content/migration/containers/_index.md b/content/migration/containers/_index.md deleted file mode 100644 index 0f7a24a04..000000000 --- a/content/migration/containers/_index.md +++ /dev/null @@ -1,14 +0,0 @@ ---- -title: "Containers on Arm servers" ---- - -## Which tools are available for building and running containers on Arm servers? - -Below are some resources to help you with multi-architecture containers: - -| Tool | Learning Paths | Other Content (Blogs/Videos) | -|-----------|----------------|----------------------------------------| -| Docker | [Learn how to use Docker](https://learn.arm.com/learning-paths/cross-platform/docker/) | [How to build cloud-native applications for multi-architecture infrastructure](https://stackoverflow.blog/2024/02/05/how-to-build-cloud-native-applications-for-multi-architecture-infrastructure/) -| AWS CodeBuild | [Build and share Docker images using AWS CodeBuild](https://learn.arm.com/learning-paths/servers-and-cloud-computing/codebuild/) | | -| Docker Build Cloud | [Build multi-architecture container images with Docker Build Cloud](https://learn.arm.com/learning-paths/cross-platform/docker-build-cloud/) | [Supercharge your Arm builds with Docker Build Cloud: Efficiency meets performance](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/supercharge-arm-builds-with-docker-build-cloud) | -| GitHub Actions | [Build multi-architecture container images with GitHub Arm-hosted runners](https://learn.arm.com/learning-paths/cross-platform/github-arm-runners/) | | \ No newline at end of file diff --git a/content/migration/databases/_index.md b/content/migration/databases/_index.md deleted file mode 100644 index b2bd88347..000000000 --- a/content/migration/databases/_index.md +++ /dev/null @@ -1,24 +0,0 @@ ---- -title: "Databases on Arm servers" ---- - -## Which databases are available on Arm servers? - -Below are some resources to help you with specific databases: - -| Database | Learning Paths | Other Content (Blogs/Videos) | -|-----------|----------------|----------------------------------------| -| MySQL | AWS: [Deploy WordPress with MySQL on Elastic Kubernetes Service (EKS)](https://learn.arm.com/learning-paths/servers-and-cloud-computing/eks/) | | -| MySQL | [Learn how to deploy MySQL](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mysql/) | | -| MySQL | [Benchmarking MySQL with Sysbench](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mysql_benchmark/) | | -| MySQL | [Learn how to Tune MySQL](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mysql_tune/) | | -| PostgreSQL | [Learn how to deploy PostgreSQL](https://learn.arm.com/learning-paths/servers-and-cloud-computing/postgresql/) | | -| Flink | [Benchmark the performance of Flink on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/flink/) | -| Clickhouse | [Measure performance of ClickHouse on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/clickhouse/) | AWS: [Improve ClickHouse Performance up to 26% by using AWS Graviton3](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/improve-clickhouse-performance-up-to-26-by-using-aws-graviton3) | -| MongoDB | [Test the performance of MongoDB on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mongodb/) | [MongoDB performance on Arm Neoverse based AWS Graviton2 processors](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/mongodb-performance-on-aws-with-the-arm-graviton2) | -| Redis | [Deploy Redis on Arm](https://learn.arm.com/learning-paths/servers-and-cloud-computing/redis/) | Alibaba: [Improve Redis performance up to 36% by deploying on Alibaba Cloud Yitian 710 instances](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/improve-redis-performance-by-deploying-on-alibaba-cloud-yitian-710-instances) | -| Spark | AWS: [Learn how to deploy Spark on AWS Graviton2](https://learn.arm.com/learning-paths/servers-and-cloud-computing/spark/) | AWS: [Spark on AWS Graviton2 best practices: K-Means clustering case study](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/optimize-spark-on-aws-graviton2-best-practices-k-means-clustering) | -| MariaDB | [Deploy MariaDB on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/mariadb/) | -| Elasticsearch/Opensearch | | -| Spark+Gluten+Velox | | -| Pinecone | | \ No newline at end of file diff --git a/content/migration/languages/_index.md b/content/migration/languages/_index.md deleted file mode 100644 index 0ec803d43..000000000 --- a/content/migration/languages/_index.md +++ /dev/null @@ -1,23 +0,0 @@ ---- -title: "Programming languages on Arm servers" ---- - -## Which programming languages work on Arm servers? - -Nearly all programming languages work on Arm. - -Below are some resources to help you with specific languages: - -| Languages | Learning Paths | Other Content (Blogs/Videos) | -|-----------|----------------|----------------------------------------| -| C/C++ | [C/C++ on Arm Neoverse processors](https://learn.arm.com/learning-paths/servers-and-cloud-computing/migration/c-c++/) | [What is new in LLVM 18?](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/p1-whats-new-in-llvm-18) | -| Rust | [Rust Install Guide](https://learn.arm.com/install-guides/rust/) | [Neon Intrinsics in Rust](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/rust-neon-intrinsics) | -| Java | | [Improving Java performance on Neoverse N1 systems](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/java-performance-on-neoverse-n1) | -| | | [Java Vector API on AArch64](https://community.arm.com/arm-community-blogs/b/high-performance-computing-blog/posts/java-vector-api-on-aarch64) | -| | | AWS: [Java on Graviton](https://github.com/aws/aws-graviton-getting-started/blob/main/java.md) | -| | | Azure: [Optimizing Java Workloads on Azure General Purpose D-series v5 VMs with Microsoft’s Build of OpenJDK](https://techcommunity.microsoft.com/t5/azure-compute-blog/optimizing-java-workloads-on-azure-general-purpose-d-series-v5/ba-p/3827610) | -| | | Ampere: [Improving Java performance on OCI Ampere A1 compute instances](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/performance-of-specjbb2015-on-oci-ampere-a1-compute-instances) | -| Go | [Go Install Guide](https://learn.arm.com/install-guides/go/) | AWS: [Making your Go workloads up to 20% faster with Go 1.18 and AWS Graviton](https://aws.amazon.com/blogs/compute/making-your-go-workloads-up-to-20-faster-with-go-1-18-and-aws-graviton/)| -| .NET | [.NET Install Guide](https://learn.arm.com/install-guides/dotnet/) | [Arm64 Performance Improvements in .NET 7](https://devblogs.microsoft.com/dotnet/arm64-performance-improvements-in-dotnet-7/) | -| Python | | [Python on Arm](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/python-on-arm)| -| PHP | | [Improving performance of PHP for Arm64 and impact on AWS Graviton2 based EC2 instances](https://aws.amazon.com/blogs/compute/improving-performance-of-php-for-arm64-and-impact-on-amazon-ec2-m6g-instances/) | \ No newline at end of file diff --git a/content/migration/libraries/_index.md b/content/migration/libraries/_index.md deleted file mode 100644 index a9bfaeb6a..000000000 --- a/content/migration/libraries/_index.md +++ /dev/null @@ -1,24 +0,0 @@ ---- -title: "Libraries on Arm servers" ---- - -## Which key libraries are optimized for Arm servers? - -| Library/Framework | Learn More | Blogs | -|-------------------|------------|-------| -| x264/x265 | [Run x265 (H.265 codec) on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/codec/) | AWS: [Improve video encoding price/performance by up to 36% with Arm Neoverse based Amazon EC2 C6g instances](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/thirty-six-percent-better-video-encoding-with-aws-graviton2_2d00_based-c6g) | -| | | AWS: [Reduce H.265 High-Res Encoding Costs by over 80% with AWS Graviton2](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/reduce-h-265-high-res-encoding-costs-by-over-80-with-aws-graviton2-1207706725) | -| | | Ampere: [Ampere Altra Max Delivers Sustainable High-Resolution H.265 Encoding](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/ampere-altra-max-delivers-sustainable-high-resolution-h-265-video-encoding-without-compromise) | -| | | Ampere: [OCI Ampere A1 Compute instances can significantly reduce video encoding costs versus modern CPUs](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/oracle-cloud-infrastructure-arm-based-a1) | -| ArmPL | [Arm Performance Libraries install guide](https://learn.arm.com/install-guides/armpl/) | [Arm Compiler for Linux and Arm Performance Libraries 24.04](https://community.arm.com/arm-community-blogs/b/high-performance-computing-blog/posts/arm-compiler-for-linux-and-arm-performance-libraries-24-04) | -| ArmRAL | [Get started with the Arm 5G RAN Acceleration Library (ArmRAL)](https://learn.arm.com/learning-paths/servers-and-cloud-computing/ran/) | [The next chapter for Arm RAN Acceleration Library: Open-sourcing the code base & accelerating adoption](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/arm-ral-is-now-open-source) | -| OpenSSL | | | -| VP9 | | AWS: [Arm-based cloud instances outperform x86 instances by up to 64% on VP9 encoding](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/arm-outperforms-x86-by-up-to-64-percent-on-vp9) | -| ISA-L | | | -| IPSEC-MB | | | -| AV1 | | | -| SLEEF | | | -| AES | | AWS: [AWS Graviton3 delivers leading AES-GCM encryption performance](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/aes-gcm-optimizations-for-armv8-4-on-neoverse-v1-graviton3) | -| Snappy | [Measure performance of compression libraries on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/snappy/) | AWS: [Comparing data compression algorithm performance on AWS Graviton2](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/comparing-data-compression-algorithm-performance-on-aws-graviton2-342166113) | -| Cloudflare zlib | [Learn how to build and use Cloudflare zlib on Arm servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/zlib/) | | - diff --git a/content/migration/networking/_index.md b/content/migration/networking/_index.md deleted file mode 100644 index eb9ed0106..000000000 --- a/content/migration/networking/_index.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: "Networking software for Arm servers" ---- - -## Which networking software works on Arm servers? - - -Below are some resources to help you with networking software - -| Software | Learning Paths | Other Content (Blogs/Videos) | -|-----------|----------------|----------------------------------------| -| Vectorscan | [Install Vectorscan (Hyperscan on Arm) and use it with Snort 3](https://learn.arm.com/learning-paths/servers-and-cloud-computing/vectorscan/) | | -| DPDK | | [DPDK Tuning Guide](https://developer.arm.com/documentation/109701/1-0/?lang=en) | \ No newline at end of file diff --git a/content/migration/web/_index.md b/content/migration/web/_index.md deleted file mode 100644 index 3eb282893..000000000 --- a/content/migration/web/_index.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: "Web applications on Arm servers" ---- - -## Which software helps me build web applications on Arm servers? - -Below are some resources to help you with web applications: - -| Software | Learning Paths | Other Content (Blogs/Videos) | -|-----------|----------------|----------------------------------------| -| Nginx | [Learn how to deploy Nginx](https://learn.arm.com/learning-paths/servers-and-cloud-computing/nginx/) | AWS: [Nginx Performance on AWS Graviton3](https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/nginx-performance-on-graviton-3) | -| | [Learn how to tune Nginx](https://learn.arm.com/learning-paths/servers-and-cloud-computing/nginx_tune/) | | -| Django | [Learn how to deploy a Django application](https://learn.arm.com/learning-paths/servers-and-cloud-computing/django/) | | diff --git a/data/stats_current_test_info.yml b/data/stats_current_test_info.yml index 2d83b293e..a5ca84621 100644 --- a/data/stats_current_test_info.yml +++ b/data/stats_current_test_info.yml @@ -1,5 +1,5 @@ summary: - content_total: 277 + content_total: 278 content_with_all_tests_passing: 32 content_with_tests_enabled: 33 sw_categories: diff --git a/data/stats_weekly_data.yml b/data/stats_weekly_data.yml index ee6e7847c..20416fdf8 100644 --- a/data/stats_weekly_data.yml +++ b/data/stats_weekly_data.yml @@ -3235,3 +3235,72 @@ avg_close_time_hrs: 0 num_issues: 12 percent_closed_vs_total: 0.0 +- a_date: '2024-08-26' + content: + cross-platform: 21 + embedded-systems: 18 + install-guides: 84 + laptops-and-desktops: 31 + microcontrollers: 24 + servers-and-cloud-computing: 78 + smartphones-and-mobile: 22 + total: 278 + contributions: + external: 38 + internal: 322 + github_engagement: + num_forks: 30 + num_prs: 8 + individual_authors: + arm: 3 + arnaud-de-grandmaison: 1 + basma-el-gaabouri: 1 + bolt-liu: 2 + brenda-strech: 1 + christopher-seidl: 7 + daniel-gubay: 1 + daniel-nguyen: 1 + david-spickett: 2 + dawid-borycki: 28 + diego-russo: 1 + diego-russo-and-leandro-nunes: 1 + elham-harirpoush: 2 + florent-lebeau: 5 + "fr\xE9d\xE9ric--lefred--descamps": 2 + gabriel-peterson: 5 + gayathri-narayana-yegna-narayanan: 1 + graham-woodward: 1 + james-whitaker,-arm: 1 + jason-andrews: 83 + johanna-skinnider: 2 + jonathan-davies: 2 + jose-emilio-munoz-lopez,-arm: 1 + julie-gaskin: 4 + julio-suarez: 5 + kasper-mecklenburg: 1 + konstantinos-margaritis: 7 + kristof-beyls: 1 + liliya-wu: 1 + mathias-brossard: 1 + michael-hall: 5 + owen-wu,-arm: 2 + pareena-verma: 35 + pareena-verma,-jason-andrews,-and-zach-lasiuk: 1 + pareena-verma,-joe-stech,-adnan-alsinan: 1 + pranay-bakre: 2 + przemyslaw-wirkus: 1 + roberto-lopez-mendez: 2 + ronan-synnott: 45 + thirdai: 1 + tom-pilar: 1 + uma-ramalingam: 1 + varun-chari: 1 + visualsilicon: 1 + ying-yu: 1 + ying-yu,-arm: 1 + zach-lasiuk: 1 + zhengjun-xing: 2 + issues: + avg_close_time_hrs: 0 + num_issues: 9 + percent_closed_vs_total: 0.0 diff --git a/themes/arm-design-system-hugo-theme/layouts/learning-paths/list.html b/themes/arm-design-system-hugo-theme/layouts/learning-paths/list.html index 8ae5eb3f7..516f48107 100644 --- a/themes/arm-design-system-hugo-theme/layouts/learning-paths/list.html +++ b/themes/arm-design-system-hugo-theme/layouts/learning-paths/list.html @@ -72,9 +72,15 @@ - + + {{if ne "Cross Platform" .Title}} + {{if ne "learning-paths" (.Title | urlize)}} + + {{end}} + {{end}} + {{ partial "filter-search-sort/mobile-search-and-filter.html" (dict "context" . "page_type" "learning-path-category")}} diff --git a/themes/arm-design-system-hugo-theme/layouts/migration/migration.html b/themes/arm-design-system-hugo-theme/layouts/migration/migration.html index 65d8b493c..dce79c9d0 100644 --- a/themes/arm-design-system-hugo-theme/layouts/migration/migration.html +++ b/themes/arm-design-system-hugo-theme/layouts/migration/migration.html @@ -4,6 +4,17 @@ {{ $thisdir := .File.Dir }} {{ $thisfile:= .File.TranslationBaseName}} +
+ +
+

Migration overview

+ {{partial "general-formatting/markdown-content-formatting.html" .Params.description}} +
+
+ Image Alt Text: Arm migration overview + +
+
diff --git a/themes/arm-design-system-hugo-theme/layouts/partials/test-maintenance/test-maintenance.html b/themes/arm-design-system-hugo-theme/layouts/partials/test-maintenance/test-maintenance.html index 0546cb7e5..a3144363c 100644 --- a/themes/arm-design-system-hugo-theme/layouts/partials/test-maintenance/test-maintenance.html +++ b/themes/arm-design-system-hugo-theme/layouts/partials/test-maintenance/test-maintenance.html @@ -23,7 +23,62 @@ */}} - + +{{ if eq true $.Page.Params.test_maintenance }} + {{ $path := .RelPermalink }} + + {{/* Split the path by "/" and manually build the path array using slice */}} + {{ $splitPath := strings.Split $path "/" }} + {{ $pathArray := slice }} + {{ range $i, $v := $splitPath }} + {{ if and (ne $v "") (ne $i (sub (len $splitPath) 1)) }} {{/* Skip empty elements and the last empty element */}} + {{ $pathArray = $pathArray | append $v }} + {{ end }} + {{ end }} + + + {{ $base := .Site.Data.stats_current_test_info.sw_categories }} + {{ $desiredKey := ""}} + + {{ if in $pathArray "learning-paths" }} + {{ $desiredKey = index $base (index $pathArray 1) (index $pathArray 2) }} + {{else}} + {{/* Multi-dir check for install guides */}} + {{ if eq (len $pathArray) 3 }} + {{ $desiredKey = index $base (index $pathArray 0) (index $pathArray 2) }} + {{else}} + {{ $desiredKey = index $base (index $pathArray 0) (index $pathArray 1) }} + {{end}} + {{end}} + + {{ range (index $desiredKey "tests_and_status") }} + {{range $image, $pass_or_fail := .}} + + {{ $image_filtered := replace $image ":" "_"}} + {{ $image_filtered := replace $image_filtered "/" "_"}} + {{ if eq "passed" $pass_or_fail }} + {{ $image }} - passed + {{ else }} + {{ $image }} - failed + {{ end }} + + {{end}} + + {{ end }} +{{ end }} + + + + + + + + + + + + +{{/* Getting it from the _index.md page itself, initial implementation only. Switched to Data file; can remove this now. {{ if eq true $.Page.Params.test_maintenance }} {{ range $idx, $el := $.Page.Params.test_images }} {{ if $.Page.Params.test_link }} @@ -44,3 +99,5 @@ {{ end }} {{ end }} {{ end }} + +*/}} \ No newline at end of file diff --git a/themes/arm-design-system-hugo-theme/layouts/shortcodes/tab.html b/themes/arm-design-system-hugo-theme/layouts/shortcodes/tab.html index a73465e63..063c2a73d 100644 --- a/themes/arm-design-system-hugo-theme/layouts/shortcodes/tab.html +++ b/themes/arm-design-system-hugo-theme/layouts/shortcodes/tab.html @@ -6,7 +6,9 @@ {{ with $.Parent }} {{- if ne $.Parent.Name "tabpane" -}} -{{- errorf "tab must be used within a tabpane block" -}} + {{- if ne $.Parent.Name "tabpane-normal" -}} + {{- errorf "tab must be used within a tabpane block" -}} + {{- end -}} {{- end -}} {{- end -}} diff --git a/themes/arm-design-system-hugo-theme/layouts/shortcodes/tabpane-normal.html b/themes/arm-design-system-hugo-theme/layouts/shortcodes/tabpane-normal.html new file mode 100644 index 000000000..670831e3e --- /dev/null +++ b/themes/arm-design-system-hugo-theme/layouts/shortcodes/tabpane-normal.html @@ -0,0 +1,35 @@ +{{/* +Create code panes via horizontal tabs. Uses the 'prismjs-codeblock.html' partial to align formatting with normal code blocks. +*/}} + + + +{{- .Inner -}} + +{{$titles := slice}} +{{- range $index, $element := $.Scratch.Get "tabs" -}} + {{$titles = $titles | append (urlize $element.header)}} +{{end}} + +
+ + {{- range $index, $element := $.Scratch.Get "tabs" -}} +
+ {{ $element.content | markdownify }} +
+ {{end}} + +
+ + + \ No newline at end of file diff --git a/themes/arm-design-system-hugo-theme/layouts/stats/list.html b/themes/arm-design-system-hugo-theme/layouts/stats/list.html index c9d4053e1..966a54fcd 100644 --- a/themes/arm-design-system-hugo-theme/layouts/stats/list.html +++ b/themes/arm-design-system-hugo-theme/layouts/stats/list.html @@ -251,7 +251,8 @@

{{ printf "%.1f%%" (mul {{if eq $key "install-guides"}} {{$level_one_dir = "/"}} {{end}} - {{$info.readable_title}} + {{/* {{$info.readable_title}} */}} + {{$info.readable_title}}