Merge pull request #1084 from ArmDeveloperEcosystem/main

Merge to production

.devcontainer/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:latest
+FROM ubuntu:22.04
 
 ARG TARGETPLATFORM
 

.wordlist.txt

@@ -658,7 +658,7 @@ TargetBoard
 TargetOptions
 Tbrk
 Tcl
-Tensorflow
+TensorFlow
 Tera
 TestScenario
 ThinkPad
@@ -674,7 +674,7 @@ Tracepoint
 Tracepoints
 Traefik
 Transactional
-Trustzone
+TrustZone
 Tunings
 UART
 UDP
@@ -1390,6 +1390,7 @@ instrinsics
 dotProduct
 uint
 TextView
+TextView's
 Spack
 MMU
 SDDiskTool
@@ -2931,7 +2932,6 @@ OpenCV's
 OpenCVLoader
 OpenCV’s
 RGBA
-TextView’s
 UC
 YOLO
 buttonStartPreview
@@ -2967,4 +2967,12 @@ setCameraPermissionGranted
 setContentView
 textViewStatus
 thresholding
-updateControls
+updateControls
+AAR
+Artifactory
+SoCs
+TFLite
+artifactory
+asymm
+memTagMode
+memtagMode

content/install-guides/armclang.md

@@ -42,7 +42,13 @@ Arm Compiler for Embedded FuSa must also be [downloaded separately](#download).
 
 ## Standalone compiler packages {#download}
 
-Individual compiler packages for all supported host platforms can be downloaded from the [Arm Product Download Hub](../pdh).
+Individual compiler packages for all supported host platforms can be downloaded from the [Arm Product Download Hub](#pdh) or the [Arm Tools Artifactory](#artifactory).
+
+Individual compiler packages for all supported host platforms can be downloaded from the [Arm Product Download Hub](https://developer.arm.com/downloads) or the [Arm Tools Artifactory](https://www.keil.arm.com/artifacts/).
+
+### Product Download Hub {#pdh}
+
+All compiler packages can be downloaded from the [Arm Product Download Hub](https://developer.arm.com/downloads) (requires login):
 
 - [Arm Compiler for Embedded](https://developer.arm.com/downloads/view/ACOMPE)
 - [Arm Compiler for Embedded FuSa](https://developer.arm.com/downloads/view/ACOMP616)
@@ -51,23 +57,25 @@ 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)
 
-## Install compiler packages
+See [Arm Product Download Hub](../pdh) for additional information on usage.
+
+### Install compiler packages
 
 To install on Windows, unzip the downloaded package, launch the installer, and follow on-screen prompts.
 ```console
 win-x86_64\setup.exe
 ```
 To install on Linux hosts, `untar` the downloaded package and run the install script (note the exact filenames are version and host dependent). For example:
 
-### x86_64
+#### x86_64
 ```console
 mkdir tmp
 mv ARMCompiler6.22_standalone_linux-x86_64.tar.gz tmp
 cd tmp
 tar xvfz ARMCompiler6.22_standalone_linux-x86_64.tar.gz
 ./install_x86_64.sh --i-agree-to-the-contained-eula --no-interactive -d /home/$USER/ArmCompilerforEmbedded6.22
 ```
-### aarch64
+#### aarch64
 ```console
 mkdir tmp
 mv ARMCompiler6.22_standalone_linux-aarch64.tar.gz tmp
@@ -81,17 +89,36 @@ cd ..
 rm -r tmp
 ```
 Add the `bin` directory of the installation to the `PATH` and confirm `armclang` can be invoked.
-### bash
+#### bash
 ```console
 export PATH=/home/$USER/ArmCompilerforEmbedded6.22/bin:$PATH
 armclang --version
 ```
-### csh/tcsh
+#### csh/tcsh
 ```console
 set path=(/home/$USER/ArmCompilerforEmbedded6.22/bin $path)
 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.
+
+Available packages can also be fetched directly from the artifactory. This is particularly useful for automated CI/CD flows.
+
+```command
+wget https://artifacts.tools.arm.com/arm-compiler/6.22/45/standalone-linux-armv8l_64-rel.tar.gz
+```
+
+Note that the artifactory packages do not have their own installers. You should manually extract files and configure, for example:
+```command
+mkdir ArmCompilerforEmbedded6.22
+tar xvzf ./standalone-linux-armv8l_64-rel.tar.gz -C ./ArmCompilerforEmbedded6.22 --strip-components=1
+rm ./standalone-linux-armv8l_64-rel.tar.gz
+export PATH=/home/$USER/ArmCompilerforEmbedded6.22/bin:$PATH
+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/).

content/install-guides/llvm-woa.md

@@ -33,7 +33,7 @@ layout: installtoolsall         # DO NOT MODIFY. Always true for tool install ar
 
 ## Download and install
 
-The latest version of the LLVM toolchain with Windows on Arm native support is 16.0.0. [Download the pre-built binary](https://github.com/llvm/llvm-project/releases/download/llvmorg-16.0.0/LLVM-16.0.0-woa64.exe).
+The latest version (at the time of writing) of the LLVM toolchain with Windows on Arm native support is 18.1.8. [Download the pre-built binary](https://github.com/llvm/llvm-project/releases/download/llvmorg-18.1.8/LLVM-18.1.8-woa64.exe).
 
 {{% notice Note %}}
 A warning message may appear in your browser due to the publisher being listed as `Unknown`. The warning is:
@@ -43,7 +43,7 @@ A warning message may appear in your browser due to the publisher being listed a
 It is safe to ignore this warning and proceed.
 {{% /notice %}}
 
-After download, run `LLVM-16.0.0-woa64.exe` on a Windows on Arm machine. The installer will start. By default, the installer does not add LLVM to the system `PATH`. If you easily want to invoke LLVM from any directory, select the option to `Add LLVM to the system PATH for all users`.
+After download, run `LLVM-18.1.8-woa64.exe` on a Windows on Arm machine. The installer will start. By default, the installer does not add LLVM to the system `PATH`. If you easily want to invoke LLVM from any directory, select the option to `Add LLVM to the system PATH for all users`.
 
 ![img1 #center](/install-guides/_images/llvm-setup.png)
 
@@ -63,7 +63,7 @@ clang --version
 The output should look like:
 
 ```output
-clang version 16.0.0
+clang version 18.1.8
 Target: aarch64-pc-windows-msvc
 Thread model: posix
 InstalledDir: C:\Program Files\LLVM\bin

content/install-guides/multipass.md

@@ -168,10 +168,10 @@ The output from `find` will be similar to the below.
 
 ```output
 Image                       Aliases           Version          Description
-20.04                       focal             20231011         Ubuntu 20.04 LTS
-22.04                       jammy,lts         20231026         Ubuntu 22.04 LTS
-23.04                       lunar             20231025         Ubuntu 23.04
-23.10                       mantic,devel      20231011         Ubuntu 23.10
+20.04                       focal             20240626         Ubuntu 20.04 LTS
+22.04                       jammy             20240701         Ubuntu 22.04 LTS
+23.10                       mantic            20240701         Ubuntu 23.10
+24.04                       noble,lts         20240702         Ubuntu 24.04 LTS
 
 Blueprint                   Aliases           Version          Description
 anbox-cloud-appliance                         latest           Anbox Cloud Appliance
@@ -220,7 +220,7 @@ multipass exec m1u -- uname -a
 The `uname` output will look similar to:
 
 ```output
-Linux m1u 5.15.0-58-generic #64-Ubuntu SMP Thu Jan 5 12:06:43 UTC 2023 aarch64 aarch64 aarch64 GNU/Linux
+Linux m1u 6.8.0-36-generic #36-Ubuntu SMP PREEMPT_DYNAMIC Mon Jun 10 13:20:23 UTC 2024 aarch64 aarch64 aarch64 GNU/Linux
 ```
 
 ### Run an application
@@ -232,13 +232,13 @@ Download and install [OpenVSCode Server](/install-guides/openvscode-server/).
 On the macOS host computer use `wget` for the download.
 
 ```console
-wget https://github.com/gitpod-io/openvscode-server/releases/download/openvscode-server-v1.79.2/openvscode-server-v1.79.2-linux-arm64.tar.gz
+wget https://github.com/gitpod-io/openvscode-server/releases/download/openvscode-server-v1.90.0/openvscode-server-v1.90.0-linux-arm64.tar.gz
 ```
 
 To copy a file to the instance
 
 ```console
-multipass transfer openvscode-server-v1.79.2-linux-arm64.tar.gz m1u:/home/ubuntu
+multipass transfer openvscode-server-v1.90.0-linux-arm64.tar.gz m1u:/home/ubuntu
 ```
 
 Now switch to the instance and extract the download and run the application. 
@@ -252,13 +252,13 @@ multipass shell m1u
 Extract the download. 
 
 ```console
-tar xvfz openvscode-server-v1.79.2-linux-arm64.tar.gz
+tar xvfz openvscode-server-v1.90.0-linux-arm64.tar.gz
 ```
 
 Run the application.
 
 ```console
-./openvscode-server-v1.79.2-linux-arm64/bin/openvscode-server --host=0.0.0.0 --without-connection-token
+./openvscode-server-v1.90.0-linux-arm64/bin/openvscode-server --host=0.0.0.0 --without-connection-token
 ```
 
 Connect to OpenVSCode Server using a browser. From the macOS host computer use the `info` command to get the IP address of the instance.

content/learning-paths/cross-platform/cca_rme/_review.md

@@ -13,7 +13,7 @@
 review:
     - questions:
         question: >
-            Arm Confidential Compute Architecture (CCA) is available on all Arm devices
+            Arm Confidential Compute Architecture (CCA) is available on all Arm devices.
         answers:
             - "True"
             - "False"
@@ -22,7 +22,7 @@ review:
             CCA requires the Realm Management Extension (RME) of Armv9-A architecture, as well as support within the software stack running on the device.
     - questions:
         question: >
-            The secure monitor would run in which world?
+            The Secure Monitor runs in which world?
         answers:
             - "Normal"
             - "Secure"

content/learning-paths/cross-platform/cca_rme/cca.md

@@ -10,7 +10,7 @@ layout: "learningpathall"
 
 [Arm Confidential Compute Architecture ](https://www.arm.com/architecture/security-features/arm-confidential-compute-architecture) (CCA) is a system solution consisting of hardware and software components to maximize the security of your data on devices and cloud.
 
-CCA enhances the virtualization capabilities of your platform by separating the management of resources from access to those resources. It does this by extending the Trustzone for Cortex-A concepts of Normal world and Secure world, adding a Realm world, and an underlying Root world. A secure monitor runs in Root world and manages the transitions between these security states.
+CCA enhances the virtualization capabilities of your platform by separating the management of resources from access to those resources. It does this by extending the TrustZone for Cortex-A concepts of Normal world and Secure world, adding a Realm world, and an underlying Root world. A secure monitor runs in Root world and manages the transitions between these security states.
 
 ![Architecture #center](_images/realms.png)
 

content/learning-paths/cross-platform/eigen-linear-algebra-on-arm/_index.md

@@ -6,7 +6,7 @@ who_is_this_for: This is an advanced topic for C/C++ developers who want to crea
 
 learning_objectives: 
     - Describe how to use Eigen on Arm systems.
-    - Build Tensorflow with SVE on Arm systems.
+    - Build TensorFlow with SVE on Arm systems.
 
 prerequisites:
     - An Arm-based computer running Linux and a recent version of a C++ compiler (Clang or GCC).

content/learning-paths/cross-platform/eigen-linear-algebra-on-arm/_next-steps.md

@@ -1,5 +1,5 @@
 ---
-next_step_guidance: You now have an understanding of how to get started with the Eigen library on Arm systems and efficiently build your own customized Tensorflow build. To learn more, please look at the links provided under further reading.
+next_step_guidance: You now have an understanding of how to get started with the Eigen library on Arm systems and efficiently build your own customized TensorFlow build. To learn more, please look at the links provided under further reading.
 
 recommended_path: /learning-paths/servers-and-cloud-computing/top-down-n1/
 
@@ -17,7 +17,7 @@ further_reading:
         link: https://static.linaro.org/connect/webinars/presentations/Eigen_Webinar_3.pdf
         type: documentation
     - resource:
-        title: Tensorflow Install from Source instructions
+        title: TensorFlow Install from Source instructions
         link: https://www.tensorflow.org/install/source
         type: documentation
 

content/learning-paths/cross-platform/eigen-linear-algebra-on-arm/eigen-intro.md

@@ -31,7 +31,7 @@ It has also been ported to SYCL and CUDA backends and further ports are in progr
 Eigen is a useful library and its success is proven by the number of projects that use it. 
 [The list of projects using Eigen](https://eigen.tuxfamily.org/index.php?title=Main_Page#Projects_using_Eigen) is rich, but here are a few high profile projects:
 
-* [Tensorflow](https://www.tensorflow.org/) - an open source software library for Machine Intelligence.
+* [TensorFlow](https://www.tensorflow.org/) - an open source software library for Machine Intelligence.
 * [Celestia](https://celestiaproject.space/) - the 3D astronomical visualization application Celestia (all orbital and geometric calculations are done with Eigen).
 * [ATLAS](https://home.cern/science/experiments/atlas) - the ATLAS experiment at the LHC (Large Hadron Collider) at CERN.
 * [Quantum++](https://github.com/softwareQinc/qpp) - a modern C++ general purpose quantum computing library.

content/learning-paths/cross-platform/eigen-linear-algebra-on-arm/eigen-on-arm-part2.md

@@ -178,4 +178,4 @@ sys     0m0.000s
 
 Interestingly, SVE performs about the same as the other versions.
 
-You are now ready to build one of the high profile applications that use Eigen with SVE enabled. This application is Tensorflow!
+You are now ready to build one of the high profile applications that use Eigen with SVE enabled. This application is TensorFlow!

content/learning-paths/cross-platform/eigen-linear-algebra-on-arm/tensorflow-with-sve.md

@@ -1,22 +1,22 @@
 ---
-title: Build and Run Tensorflow with SVE
+title: Build and Run TensorFlow with SVE
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Build Tensorflow with SVE enabled
+## Build TensorFlow with SVE enabled
 
-Now that you have seen that you can use Eigen with SVE enabled, it's time to build your own SVE-enabled Tensorflow.
+Now that you have seen that you can use Eigen with SVE enabled, it's time to build your own SVE-enabled TensorFlow.
 
-Tensorflow is a complex application, and building it requires significant effort. However, following the instructions below, you should be able to build and run it. 
+TensorFlow is a complex application, and building it requires significant effort. However, following the instructions below, you should be able to build and run it. 
 
-### Install Build Requirements for Tensorflow
+### Install Build Requirements for TensorFlow
 
-You are going to follow the [Tensorflow Instructions to build from source](https://www.tensorflow.org/install/source) with some slight modifications.
+You are going to follow the [TensorFlow Instructions to build from source](https://www.tensorflow.org/install/source) with some slight modifications.
 
-Before you build Tensorflow, you need to install the build dependencies first.
+Before you build TensorFlow, you need to install the build dependencies first.
 
 The following packages are required for the recent Debian/Ubuntu distribution used here. You might have to change the packages if you're using a different Linux distribution:
 
@@ -48,14 +48,14 @@ Your shell prompt now shows the virtual environment, which should look like this
 (python-venv) $
 ```
 
-Next, clone Tensorflow from its Git repository to your system:
+Next, clone TensorFlow from its Git repository to your system:
 
 ```bash
 git clone https://github.com/tensorflow/tensorflow.git
 cd tensorflow
 ```
 
-Now you can configure Tensorflow. Configuration requires you to answer some questions, but you can select the defaults.
+Now you can configure TensorFlow. Configuration requires you to answer some questions, but you can select the defaults.
 
 You need to pass the relevant SVE flags as you did before to make sure that Eigen selects the SVE backend.
 
@@ -111,13 +111,13 @@ When the build is complete, you should have `tensorflow` `pip` package in this d
 tensorflow_cpu-2.17.0-cp311-cp311-linux_aarch64.whl
 ```
 
-You are finally able to install your custom Tensorflow build to your system, using `pip install`:
+You are finally able to install your custom TensorFlow build to your system, using `pip install`:
 
 ```bash
 pip install
 ```
 
-Installing it will take a while as it will install all dependencies but when it finishes you should have Tensorflow ready to use! 
+Installing it will take a while as it will install all dependencies but when it finishes you should have TensorFlow ready to use! 
 
 You can test it to see if it works by running:
 
@@ -126,5 +126,5 @@ python3 -c "import tensorflow as tf; print(tf.reduce_sum(tf.random.normal([1000,
 tf.Tensor(492.89847, shape=(), dtype=float32)
 ```
 
-If you get the above response then your Tensorflow installation was successful.
+If you get the above response then your TensorFlow installation was successful.
 

content/learning-paths/cross-platform/intrinsics/simde.md

@@ -77,3 +77,9 @@ and observe the output:
 ```output
 result equals 6,8,10,12
 ```
+
+## Further reading
+
+For more information on the use of `SIMDe`, see the below blog.
+
+* [Porting to Arm Intrinsics with SIMDe](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/porting-to-arm-intrinsics-with-simde)

content/learning-paths/cross-platform/matrix/1-foundations.md

@@ -289,9 +289,6 @@ Matrix/
     └── howdy.cpp
 ```
 
-You can download the [archive](/artifacts/matrix/chapter-1.tar.xz) of the
-project in its current state to experiment locally on your machine.
-
 You have created the foundation for developing and evolving your Matrix
 library in a platform-agnostic way, meaning that it can be easily developed and used
 on macOS, Linux, and Windows. This was done *almost* effortlessly thanks to

content/learning-paths/cross-platform/matrix/2-testing.md

@@ -322,8 +322,6 @@ Matrix/
     └── main.cpp
 ```
 
-You can download the [archive](/artifacts/matrix/chapter-2.tar.xz) of the project in its current state to experiment on your computer.
-
 CMake makes it easy to use GoogleTest as an external project. Adding unit tests as you go is now easy.
 
 You have created the unit testing environment for your Matrix library and added a test. The infrastructure is now in place to implement the core of the Matrix processing library.

content/learning-paths/cross-platform/matrix/3-code-1.md

@@ -1040,8 +1040,6 @@ Matrix/
     └── main.cpp
 ```
 
-You can download the [archive](/artifacts/matrix/chapter-3.tar.xz) of the project in its current state to experiment locally on your machine.
-
 After this rather long exercise, you have a minimalistic, yet fully-functional core for the matrix processing library, with some level of regression testing.
 
 Modern C++ enables you to express move and copy semantics, and to use smart pointers to make memory management easy.