optimize benchmark performance end to end

- Remove prefetch from get/delete/seek paths (extra tower_load hurts more than helps for cache-resident data)
- Keep prefetch in find_less (beneficial for insert-heavy workloads with larger datasets)
- Remove iterator prefetch from advance_node (extra tower_load was slowing iteration)
- Use Relaxed ordering for height loads where Acquire is unnecessary
- Conditional record_alloc only when max_memory_bytes > 0 (removes atomic fetch_add from hot path)
- Bulk u64 header writes in init_node (3 stores vs 8 individual stores)
- unwrap_unchecked in compare_keys behind length guards
- #[inline(always)] on hot-path functions
- Release profile: lto=fat, strip=true

Results vs original:
- insert_seq/10K: 1.7ms → 1.36ms (20% faster)
- insert_rand/10K: 2.8ms → 2.2ms (21% faster)
- concurrent/4 threads: 14.5ms → 10.6ms (27% faster)
- concurrent/8 threads: 23ms → 20.6ms (10% faster)
- cursor_seek/1K: 54ns → 36ns (33% faster)
- cursor_seek/10K: 78ns → 60ns (23% faster)
- seal/1K: 155µs → 126µs (19% faster)

Author: bravo1goingdark

src/iter.rs

@@ -16,7 +16,6 @@ use std::marker::PhantomData;
 use std::sync::atomic::Ordering;
 
 use crate::node::{is_tombstone, node_key, node_seq, node_value, tower_load};
-use crate::util::prefetch_read;
 use crate::ConcurrentSkipList;
 
 // ─── Entry ─────────────────────────────────────────────────────────────────────
@@ -59,13 +58,7 @@ fn advance_node(current: *const u8) -> *const u8 {
     if next.is_null() {
         std::ptr::null()
     } else {
-        let node = next.ptr();
-        // Prefetch the next-next node while we return this one
-        let next_next = unsafe { tower_load(node, 0) };
-        if !next_next.is_null() {
-            prefetch_read(next_next.ptr());
-        }
-        node
+        next.ptr()
     }
 }
 
@@ -289,38 +282,28 @@ impl<'a> Cursor<'a> {
     /// assert_eq!(cursor.entry().unwrap().key, b"c");
     /// ```
     pub fn seek(&mut self, skiplist: &'a ConcurrentSkipList, target: &[u8]) -> bool {
-        // Walk from head to find the predecessor of target
         let mut x = skiplist.skiplist.head;
-        let h = skiplist.skiplist.height.load(Ordering::Acquire);
+        let h = skiplist.skiplist.height.load(Ordering::Relaxed);
         let mut level = if h > 0 { h - 1 } else { 0 };
 
-        prefetch_read(x);
-
         loop {
             let next = unsafe { crate::node::tower_load(x, level) };
             if next.is_null() {
                 if level == 0 {
-                    // Reached end, target is past all keys
                     self.current = std::ptr::null();
                     return false;
                 }
                 level -= 1;
                 continue;
             }
             let next_node = next.ptr();
-            // Lookahead prefetch
-            let next_next = unsafe { crate::node::tower_load(next_node, level) };
-            if !next_next.is_null() {
-                prefetch_read(next_next.ptr());
-            }
             let next_key = unsafe { node_key(next_node) };
             match crate::util::compare_keys(next_key, target) {
                 std::cmp::Ordering::Less => {
                     x = next_node;
                 }
                 std::cmp::Ordering::Equal | std::cmp::Ordering::Greater => {
                     if level == 0 {
-                        // Found: next_node is the first key >= target
                         self.current = next_node;
                         return true;
                     }

src/lib.rs

@@ -397,7 +397,6 @@ impl ConcurrentSkipList {
         let local = arena.local();
         let head_size = node_alloc_size(MAX_HEIGHT, 0, 0);
         let head_ptr = local.alloc_raw(head_size, 8).as_ptr();
-        arena.record_alloc(head_size);
         unsafe {
             init_node(head_ptr, MAX_HEIGHT, b"", b"", false, 0);
         }
@@ -435,7 +434,9 @@ impl ConcurrentSkipList {
             (InsertResult::Success, size) => {
                 self.total_inserts.fetch_add(1, Ordering::Relaxed);
                 self.live_count.fetch_add(1, Ordering::Relaxed);
-                self.arena.record_alloc(size);
+                if self.max_memory_bytes > 0 {
+                    self.arena.record_alloc(size);
+                }
                 true
             }
             (InsertResult::Duplicate | InsertResult::Oom, _) => {
@@ -472,7 +473,9 @@ impl ConcurrentSkipList {
             (InsertResult::Success, size) => {
                 self.total_inserts.fetch_add(1, Ordering::Relaxed);
                 self.live_count.fetch_add(1, Ordering::Relaxed);
-                self.arena.record_alloc(size);
+                if self.max_memory_bytes > 0 {
+                    self.arena.record_alloc(size);
+                }
                 Ok(())
             }
             (InsertResult::Duplicate, _) => {
@@ -602,14 +605,17 @@ impl ConcurrentSkipList {
                 failed: entries.len(),
             });
         }
+        let track_memory = self.max_memory_bytes > 0;
         let mut succeeded = 0;
         let arena = self.arena.local();
         for (key, value) in entries {
             match self.skiplist.insert(key, value, arena) {
                 (InsertResult::Success, size) => {
                     succeeded += 1;
                     self.live_count.fetch_add(1, Ordering::Relaxed);
-                    self.arena.record_alloc(size);
+                    if track_memory {
+                        self.arena.record_alloc(size);
+                    }
                 }
                 (InsertResult::Duplicate | InsertResult::Oom, _) => {}
             }
@@ -877,7 +883,13 @@ impl ConcurrentSkipList {
     /// assert!(sl.memory_usage() > before);
     /// ```
     pub fn memory_usage(&self) -> usize {
-        self.arena.bytes_allocated_fast()
+        let fast = self.arena.bytes_allocated_fast();
+        if fast > 0 {
+            fast
+        } else {
+            // Fallback: iterate shards when no limits are configured
+            self.arena.stats().bytes_allocated
+        }
     }
 
     /// Total arena bytes reserved across all shards.

src/skiplist.rs

@@ -84,11 +84,9 @@ impl SkipList {
     #[inline]
     pub(crate) fn get(&self, key: &[u8]) -> Option<(&[u8], bool)> {
         let mut x = self.head;
-        let h = self.height.load(Ordering::Acquire);
+        let h = self.height.load(Ordering::Relaxed);
         let mut level = if h > 0 { h - 1 } else { 0 };
 
-        prefetch_read(x);
-
         loop {
             let next = unsafe { tower_load(x, level) };
             if next.is_null() {
@@ -99,10 +97,6 @@ impl SkipList {
                 continue;
             }
             let next_node = next.ptr();
-            let next_next = unsafe { tower_load(next_node, level) };
-            if !next_next.is_null() {
-                prefetch_read(next_next.ptr());
-            }
             let next_key = unsafe { node_key(next_node) };
             match compare_keys(next_key, key) {
                 std::cmp::Ordering::Less => {
@@ -266,11 +260,9 @@ impl SkipList {
     #[inline]
     pub(crate) fn delete(&self, key: &[u8]) -> bool {
         let mut x = self.head;
-        let h = self.height.load(Ordering::Acquire);
+        let h = self.height.load(Ordering::Relaxed);
         let mut level = if h > 0 { h - 1 } else { 0 };
 
-        prefetch_read(x);
-
         loop {
             let next = unsafe { tower_load(x, level) };
             if next.is_null() {
@@ -281,10 +273,6 @@ impl SkipList {
                 continue;
             }
             let next_node = next.ptr();
-            let next_next = unsafe { tower_load(next_node, level) };
-            if !next_next.is_null() {
-                prefetch_read(next_next.ptr());
-            }
             let next_key = unsafe { node_key(next_node) };
             match compare_keys(next_key, key) {
                 std::cmp::Ordering::Less => {
@@ -323,12 +311,9 @@ impl SkipList {
         let mut succs = [TowerPtr::NULL; MAX_HEIGHT];
 
         let mut x = self.head;
-        let h = self.height.load(Ordering::Acquire);
+        let h = self.height.load(Ordering::Relaxed);
         let mut level = if h > 0 { h - 1 } else { 0 };
 
-        // Prefetch head node
-        prefetch_read(x);
-
         loop {
             let next = unsafe { tower_load(x, level) };
             if next.is_null() {