Function benchmark_insert

rust/src/comprehensive_performance_benchmark.rs:98–155

(
    bplus: &BPlusTreeMap<usize, usize>,
    _btree: &BTreeMap<usize, usize>,
    tree_size: usize,
    sample_size: usize,
)

}

fn benchmark_insert(
    bplus: &BPlusTreeMap<usize, usize>,
    _btree: &BTreeMap<usize, usize>,
    tree_size: usize,
    sample_size: usize,
) {
    println!("➕ INSERT Performance:");

    // Generate new keys for insertion (beyond existing range)
    let new_keys: Vec<usize> = (tree_size..tree_size + sample_size).collect();

    // Create fresh trees for insertion testing
    let capacity = bplus.capacity;
    let mut bplus_copy = BPlusTreeMap::new(capacity).unwrap();
    let mut btree_copy = BTreeMap::new();

    // Pre-populate with original data
    for i in 0..tree_size {
        bplus_copy.insert(i, i * 2);
        btree_copy.insert(i, i * 2);
    }

    // Benchmark BPlusTreeMap insert
    let start = Instant::now();
    for &key in &new_keys {
        bplus_copy.insert(key, key * 2);
    }
    let bplus_time = start.elapsed();

    // Reset and benchmark BTreeMap insert
    btree_copy.clear();
    for i in 0..tree_size {
        btree_copy.insert(i, i * 2);
    }

    let start = Instant::now();
    for &key in &new_keys {
        btree_copy.insert(key, key * 2);
    }
    let btree_time = start.elapsed();

    let bplus_per_op = bplus_time.as_nanos() as f64 / sample_size as f64;
    let btree_per_op = btree_time.as_nanos() as f64 / sample_size as f64;
    let speedup = btree_per_op / bplus_per_op;

    println!("  BPlusTreeMap: {:.1}ns per insert", bplus_per_op);
    println!("  BTreeMap:     {:.1}ns per insert", btree_per_op);
    println!(
        "  Ratio:        {:.2}x {}",
        speedup,
        if speedup > 1.0 {
            "(BPlusTreeMap faster)"
        } else {
            "(BTreeMap faster)"
        }
    );
    println!();
}