Merge pull request #1350 from ArmDeveloperEcosystem/main

Production update

Author: pareenaverma

.github/workflows/content-checks.yml

@@ -81,9 +81,11 @@ jobs:
       - name: Run Microsoft Security DevOps
         uses: microsoft/security-devops-action@latest
         id: msdo
+        with:
+          tools: container-mapping, bandit, eslint, templateanalyzer
 
       - name: Upload results to Security tab
         uses: actions/upload-artifact@v4
         with:
           path: ${{ steps.msdo.outputs.sarifFile }}
-          retention-days: 5 # Default is 90 days
+          retention-days: 5 # Default is 90 days

.wordlist.txt

@@ -3245,4 +3245,25 @@ sysbox
 tinyml
 tvOS
 watchOS
-zilliz
+zilliz
+ASGI
+ComputeLibrary
+FastAPI
+GTSRB
+KubeArchInspect
+MLOPs
+MiniLM
+OpenBLAS
+Requantize
+UpsideDownCake
+Uvicorn
+WPA
+WindowsPerfGUI
+ZGC
+Zouaoui
+gui
+kubearchinspect
+mlops
+multithreading
+preloaded
+requantize

assets/contributors.csv

@@ -41,3 +41,4 @@ Annie Tallund,Arm,annietllnd,annietallund,,
 Cyril Rohr,RunsOn,crohr,cyrilrohr,,
 Rin Dobrescu,Arm,,,,
 Przemyslaw Wirkus,Arm,PrzemekWirkus,przemyslaw-wirkus-78b73352,,
+Nader Zouaoui,Day Devs,nader-zouaoui,nader-zouaoui,@zouaoui_nader,https://daydevs.com/

content/install-guides/_images/wperf-vs-extension-counting-preview.png

@@ -23,11 +23,11 @@ title: Arm Compiler for Linux
 tool_install: true
 weight: 1
 ---
-[Arm Compiler for Linux (ACfL)](https://developer.arm.com/Tools%20and%20Software/Arm%20Compiler%20for%20Linux) is a suite of tools containing Arm C/C++ Compiler (`armclang`), Arm Fortran Compiler (`armflang`), and Arm Performance Libraries (`ArmPL`). It is tailored to the development of High Performance Computing (HPC) applications.
+[Arm Compiler for Linux (ACfL)](https://developer.arm.com/Tools%20and%20Software/Arm%20Compiler%20for%20Linux) is a suite of tools containing Arm C/C++ Compiler (`armclang`), Arm Fortran Compiler (`armflang`), and Arm Performance Libraries (ArmPL). It is tailored to the development of High Performance Computing (HPC) applications.
 
-`Arm Compiler for Linux` runs on 64-bit Arm machines, it is not a cross-compiler.
+Arm Compiler for Linux runs on 64-bit Arm machines, it is not a cross-compiler.
 
-You do not require any additional license to use `Arm Compiler for Linux`.
+You do not require any additional license to use Arm Compiler for Linux.
 
 ## Arm-based hardware
 
@@ -60,7 +60,7 @@ These packages can be installed with the appropriate package manager for your OS
   - Amazon Linux: environment-modules glibc-devel gzip procps python3 tar
   - Ubuntu: environment-modules libc6-dev python3
 
-Note: The minimum supported version for Python is version 3.6.
+The minimum supported version for Python is version 3.6.
 
 You must have at least 2 GB of free hard disk space to both download and unpack
 the Arm Compiler for Linux package. You must also have an additional 6 GB of
@@ -77,7 +77,7 @@ You are now ready to install ACfL [manually](#manual) or with [Spack](#spack).
 
 ## Download and install using install script
 
-Use an Arm recommended script to select, download, and install your preferred `ACfL` package.
+Use an Arm recommended script to select, download, and install your preferred ACfL package.
 
 ```console
 bash <(curl -L https://developer.arm.com/-/cdn-downloads/permalink/Arm-Compiler-for-Linux/Package/install.sh)
@@ -95,46 +95,56 @@ sudo apt install wget
 
 ### Fetch the appropriate installer
 
-`ACfL` installation packages are available to download from [Arm Developer](https://developer.arm.com/downloads/-/arm-compiler-for-linux). Individual `Arm Performance Libraries (ArmPL)` packages are also available.
+ACfL installation packages are available to download from [Arm Developer](https://developer.arm.com/downloads/-/arm-compiler-for-linux). Individual Arm Performance Libraries (ArmPL) packages are also available.
+
+Fetch the ACfL installers:
 
-Fetch the `ACfL` installers:
 #### Ubuntu Linux:
 
 ```bash { target="ubuntu:latest" }
-wget  https://developer.arm.com/-/cdn-downloads/permalink/Arm-Compiler-for-Linux/Version_24.04/arm-compiler-for-linux_24.04_Ubuntu-22.04_aarch64.tar
+wget  https://developer.arm.com/-/cdn-downloads/permalink/Arm-Compiler-for-Linux/Version_24.10/arm-compiler-for-linux_24.10_Ubuntu-22.04_aarch64.tar
 ```
 #### Red Hat Linux:
 ```bash { target="fedora:latest" }
-wget https://developer.arm.com/-/cdn-downloads/permalink/Arm-Compiler-for-Linux/Version_24.04/arm-compiler-for-linux_24.04_RHEL-8_aarch64.tar
+wget https://developer.arm.com/-/cdn-downloads/permalink/Arm-Compiler-for-Linux/Version_24.10/arm-compiler-for-linux_24.10_RHEL-9_aarch64.tar
 ```
 
 ### Install
 
-To install the `Arm Compiler for Linux` package on your 64-bit Linux Arm machine extract the package and run the installation script.
+To install Arm Compiler for Linux on your 64-bit Linux Arm machine extract the package and run the installation script.
 
-Each command sequence includes accepting the license agreement to automate the installation and installing the `modules` software.
+Each command sequence includes accepting the license agreement to automate the installation and installing Environment Modules.
 
 #### Ubuntu Linux:
 
 ```bash { target="ubuntu:latest", env="DEBIAN_FRONTEND=noninteractive" }
 sudo -E apt-get -y install environment-modules python3 libc6-dev
-tar -xvf arm-compiler-for-linux_24.04_Ubuntu-22.04_aarch64.tar
-cd ./arm-compiler-for-linux_24.04_Ubuntu-22.04
-sudo ./arm-compiler-for-linux_24.04_Ubuntu-22.04.sh --accept
+tar -xvf arm-compiler-for-linux_24.10_Ubuntu-22.04_aarch64.tar
+cd ./arm-compiler-for-linux_24.10_Ubuntu-22.04
+sudo ./arm-compiler-for-linux_24.10_Ubuntu-22.04.sh --accept
 ```
 
 #### Red Hat Linux:
 
 ```bash { target="fedora:latest" }
 sudo yum -y install environment-modules python3 glibc-devel
-tar -xvf arm-compiler-for-linux_24.04_RHEL-8_aarch64.tar
-cd arm-compiler-for-linux_24.04_RHEL-8
-sudo ./arm-compiler-for-linux_24.04_RHEL-8.sh --accept
+tar -xvf arm-compiler-for-linux_24.10_RHEL-9_aarch64.tar
+cd arm-compiler-for-linux_24.10_RHEL-9
+sudo ./arm-compiler-for-linux_24.10_RHEL-9.sh --accept
 ```
 
+{{% notice Warning %}}
+⚠️ On RPM based systems (such as Red Hat), if an
+alternative version of GCC (not the GCC bundled with ACfL) is installed
+**after** ACfL, you will not be able to uninstall ACfL fully. For example, a GDB
+(GNU Project Debugger) installation will install the native system GCC.  If this
+install takes place **after** ACfL, you will no longer be able to fully
+uninstall ACfL.
+{{% /notice %}}
+
 ### Set up environment
 
-`Arm Compiler for Linux` uses environment modules to dynamically modify your user environment. Refer to the [Environment Modules documentation](https://lmod.readthedocs.io/en/latest/#id) for more information.
+Arm Compiler for Linux uses environment modules to dynamically modify your user environment. Refer to the [Environment Modules documentation](https://lmod.readthedocs.io/en/latest/#id) for more information.
 
 Set up the environment, for example, in your `.bashrc` and add module files.
 
@@ -163,25 +173,26 @@ module avail
 To configure Arm Compiler for Linux:
 
 ```bash { env_source="~/.bashrc" }
-module load acfl/24.04
+module load acfl/24.10
 ```
 
 To configure GCC:
 
 ```bash { env_source="~/.bashrc" }
-module load gnu/13.2.0
+module load gnu/14.2.0
 ```
-`ACfL` is now [ready to use](#armclang).
+
+ACfL is now [ready to use](#armclang).
 
 ## Download and install with Spack {#spack}
 
-`Arm Compiler for Linux` is available with the [Spack](https://spack.io/) package manager.
+Arm Compiler for Linux is available with the [Spack](https://spack.io/) package manager.
 
 See the [Arm Compiler for Linux and Arm PL now available in Spack](https://community.arm.com/arm-community-blogs/b/high-performance-computing-blog/posts/arm-compiler-for-linux-and-arm-pl-now-available-in-spack) blog for full details.
 
 ### Setup Spack
 
-Clone the `Spack` repostitory and add `bin` directory to the path:
+Clone the Spack repository and add `bin` directory to the path:
 
 ```console
 git clone -c feature.manyFiles=true https://github.com/spack/spack.git
@@ -194,17 +205,17 @@ Set up shell support:
 . /home/ubuntu/spack/share/spack/setup-env.sh
 ```
 
-`Spack` is now ready to use.
+Spack is now ready to use.
 
 ### Install ACfL
 
-Download and install `Arm Compiler for Linux` with:
+Download and install Arm Compiler for Linux with:
 
 ```console
 spack install acfl
 ```
 
-If you wish to install just the `Arm Performance Libraries`, use:
+If you wish to install just the Arm Performance Libraries, use:
 
 ```console
 spack install armpl-gcc
@@ -218,15 +229,15 @@ spack load acfl
 spack compiler find
 ```
 
-`ACfL` is now [ready to use](#armclang).
+ACfL is now [ready to use](#armclang).
 
 
 ## Get started with Arm C/C++ compiler {#armclang}
 
 To get started with the Arm C/C++ Compiler and compile a simple application follow the steps below.
 
 Check that the correct compiler version is being used:
-```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.04" }
+```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.10" }
 armclang --version
 ```
 
@@ -244,13 +255,13 @@ int main()
 
 Build the application with:
 
-```console { env_source="~/.bashrc", pre_cmd="module load acfl/24.04" }
+```console { env_source="~/.bashrc", pre_cmd="module load acfl/24.10" }
 armclang hello.c -o hello
 ```
 
 Run the application with:
 
-```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.04" }
+```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.10" }
 ./hello
 ```
 
@@ -264,7 +275,7 @@ Hello, C World!
 To get started with the Arm Fortran Compiler and compile a simple application follow the steps below.
 
 Check that the correct compiler version is being used:
-```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.04" }
+```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.10" }
 armflang --version
 ```
 
@@ -278,12 +289,12 @@ end program hello
 ```
 
 Build the application with:
-```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.04" }
+```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.10" }
 armflang hello.f90 -o hello
 ```
 
 Run the application with:
-```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.04" }
+```bash { env_source="~/.bashrc", pre_cmd="module load acfl/24.10" }
 ./hello
 ```
 

content/install-guides/_images/wperf-vs-extension-install-page.png

@@ -70,28 +70,28 @@ For more information refer to [Get started with Arm Performance Libraries](https
 
 In a terminal, run the command shown below to download the macOS package:
 ```console
-wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-performance-libraries/24-04/macos/arm-performance-libraries_24.04_macOS.tgz
+wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-performance-libraries/24-10/macos/arm-performance-libraries_24.10_macOS.tgz
 ```
 
 Use tar to extract the file:
 ```console
-tar zxvf arm-performance-libraries_24.04_macOS.tgz
+tar zxvf arm-performance-libraries_24.10_macOS.tgz
 ```
 
 Output of above command:
 ```console
-armpl_24.04_flang-new_clang_18.dmg
+armpl_24.10_flang-new_clang_19.dmg
 ```
 
 Mount the disk image by running from a terminal:
 ```console
-hdiutil attach armpl_24.04_flang-new_clang_18.dmg
+hdiutil attach armpl_24.10_flang-new_clang_19.dmg
 ```
 
 Now run the installation script as a superuser:
 
 ```console
-/Volumes/armpl_24.04_flang-new_clang_18_installer/armpl_24.04_flang-new_clang_18_install.sh -y
+/Volumes/armpl_24.10_flang-new_clang_19_installer/armpl_24.10_flang-new_clang_19_install.sh -y
 ```
 
 Using this command you automatically accept the End User License Agreement and the packages are installed to the `/opt/arm` directory. If you want to change the installation directory location use the `--install_dir` option with the script and provide the desired directory location.
@@ -103,33 +103,33 @@ For more information refer to [Get started with Arm Performance Libraries](https
 
 ## Linux {#linux}
 
-Arm Performance Libraries are supported on most Linux Distributions like Ubuntu, RHEL, SLES and Amazon Linux on an `AArch64` host and compatible with various versions of GCC and NVHPC. The GCC compatible releases are built with GCC 13 and tested with GCC versions 7 to 13. The NVHPC compatible releases are built and tested with NVHPC 24.1.
+Arm Performance Libraries are supported on most Linux Distributions like Ubuntu, RHEL, SLES and Amazon Linux on an `AArch64` host and compatible with various versions of GCC and NVHPC. The GCC compatible releases are built with GCC 14 and tested with GCC versions 7 to 14. The NVHPC compatible releases are built and tested with NVHPC 24.7.
 
 [Download](https://developer.arm.com/downloads/-/arm-performance-libraries) the appropriate package for your Linux distribution. The deb based installers can be used on Ubuntu 20 and Ubuntu 22. The RPM based installers can be used on the following supported distributions:
 
 - Amazon Linux 2, Amazon Linux 2023
-- RHEL-7, RHEL-8, RHEL-9
-- SLES-15
+- RHEL-8, RHEL-9
+- SLES-15 Service Packs 5 and 6
 
 The instructions shown below are for deb based installers for GCC users.
 
 In a terminal, run the command shown below to download the debian package:
 
 ```console
-wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-performance-libraries/24-04/linux/arm-performance-libraries_24.04_deb_gcc.tar
+wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-performance-libraries/24-10/linux/arm-performance-libraries_24.10_deb_gcc.tar
 ```
 
 Use `tar` to extract the file and then change directory:
 
 ```console
-tar -xf arm-performance-libraries_24.04_deb_gcc.tar
-cd arm-performance-libraries_24.04_deb/
+tar -xf arm-performance-libraries_24.10_deb_gcc.tar
+cd arm-performance-libraries_24.10_deb/
 ```
 
 Run the installation script as a super user:
 
 ```console
-sudo ./arm-performance-libraries_24.04_deb.sh --accept
+sudo ./arm-performance-libraries_24.10_deb.sh --accept
 ```
 
 Using the `--accept` switch you automatically accept the End User License Agreement and the packages are installed to the `/opt/arm` directory.
@@ -165,13 +165,13 @@ module avail
 The output should be similar to:
 
 ```output
-armpl/24.04.0_gcc
+armpl/24.10.0_gcc
 ```
 
 Load the appropriate module:
 
 ```console
-module load armpl/24.04.0_gcc
+module load armpl/24.10.0_gcc
 ```
 
 You can now compile and test the examples included in the `/opt/arm/<armpl_dir>/examples/`, or `<install_dir>/<armpl_dir>/examples/` directory, if you have installed to a different location than the default.

content/install-guides/_images/wperf-vs-extension-sampling-preview.png

@@ -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.