Further updates

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/bitmap_scan_sve2/01-introduction.md

@@ -1,6 +1,6 @@
 ---
 # User change
-title: "Optimize Bitmap Scanning with SVE and NEON on Arm Servers"
+title: "Optimize bitmap scanning with SVE and NEON on Arm servers"
 
 weight: 2
 
@@ -58,5 +58,6 @@ Create a directory for your implementations:
 mkdir -p bitmap_scan
 cd bitmap_scan
 ```
-## Next Steps
+## Next steps
+
 In the next section, you’ll define the core bitmap data structure and utility functions for setting, clearing, and inspecting bits.

content/learning-paths/servers-and-cloud-computing/bitmap_scan_sve2/02-bitmap-data-structure.md

@@ -1,22 +1,22 @@
 ---
 # User change
-title: "Build and manage the bit vector Structure"
+title: "Build and manage a bit vector in C"
 
 weight: 3
 
 layout: "learningpathall"
 
 ---
-## Bitmap Data Structure
+## Bitmap data structure
 
 Now let's define a simple bitmap data structure that serves as the foundation for the different implementations. The bitmap implementation uses a simple structure with three key components:
    - A byte array to store the actual bits
-   - Tracking of the physical size(bytes)
-   - Tracking of the logical size(bits)
+   - Tracking of the physical size (bytes)
+   - Tracking of the logical size (bits)
 
 For testing the different implementations in this Learning Path, you also need functions to generate and analyze the bitmaps.
 
-Use a file editor of your choice and the copy the code below into `bitvector_scan_benchmark.c`:
+Use a file editor of your choice and then copy the code below into `bitvector_scan_benchmark.c`:
 
 ```c
 // Define a simple bit vector structure
@@ -81,4 +81,6 @@ size_t bitvector_count_scalar(bitvector_t* bv) {
     }
     return count;
 }
-```
+```
+
+You now have a functional, compact bit vector in C for testing bitmap scanning performance. Next, you'll implement scalar, NEON, and SVE-based scanning routines that operate on this structure.

content/learning-paths/servers-and-cloud-computing/bitmap_scan_sve2/03-scalar-implementations.md

@@ -1,6 +1,6 @@
 ---
 # User change
-title: "Scalar Implementations of Bitmap Scanning"
+title: "Implement Scalar Bitmap Scanning in C"
 
 weight: 4
 
@@ -10,11 +10,17 @@ layout: "learningpathall"
 ---
 ## Bitmap scanning implementations
 
-Now, let's implement four versions of a bitmap scanning operation that finds all positions where a bit is set:
+Bitmap scanning is a fundamental operation in performance-critical systems such as databases, search engines, and filtering pipelines. It involves identifying the positions of set bits (`1`s) in a bit vector, which is often used to represent filtered rows, bitmap indexes, or membership flags. 
 
-### 1. Generic Scalar Implementation
+In this section, you'll implement multiple scalar approaches to bitmap scanning in C, starting with a simple per-bit baseline, followed by an optimized version that reduces overhead for sparse data.
 
-This is the most straightforward implementation, checking each bit individually. It serves as our baseline for comparison against the other implementations to follow. Copy the code below into the same file:
+Now, let’s walk through the scalar versions of this operation that locate all set bit positions.
+
+### Generic scalar implementation
+
+This is the most straightforward implementation, checking each bit individually. It serves as the baseline for comparison against the other implementations to follow. 
+
+Copy the code below into the same file:
 
 ```c
 // Generic scalar implementation of bit vector scanning (bit-by-bit)
@@ -31,13 +37,15 @@ size_t scan_bitvector_scalar_generic(bitvector_t* bv, uint32_t* result_positions
 }
 ```
 
-You will notice this generic C implementation processes every bit, even when most bits are not set. It has high function call overhead and does not advantage of vector instructions.
+You might notice that this generic C implementation processes every bit, even when most bits are not set. It has high per-bit function call overhead and does not take advantage of any vector instructions.
 
-In the following implementations, you will address these inefficiencies with more optimized techniques.
+In the following implementations, you can address these inefficiencies with more optimized techniques.
 
-### 2. Optimized Scalar Implementation
+### Optimized scalar implementation
 
-This implementation adds byte-level skipping to avoid processing empty bytes. Copy this optimized C scalar implementation code into the same file:
+This implementation adds byte-level skipping to avoid processing empty bytes. 
+
+Copy this optimized C scalar implementation code into the same file:
 
 ```c
 // Optimized scalar implementation of bit vector scanning (byte-level)
@@ -66,5 +74,9 @@ size_t result_count = 0;
     return result_count;
 }
 ```
-Instead of iterating through each bit, this implementation processes one byte(8 bits) at a time. The main optimization over the previous scalar implementation is checking if an entire byte is zero and skipping it entirely, For sparse bitmaps, this can dramatically reduce the number of bit checks.
+Instead of iterating through each bit individually, this implementation processes one byte (8 bits) at a time. The main optimization over the previous scalar implementation is checking if an entire byte is zero and skipping it entirely. For sparse bitmaps, this can dramatically reduce the number of bit checks.
+
+## Next steps
+
+Next, you’ll explore how to accelerate bitmap scanning using NEON and SVE SIMD instructions on Arm Neoverse platforms like Graviton4, comparing them directly to these scalar baselines.
 

content/learning-paths/servers-and-cloud-computing/bitmap_scan_sve2/04-vector-implementations.md

@@ -8,7 +8,9 @@ layout: "learningpathall"
 
 
 ---
-### 3. NEON Implementation
+Modern Arm CPUs like Neoverse V2 support SIMD (Single Instruction, Multiple Data) extensions that allow processing multiple bytes in parallel. In this section, you'll explore how NEON and SVE vector instructions can dramatically accelerate bitmap scanning by skipping over large regions of unset data and reducing per-bit processing overhead.
+
+## NEON Implementation
 
 This implementation uses NEON SIMD (Single Instruction, Multiple Data) instructions to process 16 bytes (128 bits) at a time, significantly accelerating the scanning process. Copy the NEON implementation shown below into the same file:
 ```c
@@ -81,7 +83,7 @@ size_t scan_bitvector_neon(bitvector_t* bv, uint32_t* result_positions) {
 ```
 This NEON implementation processes 16 bytes at a time with vector instructions. For sparse bitmaps, entire 16-byte chunks can be skipped at once, providing a significant speedup over byte-level skipping. After vector processing, it falls back to scalar code for any remaining bytes that don't fill a complete 16-byte chunk.
 
-### 4. SVE Implementation
+## SVE Implementation
 
 This implementation uses SVE instructions which are available in the Arm Neoverse V2 based AWS Graviton 4 processor. Copy this SVE implementation into the same file:
 

content/learning-paths/servers-and-cloud-computing/bitmap_scan_sve2/05-benchmarking-and-results.md

@@ -1,16 +1,18 @@
 ---
 # User change
-title: "Benchmarking Bitmap Scanning Across Implementations"
+title: "Benchmarking bitmap scanning across implementations"
 
 weight: 6
 
 layout: "learningpathall"
 
 
 ---
-## Benchmarking Code
+## Benchmarking code
 
-Now, that you have created four different implementations of a bitmap scanning algorithm, let's create a benchmarking framework to compare the performance of our implementations. Copy the code shown below into `bitvector_scan_benchmark.c` :
+Now that you've created four different bitmap scanning implementations, let’s build a benchmarking framework to compare their performance.
+
+Copy the code shown below into `bitvector_scan_benchmark.c` :
 
 ```c
 // Timing function for bit vector scanning
@@ -37,7 +39,7 @@ double benchmark_scan(size_t (*scan_func)(bitvector_t*, uint32_t*),
 }
 ```
 
-## Main Function
+## Main function
 The main function of your program is responsible for setting up the test environment, running the benchmarking code for the four different implementations across various bit densities, and reporting the results. In the context of bitmap scanning, bit density refers to the percentage or proportion of bits that are set (have a value of 1) in the bitmap. Copy the main function code below into `bitvector_scan_benchmark.c`:
 
 ```C
@@ -122,7 +124,7 @@ int main() {
 }
 ```
 
-## Compiling and Running
+## Compiling and running
 
 You are now ready to compile and run your bitmap scanning implementations.
 
@@ -132,11 +134,11 @@ To compile our bitmap scanning implementations with the appropriate flags, run:
 gcc -O3 -march=armv9-a+sve2 -o bitvector_scan_benchmark bitvector_scan_benchmark.c -lm
 ```
 
-## Performance Results
+## Performance results
 
 When running on a Graviton4 c8g.large instance with Ubuntu 24.04, the results should look similar to:
 
-### Execution Time (ms)
+### Execution time (ms)
 
 | Density | Set Bits | Scalar Generic | Scalar Optimized | NEON  | SVE	      |
 |---------|----------|----------------|------------------|-------|------------|
@@ -146,7 +148,7 @@ When running on a Graviton4 c8g.large instance with Ubuntu 24.04, the results sh
 | 0.0100  | 99,511   | 7.821          | 1.570            | 2.252 | 1.353      |
 | 0.1000  | 951,491  | 12.817         | 8.336            | 9.106 | 6.770      |
 
-### Speedup vs Generic Scalar
+### Speed-up vs generic Scalar
 
 | Density | Scalar Optimized | NEON    | SVE        |
 |---------|------------------|---------|------------|
@@ -156,25 +158,25 @@ When running on a Graviton4 c8g.large instance with Ubuntu 24.04, the results sh
 | 0.0100  | 5.02x            | 3.49x   | 5.78x      |
 | 0.1000  | 1.54x            | 1.40x   | 1.90x      |
 
-## Understanding the Performance Results
+## Understanding the results
 
-### Generic Scalar vs Optimized Scalar
+## Generic Scalar vs Optimized Scalar
 
 The optimized scalar implementation shows significant improvements over the generic scalar implementation due to:
 
 1. **Byte-level Skipping**: Avoiding processing empty bytes
 2. **Reduced Function Calls**: Accessing bits directly rather than through function calls
 3. **Better Cache Utilization**: More sequential memory access patterns
 
-### Optimized Scalar vs NEON
+## Optimized Scalar vs NEON
 
 The NEON implementation shows further improvements over the optimized scalar implementation for sparse bit vectors due to:
 
 1. **Chunk-level Skipping**: Quickly skipping 16 empty bytes at once
 2. **Vectorized Comparison**: Checking multiple bytes in parallel
 3. **Early Termination**: Quickly determining if a chunk contains any set bits
 
-### NEON vs SVE
+## NEON vs SVE
 
 The performance comparison between NEON and SVE depends on the bit density:
 
@@ -188,7 +190,7 @@ The performance comparison between NEON and SVE depends on the bit density:
    - SVE consistently outperforms NEON
    - SVE achieves up to 1.66x speedup over NEON at 0.01% density
 
-# Key Optimizations in SVE Implementation
+## Key Optimizations in SVE Implementation
 
 The SVE implementation includes several key optimizations:
 

content/learning-paths/servers-and-cloud-computing/bitmap_scan_sve2/06-application-and-best-practices.md

@@ -1,6 +1,6 @@
 ---
 # User change
-title: "Applications and Optimization Best Practices"
+title: "Applications and optimization best practices"
 
 weight: 7
 
@@ -10,21 +10,20 @@ layout: "learningpathall"
 
 These bitmap scanning optimizations can be applied to various database operations:
 
-### 1. Bitmap Index Scans
-
+### Bitmap Index Scans
 Bitmap indexes are commonly used in analytical databases to accelerate queries with multiple filter conditions. The NEON and SVE implementations can significantly speed up the scanning of these bitmap indexes, especially for queries with low selectivity.
 
-### 2. Bloom Filter Checks
+### Bloom Filter Checks
 
 Bloom filters are probabilistic data structures used to test set membership. They are often used in database systems to quickly filter out rows that don't match certain conditions. The NEON and SVE implementations can accelerate these bloom filter checks.
 
-### 3. Column Filtering
+### Column Filtering
 
 In column-oriented databases, bitmap filters are often used to represent which rows match certain predicates. The NEON and SVE implementation can speed up the scanning of these bitmap filters, improving query performance.
 
 ## Best Practices
 
-Based on our benchmark results, here are some best practices for optimizing bitmap scanning operations:
+Based on the benchmark results, here are some best practices for optimizing bitmap scanning operations:
 
 1. **Choose the Right Implementation**: Select the appropriate implementation based on the expected bit density:
    - For empty bit vectors: NEON is optimal