Reverted optimization and addef perf for i32

Author: radevgit

examples/perf_i32.rs

@@ -0,0 +1,85 @@
+//! Performance profiling example for i32 variant query_intersecting
+//! 
+//! This example performs intensive query_intersecting operations on a large spatial index
+//! using the i32 coordinate variant for comparison with the f64 version.
+//! Designed to be used with low-level profilers like `samply`:
+//! 
+//! ```bash
+//! samply record cargo run --release --example perf_i32
+//! ```
+
+use aabb::HilbertRTreeI32;
+use std::time::Instant;
+
+fn main() {
+    println!("Building large spatial index (i32 variant)...");
+    let mut tree = HilbertRTreeI32::with_capacity(1_000_000);
+    
+    // Generate 1 million random bounding boxes with i32 coordinates
+    let mut rng = 12345u64; // Simple LCG random number generator
+    for _ in 0..1_000_000 {
+        rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        let x1 = ((rng >> 32) as i32).abs() % 1000;
+        
+        rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        let y1 = ((rng >> 32) as i32).abs() % 1000;
+        
+        rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        let size_x = ((rng >> 32) as i32).abs() % 50 + 1;
+        
+        rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        let size_y = ((rng >> 32) as i32).abs() % 50 + 1;
+        
+        tree.add(x1, y1, x1 + size_x, y1 + size_y);
+    }
+    
+    let build_start = Instant::now();
+    tree.build();
+    let build_duration = build_start.elapsed();
+    
+    let mut results = Vec::new();
+    let query_start = Instant::now();
+    
+    // Perform 100,000 intensive queries for profiling
+    // Each query covers approximately 10% of the space
+    for _ in 0..100_000 {
+        rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        let center_x = ((rng >> 32) as i32).abs() % 1000;
+        
+        rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        let center_y = ((rng >> 32) as i32).abs() % 1000;
+        
+        let query_size = 100; // 10% of space
+        let min_x = (center_x - query_size / 2).max(0);
+        let min_y = (center_y - query_size / 2).max(0);
+        let max_x = (center_x + query_size / 2).min(1000);
+        let max_y = (center_y + query_size / 2).min(1000);
+        
+        tree.query_intersecting(min_x, min_y, max_x, max_y, &mut results);
+    }
+    
+    let query_duration = query_start.elapsed();
+    
+    println!(
+        "\nCompleted 100,000 queries in {:.2}ms ({:.2}µs per query)",
+        query_duration.as_secs_f64() * 1000.0,
+        query_duration.as_secs_f64() * 1_000_000.0 / 100_000.0
+    );
+    
+    println!("\nProfile Summary (i32 variant):");
+    println!("  Building: {:.2}ms", build_duration.as_secs_f64() * 1000.0);
+    println!("  Querying: {:.2}ms", query_duration.as_secs_f64() * 1000.0);
+    println!("  Total:    {:.2}ms", (build_duration + query_duration).as_secs_f64() * 1000.0);
+}
+
+
+/*
+Base
+Completed 100,000 queries in 11622.38ms (116.22µs per query)
+
+Profile Summary (i32 variant):
+  Building: 96.11ms
+  Querying: 11622.38ms
+  Total:    11718.49ms
+
+*/

src/hilbert_rtree.rs

@@ -1174,25 +1174,21 @@ impl HilbertRTree {
         }
     }
 
-    // --- Private helpers ---
-
-    /// Get box at position (true zero-copy: direct pointer dereference)
+    /// Get box at position using read_unaligned
     #[inline(always)]
     pub(crate) fn get_box(&self, pos: usize) -> Box {
         let idx = HEADER_SIZE + pos * size_of::<Box>();
         unsafe {
-            // Direct dereference of the pointer - compiler generates a single memcpy at most
-            // LLVM will optimize this to a load if alignment allows, memcpy only if needed
-            *((&self.data[idx]) as *const u8 as *const Box)
+            std::ptr::read_unaligned(&self.data[idx] as *const u8 as *const Box)
         }
     }
 
-    /// Get index at position (true zero-copy: direct pointer dereference)
+    /// Get index at position using read_unaligned
     #[inline(always)]
     pub(crate) fn get_index(&self, pos: usize) -> u32 {
         let indices_start = HEADER_SIZE + self.total_nodes * size_of::<Box>();
         unsafe {
-            *((&self.data[indices_start + pos * size_of::<u32>()] ) as *const u8 as *const u32)
+            std::ptr::read_unaligned(&self.data[indices_start + pos * size_of::<u32>()] as *const u8 as *const u32)
         }
     }
 

src/hilbert_rtree_i32.rs

@@ -724,21 +724,21 @@ impl HilbertRTreeI32 {
 
     // --- Private helpers ---
 
-    /// Get box at position (true zero-copy: direct pointer dereference)
+    /// Get box at position using read_unaligned
     #[inline]
     pub(crate) fn get_box(&self, pos: usize) -> BoxI32 {
         let idx = HEADER_SIZE + pos * size_of::<BoxI32>();
         unsafe {
-            *((&self.data[idx]) as *const u8 as *const BoxI32)
+            std::ptr::read_unaligned(&self.data[idx] as *const u8 as *const BoxI32)
         }
     }
 
-    /// Get index at position (true zero-copy: direct pointer dereference)
+    /// Get index at position using read_unaligned
     #[inline(always)]
     pub(crate) fn get_index(&self, pos: usize) -> u32 {
         let indices_start = HEADER_SIZE + self.total_nodes * size_of::<BoxI32>();
         unsafe {
-            *((&self.data[indices_start + pos * size_of::<u32>()] ) as *const u8 as *const u32)
+            std::ptr::read_unaligned(&self.data[indices_start + pos * size_of::<u32>()] as *const u8 as *const u32)
         }
     }