Merge pull request #2989 from pareenaverma/review_branch

Rename NEON references to Arm approved TM Neon

Author: pareenaverma

content/install-guides/claude-code.md

@@ -260,7 +260,7 @@ Here are some example prompts that use the Arm MCP Server tools:
 
 - `Scan my workspace for code that needs updating for Arm compatibility`
 - `Check if the postgres:latest container image supports Arm64 architecture`
-- `Search the Arm knowledge base for NEON intrinsics examples`
+- `Search the Arm knowledge base for Neon intrinsics examples`
 - `Find learning resources about migrating from x86 to Arm`
 - `Analyze this assembly code for performance on Arm processors`
 

content/install-guides/github-copilot.md

@@ -332,7 +332,7 @@ Example prompts that use the Arm MCP Server:
 
 - `Scan my workspace for code that needs updating for Arm compatibility`
 - `Check if the postgres:latest container image supports Arm64 architecture`
-- `Search the Arm knowledge base for NEON intrinsics examples`
+- `Search the Arm knowledge base for Neon intrinsics examples`
 - `Find learning resources about migrating from x86 to Arm`
 
 ## Troubleshooting MCP Server connections

content/learning-paths/cross-platform/adler32/_index.md

@@ -1,12 +1,12 @@
 ---
-title: Write NEON intrinsics using GitHub Copilot to improve Adler32 performance
+title: Write Neon intrinsics using GitHub Copilot to improve Adler32 performance
 
 minutes_to_complete: 45
 
-who_is_this_for: This is an introductory topic for C/C++ developers who are interested in using GitHub Copilot to improve performance using NEON intrinsics.
+who_is_this_for: This is an introductory topic for C/C++ developers who are interested in using GitHub Copilot to improve performance using Neon intrinsics.
 
 learning_objectives: 
-    - Use GitHub Copilot to write NEON intrinsics that accelerate the Adler32 checksum algorithm.
+    - Use GitHub Copilot to write Neon intrinsics that accelerate the Adler32 checksum algorithm.
 
 prerequisites:
     - An Arm computer running Linux with the GNU compiler (gcc) installed.
@@ -43,7 +43,7 @@ further_reading:
         link: https://en.wikipedia.org/wiki/Adler-32
         type: Article
     - resource:
-        title: NEON Programming Quick Reference
+        title: Neon Programming Quick Reference
         link: https://developer.arm.com/documentation/den0018/a
         type: Documentation
 

content/learning-paths/cross-platform/adler32/about-2.md

@@ -1,5 +1,5 @@
 ---
-title: About NEON and Adler32
+title: About Neon and Adler32
 weight: 2
 
 ### FIXED, DO NOT MODIFY
@@ -10,23 +10,23 @@ layout: learningpathall
 
 In computing, optimizing performance is crucial for applications that process large amounts of data. This Learning Path guides you through implementing and optimizing the Adler32 checksum algorithm using Arm advanced SIMD (Single Instruction, Multiple Data) instructions. You'll learn how to leverage GitHub Copilot to simplify the development process while achieving significant performance improvements.
 
-## Simplifying Arm NEON Development with GitHub Copilot
+## Simplifying Arm Neon Development with GitHub Copilot
 
-Developers recognize that Arm NEON SIMD instructions can significantly boost performance for computationally intensive applications, particularly in areas like image processing, audio/video codecs, and machine learning. However, writing NEON intrinsics directly requires specialized knowledge of the instruction set, careful consideration of data alignment, and complex vector operations that can be error-prone and time-consuming. Many developers avoid implementing these optimizations due to the steep learning curve and development overhead.
+Developers recognize that Arm Neon SIMD instructions can significantly boost performance for computationally intensive applications, particularly in areas like image processing, audio/video codecs, and machine learning. However, writing Neon intrinsics directly requires specialized knowledge of the instruction set, careful consideration of data alignment, and complex vector operations that can be error-prone and time-consuming. Many developers avoid implementing these optimizations due to the steep learning curve and development overhead.
 
-The good news is that AI developer tools such as GitHub Copilot make working with NEON intrinsics much more accessible. By providing intelligent code suggestions, automated vectorization hints, and contextual examples tailored to your specific use case, GitHub Copilot can help bridge the knowledge gap and accelerate the development of NEON-optimized code. This allows developers to harness the full performance potential of Arm processors - without the usual complexity and overhead.
+The good news is that AI developer tools such as GitHub Copilot make working with Neon intrinsics much more accessible. By providing intelligent code suggestions, automated vectorization hints, and contextual examples tailored to your specific use case, GitHub Copilot can help bridge the knowledge gap and accelerate the development of Neon-optimized code. This allows developers to harness the full performance potential of Arm processors - without the usual complexity and overhead.
 
-You can demonstrate writing NEON intrinsics with GitHub Copilot by creating a full project from scratch and comparing the C implementation to a NEON-optimized version.
+You can demonstrate writing Neon intrinsics with GitHub Copilot by creating a full project from scratch and comparing the C implementation to a Neon-optimized version.
 
 While you may not create complete projects from scratch - and you shouldn't blindly trust the generated code - it's helpful to see what's possible using an example so you can apply the principles to your own projects.
 
-## Accelerating Adler32 with Arm NEON
+## Accelerating Adler32 with Arm Neon
 
-This project demonstrates how to accelerate Adler32 checksum calculations using Arm NEON instructions.
+This project demonstrates how to accelerate Adler32 checksum calculations using Arm Neon instructions.
 
-### What is Arm NEON?
+### What is Arm Neon?
 
-Arm NEON is an advanced SIMD architecture extension for Arm processors. It provides a set of instructions that can process multiple data elements in parallel using specialized vector registers. NEON technology enables developers to accelerate computationally intensive algorithms by performing the same operation on multiple data points simultaneously, rather than processing them one at a time. This parallelism is particularly valuable for multimedia processing, scientific calculations, and cryptographic operations where the same operation needs to be applied to large datasets.
+Arm Neon is an advanced SIMD architecture extension for Arm processors. It provides a set of instructions that can process multiple data elements in parallel using specialized vector registers. Neon technology enables developers to accelerate computationally intensive algorithms by performing the same operation on multiple data points simultaneously, rather than processing them one at a time. This parallelism is particularly valuable for multimedia processing, scientific calculations, and cryptographic operations where the same operation needs to be applied to large datasets.
 
 ## What Is the Adler32 Algorithm?
 
@@ -47,7 +47,7 @@ This project walks you through building the following components using GitHub Co
 - A test program to validate outputs for various input sizes.
 - A Makefile to build and run the program.
 - Performance measurement code to record how long the algorithm takes.
-- A NEON-optimized version of Adler32.
+- A Neon-optimized version of Adler32.
 - A performance comparison table for both implementations.
 
 Continue to the next section to start creating the project.

content/learning-paths/cross-platform/adler32/build-6.md

@@ -59,4 +59,4 @@ The results confirm that your Adler-32 checksum implementation is correct for al
 
 The results from GitHub Copilot confirm that the Adler32 checksum calculations are correct and provide initial performance benchmarks. These results offer a solid baseline, but a meaningful comparison requires an optimized implementation.
 
-In the next section, you’ll implement Adler32 using NEON intrinsics and compare its performance against this baseline.
+In the next section, you’ll implement Adler32 using Neon intrinsics and compare its performance against this baseline.

content/learning-paths/cross-platform/adler32/more-11.md

@@ -13,6 +13,6 @@ GitHub Copilot can help you explore additional performance and optimization idea
 - Test different compiler flags using Agent mode to automate iteration and identify the best combinations.
 - Add Clang support to your Makefile and compare performance against GCC — performance can differ significantly depending on your code structure.
 - Generate a wider range of data sizes and random patterns to stress-test functionality and measure performance under varied conditions.
-- Explore alternative algorithm structures that rely on compiler autovectorization instead of NEON intrinsics — you might discover better performance simply by restructuring the C code.
+- Explore alternative algorithm structures that rely on compiler autovectorization instead of Neon intrinsics — you might discover better performance simply by restructuring the C code.
 
-AI tools won’t always generate high-performance code out of the box, but they can rapidly accelerate your experimentation and learning — especially in new areas of programming like NEON-based performance optimization.
+AI tools won’t always generate high-performance code out of the box, but they can rapidly accelerate your experimentation and learning — especially in new areas of programming like Neon-based performance optimization.

content/learning-paths/cross-platform/adler32/neon-7.md

@@ -1,16 +1,16 @@
 ---
-title: Create a NEON version of Adler32
+title: Create a Neon version of Adler32
 weight: 7
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## How Can I Create a NEON Version of Adler32 To Improve Performance? 
+## How Can I Create a Neon Version of Adler32 To Improve Performance? 
 
-Writing NEON intrinsics is an advanced programming topic which requires time and effort to learn and apply. GitHub Copilot is a good way to get started with NEON, both to write new code and to debug issues during development. 
+Writing Neon intrinsics is an advanced programming topic which requires time and effort to learn and apply. GitHub Copilot is a good way to get started with Neon, both to write new code and to debug issues during development. 
 
-You can instruct Github Copilot to create a NEON-optimized version of Adler32 using the prompt below: 
+You can instruct Github Copilot to create a Neon-optimized version of Adler32 using the prompt below: 
 
 ```console
 Add a second implementation of adler32 that processes data in blocks and uses Arm NEON intrinsics to improve performance.
@@ -553,6 +553,6 @@ Now that I've created the NEON implementation and updated the test code and Make
 
 ```
 
-GitHub Copilot generated a NEON-optimized implementation of Adler32, along with updates to the test program and Makefile. These changes make it easy to compare the performance of both versions.
+GitHub Copilot generated a Neon-optimized implementation of Adler32, along with updates to the test program and Makefile. These changes make it easy to compare the performance of both versions.
 
-Continue to the next section to compile and run the NEON version, and to compare its performance against the original implementation. 
+Continue to the next section to compile and run the Neon version, and to compare its performance against the original implementation. 

content/learning-paths/cross-platform/adler32/neon-debug-9.md

@@ -1,14 +1,14 @@
 ---
-title: Debug the NEON version to match the standard C version
+title: Debug the Neon version to match the standard C version
 weight: 9
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## How Can I Debug the NEON Version Adler32 and Compare Performance?
+## How Can I Debug the Neon Version Adler32 and Compare Performance?
 
-In the previous step, GitHub Copilot revealed that the NEON implementation did not produce the same checksum results as the standard C version.
+In the previous step, GitHub Copilot revealed that the Neon implementation did not produce the same checksum results as the standard C version.
 
 Use the prompt below to instruct GitHub Copilot to try to debug and fix the issue.
 
@@ -17,7 +17,7 @@ Can you modify adler32-neon.c to produce the correct checksum results for the ad
 The NEON version should produce the same checksum as adler32-simple.c but run faster. 
 ```
 
-If the LLM you’re using cannot resolve the NEON functional issues, consider trying another model, such as Gemini 2.5 Pro.
+If the LLM you’re using cannot resolve the Neon functional issues, consider trying another model, such as Gemini 2.5 Pro.
 
 The output is:
 
@@ -94,6 +94,6 @@ I then checked for errors in the modified file and rebuilt the project using `ma
 You can now run the test program adler32-test to verify that the NEON implementation produces the same results as the simple implementation.
 ```
 
-GitHub Copilot successfully modified the NEON version to produce correct checksum results matching the standard C implementation.
+GitHub Copilot successfully modified the Neon version to produce correct checksum results matching the standard C implementation.
 
 Continue to the next section to summarize the project, highlight the performance improvements, and generate a full project description.

content/learning-paths/cross-platform/adler32/neon-run-8.md

@@ -1,16 +1,16 @@
 ---
-title: Compare the NEON version to the standard C version of Adler32
+title: Compare the Neon version to the standard C version of Adler32
 weight: 8
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## How Can I Run the NEON Version of Adler32 and Compare Performance?
+## How Can I Run the Neon Version of Adler32 and Compare Performance?
 
-Before comparing performance, you need to ensure that the NEON implementation builds, runs, and produces the same results as the standard C version.
+Before comparing performance, you need to ensure that the Neon implementation builds, runs, and produces the same results as the standard C version.
 
-To build the NEON version and compare it to the C version use the prompt below in your GitHub Copilot Agent session:
+To build the Neon version and compare it to the C version use the prompt below in your GitHub Copilot Agent session:
 
 ```console
 Use the Makefile to compile and run the new test program and compare the checksum values and performance of each implementation.
@@ -123,6 +123,6 @@ The NEON implementation offers significant performance improvements (up to 5x fa
 If you'd like, I can analyze the code to identify and fix the issue in the NEON implementation so you can maintain both correctness and the performance benefits.
 ```
 
-GitHub Copilot determined that while the NEON version delivers better performance, it currently produces incorrect checksums. This must be addressed before the NEON implementation can be considered correct or production-ready.
+GitHub Copilot determined that while the Neon version delivers better performance, it currently produces incorrect checksums. This must be addressed before the Neon implementation can be considered correct or production-ready.
 
-In the next section, you'll fix the functional issues in the NEON implementation and re-run the performance comparison.
+In the next section, you'll fix the functional issues in the Neon implementation and re-run the performance comparison.