final check

Author: Your Name

content/learning-paths/cross-platform/cpp-loop-size-context/Example.md

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Example
 
-The following `C++` snippet takes user input as the loop size so that the loop size, `max_loop_size`, is only known at runtime. This initialises an array of size, , `max_loop_size` with the value for each element corresponding to the index position. The function, `foo`, loops of each element to print out the sum of all elements. 
+The following `C++` snippet takes user input as the loop size so that the loop size, `max_loop_size`, is only known at runtime. This initialises an array of size, , `max_loop_size` with the value for each element corresponding to the index position. The function, `foo`, loops through each element to print out the sum of all elements. 
 
 Copy the snippet below into a file named, `no-context.cpp`. 
 
@@ -51,10 +51,10 @@ int main() {
 Compiling using the following command. 
 
 ```bash
-g++ -O3 -march=armv8-a+simd -o no_context
+g++ -O3 -march=armv8-a+simd no_context.cpp -o no_context
 ```
 
-Running the example with the number 4000 leads to the following results. Naturally you will see variability depending on which platform you run this on. 
+Running the example with the number 4000 leads to the following results. You will see runtime variability depending on which platform you run this on. 
 
 ```output
 ./no_context 

content/learning-paths/cross-platform/cpp-loop-size-context/Introduction.md

@@ -8,15 +8,15 @@ layout: learningpathall
 
 ## Introduction
 
-Often the programmer will have a better understanding of their software and the inputs than the compiler. For example, if the loop size is calculated at runtime, the compiler will have to account for a variable size. However, a developer may have knowledge of the runtime profile, for example if the loop size is always a multiple of a specific number. 
+Often, the programmer has deeper insights into their software's behavior and its inputs than the compiler does. For instance, if a loop's size is determined at runtime, the compiler must conservatively handle the possibility of variable sizes, potentially limiting optimization opportunities. However, a developer might know more about the application's runtime characteristics—such as the fact that the loop size always adheres to specific constraints, like being a multiple of a particular number.
 
-To provide this context to the compiler we will use a simple example written in C++. 
+To illustrate how you can explicitly provide this valuable context to the compiler, we'll walk through a simple C++ example.
 
 ## Setup
 
-In this learning path I will be using an Arm-based `r7g.large` instance from AWS but any Arm-based machine can be used. 
+In this learning path, I will be demonstrating the examples using an Arm-based `r7g.large` instance from AWS; however, you're welcome to follow along using any Arm-based machine that suits your environment or preference.
 
-Install the `g++` compiler with the following commands. Adjust to the appropriate commands for your operating system.
+To get started, you'll first need to install the `g++` compiler on your system. Use the following commands as a guide, adjusting them accordingly based on the operating system or distribution you're working with.
 
 ```bash
 sudo apt update

content/learning-paths/cross-platform/cpp-loop-size-context/_index.md

@@ -1,9 +1,9 @@
 ---
-title: Learn to improve for loop run time with loop size context
+title: Learn to Optimize C++ Loops with Size Context
 
 minutes_to_complete: 15
 
-who_is_this_for: C++ developers
+who_is_this_for: C++ developer who want to improve the runtime of for loops with basic insider knowledge of the loop size
 
 learning_objectives: 
     - Learn how to add preexisting knowledge of loop sizes to for loops
@@ -16,7 +16,7 @@ author: Kieran Hejmadi
 
 ### Tags
 skilllevels: Introductory
-subjects: C++
+subjects: ML
 armips:
     - Neoverse
 tools_software_languages:

content/learning-paths/cross-platform/cpp-loop-size-context/providing-inside-knowledge.md

@@ -8,21 +8,23 @@ layout: learningpathall
 
 ## Adding Inside Knowledge
 
-To make the compiler aware that the input will be a multiple of 4 we will rewrite our loop size as the following. 
+To explicitly inform the compiler that our input will always be a multiple of 4, we can rewrite the loop size calculation as follows:
 
 ```output
 ((max_loop_size/4)*4)
 ```
 
-Mathematically this may seem redundant. However since `(max_loop_size/4)` will be truncated to an integer this guarantees `(max_loop_size/4)*4` is a multiple of 4. 
+At first glance, this calculation might seem mathematically redundant. However, since the expression `(max_loop_size/4)` is an integer division, it truncates the result, effectively guaranteeing that `(max_loop_size/4)*4` will always yield a number divisible by 4. The compiler can pick up on this information and optimise accordingly. 
 
-As slightly easier to read method that avoids confusion when arguments are passed in is dividing the variable before passing it in. For example.
+As slightly easier to read method that avoids confusion when passing arguments is to divide the variable and rename before it is passed in. For example.
 
 ```output
 (max_loop_size_div_4 * 4)
 ```
 
-## Adding Insider Knowledge
+## Improved Example
+
+Copy the snippet below and paste into a file named `context.cpp`.
 
 ```cpp
 #include <iostream>
@@ -64,7 +66,7 @@ int main() {
 Again compile with the same compiler flags. 
 
 ```bash
-g++ -O3 -march=armv8-a+simd  -o context
+g++ -O3 -march=armv8-a+simd context.cpp -o context
 ```
 
 ```output
@@ -73,17 +75,11 @@ Enter a value for max_loop_size (must be a multiple of 4): 40000
 Sum: 799980000
 Time taken by foo: 24650 nanoseconds
 ```
+In this particular run, the time taken has significantly reduced compared to our previous example. 
 
 ## Comparison
 
-To compare we will use compiler explorer to see the assembly. 
-
-First, looking at the example without context [here](https://godbolt.org/z/qPaW5Kjxa).
-Second, looking at the example with context [here](https://godbolt.org/z/rhj65Pe4v).
-
-
-[Here](https://godbolt.org/z/nvx4j1vTK). 
-
-As the assembly shows we have fewer lines of assembly corresponding to the function `foo` as there is less setup code to account given the insider knowledge. 
+To compare we will use compiler explorer to see the assembly [here](https://godbolt.org/z/nvx4j1vTK). 
 
+As the assembly shows we have fewer lines of assembly corresponding to the function `foo` when context is added. This is because the compiler can optimise the conditional checking and any clean up code given the context.