Merge branch 'ArmDeveloperEcosystem:main' into main

Author: madeline-underwood

content/install-guides/acfl.md

@@ -142,6 +142,33 @@ install takes place **after** ACfL, you will no longer be able to fully
 uninstall ACfL.
 {{% /notice %}}
 
+## Download and install using System Packages - Ubuntu Linux
+
+Arm Compiler for Linux is available to install with the Ubuntu system package manager `apt` command.
+
+### Setup the ACfL package repository:
+
+Add the ACfL `apt` package repository to your Ubuntu 20.04 or 22.04 system:
+
+```bash { target="ubuntu:latest" }
+sudo apt update
+sudo apt install -y curl
+source /etc/os-release
+curl "https://developer.arm.com/packages/ACfL%3A${NAME}-${VERSION_ID/%.*/}/${VERSION_CODENAME}/Release.key" | sudo tee /etc/apt/trusted.gpg.d/developer-arm-com.asc
+echo "deb https://developer.arm.com/packages/ACfL%3A${NAME}-${VERSION_ID/%.*/}/${VERSION_CODENAME}/ ./" | sudo tee /etc/apt/sources.list.d/developer-arm-com.list
+sudo apt update
+```
+
+The ACfL Ubuntu package repository is now ready to use.
+
+### Install ACfL
+
+Download and install Arm Compiler for Linux with:
+
+```bash { target="ubuntu:latest" }
+sudo apt install acfl
+```
+
 ### 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.

content/install-guides/windows-perf-wpa-plugin.md

@@ -90,13 +90,13 @@ Alternatively, you can download the `.zip` file from a command prompt:
 ```console
 mkdir wpa-plugin
 cd wpa-plugin
-curl -L -O https://github.com/arm-developer-tools/windowsperf-wpa-plugin/releases/download/1.0.2/wpa-plugin-1.0.2.zip
+curl -L -O https://github.com/arm-developer-tools/windowsperf-wpa-plugin/releases/download/1.0.3/wpa-plugin-1.0.3.zip
 ```
 
 Extract the `.dll` file from the downloaded `.zip` file. 
 
 ```console
-tar -xmf wpa-plugin-1.0.2.zip
+tar -xmf wpa-plugin-1.0.3.zip
 ```
 
 The file `WPAPlugin.dll` is now in your `wpa-plugin` directory. 
@@ -110,7 +110,7 @@ Use the `-addsearchdir` flag to tell `wpa` where to find plugins.
 For example, if you downloaded the `.dll` in your `Downloads` directory, you can run `wpa` as shown below:
 
 ```bash
-wpa -addsearchdir %USERPROFILE%\Downloads\wpa-plugin-1.0.2
+wpa -addsearchdir %USERPROFILE%\Downloads\wpa-plugin-1.0.3
 ```
         
 ##### Option 2: Set an environment variable.
@@ -135,7 +135,7 @@ To open a JSON file directly from the command line, you can use the `-i` flag to
 For example, to open `timeline_long.json` in your  `downloads` directory, run the command:
 
 ```console
-wpa -addsearchdir %USERPROFILE%\Downloads\wpa-plugin-1.0.2 -i %USERPROFILE%\Downloads\timeline_long.json
+wpa -addsearchdir %USERPROFILE%\Downloads\wpa-plugin-1.0.3 -i %USERPROFILE%\Downloads\timeline_long.json
 ```
 ## How do I uninstall the WPA plugin?
 

content/learning-paths/cross-platform/simd-info-demo/_index.md

@@ -1,30 +1,30 @@
 ---
 title: Introduction to SIMD.info
 
-draft: true
+
 cascade:
-    draft: true
+
 
 minutes_to_complete: 30
 
-who_is_this_for: This is for advanced topic for software developers interested in porting SIMD code across Arm platforms.
+who_is_this_for: This Learning Path is for software developers who are interested in porting SIMD code across Arm platforms.
 
 learning_objectives: 
-    - Learn how to use SIMD.info’s tools and features, such as navigation, search, and comparison, to simplify the process of finding equivalent SIMD intrinsics between architectures and improving code portability.
+    - Describe how to use SIMD.info’s tools and features, such as navigation, search, and comparison, to simplify the process of finding equivalent SIMD intrinsics between architectures to improve code portability.
 
 prerequisites:
     - A basic understanding of SIMD.
-    - Access to an Arm platform with SIMD supported engine, with recent versions of a C compiler (Clang or GCC) installed.
+    - Access to an Arm platform with a SIMD-supported engine, installed with recent versions of a C compiler such as Clang or GCC.
 
-author_primary: Georgios Mermigkis & Konstantinos Margaritis, VectorCamp
+author_primary: Georgios Mermigkis and Konstantinos Margaritis, VectorCamp
 
 ### Tags
 skilllevels: Advanced
 subjects: Performance and Architecture
 armips:
-    - Aarch64
-    - Armv8-a
-    - Armv9-a
+    - AArch64
+    - Armv8-A
+    - Armv9-A
 tools_software_languages:
     - GCC
     - Clang

content/learning-paths/cross-platform/simd-info-demo/_next-steps.md

@@ -1,7 +1,7 @@
 ---
 next_step_guidance: You should explore **SIMD.info** more and find out porting opportunities between different SIMD engines.
 
-recommended_path: /learning-paths/cross-platform/
+recommended_path: /learning-paths/cross-platform/vectorization-friendly-data-layout/
 
 further_reading:
     - resource:

content/learning-paths/cross-platform/simd-info-demo/_review.md

@@ -4,34 +4,34 @@ review:
         question: >
             What is SIMD.info?
         answers:
-            - An online resource for SIMD C intrinsics for all major architectures
-            - It's an online forum for SIMD developers
-            - A book about SIMD programming
+            - It's an online resource for SIMD C intrinsics for all major architectures.
+            - It's an online forum for SIMD developers.
+            - It's a book about SIMD programming.
         correct_answer: 1                    
         explanation: >
-            While it allows comments in the SIMD intrinsics, SIMD.info is not really a forum. It is an online **free** resource to assist developers porting C code between popular architectures, for example, from SSE/AVX/AVX512 to Arm ASIMD.
+            While it allows comments in the SIMD intrinsics, SIMD.info is not a forum. It is an online free resource to assist developers porting C code between popular architectures, for example, from SSE/AVX/AVX512 to Arm ASIMD.
 
     - questions:
         question: >
             What architectures are listed in SIMD.info?
         answers:
-            - Intel SSE and Arm ASIMD
-            - Power VSX and Arm ASIMD/SVE
-            - Intel SSE4.2/AVX/AVX2/AVX512, Arm ASIMD, Power VSX
+            - Intel SSE and Arm ASIMD.
+            - Power VSX and Arm ASIMD/SVE.
+            - Intel SSE4.2/AVX/AVX2/AVX512, Arm ASIMD, Power VSX.
         correct_answer: 3
         explanation: >
-            At the time of writing SIMD.info supports Intel SSE4.2/AVX/AVX2/AVX512, Arm ASIMD, Power VSX as SIMD architectures. Work is in progress to include Arm SVE/SVE2, MIPS MSA, RISC-V RVV 1.0, s390 Z and others.
+            SIMD.info supports Intel SSE4.2/AVX/AVX2/AVX512, Arm ASIMD, Power VSX as SIMD architectures. Work is in progress to include Arm SVE/SVE2, MIPS MSA, RISC-V RVV 1.0, s390 Z and others.
 
     - questions:
         question: >
             What are SIMD.info's major features?
         answers:
-            - Hierarchical tree, Search, AI code translation
-            - Search, Hierarchical tree, Code examples
-            - Hierarchical tree, Search, Intrinsics Comparison, Code examples, Equivalents mapping, links to official documentation
+            - Hierarchical tree, search, and AI code translation.
+            - Search, hierarchical tree, and code examples.
+            - Hierarchical tree, search, intrinsics comparison, code examples, equivalents mapping, and links to official documentation.
         correct_answer: 3
         explanation: >
-            SIMD.info provides multiple features, including a hierarchical tree, Search facility, Intrinsics Comparison, Code examples, Equivalents mapping, links to official documentation and others. AI code translation is not a feature of SIMD.info but will be the focus of another project, SIMD.ai.
+            SIMD.info provides multiple features, including a hierarchical tree, search facility, intrinsics comparison, code examples, equivalents mapping, links to official documentation, and others. AI code translation is not a feature of SIMD.info but is the focus of another project, SIMD.ai.
 
 
 

content/learning-paths/cross-platform/simd-info-demo/conclusion.md

@@ -6,12 +6,16 @@ weight: 8
 layout: learningpathall
 ---
 
-### Conclusion and Additional Resources
+### Conclusion and further reading
 
-Porting SIMD code between architecture can be a daunting process, in many cases requiring many hours of studying multiple ISAs in online resources or ISA manuals of thousands pages. Our primary focus in this work was to optimize the existing algorithm directly with SIMD intrinsics, without altering the algorithm or data layout. While reordering data to align with native Arm instructions could offer performance benefits, our scope remained within the constraints of the current data layout and algorithm. For those interested in data layout strategies to further enhance performance on Arm, the [vectorization-friendly data layout learning path](https://learn.arm.com/learning-paths/cross-platform/vectorization-friendly-data-layout/) offers valuable insights.
+Porting SIMD code between architectures can be a daunting process, often requiring many hours of studying multiple ISAs in online resources or ISA manuals that run into thousands of pages. 
 
-Using **[SIMD.info](https://simd.info)** can be be instrumental in reducing the amount of time spent in this process, providing a centralized and user-friendly resource for finding **NEON** equivalents to intrinsics of other architectures. It saves considerable time and effort by offering detailed descriptions, prototypes, and comparisons directly, eliminating the need for extensive web searches and manual lookups.
+The primary focus of this Learning Path is to optimize the existing algorithm directly with SIMD intrinsics, without altering the algorithm or data layout. While reordering data to align with native Arm instructions can offer performance benefits, this is outside the scope of this Learning Path. 
 
-While porting between vectors of different sizes is more complex, work is underway -at the time of writing this guide- to complete integration of **SVE**/**SVE2** Arm extensions and allow matching them with **AVX512** intrinsics, as they are both using predicate masks.
+If you are interested in data layout strategies to further enhance performance on Arm, see the Learning Path *Optimize SIMD code with vectorization-friendly data layout* linked to in the **Next Steps** section at the of this Learning Path. 
 
-Please check **[SIMD.info](https://simd.info)** regularly for updates on this.
+Using SIMD.info can be instrumental in reducing the amount of time spent in this process, providing a centralized and user-friendly resource for finding NEON equivalents to intrinsics of other architectures. It saves considerable time and effort by offering detailed descriptions, prototypes, and comparisons directly, eliminating the need for extensive web searches and manual lookups.
+
+While porting between vectors of different sizes is more complex, work is underway to complete the integration of SVE and SVE2 Arm extensions and allow matching them with AVX512 intrinsics, as they both use predicate masks.
+
+You can check **[SIMD.info](https://simd.info)** for updates.

content/learning-paths/cross-platform/simd-info-demo/intro-to-simdinfo.md

@@ -7,10 +7,12 @@ layout: learningpathall
 ---
 
 ### The Challenge of SIMD Code Portability
-One of the biggest challenges developers face when working with SIMD code is making it portable across different platforms. SIMD instructions are designed to increase performance by executing the same operation on multiple data elements in parallel. However, each architecture has its own set of SIMD instructions, making it difficult to write code that works on all of them without major changes to the code and/or algorithm.
+SIMD instructions are designed to improve performance by executing the same operation on multiple data elements in parallel. One of the biggest challenges developers face when working with SIMD code is making it portable across different platforms.  
 
-To port software written using Intel intrinsics, like SSE/AVX/AVX512, to Arm Neon, you have pay attention to data handling with the different instruction sets.
+Each architecture has its own set of SIMD instructions, which makes it difficult to port code without major changes to either the code itself, or the algorithm, or both.
 
-Having to port the code between architectures can increase development time and introduce the risk of errors during the porting process. Currently, developers rely on ISA documentation and manually search across various vendor platforms like [Arm Developer](https://developer.arm.com/architectures/instruction-sets/intrinsics/) and [Intel Intrinsics Guide](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html) to find equivalent instructions.
+For example, to port software written using Intel intrinsics, such as SSE/AVX/AVX512, to Arm Neon, you must address issues with data handling with the different instruction sets.
 
-[SIMD.info](https://simd.info) aims to solve this by helping you find equivalent instructions and providing a more streamlined way to adapt your code for different architectures.
+Porting the code between architectures can increase development time and introduce the risk of errors. Currently, developers rely on ISA documentation and must manually search across various vendor platforms such as [Arm Developer](https://developer.arm.com/architectures/instruction-sets/intrinsics/) and [Intel Intrinsics Guide](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html) to find equivalent instructions.
+
+[SIMD.info](https://simd.info) aims to address this challenge by enabling developers to find equivalent instructions and providing a streamlined way to adapt code for different architectures.