Refactor benchmarking.md for clarity and consistency

Updated terminology from 'aarch64' to 'Arm64' for consistency. Revised sections for clarity and improved readability.

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/rust-on-gcp/benchmarking.md

@@ -6,11 +6,11 @@ weight: 6
 layout: learningpathall
 ---
 
-## Benchmark Rust performance
+## Overview
 
-This section demonstrates how to benchmark Rust performance using `cargo bench` and the Criterion library to measure code execution speed and performance consistency on aarch64 hardware.
+This section demonstrates how to benchmark Rust performance using `cargo bench` and the Criterion library to measure code execution speed and performance consistency on Arm64 hardware.
 
-### Create a benchmark project
+## Create a benchmark project
 
 Create a new Rust project specifically for benchmarking:
 
@@ -19,9 +19,9 @@ cargo new rust-benchmark
 cd rust-benchmark
 ```
 
-### Configure Criterion as a dependency
+## Configure Criterion as a dependency
 
-Criterion is the recommended benchmarking crate for Rust. Edit the `Cargo.toml` file in your project root directory and replace the existing content with:
+Criterion is the recommended benchmarking crate for Rust. Open the `Cargo.toml` file in your project root directory and replace the existing content with:
 
 ```toml
 [dependencies]
@@ -34,21 +34,15 @@ harness = false
 
 This configuration enables Criterion for high-precision benchmarking and disables the default test harness.
 
-### Create the benchmark directory and file
+## Create the benchmark directory and file
 
 Create the benchmark structure that Cargo expects:
 
 ```console
 mkdir benches
 ```
 
-Create a new benchmark file in the `benches/` directory:
-
-```console
-edit benches/my_benchmark.rs
-```
-
-Add the following benchmark code to measure Fibonacci number calculation performance:
+Create a new file named `my_benchmark.rs` in the `benches/` directory and add the following benchmark code to measure Fibonacci number calculation performance:
 
 ```rust
 use criterion::{black_box, Criterion, criterion_group, criterion_main};
@@ -72,7 +66,7 @@ criterion_main!(benches);
 
 This code implements a recursive Fibonacci function and measures how efficiently Rust computes the 20th Fibonacci number. The `black_box` function prevents the compiler from optimizing away the benchmark.
 
-### Run the benchmark
+## Run the benchmark
 
 Execute the benchmark using Cargo:
 
@@ -92,29 +86,13 @@ Found 1 outliers among 100 measurements (1.00%)
   1 (1.00%) low mild
 ```
 
-### Benchmark Metrics Explanation
-
-- **Average Time:** Mean execution time across benchmark runs.  
-- **Outliers:** Represent runs significantly slower or faster than average.  
-- **Plotting Backend:** Used `plotters` since Gnuplot was not found.  
-- The results show **consistent performance** with only slight variation across 100 measurements.
-
-### Understand the results
-
-The benchmark output provides several key metrics:
-
-- **Average time**: Mean execution time across benchmark runs
-- **Outliers**: Runs significantly slower or faster than average  
-- **Plotting backend**: Uses plotters since Gnuplot wasn't found
-
-The results show consistent performance with only slight variation across 100 measurements.
-
-### Performance summary
+## Performance summary
+The benchmark output provides several key metrics: the average time represents the mean execution time across benchmark runs, outliers identify runs that were significantly slower or faster than average, and the plotting backend indicates that plotters is being used since Gnuplot wasn't found on the system.
 
-The following table shows results from running the benchmark on a `c4a-standard-4` (4 vCPU, 16 GB memory) aarch64 VM in GCP using SUSE:
+The following table shows results from running the benchmark on a `c4a-standard-4` (4 vCPU, 16 GB memory) Arm64 VM in GCP using SUSE:
 
 | Benchmark     | Average Time (µs) | Min (µs) | Max (µs) | Outliers (%) | Remarks |
 |---------------|------------------:|---------:|---------:|-------------:|---------|
 | fibonacci 20  | 12.028           | 12.026   | 12.030   | 1.00%        | Stable performance with minimal variation |
 
-The Fibonacci benchmark demonstrates consistent performance on the aarch64 platform. The average execution time of 12.028 µs indicates efficient CPU computation, while only 1% of measurements were outliers. This low variance confirms Rust's reliable execution speed and performance stability on aarch64 architecture.
+The Fibonacci benchmark demonstrates consistent performance on the Arm64 platform. The average execution time of 12.028 µs indicates efficient CPU computation, while only 1% of measurements were outliers. This low variance confirms Rust's reliable execution speed and performance stability on Arm64 architecture.