Tech review part sweet part1

pareenaverma · pareenaverma · commit 7e271e38f1db · 2025-06-19T19:16:41.000Z
diff --git a/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/_index.md b/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/_index.md
@@ -1,17 +1,21 @@
 ---
 title: Go Benchmarks with Sweet and Benchstat
 
+draft: true
+cascade:
+    draft: true
+
 minutes_to_complete: 60
 
-who_is_this_for: This learning path is for developers who are interested in measuring the performance of Go-based applications on their servers.
+who_is_this_for: This is an introductory topic for developers who are interested in measuring the performance of Go-based applications on Arm-based servers.
 
 learning_objectives: 
-    - Bring up two instances of GCP VMs 
+    - Learn how to start up Arm64 and x64 instances of GCP VMs 
     - Install Go, benchmarks, benchstat, and sweet on the two VMs  
-    - Using sweet and benchstat, compare performance of Go applications on the two VMs
+    - Use sweet and benchstat to compare the performance of Go applications on the two VMs
 
 prerequisites:
-    - A [Google Cloud account](https://console.cloud.google.com/).  This learning path can be run on-prem or on any cloud provider, but specifically documents the process on GCP's Google Axion platform.
+    - A [Google Cloud account](https://console.cloud.google.com/).  This learning path can be run on on-prem or on any cloud provider instance, but specifically documents the process for running on Google Axion.
     - A local machine with [Google Cloud CLI](/install-guides/gcloud/) installed.
 
 author: Geremy Cohen
@@ -21,8 +25,9 @@ skilllevels: Introductory
 subjects: Performance and Architecture
 armips:
     - Neoverse
+cloud_service_providers: Google Cloud
 tools_software_languages:
-
+    - Go
 operatingsystems:
     - Linux
 
diff --git a/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/add_c4_vm.md b/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/add_c4_vm.md
@@ -1,13 +1,13 @@
 ---
-title: Launching an Intel C4 Instance
+title: Launching a Intel Emerald Rapids Instance
 weight: 30
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
 ## Section Overview
-In this section, you will set up the second benchmarking system, an Intel-based c4-standard-8 instance.
+In this section, you will set up the second benchmarking system, an Intel Emerald Rapids `c4-standard-8` instance.
 
 ## Creating the Instance
 
@@ -27,4 +27,4 @@ To create the second system, follow the previous lesson's c4a install instructio
 
 ![](images/launch_c4/5.png)
 
-After the c4 instance starts up, you are ready to continue to the next section, where you'll install the benchmarking software.
+After the c4 instance starts up, you are ready to continue to the next section, where you'll install the benchmarking software.
diff --git a/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/add_c4a_vm.md b/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/add_c4a_vm.md
@@ -1,13 +1,13 @@
 ---
-title: Launching an Arm Axion C4a Instance
+title: Launching a Google Axion Instance
 weight: 20
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Section Overview
-In this section, you'll learn how to spin up the first of two different systems used in our benchmarking tests, an Arm-based Google Axion c4a-standard-4 (c4a for short).
+## Overview
+In this section, you'll learn how to spin up the first of two different VMs used for benchmarking Go tests, an Arm-based Google Axion c4a-standard-4 (c4a for short).
 
 ## Creating the c4a-standard-4 Instance
 
@@ -63,5 +63,5 @@ The Machine configuration page appears.
 
 ![](images/launch_c4a/19.png)
 
-After a few seconds, your c4a instance starts up, and you are ready to continue to the next section. In the next step, you will launch the second system, an Intel-based Emerald Rapids c4-standard-8 (c4 for short), which will serve as the comparison system for our benchmarking tests.
+After a few seconds, your c4a instance starts up, and you are ready to continue to the next section. In the next step, you will launch the second VM, an Intel-based Emerald Rapids c4-standard-8 (c4 for short), which will serve as the comparison system for our benchmarking tests.
 
diff --git a/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/installing_go_and_sweet.md b/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/installing_go_and_sweet.md
@@ -6,21 +6,19 @@ weight: 40
 layout: learningpathall
 ---
 
-## Section Overview
-
 In this section, you'll install Go, Sweet, and the Benchstat comparison tool on both VMs.
 
 ## Installation Script
 
-Sweet is a Go benchmarking tool that provides a standardized way to run performance tests across different systems. Benchstat is a companion tool that analyzes and compares benchmark results, helping you understand performance differences between systems. Together, these tools will allow us to accurately measure and compare Go performance on Arm and x86 architectures.
+Sweet is a Go benchmarking tool that provides a standardized way to run performance tests across different systems. Benchstat is a companion tool that analyzes and compares benchmark results, helping you understand performance differences between systems. Together, these tools will allow you to accurately measure and compare Go performance on Arm and x86 architectures.
 
 
 {{% notice Note %}}
-Subsequent steps in the learning path assume you are running this script (installing) from your home directory (`~`), resulting in the creation of a `~/benchmarks/sweet` final install path. If you decide to install elsewhere, adjust the path accordingly when prompted to run the benchmark logic later in the learning path.
+Subsequent steps in the learning path assume you are running this script (installing) from your home directory (`$HOME`), resulting in the creation of a `$HOME/benchmarks/sweet` final install path. If you decide to install elsewhere, you will need to adjust the path accordingly when prompted to run the benchmark logic later in the learning path.
 {{% /notice %}}
 
 
-Copy and paste this script to **both** of your GCP VMs.  
+Start by copying and pasting the script below on **both** of your GCP VMs. This script checks the architecture of your running VM, installs the required Go packge on your VM. It then installs sweet, benchmarks, and the benchstat tools.
 
 **You don't need to run it after pasting**, just paste it into your home directory and press enter to install all needed dependencies: 
 
@@ -92,18 +90,39 @@ chmod 755 install_go_and_sweet.sh
 
 ```
 
+The end of the output should look like:
+
+```output
+Sweet v0.3.0: Go Benchmarking Suite
+
+Retrieves assets for benchmarks from GCS.
+
+Usage: sweet get [flags]
+  -cache string
+        cache location for assets (default "/home/pareena_verma_arm_com/.cache/go-sweet")
+  -clean
+        delete all cached assets before installing new ones
+  -copy string
+        location to extract assets into, useful for development
+  -version string
+        the version to download assets for (default "v0.3.0")
+```
 
 
 ## Verify Installation
 
-To test that everything is installed correctly, run the following command on each VM after the script completes:
+To test that everything is installed correctly, set the environment variables shown below on each VM:
 
 ```bash
-# Run the benchmarks
 export GOPATH=$HOME/go
 export GOBIN=$GOPATH/bin
 export PATH=$PATH:$GOBIN:/usr/local/go/bin
+```
+Now run the `markdown` benchmark with `sweet` on both VMs as shown:
+
+```bash
 cd benchmarks/sweet
+sweet get
 sweet run -count 10 -run="markdown" config.toml # run one, 1X
 ```
 
@@ -117,4 +136,4 @@ You should see output similar to the following:
 [sweet] Running benchmark markdown for arm-benchmarks: run 1
 ...
 [sweet] Running benchmark markdown for arm-benchmarks: run 10
-```
+```
diff --git a/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/manual_run_benchmark.md b/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/manual_run_benchmark.md
@@ -6,59 +6,29 @@ weight: 51
 layout: learningpathall
 ---
 
-## Section Overview
+In this section, you'll download the results of the benchmark you ran manually in the previous sections from each VM. You will use these results to understand how `sweet` and `benchstat` work together.
 
-In this section, you'll run benchmarks manually to understand how `sweet` and `benchstat` work together.
+## Download Benchmark Results from each VM
+Lets walk through the steps to manually download the sweet benchmark results from your initial run on each VM.
 
-## Run Benchmarks on Each Machine
-The following explains how to run the benchmarks by hand on each machine.
 
-1. **Access VM instances:** Navigate to the GCP [VM Instances](https://console.cloud.google.com/compute/instances) console.
-
-2. **Connect to c4a instance:** Click on the `SSH` button next to your `c4a` instance.
-   An SSH terminal will open in a new tab.
-
-   ![](images/run_manually/2.png)
-
-3. **Set up environment:** Copy and paste the following into the SSH terminal to setup the environment and change to the sweet directory:
-
-   ```bash
-   cd benchmarks/sweet
-   export GOPATH=$HOME/go
-   export GOBIN=$GOPATH/bin
-   export PATH=$PATH:$GOBIN:/usr/local/go/bin
-   ```
-
-   ![](images/run_manually/3.png)
-
-{{% notice Note %}}
-The above instructions assume you installed the benchmarks in the `~/benchmarks/sweet` directory. If you installed them elsewhere, adjust the path accordingly.
-{{% /notice %}}   
-
-
-4. **Run the benchmark:** Copy and paste the following command to run the `markdown` benchmark with `sweet`:
-
-   ```bash
-   sweet run -count 10 -run="markdown" config.toml
-   ```
-
-5. **Locate results:** After the benchmark completes, cd to the `results/markdown` directory and list the files to see the `arm-benchmarks.result` file:
+1. **Locate results:** Change directory to the `results/markdown` directory and list the files to see the `arm-benchmarks.result` file:
 
    ```bash
    cd results/markdown
    ls -d $PWD/*
    ```
 
-6. **Copy result path:** Copy the absolute pathname of `arm-benchmarks.result`.
+2. **Copy result path:** Copy the absolute pathname of `arm-benchmarks.result`.
 
-7. **Download results:** Click `DOWNLOAD FILE`, and paste the **ABSOLUTE PATHNAME** you just copied for the filename, and then click `Download`. This will download the benchmark results to your local machine.
+3. **Download results:** Click `DOWNLOAD FILE`, and paste the **ABSOLUTE PATHNAME** you just copied for the filename, and then click `Download`. This will download the benchmark results to your local machine.
 
    ![](images/run_manually/6.png)
 
-8. **Rename the file:** Once downloaded, on your local machine, rename this file to `c4a.result` so you can distinguish it from the x86 results you'll download later. This naming convention will help you clearly identify which results came from which architecture. You'll know the file downloaded successfully if you see the file in your Downloads directory with the name `c4a.result`, as well as the confirmation dialog in your browser:
+4. **Rename the file:** Once downloaded, on your local machine, rename this file to `c4a.result` so you can distinguish it from the x86 results you'll download later. This naming convention will help you clearly identify which results came from which architecture. You'll know the file downloaded successfully if you see the file in your Downloads directory with the name `c4a.result`, as well as the confirmation dialog in your browser:
 
    ![](images/run_manually/7.png)
 
-9. **Repeat for c4 instance:** Repeat steps 2-8 with your `c4` (x86) instance. Do everything the same, except after downloading the c4's `arm-benchmarks.result` file, rename it to `c4.result`.
+5. **Repeat for c4 instance:** Repeat steps 2-8 with your `c4` (x86) instance. Do everything the same, except after downloading the c4's `arm-benchmarks.result` file, rename it to `c4.result`.
 
-Now that you have the results from both VMs, in the next section, you'll learn how to use benchstat to analyze these results and understand the performance differences between the two architectures.
+Now that you have the results from both VMs, in the next section, you'll learn how to use benchstat to analyze these results and understand the performance differences between the two architectures.
diff --git a/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/overview.md b/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/overview.md
@@ -6,9 +6,9 @@ weight: 10
 layout: learningpathall
 ---
 
-# Go Benchmarking Learning Path Overview
+# Go Benchmarking Overview
 
-In this module, you'll learn how to measure, collect, and compare Go performance data across different CPU architectures. This knowledge is essential for developers and system architects who need to make informed decisions about infrastructure choices for their Go applications.
+In this section, you will learn how to measure, collect, and compare Go performance data across different CPU architectures. This knowledge is essential for developers and system architects who need to make informed decisions about infrastructure choices for their Go applications.
 
 You'll gain hands-on experience with:
 
@@ -31,18 +31,4 @@ Arm-based c4a-standard-4 instances and Intel-based c4-standard-8 instances both
 {{% /notice %}}   
 
 
-## Prerequisites
 
-Before starting this learning path, you should have:
-- A Google Cloud Platform account with permissions to create VMs
-- Basic familiarity with Linux command line
-- Basic understanding of what benchmarking is and why it's useful
-
-## What You'll Accomplish
-
-When you are finished running through this learning path, you'll have:
-
-1. Brought up Arm and x86 instances of GCP-based VMs
-2. Installed Go, benchmarks, benchstat, and sweet on the two VMs
-3. Used sweet and benchstat to compare performance of Go applications on the two VMs
-4. Extrapolated the knowledge to create Go Benchmarks for your own workloads and systems
diff --git a/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/running_benchmarks.md b/content/learning-paths/servers-and-cloud-computing/go-benchmarking-with-sweet/running_benchmarks.md
@@ -6,13 +6,11 @@ weight: 50
 layout: learningpathall
 ---
 
-## Section Overview
-
-With setup complete, you can now run and analyze the benchmarks.  Before you do, it's good to understand all the moving pieces in more detail.
+With setup complete, you can now run and analyze the benchmarks.  Before you do, it's good to understand all the different pieces in more detail.
 
 ## Choosing a Benchmark to Run
 
-Whether running manually or automatic, the benchmarking process consists of two main steps:
+Whether running manually or automatically, the benchmarking process consists of two main steps:
 
 1. **Running benchmarks with Sweet**: `sweet` executes the benchmarks on each VM, generating raw performance data
 
@@ -99,7 +97,7 @@ Large gaps between average and peak memory usage suggest opportunities for memor
 
 Here are some general tips to keep in mind as you explore benchmarking across different apps and instance types:
 
-- Unlike Intel and AMD processors that use hyper-threading, Arm processors provide single-threaded cores without hyper-threading. A four-core Arm processor has four independent cores running four threads, while an four-core Intel processor provides eight logical cores through hyper-threading. This means each Arm vCPU represents a full physical core, while each Intel/AMD vCPU represents half a physical core. For fair comparison, this learning path uses a 4-vCPU Arm instance against an 8-vCPU Intel instance.  When scaling up instance sizes during benchmarking, make sure to keep a 2:1 Intel/AMD:Arm VCPU ratio if you wish to keep parity on CPU resources.
+- Unlike Intel and AMD processors that use hyper-threading, Arm processors provide single-threaded cores without hyper-threading. A four-core Arm processor has four independent cores running four threads, while an four-core Intel processor provides eight logical cores through hyper-threading. This means each Arm vCPU represents a full physical core, while each Intel/AMD vCPU represents half a physical core. For fair comparison, this learning path uses a 4-vCPU Arm instance against an 8-vCPU Intel instance.  When scaling up instance sizes during benchmarking, make sure to keep a 2:1 Intel/AMD:Arm vCPU ratio if you wish to keep parity on CPU resources.
 
 - It's suggested to run each benchmark at least 10 times (specified via the `count` parameter) to handle outlier/errant runs and ensure statistical significance.
 
