Merge branch 'ArmDeveloperEcosystem:main' into MLOps_GH_runners

Author: madeline-underwood

content/install-guides/java.md

@@ -234,6 +234,20 @@ To print the final values of the flags after the JVM has been initialized, run:
 java -XX:+PrintFlagsFinal -version
 ```
 
+Generally the biggest performance improvements from JVM flags can be obtained from heap and garbage collection (GC) tuning, as long as you understand your workload well.
+
+Default initial heap size is 1/64th of RAM and default maximum heap size is 1/4th of RAM. If you know your memory requirements, you should set both of these flags to the same value (e.g. `-Xms12g` and `-Xmx12g` for an application that uses at most 12 GB). Setting both flags to the same value will prevent the JVM from having to periodically allocate additional memory. Additionally, for cloud workloads max heap size is often set to 75%-85% of RAM, much higher than the default setting.
+
+If you are deploying in a cloud scenario where you might be deploying the same stack to systems that have varying amounts of RAM, you might want to use `-XX:MaxRAMPercentage` instead of `-Xmx`, so you can specify a percentage of max RAM rather than a fixed max heap size. This setting can also be helpful in containerized workloads.
+
+Garbage collector choice will depend on the workload pattern for which you're optimizing.
+
+* If your workload is a straightforward serial single-core load with no multithreading, the `UseSerialGC` flag should be set to true.
+* For multi-core small heap batch jobs (<4GB), the `UseParallelGC` flag should be set to true.
+* The G1 garbage collector (`UseG1GC` flag) is better for medium to large heaps (>4GB). This is the most commonly used GC for large parallel workloads, and is the default for high-core environments. If you want to optimize throughput, use this one.
+* The ZGC (`UseZGC` flag) has low pause times, which can drastically improve tail latencies. If you want to prioritize response time at a small cost to throughput, use ZGC.
+* The Shenandoah GC (`UseShenandoahGC` flag) is still fairly niche. It has ultra low pause times and concurrent evacuation, making it ideal for low-latency applications, at the cost of increased CPU use.
+
 ## Are there other tools commonly used in Java projects?
 
 There are a number of Java-related tools you might like to install.

content/install-guides/streamline-cli.md

@@ -68,29 +68,73 @@ Arm recommends that you profile an optimized release build of your application,
 
 If you are using the `workflow_topdown_basic option`, ensure that your application workload is at least 20 seconds long, in order to give the core time to capture all of the metrics needed. This time increases linearly as you add more metrics to capture.
 
-## Install Streamline CLI Tools
+## Using Python scripts
 
-1. Download and extract the Streamline CLI tools on your Arm server:
+The Python scripts provided with Streamline CLI tools require Python 3.8 or later, and depend on several third-party modules. We recommend creating a Python virtual environment containing these modules to run the tools. 
+
+Create a virtual environment:
+
+```sh
+# From Bash
+python3 -m venv sl-venv
+source ./sl-venv/bin/activate
+```
+
+The prompt of your terminal has (sl-venv) as a prefix indicating the virtual environment is active.
+
+{{% notice Note%}}
+The instructions assume that you run all Python commands from inside the virtual environment.
+{{% /notice %}}
+
+## Installing the tools {.reference}
+
+The Streamline CLI tools are available as a standalone download to enable easy integration in to server workflows.
+
+To download the latest version of the tool and extract it to the current working directory you can use our download utility script:
+
+```sh
+wget https://artifacts.tools.arm.com/arm-performance-studio/Streamline_CLI_Tools/get-streamline-cli.py
+python3 get-streamline-cli.py install
+python3 -m pip install -r ./streamline_cli_tools/bin/requirements.txt
+```
+
+If you want to add the Streamline tools to your search path:
+
+```sh
+export PATH=$PATH:$PWD/streamline_cli_tools/bin
+```
+
+The script can also be used to download a specific version, or install to a user-specified directory:
+
+* To list all available versions:
 
     ```sh
-    wget https://artifacts.tools.arm.com/arm-performance-studio/2024.3/Arm_Streamline_CLI_Tools_9.2.2_linux_arm64.tgz 
-    tar -xzf Arm_Streamline_CLI_Tools_9.2.2_linux_arm64.tgz 
+    python3 get-streamline-cli.py list
     ```
 
-1. The `sl-format.py` Python script requires Python 3.8 or later, and depends on several third-party modules. We recommend creating a Python virtual environment containing these modules to run the tools. For example:
+* To download, but not install, a specific version:
 
     ```sh
-    # From Bash
-    python3 -m venv sl-venv
-    source ./sl-venv/bin/activate
+    python3 get-streamline-cli.py download --tool-version <version>
+    ```
+
+* To download and install a specific version:
 
-    # From inside the virtual environment
-    python3 -m pip install -r ./streamline_cli_tools/bin/requirements.txt
+    ```sh
+    python3 get-streamline-cli.py install --tool-version <version>
     ```
 
-   {{% notice Note%}}
-  The instructions in this guide assume you have added the `<install>/bin/` directory to your `PATH` environment variable, and that you run all Python commands from inside the virtual environment.
-  {{% /notice %}}
+* To download and install to a specific directory
+
+    ```sh
+    python3 get-streamline-cli.py install --install-dir <path>
+    ```
+
+For manual download, you can find all available releases here:
+
+```sh
+https://artifacts.tools.arm.com/arm-performance-studio/Streamline_CLI_Tools/
+```
 
 ## Applying the kernel patch
 
@@ -135,10 +179,10 @@ Follow these steps to integrate these patches into an RPM-based distribution's k
 
 1. Install the RPM build tools:
 
-    ```
+    ```sh
     sudo yum install rpm-build rpmdevtools
     ```
-    
+
 1. Remove any existing `rpmbuild` directory, renaming as appropriate:
 
     ```sh
@@ -150,18 +194,21 @@ Follow these steps to integrate these patches into an RPM-based distribution's k
     ```sh
     yum download --source kernel
     ```
+
 1. Install the sources binary:
 
     ```sh
    rpm -i kernel-<VERSION>.src.rpm
     ```
 
 1. Enter the `rpmbuild` directory that is created:
+
     ```sh
     cd rpmbuild
     ```
 
 1. Copy the patch into the correct location. Replace the 9999 patch number with the next available patch number in the sequence:
+
     ```sh
     cp vX.Y-combined.patch SOURCES/9999-strobing-patch.patch
     ```

content/learning-paths/microcontrollers/cmsis-dsp/cmsis-dsp-tests.md

@@ -7,7 +7,7 @@ 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).
+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 reference systems](https://www.arm.com/products/silicon-ip-subsystems/), for example [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](/learning-paths/microcontrollers/cmsis-dsp/_review/).
 

content/learning-paths/microcontrollers/iot-sdk/_next-steps.md

@@ -14,7 +14,7 @@ recommended_path: "/learning-paths/microcontrollers/tfm"
 # 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) 
+    # General online references                 (type: website)
 
 further_reading:
     - resource:
@@ -25,6 +25,10 @@ further_reading:
         title: Arm Speech Recognition Total Solution example video, using the Arm Open IoT SDK, Corstone-310 and AVH
         link: https://devsummit.arm.com/flow/arm/devsummit22/sessions-catalog/page/sessions/session/16600464346670018mPQ
         type: website
+    - resource:
+        title: Learn more about the Corstone reference systems
+        link: https://www.arm.com/products/silicon-ip-subsystems/
+        type: website
 
 # ================================================================================
 #       FIXED, DO NOT MODIFY

content/learning-paths/microcontrollers/mlek/build.md

@@ -9,31 +9,31 @@ layout: "learningpathall"
 ---
 The [Arm ML Evaluation Kit (MLEK)](https://review.mlplatform.org/plugins/gitiles/ml/ethos-u/ml-embedded-evaluation-kit) provides a number of ready-to-use ML applications. These allow you to investigate the embedded software stack and evaluate performance on the Cortex-M55 and Ethos-U55 processors.
 
-You can use the MLEK source code to build sample applications and run them on the [Corstone-300](https://developer.arm.com/Processors/Corstone-300) Fixed Virtual Platform (FVP).
+You can use the MLEK source code to build sample applications and run them on the [Corstone reference systems](https://www.arm.com/products/silicon-ip-subsystems/), for example the [Corstone-300](https://developer.arm.com/Processors/Corstone-300) Fixed Virtual Platform (FVP).
 
-## Before you begin 
+## Before you begin
 
 You can use your own Ubuntu Linux host machine or use [Arm Virtual Hardware (AVH)](https://www.arm.com/products/development-tools/simulation/virtual-hardware) for this Learning Path.
 
-The Ubuntu version should be 20.04 or 22.04. The `x86_64` architecture must be used because the Corstone-300 FVP is not currently available for the Arm architecture. You will need a Linux desktop to run the FVP because it opens graphical windows for input and output from the software applications. 
+The Ubuntu version should be 20.04 or 22.04. The `x86_64` architecture must be used because the Corstone-300 FVP is not currently available for the Arm architecture. You will need a Linux desktop to run the FVP because it opens graphical windows for input and output from the software applications.
 
 If you want to use Arm Virtual Hardware the [Arm Virtual Hardware install guide](/install-guides/avh#corstone) provides setup instructions.
 
-### Compilers 
+### Compilers
 
-The examples can be built with [Arm Compiler for Embedded](https://developer.arm.com/Tools%20and%20Software/Arm%20Compiler%20for%20Embedded) or [Arm GNU Toolchain](https://developer.arm.com/Tools%20and%20Software/GNU%20Toolchain). 
+The examples can be built with [Arm Compiler for Embedded](https://developer.arm.com/Tools%20and%20Software/Arm%20Compiler%20for%20Embedded) or [Arm GNU Toolchain](https://developer.arm.com/Tools%20and%20Software/GNU%20Toolchain).
 
 Use the install guides to install the compilers on your computer:
 - [Arm Compiler for Embedded](/install-guides/armclang/)
 - [Arm GNU Toolchain](/install-guides/gcc/arm-gnu)
 
-Both compilers are pre-installed in Arm Virtual Hardware. 
+Both compilers are pre-installed in Arm Virtual Hardware.
 
 ### Corstone-300 FVP {#fvp}
 
-To install the Corstone-300 FVP on your computer refer to the [install guide for Arm Ecosystem FVPs](/install-guides/fm_fvp). 
+To install the Corstone-300 FVP on your computer refer to the [install guide for Arm Ecosystem FVPs](/install-guides/fm_fvp).
 
-The Corstone-300 FVP is pre-installed in Arm Virtual Hardware. 
+The Corstone-300 FVP is pre-installed in Arm Virtual Hardware.
 
 ## Clone the repository
 
@@ -54,9 +54,9 @@ git submodule update --init
 
 ## Build the example applications
 
-The default compiler is `gcc`, but `armclang` can also be used. 
+The default compiler is `gcc`, but `armclang` can also be used.
 
-You can select either compiler to build applications. You can also try them both and compare the results. 
+You can select either compiler to build applications. You can also try them both and compare the results.
 
 - Build with Arm GNU Toolchain (`gcc`)
 
@@ -70,6 +70,6 @@ You can select either compiler to build applications. You can also try them both
 ./build_default.py --toolchain arm
 ```
 
-The build will take a few minutes. 
+The build will take a few minutes.
 
 When the build is complete, you will find the example images (`.axf` files) in the `cmake-build-*/bin` directory. The `cmake-build` directory names are specific to the compiler used and Ethos-U55 configuration.

content/learning-paths/microcontrollers/nav-mlek/intro.md

@@ -1,16 +1,16 @@
 ---
 title: Overview
 
-weight: 2 
+weight: 2
 
 # Do not modify these elements
 layout: "learningpathall"
 ---
 
 As a microcontroller software developer, you likely start projects by identifying tools and software, setting up a development environment, and gathering evaluation boards and models.
 
-Machine Learning (ML) applications follow the same pattern, but introduce additional complexity around the inclusion of machine learning models, software libraries for ML operations, and driver software to program neural processing unit (NPU) hardware. 
+Machine Learning (ML) applications follow the same pattern, but introduce additional complexity around the inclusion of machine learning models, software libraries for ML operations, and driver software to program neural processing unit (NPU) hardware.
 
-The [Corstone-300](https://developer.arm.com/Processors/Corstone-300) and [Corstone-310](https://developer.arm.com/Processors/Corstone-310) reference designs are the basis of many ML IoT solutions. These designs offer a jump start on building hardware for ML applications. There are many software tools and examples available to get started creating ML applications, but you may find it difficult to see the big picture and understand which tools and software are best for you. 
+The [Corstone reference systems](https://www.arm.com/products/silicon-ip-subsystems) are the basis of many ML IoT solutions. These designs offer a jump start on building hardware for ML applications. There are many software tools and examples available to get started creating ML applications, but you may find it difficult to see the big picture and understand which tools and software are best for you. You can review the differences between the Corstone reference systems on the [Arm Developer Homepage for Corstone](https://developer.arm.com/documentation/102801/latest/).
 
 This Learning Path is to help you get started with Cortex-M and Ethos-U machine learning application development.