Up

Author: madeline-underwood

content/learning-paths/laptops-and-desktops/win_profile_guided_optimisation/_index.md

@@ -6,13 +6,13 @@ minutes_to_complete: 30
 who_is_this_for: This is an introductory topic for software developers who want to optimize C++ application performance on Windows on Arm using Profile-Guided Optimization (PGO).
 
 learning_objectives: 
-    - Microbenchmark a function using Google Benchmark.
-    - Apply profile-guided optimization to build performance-tuned binaries for Windows on Arm.
-    - Measure and compare performance improvements from PGO-optimized builds.
+    - Microbenchmark a function using Google Benchmark
+    - Apply profile-guided optimization to build performance-tuned binaries for Windows on Arm
+    - Measure and compare performance improvements from PGO-optimized builds
 
 prerequisites:
-    - Familiarity with C++ development and compiling programs from the command line.
-    - A Windows on Arm machine with [Visual Studio](/install-guides/vs-woa/) and the C++ desktop development tools installed.
+    - Familiarity with C++ development and compiling programs from the command line
+    - A Windows on Arm machine with [Visual Studio](/install-guides/vs-woa/) and the C++ desktop development tools installed
 
 author: Tom Dunkle
 

content/learning-paths/laptops-and-desktops/win_profile_guided_optimisation/how-to-1.md

@@ -40,6 +40,6 @@ Additionally, the process requires extra build steps, which can increase compile
 
 PGO might not be ideal for early-stage development or applications with highly variable or unpredictable usage patterns.
 
-## What you've learned and what's next
+## What you've accomplished and what's next
 
 You now understand what PGO is, how it improves performance through code layout and inlining optimizations, and when to apply it. In the next section, you'll learn about Google Benchmark, the tool you'll use to measure these performance improvements.

content/learning-paths/laptops-and-desktops/win_profile_guided_optimisation/how-to-2.md

@@ -34,7 +34,7 @@ BENCHMARK(BM_StringCreation);
 BENCHMARK_MAIN();
 ```
 
-## Control benchmarks with Google Benchmark filters
+## Control benchmark execution
 
 Google Benchmark provides tools to ensure accurate measurements by preventing unintended compiler optimizations and allowing flexible benchmark selection.
 
@@ -48,6 +48,6 @@ When you have multiple benchmarks, you can run a specific subset using the `--be
 
 Filtering eliminates the need to repeatedly comment out lines of source code when you want to focus on specific benchmarks.
 
-## What you've learned
+## What you've accomplished and what's next
 
 You now understand how to write basic benchmarks with Google Benchmark, use `benchmark::DoNotOptimize` to prevent unwanted compiler optimizations, and filter benchmark execution with command-line options. In the next section, you'll install Google Benchmark and create a baseline benchmark to measure division performance on Windows on Arm.

content/learning-paths/laptops-and-desktops/win_profile_guided_optimisation/how-to-3.md

@@ -58,7 +58,7 @@ BENCHMARK(baseDiv)->Arg(1500)->Unit(benchmark::kMicrosecond); // value of 1500 i
 BENCHMARK_MAIN();
 ```
 
-## Compile and run the baseline benchmark with MSVC
+## Compile the baseline benchmark with MSVC
 
 Open an **ARM64 Native Tools Command Prompt** from the Windows Start menu and start PowerShell:
 
@@ -107,6 +107,6 @@ baseDiv/1500       7.90 us         7.90 us        88512
 
 The warning appears because the Google Benchmark library was built in debug mode, but it doesn't affect the validity of the measurements for this example.
 
-## What you've accomplished
+## What you've accomplished and what's next
 
 You've set up Google Benchmark on Windows on Arm, created a division-heavy benchmark, and established a baseline performance measurement of 7.90 microseconds. This baseline gives you a clear reference point to measure the impact of Profile-Guided Optimization. In the next section, you'll apply PGO to this code and measure the performance improvement.

content/learning-paths/laptops-and-desktops/win_profile_guided_optimisation/how-to-4.md

@@ -6,6 +6,8 @@ weight: 5
 layout: learningpathall
 ---
 
+## Overview
+
 Now that you have a baseline benchmark, you're ready to apply Profile-Guided Optimization. The PGO process involves three steps: build an instrumented binary, run it to collect profile data, and rebuild with optimizations based on that data.
 
 ## Build instrumented binary with MSVC
@@ -26,7 +28,7 @@ cl /O2 /GL /D BENCHMARK_STATIC_DEFINE /I "$VCPKG\include" /Fe:div_bench.exe div_
 
 This command uses several important compiler and linker options. The `/O2` flag creates fast code, while `/GL` enables whole program optimization. The `/GENPROFILE` linker option generates a `.pgd` file for PGO, and `/LTCG` specifies link time code generation. The `/PGD` option specifies the database file where profile data will be stored.
 
-## Collect profile data
+## Collect PGO profile data on Windows on Arm
 
 Run the instrumented binary to generate profile data:
 
@@ -36,7 +38,7 @@ Run the instrumented binary to generate profile data:
 
 This execution creates profile data files (typically with a `.pgc` extension) in the same directory. The profile data captures information about which code paths execute most frequently and how the program behaves at runtime.
 
-## Rebuild with optimizations
+## Rebuild with PGO optimizations
 
 Now recompile the program using the `/USEPROFILE` flag to apply optimizations based on the collected data:
 
@@ -46,7 +48,7 @@ cl /O2 /GL /D BENCHMARK_STATIC_DEFINE /I "$VCPKG\include" /Fe:div_bench_opt.exe
 
 The `/USEPROFILE` linker option instructs the linker to enable PGO with the profile generated during the previous run. The compiler can now make informed decisions about code layout, inlining, and other optimizations based on actual runtime behavior.
 
-## Measure the improvement
+## Measure PGO performance gains
 
 Run the optimized binary to see the performance improvement:
 
@@ -80,4 +82,4 @@ The compiler used the profile data to determine that the divisor was consistentl
 
 ## What you've accomplished
 
-You've applied PGO to reduce execution time by 64% on a division-heavy benchmark. You completed the full PGO workflow: instrument, profile, and optimize. Apply this same technique to performance-critical sections of your own code to achieve similar gains on Windows on Arm.
+You've applied PGO to reduce execution time by 64% on a division-heavy benchmark. You completed the full PGO workflow: instrument, profile, and optimize. Apply this same technique to performance-critical sections of your own code to achieve similar gains on Windows on Arm.