Benchmark different buffer copy methods for Rust vec

main.rs

/// You need this as dependency in Cargo.toml
///
/// [dependencies]
/// time = "0.2.26"

use std::collections::HashMap;
use std::env;
use std::ptr;
use time::Duration;

const SIZE: usize = 10 * 1024 * 1024;

fn copy_iter(src: &[u8], dst: &mut Vec<u8>) {
  for &byte in src {
    dst.push(byte);
  }
}

fn copy_index(src: &[u8], dst: &mut Vec<u8>) {
  let mut index = 0;
  unsafe {
    dst.set_len(SIZE);
  }
  while index < src.len() {
    dst[index] = src[index];
    index += 1;
  }
}

fn copy_extend(src: &[u8], dst: &mut Vec<u8>) {
  dst.extend(src);
}

fn copy_extend_s(src: &[u8], dst: &mut Vec<u8>) {
  dst.extend_from_slice(src);
}

fn copy_ptr(src: &[u8], dst: &mut Vec<u8>) {
  unsafe {
    dst.set_len(SIZE);
    ptr::copy_nonoverlapping(src.as_ptr(), (&mut dst[..]).as_mut_ptr(), SIZE);
  }
}

fn main() {
  let max = 100;
  let mut results: HashMap<&str, i128> = HashMap::new();
  let methods = vec!["iter", "index", "ptr", "extend", "extend_s"];
  // init map
  for method in &methods {
    results.insert(method, 0);
  }

  for (method, time) in results.iter_mut() {
    for _ in 0..max {
      *time = *time + measure(method);
    }
  }

  for (method, time) in results {
    let dur = std::time::Duration::from_nanos((time / max) as u64);
    println!("{:>10} {:>10?}", method, dur);
  }
}

fn measure(method: &str) -> i128 {
  let src = vec![1; SIZE];
  let mut dst = Vec::with_capacity(SIZE);

  let (a, _) = Duration::time_fn(|| match method {
    "iter" => copy_iter(&src[..], &mut dst),
    "index" => copy_index(&src[..], &mut dst),
    "extend_s" => copy_extend_s(&src[..], &mut dst),
    "ptr" => copy_ptr(&src[..], &mut dst),
    "extend" => copy_extend(&src[..], &mut dst),
    m => panic!("Wrong method '{}'", m),
  });

  a.whole_nanoseconds()
}

I get those results on a Intel i5-9600K (on Windows 10)

       ptr 2.125404ms
     index 6.417303ms
    extend 2.030989ms
      iter 13.693452ms
  extend_s 2.350077ms