feat(hpc): W4 bulk polish — bulk_for_each + deprecated bulk_scan alias

Rename bulk_scan to bulk_for_each (bulk_scan kept as a #[deprecated] forwarding
alias), un-gate the bulk_apply x aos_to_soa integration test, add #[inline].
Updated the one in-repo caller in blocked_grid/tests.rs.

https://claude.ai/code/session_017GFLBnDy23AWBqvkbHHC41

Author: claude

src/hpc/blocked_grid/tests.rs

@@ -7,7 +7,7 @@
 //! Test groups
 //! -----------
 //! 1. W4 bulk_apply composition  — map_l1 composes with `hpc::bulk::bulk_apply`
-//!    and `bulk_scan` over per-row slices inside the closure.
+//!    and `bulk_for_each` over per-row slices inside the closure.
 //! 2. L1→L2 cascade              — 256×256 ShaderMantissaGrid map_l1 populates
 //!    cell-by-cell, then map_l2 aggregates per super-block.
 //! 3. Half-square AMX INT8       — AmxInt8Grid::new(32, 128), blocks_base coords.
@@ -22,24 +22,24 @@ use crate::hpc::blocked_grid::{
 };
 
 // ============================================================
-// 1. W4 bulk_apply / bulk_scan composition
+// 1. W4 bulk_apply / bulk_for_each composition
 //
 // Demonstrates that PR-X3's map_l1 composes with the W4 primitives:
 //   - outer loop = map_l1 (one closure per 64×64 base block)
-//   - inner loop = bulk_apply / bulk_scan over each row slice in the block
+//   - inner loop = bulk_apply / bulk_for_each over each row slice in the block
 //
 // This proves the two design layers nest without either re-implementing the
 // other's chunking logic.
 // ============================================================
 
-/// map_l1 closure using bulk_scan to read each row and compute a per-row sum,
-/// storing it into the first cell of the corresponding output row.
+/// map_l1 closure using bulk_for_each to read each row and compute a per-row
+/// sum, storing it into the first cell of the corresponding output row.
 ///
-/// Demonstrates: bulk_scan(row_slice, chunk_size, closure) correctly
+/// Demonstrates: bulk_for_each(row_slice, chunk_size, closure) correctly
 /// accumulates the sum; no re-implemented chunking inside map_l1.
 #[test]
-fn w4_bulk_scan_inside_map_l1_row_sum() {
-    use crate::hpc::bulk::bulk_scan;
+fn w4_bulk_for_each_inside_map_l1_row_sum() {
+    use crate::hpc::bulk::bulk_for_each;
 
     // Build a 64×64 grid filled with known values.
     let mut g = BlockedGrid::<u64>::new(64, 64);
@@ -50,13 +50,13 @@ fn w4_bulk_scan_inside_map_l1_row_sum() {
         }
     }
 
-    // map_l1: for each block row, use bulk_scan to compute the row sum and
+    // map_l1: for each block row, use bulk_for_each to compute the row sum and
     // store it in the first cell of the output row.
     let out = g.map_l1::<u64, _>(|inp, outp| {
         for r in 0..64 {
             let row = inp.row(r);
             let mut row_sum = 0u64;
-            bulk_scan(row, 16, |chunk, _start| {
+            bulk_for_each(row, 16, |chunk, _start| {
                 row_sum += chunk.iter().sum::<u64>();
             });
             outp.row_mut(r)[0] = row_sum;

src/hpc/bulk.rs

@@ -5,7 +5,8 @@
 //! (chunk_size matched to L1 working-set) or when staging chunks to SoA for
 //! SIMD processing inside the closure.
 //!
-//! [`bulk_scan`] is the read-only sibling for non-mutating traversal.
+//! [`bulk_for_each`] is the read-only sibling for non-mutating traversal.
+//! [`bulk_scan`] is a deprecated alias for [`bulk_for_each`].
 //!
 //! Both helpers are scalar wrappers — no `#[target_feature]`, no per-arch
 //! dispatch. They are user-level code per the layering rule in
@@ -30,7 +31,7 @@
 //!     .map(|i| Item { a: i as f32, b: (i * 2) as f32, c: (i * 3) as f32 })
 //!     .collect();
 //! bulk_apply(&mut items, 16, |chunk, _start| {
-//!     let soa = aos_to_soa::<_, _, 3, _>(chunk, |it| [it.a, it.b, it.c]);
+//!     let soa = aos_to_soa::<_, f32, 3, _>(chunk, |it| [it.a, it.b, it.c]);
 //!     // ... per-field SIMD-style loops over soa.field(0), soa.field(1), ...
 //!     let _ = soa;
 //! });
@@ -65,6 +66,7 @@
 /// });
 /// assert_eq!(v, vec![0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
 /// ```
+#[inline]
 pub fn bulk_apply<T, F>(items: &mut [T], chunk_size: usize, mut f: F)
 where
     F: FnMut(&mut [T], usize),
@@ -89,19 +91,20 @@ where
 ///
 /// # Example
 /// ```
-/// use ndarray::hpc::bulk::bulk_scan;
+/// use ndarray::hpc::bulk::bulk_for_each;
 /// let v: Vec<i32> = (0..10).collect();
 /// let mut sum = 0i32;
-/// bulk_scan(&v, 4, |chunk, _start| {
+/// bulk_for_each(&v, 4, |chunk, _start| {
 ///     sum += chunk.iter().sum::<i32>();
 /// });
 /// assert_eq!(sum, 45);
 /// ```
-pub fn bulk_scan<T, F>(items: &[T], chunk_size: usize, mut f: F)
+#[inline]
+pub fn bulk_for_each<T, F>(items: &[T], chunk_size: usize, mut f: F)
 where
     F: FnMut(&[T], usize),
 {
-    assert!(chunk_size > 0, "bulk_scan: chunk_size must be > 0");
+    assert!(chunk_size > 0, "bulk_for_each: chunk_size must be > 0");
     let mut start = 0;
     for chunk in items.chunks(chunk_size) {
         let n = chunk.len();
@@ -110,6 +113,32 @@ where
     }
 }
 
+/// Deprecated alias for [`bulk_for_each`].
+///
+/// Use [`bulk_for_each`] instead. This alias exists only to avoid breaking
+/// callers from before the rename and will be removed in a future release.
+///
+/// # Example
+/// ```
+/// #[allow(deprecated)]
+/// use ndarray::hpc::bulk::bulk_scan;
+/// let v: Vec<i32> = (0..10).collect();
+/// let mut sum = 0i32;
+/// #[allow(deprecated)]
+/// bulk_scan(&v, 4, |chunk, _start| {
+///     sum += chunk.iter().sum::<i32>();
+/// });
+/// assert_eq!(sum, 45);
+/// ```
+#[deprecated(note = "renamed to `bulk_for_each`")]
+#[inline]
+pub fn bulk_scan<T, F>(items: &[T], chunk_size: usize, f: F)
+where
+    F: FnMut(&[T], usize),
+{
+    bulk_for_each(items, chunk_size, f)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -206,71 +235,71 @@ mod tests {
         assert_eq!(count, 0);
     }
 
-    // ----- bulk_scan -----
+    // ----- bulk_for_each -----
 
     #[test]
-    fn bulk_scan_chunk_size_divides_len() {
+    fn bulk_for_each_chunk_size_divides_len() {
         let v: Vec<i32> = (0..10).collect();
         let mut sizes = Vec::new();
-        bulk_scan(&v, 5, |chunk, _start| {
+        bulk_for_each(&v, 5, |chunk, _start| {
             sizes.push(chunk.len());
         });
         assert_eq!(sizes, vec![5, 5]);
     }
 
     #[test]
-    fn bulk_scan_chunk_size_does_not_divide_len() {
+    fn bulk_for_each_chunk_size_does_not_divide_len() {
         let v: Vec<i32> = (0..10).collect();
         let mut sizes = Vec::new();
-        bulk_scan(&v, 3, |chunk, _start| {
+        bulk_for_each(&v, 3, |chunk, _start| {
             sizes.push(chunk.len());
         });
         assert_eq!(sizes, vec![3, 3, 3, 1]);
     }
 
     #[test]
-    fn bulk_scan_chunk_size_greater_than_len() {
+    fn bulk_for_each_chunk_size_greater_than_len() {
         let v: Vec<i32> = (0..10).collect();
         let mut sizes = Vec::new();
-        bulk_scan(&v, 100, |chunk, start| {
+        bulk_for_each(&v, 100, |chunk, start| {
             assert_eq!(start, 0);
             sizes.push(chunk.len());
         });
         assert_eq!(sizes, vec![10]);
     }
 
     #[test]
-    fn bulk_scan_start_indices_3_3_3_1() {
+    fn bulk_for_each_start_indices_3_3_3_1() {
         let v: Vec<i32> = (0..10).collect();
         let mut start_indices: Vec<usize> = Vec::new();
-        bulk_scan(&v, 3, |_chunk, start| {
+        bulk_for_each(&v, 3, |_chunk, start| {
             start_indices.push(start);
         });
         assert_eq!(start_indices, vec![0, 3, 6, 9]);
     }
 
     #[test]
-    fn bulk_scan_sums_chunks() {
+    fn bulk_for_each_sums_chunks() {
         let v: Vec<i32> = (0..10).collect();
         let mut sum = 0i32;
-        bulk_scan(&v, 4, |chunk, _start| {
+        bulk_for_each(&v, 4, |chunk, _start| {
             sum += chunk.iter().sum::<i32>();
         });
         assert_eq!(sum, 45);
     }
 
     #[test]
     #[should_panic(expected = "chunk_size must be > 0")]
-    fn bulk_scan_panics_on_zero_chunk_size() {
+    fn bulk_for_each_panics_on_zero_chunk_size() {
         let v: Vec<i32> = (0..4).collect();
-        bulk_scan(&v, 0, |_, _| {});
+        bulk_for_each(&v, 0, |_, _| {});
     }
 
     #[test]
-    fn bulk_scan_chunk_size_usize_max_single_chunk() {
+    fn bulk_for_each_chunk_size_usize_max_single_chunk() {
         let v: Vec<i32> = (0..4).collect();
         let mut count = 0;
-        bulk_scan(&v, usize::MAX, |chunk, start| {
+        bulk_for_each(&v, usize::MAX, |chunk, start| {
             count += 1;
             assert_eq!(start, 0);
             assert_eq!(chunk.len(), 4);
@@ -279,15 +308,37 @@ mod tests {
     }
 
     #[test]
-    fn bulk_scan_empty_slice() {
+    fn bulk_for_each_empty_slice() {
         let v: Vec<i32> = Vec::new();
         let mut count = 0;
-        bulk_scan(&v, 4, |_, _| {
+        bulk_for_each(&v, 4, |_, _| {
             count += 1;
         });
         assert_eq!(count, 0);
     }
 
+    // ----- bulk_scan (deprecated alias) -----
+    // These tests verify the alias still compiles and delegates correctly.
+
+    #[test]
+    #[allow(deprecated)]
+    fn bulk_scan_deprecated_alias_still_works() {
+        let v: Vec<i32> = (0..10).collect();
+        let mut sum = 0i32;
+        bulk_scan(&v, 4, |chunk, _start| {
+            sum += chunk.iter().sum::<i32>();
+        });
+        assert_eq!(sum, 45);
+    }
+
+    #[test]
+    #[allow(deprecated)]
+    #[should_panic(expected = "chunk_size must be > 0")]
+    fn bulk_scan_deprecated_alias_panics_on_zero_chunk_size() {
+        let v: Vec<i32> = (0..4).collect();
+        bulk_scan(&v, 0, |_, _| {});
+    }
+
     // ----- integration with aos_to_soa -----
     //
     // hpc::soa and hpc::bulk co-merge in PR #156, so the worker-isolation