Merge pull request #1946 from madeline-underwood/profile_guided_opt

Profile guided opt_JA to review

Author: jasonrandrews

content/learning-paths/servers-and-cloud-computing/cpp-profile-guided-optimisation/_index.md

@@ -1,17 +1,13 @@
 ---
-title: Optimizing Performance with Profile-Guided Optimization and Google Benchmark
-
-draft: true
-cascade:
-    draft: true
+title: Optimize C++ performance with Profile-Guided Optimization and Google Benchmark
 
 minutes_to_complete: 15
 
-who_is_this_for: Developers who are looking to optimize C++ performance using characteristics observed at runtime.
+who_is_this_for: Developers looking to optimize C++ performance based on runtime behavior.
 
 learning_objectives: 
-    - Learn how to microbenchmark a function using Google Benchmark.
-    - Learn how to use profile guided optimization to build binaries optimized for real-world workloads.
+    - Microbenchmark a function using Google Benchmark.
+    - Apply profile-guided optimization to build performance-tuned binaries.
 
 prerequisites:
     - Basic C++ understanding.
@@ -32,7 +28,7 @@ operatingsystems:
 
 further_reading:
     - resource:
-        title: G++ Profile Guided Optimization Documentation 
+        title: G++ profile-guided optimization documentation 
         link: https://gcc.gnu.org/onlinedocs/gcc-13.3.0/gcc/Instrumentation-Options.html
         type: documentation
     - resource:

content/learning-paths/servers-and-cloud-computing/cpp-profile-guided-optimisation/how-to-1.md

@@ -1,5 +1,5 @@
 ---
-title: Introduction to Profile-Guided Optimization
+title: Profile-Guided Optimization
 weight: 2
 
 ### FIXED, DO NOT MODIFY
@@ -8,16 +8,19 @@ layout: learningpathall
 
 ### What is Profile-Guided Optimization (PGO) and how does it work?
 
-Profile-Guided Optimization (PGO) is a compiler optimization technique that enhances program performance by utilizing real-world execution data. In GCC/G++, PGO involves a two-step process: first, compile the program with the `-fprofile-generate` flag to produce an instrumented binary that collects profiling data during execution; and second, recompile the program with the `-fprofile-use` flag, allowing the compiler to leverage the collected data to make informed optimization decisions. This approach identifies frequently executed paths—known as “hot” paths—and optimizes them more aggressively, while potentially reducing emphasis on less critical code paths.
+Profile-Guided Optimization (PGO) is a compiler optimization technique that enhances program performance by utilizing real-world execution data. In GCC/G++, PGO involves a two-step process: 
+
+- First, compile the program with the `-fprofile-generate` flag to produce an instrumented binary that collects profiling data during execution; 
+- Second, recompile the program with the `-fprofile-use` flag, allowing the compiler to leverage the collected data to make informed optimization decisions. This approach identifies frequently executed paths — known as “hot” paths — and optimizes them more aggressively, while potentially reducing emphasis on less critical code paths.
 
 ### When should I use Profile-Guided Optimization?
 
-PGO is particularly beneficial in the later stages of development when real-world workloads are available. It is most effective for applications where performance is critical and runtime behavior is complex or data-dependent. For instance, consider optimizing “hot” functions that execute frequently. Doing so ensures that the most impactful parts of your code are optimized based on actual usage patterns.
+PGO is particularly beneficial in the later stages of development when real-world workloads are available. It is especially useful for applications where performance is critical and runtime behavior is complex or data-dependent. For instance, consider optimizing “hot” functions that execute frequently. Doing so ensures that the most impactful parts of your code are optimized based on actual usage patterns.
 
 ### What are the limitations of Profile-Guided Optimization and when should I avoid it?
 
 While PGO offers substantial performance benefits, it has limitations. The profiling data must accurately represent typical usage scenarios; otherwise, the optimizations may not deliver the desired performance improvements and could even degrade performance.
 
 Additionally, the process requires extra build steps, potentially increasing compile times for large codebases. Therefore, use PGO only on performance-critical sections that are heavily influenced by actual runtime behavior. PGO might not be ideal for early-stage development or applications with highly variable or unpredictable usage patterns.
 
-Please refer to the [GCC documentation](https://gcc.gnu.org/onlinedocs/gcc-13.3.0/gcc/Instrumentation-Options.html) for further details on enabling and using PGO.
+For further information, see the [GCC documentation](https://gcc.gnu.org/onlinedocs/gcc-13.3.0/gcc/Instrumentation-Options.html) for further details on enabling and using PGO.

content/learning-paths/servers-and-cloud-computing/cpp-profile-guided-optimisation/how-to-2.md

@@ -1,5 +1,5 @@
 ---
-title: Introduction to Google Benchmark
+title: Google Benchmark
 weight: 3
 
 ### FIXED, DO NOT MODIFY
@@ -8,9 +8,11 @@ layout: learningpathall
 
 ## Google Benchmark
 
-Google Benchmark is a C++ library specifically designed for microbenchmarking – measuring the performance of small code snippets with high accuracy. Microbenchmarking is essential for identifying bottlenecks and optimizing critical sections of code, especially in performance-sensitive applications. Google Benchmark simplifies this process by providing a framework that handles common tasks like managing iterations, timing execution, and performing statistical analysis. This allows you to focus on the code being measured rather than writing boilerplate code for testing scenarios or trying to prevent unwanted compiler optimizations.
+Google Benchmark is a C++ library specifically designed for microbenchmarking – measuring the performance of small code snippets with high accuracy. Microbenchmarking is essential for identifying bottlenecks and optimizing critical sections, especially in performance-sensitive applications. 
 
-To use Google Benchmark, you define a function that contains the code you want to measure. This function should accept a `benchmark::State&` parameter and iterate over it to perform the benchmarking. You then register this function using the `BENCHMARK` macro and include `BENCHMARK_MAIN()` to create the main function for the benchmark executable.
+Google Benchmark simplifies this process by providing a framework that manages iterations, times execution, and performs statistical analysis. This allows you to focus on the code being measured, rather than writing boilerplate or trying to prevent unwanted compiler optimizations manually.
+
+To use Google Benchmark, define a function that accepts a `benchmark::State&` parameter and iterate over it to perform the benchmarking. Register the function using the `BENCHMARK` macro and include `BENCHMARK_MAIN()` to generate the benchmark's entry point.
 
 Here's a basic example:
 
@@ -28,7 +30,7 @@ BENCHMARK_MAIN();
 
 ### Filtering and Preventing Compiler Optimizations
 
-Google Benchmark provides tools to ensure accurate measurements by preventing the compiler from optimizing away parts of your benchmarked code:
+Google Benchmark provides tools to ensure accurate measurements  by preventing unintended compiler optimizations and allowing flexible benchmark selection.
 
 1. **Preventing Optimizations**: Use `benchmark::DoNotOptimize(value);` to force the compiler to read and store a variable or expression, ensuring it is not optimized away.
    
@@ -37,6 +39,7 @@ Google Benchmark provides tools to ensure accurate measurements by preventing th
    ```bash
    ./benchmark_binary --benchmark_filter=BM_String.*
    ```
-   This eliminates the need to repeatedly comment out lines of source code.
+   
+This eliminates the need to repeatedly comment out lines of source code.
 
 For more detailed information and advanced usage, refer to the [official documentation](https://github.com/google/benchmark).

content/learning-paths/servers-and-cloud-computing/cpp-profile-guided-optimisation/how-to-3.md

@@ -1,16 +1,16 @@
 ---
-title: Division Example
+title: Example operation
 weight: 4
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Introduction
+## Optimizing costly division operations with Google Benchmark and PGO
 
 In this section, you'll learn how to use Google Benchmark and Profile-Guided Optimization to improve the performance of a simple division operation. This example demonstrates how even seemingly straightforward operations can benefit from optimization techniques.
 
-Integer division is an excellent operation to benchmark because it's typically much more expensive than other arithmetic operations like addition, subtraction, or multiplication. On most CPU architectures, including Arm, division instructions have higher latency and lower throughput compared to other arithmetic operations. By applying Profile-Guided Optimization to code containing division operations, we can potentially achieve significant performance improvements.
+Integer division is ideal for benchmarking because it's significantly more expensive than operations like addition, subtraction, or multiplication. On most CPU architectures, including Arm, division instructions have higher latency and lower throughput compared to other arithmetic operations. By applying Profile-Guided Optimization to code containing division operations, we can potentially achieve significant performance improvements.
 
 ## What tools are needed to run a Google Benchmark example?
 
@@ -63,7 +63,7 @@ Run the program:
 ./div_bench.base
 ```
 
-The output is:
+### Example output
 
 ```output
 Running ./div_bench.base
@@ -81,9 +81,9 @@ Benchmark             Time             CPU   Iterations
 baseDiv/1500       7.90 us         7.90 us        88512
 ```
 
-### Inspect Assembly
+### Inspect assembly
 
-To inspect what assembly instructions are being executed the most frequently, you can use the `perf` command. This is useful for identifying bottlenecks and understanding the performance characteristics of your code.
+To inspect what assembly instructions are being executed most frequently, you can use the `perf` command. This is useful for identifying bottlenecks and understanding the performance characteristics of your code.
 
 Install Perf using the [install guide](https://learn.arm.com/install-guides/perf/) before proceeding.
 

content/learning-paths/servers-and-cloud-computing/cpp-profile-guided-optimisation/how-to-4.md

@@ -6,9 +6,9 @@ weight: 5
 layout: learningpathall
 ---
 
-### Building binary with PGO
+### Build with PGO
 
-To generate a binary optimized using the runtime profile, first build an instrumented binary that records usage data. Run the following command, which includes the `-fprofile-generate` flag, to build the instrumented binary:
+To generate a binary optimized using runtime profile data, first build an instrumented binary that records usage data. Run the following command, which includes the `-fprofile-generate` flag, to build the instrumented binary:
 
 ```bash
 g++ -O3 -std=c++17 -fprofile-generate div_bench.cpp -lbenchmark -lpthread -o div_bench.opt
@@ -20,21 +20,23 @@ Next, run the instrumented binary to generate the profile data:
 ./div_bench.opt
 ```
 
-This execution creates profile data files (typically with a `.gcda` extension) in the same directory. To incorporate this profile data into the compilation, rebuild the program using the `-fprofile-use` flag:
+This execution creates profile data files (typically with a `.gcda` extension) in the same directory. 
+
+Now recompile the program using the `-fprofile-use` flag to apply optimizations based on the collected data: 
 
 ```bash
 g++ -O3 -std=c++17 -fprofile-use div_bench.cpp -lbenchmark -lpthread -o div_bench.opt
 ```
 
-### Running the optimized binary 
+### Run the optimized binary 
 
-Run again with the optimized binary:
+Now run the optimized binary:
 
 ```bash
 ./div_bench.opt
 ```
 
-Running the newly created `div_bench.opt` binary, you observe the following improvement:
+The following output shows the performance improvement:
 
 ```output
 Running ./div_bench.opt
@@ -52,13 +54,13 @@ Benchmark             Time             CPU   Iterations
 baseDiv/1500       2.86 us         2.86 us       244429
 ```
 
-As the terminal output above shows, the average execution time is reduced from 7.90 to 2.86 microseconds. **This improvement occurs because the profile data informed the compiler that the input divisor was consistently 1500 during the profiled runs, allowing it to apply specific optimizations.** 
+As the terminal output above shows, the average execution time is reduced from 7.90 to 2.86 microseconds. This improvement occurs because the profile data informed the compiler that the input divisor was consistently 1500 during the profiled runs, allowing it to apply specific optimizations.
 
 Next, let's examine how the code was optimized at the assembly level.
 
-### Inspect Assembly 
+### Inspect assembly 
 
-Run the following commands to record `perf` data for the optimized binary and create a report:
+Use `perf` to inspect how the compiler optimized the binary:
 
 ```bash
 sudo perf record -o perf-division-opt ./div_bench.opt

content/learning-paths/servers-and-cloud-computing/cpp-profile-guided-optimisation/how-to-5.md

@@ -6,15 +6,15 @@ weight: 6
 layout: learningpathall
 ---
 
-### Building locally with make
+### Build locally with make
 
 PGO can be integrated into a `Makefile` and continuous integration (CI) systems using simple command-line instructions, as shown in the sample `Makefile` below.
 
 {{% notice Caution %}}
-PGO requires additional build steps which will inevitably increase compile time which can be an issue for large code bases. As such, PGO is not suitable for all sections of code. You should PGO only for sections of code which are heavily influenced by run-time behavior and are performance critical. Therefore, PGO might not be ideal for early-stage development or for applications with highly variable or unpredictable usage patterns.
+PGO adds additional build steps which can increase compile time - especially for large code bases. As such, PGO is not suitable for all sections of code. You should PGO only for sections of code which are heavily influenced by run-time behavior and are performance critical. Therefore, PGO might not be ideal for early-stage development or for applications with highly variable or unpredictable usage patterns.
 {{% /notice %}}
 
-Use a text editor to create a `Makefile` for the example.
+Use a text editor to create a file named `Makefile` containing the following content:
 
 ```makefile
 # Simple Makefile for building and benchmarking div_bench with and without PGO
@@ -69,7 +69,7 @@ You can run the following commands in your terminal:
 *   `make run`: Builds both binaries (if they don't exist) and then runs them, displaying the benchmark results for comparison.
 *   `make clean`: Removes the compiled binaries (`div_bench.base`, `div_bench.opt`) and any generated profile data files (`*.gcda`).
 
-### Building with GitHub Actions
+### Build with GitHub Actions
 
 Alternatively, you can integrate PGO into your Continuous Integration (CI) workflow using GitHub Actions. The YAML file below provides a basic example that compiles and runs the benchmark on a GitHub-hosted Ubuntu 24.04 Arm-based runner. This setup can be extended with automated tests to check for performance regressions.