Perf: preallocate node vectors to capacity; drop merge-time reserves. Keeps capacity invariant while avoiding reallocs; validated tests + large delete bench.

Author: KentBeck

rust/src/construction.rs

@@ -122,10 +122,11 @@ impl<K, V> LeafNode<K, V> {
     /// // Leaf node created successfully
     /// ```
     pub fn new(capacity: usize) -> Self {
+        // Pre-allocate to capacity to avoid reallocations during steady-state ops
         Self {
             capacity,
-            keys: Vec::new(),
-            values: Vec::new(),
+            keys: Vec::with_capacity(capacity),
+            values: Vec::with_capacity(capacity),
             next: NULL_NODE,
         }
     }
@@ -187,10 +188,11 @@ impl<K, V> BranchNode<K, V> {
     /// // Branch node created successfully
     /// ```
     pub fn new(capacity: usize) -> Self {
+        // Pre-allocate: keys up to capacity, children up to capacity+1
         Self {
             capacity,
-            keys: Vec::new(),
-            children: Vec::new(),
+            keys: Vec::with_capacity(capacity),
+            children: Vec::with_capacity(capacity + 1),
         }
     }
 

rust/src/delete_operations.rs

@@ -462,9 +462,6 @@ impl<K: Ord + Clone, V: Clone> BPlusTreeMap<K, V> {
             let Some(left_branch) = self.get_branch_mut(left_id) else {
                 return false;
             };
-            let add_keys = 1 + child_keys.len(); // separator + child keys
-            let add_children = child_children.len();
-            left_branch.reserve_for_merge(add_keys, add_children);
             left_branch.keys.push(separator_key);
             left_branch.keys.append(&mut child_keys);
             left_branch.children.append(&mut child_children);
@@ -518,9 +515,6 @@ impl<K: Ord + Clone, V: Clone> BPlusTreeMap<K, V> {
             let Some(child_branch) = self.get_branch_mut(child_id) else {
                 return false;
             };
-            let add_keys = 1 + right_keys.len(); // separator + right keys
-            let add_children = right_children.len();
-            child_branch.reserve_for_merge(add_keys, add_children);
             child_branch.keys.push(separator_key);
             child_branch.keys.append(&mut right_keys);
             child_branch.children.append(&mut right_children);
@@ -735,8 +729,6 @@ impl<K: Ord + Clone, V: Clone> BPlusTreeMap<K, V> {
 
         // Merge into left leaf and update linked list - reserve to avoid reallocations
         let Some(left_leaf) = self.get_leaf_mut(left_id) else { return false; };
-        let add = child_keys.len();
-        left_leaf.reserve_for_merge(add);
         left_leaf.append_keys(&mut child_keys);
         left_leaf.append_values(&mut child_values);
         left_leaf.next = child_next;
@@ -788,8 +780,6 @@ impl<K: Ord + Clone, V: Clone> BPlusTreeMap<K, V> {
 
             // Then merge into child, reserving capacity to avoid reallocations
             let Some(child_leaf) = self.get_leaf_mut(child_id) else { return false; };
-            let add = right_keys.len();
-            child_leaf.reserve_for_merge(add);
             child_leaf.append_keys(&mut right_keys);
             child_leaf.append_values(&mut right_values);
             child_leaf.next = right_next;

rust/src/node.rs

@@ -226,13 +226,6 @@ impl<K: Ord + Clone, V: Clone> LeafNode<K, V> {
         self.values.append(other);
     }
 
-    /// Reserve capacity for an incoming merge of `additional` items.
-    #[inline]
-    pub fn reserve_for_merge(&mut self, additional: usize) {
-        // Reserve for both keys and values (kept in lockstep)
-        self.keys.reserve(additional);
-        self.values.reserve(additional);
-    }
 
     /// Take all keys, leaving an empty vector.
     #[inline]
@@ -723,10 +716,4 @@ impl<K: Ord + Clone, V: Clone> BranchNode<K, V> {
         self.children.append(&mut other.children);
     }
 
-    /// Reserve capacity for an incoming merge.
-    #[inline]
-    pub fn reserve_for_merge(&mut self, additional_keys: usize, additional_children: usize) {
-        self.keys.reserve(additional_keys);
-        self.children.reserve(additional_children);
-    }
 }