Update benchmarking.md

Author: pareenaverma

content/learning-paths/servers-and-cloud-computing/mysql-azure/benchmarking.md

@@ -8,27 +8,32 @@ layout: learningpathall
 
 ## Benchmark MySQL on Azure Cobalt 100 Arm-based instances and x86_64 instances
 
-`mysqlslap` is the official MySQL benchmarking tool used to simulate multiple client connections and measure query performance. It helps evaluate **read/write throughput, query response times**, and overall MySQL server performance under different workloads, making it ideal for baseline testing and optimization.
+To understand how MySQL performs on Azure Cobalt 100 (Arm64) VMs compared to x86_64 instances, you can use the built-in mysqlslap tool.
+
+`mysqlslap` is the official MySQL benchmarking tool used to simulate multiple client connections and measure query performance. It helps evaluate read/write throughput, query response times, and overall MySQL server performance under different workloads, making it ideal for baseline testing and optimization.
 
 ## Steps for MySQL Benchmarking with mysqlslap
 
 1. Connect to MySQL and Create a Database
 
-To access the MySQL server, use the following command based on your `admin` user password:
+Before running `mysqlslap`, you will create a dedicated test database so that benchmarking doesn’t interfere with your application data. This ensures clean test results and avoids accidental modifications to production schemas.
+Connect to MySQL using the admin user:
 
 ```console
 mysql -u admin -p 
 ```
-Once logged in, you can create a benchmark_db using SQL commands like:
+Once logged in, create a benchmarking database:
 
 ```sql
 CREATE DATABASE benchmark_db;
 USE benchmark_db;
 ```
 
-3. Create a Table and Populate Data
+2. Create a Table and Populate Data
+
+With a dedicated `benchmark_db` created, the next step is to define a test table and populate it with data. This simulates a realistic workload so that `mysqlslap` can measure query performance against non-trivial datasets.
 
-After logging into MySQL, you can create a table to store benchmark data. Here’s a simple example:
+Create a benchmark table:
 
 ```sql
 CREATE TABLE benchmark_table (
@@ -37,14 +42,18 @@ CREATE TABLE benchmark_table (
     score INT
 );
 ```
-Insert some sample rows manually:
+Insert Sample Rows Manually:
 
+For quick validation:
 ```sql
 INSERT INTO benchmark_table (username,score) VALUES 
 ('John',100),('Jane',200),('Mike',300);
 ```
+This verifies that inserts work correctly and allows you to test small queries.
 
-Or populate automatically with 1000 rows:
+Populate Automatically with 1000 Rows
+
+For benchmarking, larger datasets give more meaningful results. You can use a stored procedure to generate rows programmatically:
 
 ```sql
 DELIMITER //
@@ -62,15 +71,14 @@ DELIMITER ;
 CALL populate_benchmark_data();
 DROP PROCEDURE populate_benchmark_data;
 ```
-- The table `benchmark_table` has three columns: `record_id` (primary key), `username`, and `score`.
-- You can insert a few rows manually for testing or use a procedure to generate **1000 rows automatically** for more realistic benchmarking
+At this stage, you have a populated `benchmark_table` inside `benchmark_db`. This provides a realistic dataset for running `mysqlslap`, enabling you to measure how MySQL performs on Azure Cobalt 100 under read-heavy, write-heavy, or mixed workloads.
 
 ## Run a Simple Read/Write Benchmark
 
-Once your table is ready, you can use `mysqlslap` to simulate multiple clients performing queries. This helps test MySQL’s performance under load.
+With the `benchmark_table` populated, you can run a synthetic workload using mysqlslap to simulate multiple clients performing inserts or queries at the same time. This tests how well MySQL handles concurrent connections and query execution.
 
 ```console
-mysqlslap   --user=admin   --password="MyStrongPassword!"   --host=127.0.0.1   --concurrency=10   --iterations=5   --query="INSERT INTO benchmark_db.benchmark_table (username,score) VALUES('TestUser',123);"   --create-schema=benchmark_db
+mysqlslap   --user=admin   --password=`MyStrongPassword!`   --host=127.0.0.1   --concurrency=10   --iterations=5   --query="INSERT INTO benchmark_db.benchmark_table (username,score) VALUES('TestUser',123);"   --create-schema=benchmark_db
 ```
 - **--user / --password:** MySQL login credentials.
 - **--host:** MySQL server address (127.0.0.1 for local).
@@ -79,7 +87,7 @@ mysqlslap   --user=admin   --password="MyStrongPassword!"   --host=127.0.0.1   -
 - **--query:** The SQL statement to run repeatedly.
 - **--create-schema:** The database in which to run the query.
 
-You should see output similar to the following:
+You should see output similar to:
 
 ```output
 Benchmark
@@ -90,13 +98,15 @@ Benchmark
         Average number of queries per client: 1
 ```
 
-Below command runs a **read benchmark** on your MySQL database using `mysqlslap`. It simulates multiple clients querying the table at the same time and records the results.
+Run a Read Benchmark (table scan):
+
+You can now run a test that simulates multiple clients querying the table at the same time and records the results:
 
 ```console
 mysqlslap --user=admin --password="MyStrongPassword!"  --host=127.0.0.1 --concurrency=10 --iterations=5 --query="SELECT * FROM benchmark_db.benchmark_table WHERE record_id < 500;"  --create-schema=benchmark_db  --verbose | tee -a /tmp/mysqlslap_benchmark.log
 ```
 
-You should see output similar to the following:
+You should see output similar to:
 
 ```output
 Benchmark
@@ -109,11 +119,11 @@ Benchmark
 
 ## Benchmark Results Table Explained:
 
-- **Average number of seconds to run all queries:** This is the average time it took for all the queries in one iteration to complete across all clients. It gives you a quick sense of overall performance.
-- **Minimum number of seconds to run all queries:** This is the fastest time any iteration of queries took.
-- **Maximum number of seconds to run all queries:** This is the slowest time any iteration of queries took. The closer this is to the average, the more consistent your performance is.
-- **Number of clients running queries:** Indicates how many simulated users (or connections) ran queries simultaneously during the test.
-- **Average number of queries per client:** Shows the average number of queries each client executed in the benchmark iteration.
+  Average number of seconds to run all queries: This is the average time it took for all the queries in one iteration to complete across all clients. It gives you a quick sense of overall performance.
+  Minimum number of seconds to run all queries: This is the fastest time any iteration of queries took.
+  Maximum number of seconds to run all queries: This is the slowest time any iteration of queries took. The closer this is to the average, the more consistent your performance is.
+  Number of clients running queries: Indicates how many simulated users (or connections) ran queries simultaneously during the test.
+  Average number of queries per client: Shows the average number of queries each client executed in the benchmark iteration.
 
 ## Benchmark summary on Arm64:
 Here is a summary of benchmark results collected on an Arm64 **D4ps_v6 Ubuntu Pro 24.04 LTS virtual machine**.
@@ -123,21 +133,15 @@ Here is a summary of benchmark results collected on an Arm64 **D4ps_v6 Ubuntu Pr
 | INSERT     | 0.267           | 0.265           | 0.271           | 10     | 1                    |
 | SELECT     | 0.263           | 0.261           | 0.264           | 10     | 1                    |
 
-## Benchmark summary on x86_64:   
-Here is a summary of the benchmark results collected on x86_64 **D4s_v6 Ubuntu Pro 24.04 LTS virtual machine**.    
-
-| Query Type | Average Time (s) | Minimum Time (s) | Maximum Time (s) | Clients | Avg Queries per Client |
-|------------|-----------------|-----------------|-----------------|--------|----------------------|
-| INSERT     | 0.243           | 0.231           | 0.273           | 10     | 1                    |
-| SELECT     | 0.222           | 0.214           | 0.233           | 10     | 1                    |
 
 ## Insights from Benchmark Results
 
 The benchmark results on the Arm64 virtual machine show:
 
-- **Balanced Performance for Read and Write Queries:** Both `INSERT` and `SELECT` queries performed consistently, with average times of **0.267s** and **0.263s**, respectively.
-- **Low Variability Across Iterations:** The difference between the minimum and maximum times was very small for both query types, indicating stable and predictable behavior under load.
-- **Moderate Workload Handling:** With **10 clients** and an average of **1 query per client**, the system handled concurrent operations efficiently without significant delays.
-- **Key Takeaway:** The MySQL setup on Arm64 provides reliable and steady performance for both data insertion and retrieval tasks, making it a solid choice for applications requiring dependable database operations.
+  Balanced Performance for Read and Write Queries: Both `INSERT` and `SELECT` queries performed consistently, with average times of 0.267s and 0.263s, respectively.
+  Low Variability Across Iterations: The difference between the minimum and maximum times was very small for both query types, indicating stable and predictable behavior under load.
+  Moderate Workload Handling: With 10 clients and an average of 1 query per client, the system handled concurrent operations efficiently without significant delays.
+  
+This demonstrates that the MySQL setup on Arm64 provides reliable and steady performance for both data insertion and retrieval tasks, making it a solid choice for applications requiring dependable database operations.
 
 You have now benchmarked MySql on an Azure Cobalt 100 Arm64 virtual machine and compared results with x86_64.