initial commit

Author: Your Name

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

@@ -0,0 +1,65 @@
+---
+title: Example
+weight: 3
+
+### FIXED, DO NOT MODIFY
+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. 
+
+Copy the snippet below into a file named, `no-context.cpp`. 
+
+```cpp
+#include <iostream>
+#include <chrono>
+
+void foo(const int* x, int max_loop_size)
+{
+    int sum = 0;
+    for (int k = 0; k < max_loop_size; k++) {
+        sum += x[k];
+    }
+    std::cout << "Sum: " << sum << std::endl;
+}
+
+int main() {
+    int max_loop_size;
+    std::cout << "Enter a value for max_loop_size (must be a multiple of 4): ";
+    std::cin >> max_loop_size;
+
+    int x[max_loop_size];
+    // Initialise test data
+    for(int i = 0; i < max_loop_size; ++i) x[i] = i;
+ 
+    // Start timing
+    auto start = std::chrono::high_resolution_clock::now();
+    foo(x, max_loop_size);
+    // Stop timing
+    auto end = std::chrono::high_resolution_clock::now();
+
+    // Calculate and display the elapsed time
+    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
+    std::cout << "Time taken by foo: " << duration << " nanoseconds" << std::endl;
+
+    return 0;
+}
+```
+
+Compiling using the following command. 
+
+```bash
+g++ -O3 -march=armv8-a+simd -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. 
+
+```output
+./no_context 
+Enter a value for max_loop_size (must be a multiple of 4): 40000
+Sum: 799980000
+Time taken by foo: 138100 nanoseconds
+```
+

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

@@ -0,0 +1,25 @@
+---
+title: Setup
+weight: 2
+
+### FIXED, DO NOT MODIFY
+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. 
+
+To provide this context to the compiler we will use a simple example written in C++. 
+
+## 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. 
+
+Install the `g++` compiler with the following commands. Adjust to the appropriate commands for your operating system.
+
+```bash
+sudo apt update
+sudo apt install g++
+```
+

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

@@ -0,0 +1,41 @@
+---
+title: Learn to improve for loop run time with loop size context
+
+minutes_to_complete: 15
+
+who_is_this_for: C++ developers
+
+learning_objectives: 
+    - Learn how to add preexisting knowledge of loop sizes to for loops
+
+prerequisites:
+    - Access to an Arm-based machine / instance
+    - Basic understanding of C++
+
+author: Kieran Hejmadi
+
+### Tags
+skilllevels: Introductory
+subjects: C++
+armips:
+    - Neoverse
+tools_software_languages:
+    - C++
+operatingsystems:
+    - Linux
+
+
+
+further_reading:
+    - resource:
+        title: PLACEHOLDER MANUAL 
+        link: PLACEHOLDER MANUAL LINK
+        type: documentation
+
+
+### FIXED, DO NOT MODIFY
+# ================================================================================
+weight: 1                       # _index.md always has weight of 1 to order correctly
+layout: "learningpathall"       # All files under learning paths have this same wrapper
+learning_path_main_page: "yes"  # This should be surfaced when looking for related content. Only set for _index.md of learning path content.
+---

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

@@ -0,0 +1,8 @@
+---
+# ================================================================================
+#       FIXED, DO NOT MODIFY THIS FILE
+# ================================================================================
+weight: 21                  # Set to always be larger than the content in this path to be at the end of the navigation.
+title: "Next Steps"         # Always the same, html page title.
+layout: "learningpathall"   # All files under learning paths have this same wrapper for Hugo processing.
+---

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

@@ -0,0 +1,89 @@
+---
+title: Adding Inside Knowledge
+weight: 4
+
+### FIXED, DO NOT MODIFY
+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. 
+
+```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. 
+
+As slightly easier to read method that avoids confusion when arguments are passed in is dividing the variable before passing it in. For example.
+
+```output
+(max_loop_size_div_4 * 4)
+```
+
+## Adding Insider Knowledge
+
+```cpp
+#include <iostream>
+#include <chrono>
+
+void foo(const int* x, int max_loop_size_div_4)
+{
+    int sum = 0;
+    for (int k = 0; k < max_loop_size_div_4 * 4; k++) {
+        sum += x[k];
+    }
+    std::cout << "Sum: " << sum << std::endl;
+}
+
+int main() {
+    int max_loop_size;
+    std::cout << "Enter a value for max_loop_size (must be a multiple of 4): ";
+    std::cin >> max_loop_size;
+
+    int max_loop_size_div_4 = max_loop_size / 4;
+    int x[max_loop_size];
+    // Initialise test data
+    for(int i = 0; i < max_loop_size; ++i) x[i] = i;
+ 
+    // Start timing
+    auto start = std::chrono::high_resolution_clock::now();
+    foo(x, max_loop_size_div_4);
+    // Stop timing
+    auto end = std::chrono::high_resolution_clock::now();
+
+    // Calculate and display the elapsed time
+    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
+    std::cout << "Time taken by foo: " << duration << " nanoseconds" << std::endl;
+
+    return 0;
+}
+```
+
+Again compile with the same compiler flags. 
+
+```bash
+g++ -O3 -march=armv8-a+simd  -o context
+```
+
+```output
+./context 
+Enter a value for max_loop_size (must be a multiple of 4): 40000
+Sum: 799980000
+Time taken by foo: 24650 nanoseconds
+```
+
+## 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. 
+
+