Refactor content for clarity and consistency in Profile-Guided Optimization documentation

Author: madeline-underwood

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

@@ -43,7 +43,7 @@ further_reading:
         link: https://learn.microsoft.com/en-us/windows/arm/overview
         type: documentation
     - resource:
-        title: Arm Performance optimization resources
+        title: Arm performance optimization resources
         link: https://learn.arm.com/learning-paths/laptops-and-desktops/
         type: website
 

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

@@ -14,7 +14,7 @@ First, you compile your program to produce an instrumented binary that collects
 
 This approach identifies frequently executed paths (known as "hot" paths) and optimizes them more aggressively, while reducing emphasis on less critical code paths.
 
-## How does PGO improve performance?
+## How PGO improves performance on Windows on Arm
 
 PGO enables several compiler optimizations that aren't possible with static analysis alone.
 
@@ -24,7 +24,7 @@ For C++ virtual functions, PGO can identify the most common call targets and opt
 
 If your application has an error handling path that rarely executes, PGO ensures the compiler doesn't optimize for that path at the expense of your main execution flow. Performance improvements typically range from 5-15%, though results vary by workload and architecture.
 
-## When should you use Profile-Guided Optimization?
+## When to use PGO on Arm
 
 You'll find PGO particularly beneficial in the later stages of development when real-world workloads are available. It's especially useful for applications where performance is critical and runtime behavior is complex or data-dependent.
 

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

@@ -6,15 +6,21 @@ weight: 3
 layout: learningpathall
 ---
 
+## Overview
+
 Before you start working with Profile-Guided Optimization, you need to understand how to measure performance. This section introduces Google Benchmark, the tool you'll use to measure the impact of your optimizations. Don't worry about installing anything yet. You'll set up your environment and run your first benchmark in the next section.
 
+## What is Google Benchmark?
+
 Google Benchmark is a C++ library specifically designed for microbenchmarking, which means measuring the performance of small code snippets with high accuracy. Microbenchmarking helps you identify bottlenecks and optimize critical sections, especially in performance-sensitive applications. 
 
 Google Benchmark simplifies this process by providing a framework that manages iterations, times execution, and performs statistical analysis. You can focus on the code being measured, rather than writing test code or trying to prevent unwanted compiler optimizations manually.
 
-To use Google Benchmark, you define a function that accepts a `benchmark::State&` parameter and iterate over it to perform the benchmarking. You register the function using the `BENCHMARK` macro and include `BENCHMARK_MAIN()` to generate the benchmark's entry point.
+## Write a simple benchmark
 
-The following example shows a basic benchmark that measures the time it takes to create an empty string:
+To use Google Benchmark, define a function that accepts a benchmark::State& parameter and use it to run the benchmark in a loop. You register the function using the `BENCHMARK` macro and include `BENCHMARK_MAIN()` to generate the benchmark's entry point.
+
+The following example shows a basic benchmark that measures the time it takes to create an empty string. A minimal benchmark looks like this:
 
 ```cpp
 #include <benchmark/benchmark.h>
@@ -28,7 +34,7 @@ BENCHMARK(BM_StringCreation);
 BENCHMARK_MAIN();
 ```
 
-## Filter benchmarks and prevent compiler optimizations
+## Control benchmarks with Google Benchmark filters
 
 Google Benchmark provides tools to ensure accurate measurements by preventing unintended compiler optimizations and allowing flexible benchmark selection.
 
@@ -42,4 +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.
 
-Now that you understand how Google Benchmark works, you're ready to install it and run your first benchmark. In the next section, you'll set up your environment and use Google Benchmark with Profile-Guided Optimization to measure and improve performance.
+## What you've learned
+
+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

@@ -6,13 +6,15 @@ weight: 4
 layout: learningpathall
 ---
 
-In this section, you'll create a baseline benchmark to measure the performance of a division operation. This baseline will help you see the improvement when you apply Profile-Guided Optimization in the next section. This example demonstrates how even seemingly straightforward operations can benefit from optimization techniques.
+## Overview
+
+In this section, you'll create a baseline benchmark to measure the performance of a division operation. This baseline allows you to measure the improvement when you apply profile-guided optimization in the next section.
 
 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, you can achieve significant performance improvements.
 
 For this example, you'll use an Arm computer running Windows.
 
-## Set up your environment
+## Set up Google Benchmark on Windows on Arm
 
 Before you can run benchmarks, you need to install vcpkg (a C++ package manager) and Google Benchmark. This is a one-time setup step.
 
@@ -56,7 +58,7 @@ BENCHMARK(baseDiv)->Arg(1500)->Unit(benchmark::kMicrosecond); // value of 1500 i
 BENCHMARK_MAIN();
 ```
 
-## Compile and run the baseline benchmark
+## Compile and run the baseline benchmark with MSVC
 
 Open an **ARM64 Native Tools Command Prompt** from the Windows Start menu and start PowerShell:
 
@@ -76,6 +78,8 @@ Compile the benchmark. This command uses the MSVC compiler and links with the Go
 cl /I"$VCPKG\include" /D BENCHMARK_STATIC_DEFINE div_bench.cpp /link /LIBPATH:"$VCPKG\lib" benchmark.lib benchmark_main.lib shlwapi.lib
 ```
 
+## Run the benchmark
+
 Add the vcpkg binary directory to your PATH so the program can find required DLLs, then run the benchmark:
 
 ```console
@@ -86,7 +90,7 @@ $env:PATH += ";$HOME\pgo-benchmark\vcpkg_installed\arm64-windows\bin"
 The output is similar to:
 
 ```output
-Running ./div_bench.base
+Running ./div_bench.exe
 Run on (4 X 2100 MHz CPU s)
 CPU Caches:
   L1 Data 64 KiB (x4)
@@ -103,4 +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.
 
-The baseline shows an average execution time of 7.90 microseconds. This gives you a clear starting point to measure improvement. Now that you have this baseline measurement, you're ready to apply Profile-Guided Optimization. In the next section, you'll use PGO to optimize this code and see how much faster it can run.
+## What you've accomplished
+
+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

@@ -8,7 +8,7 @@ layout: learningpathall
 
 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 the instrumented binary
+## Build instrumented binary with MSVC
 
 Open an **ARM64 Native Tools Command Prompt** from the Windows Start menu and start PowerShell if it's not already open. If you're starting a new session, navigate to your project directory and set the `$VCPKG` environment variable again: