Simple back copy vs memmove in Rust.

bench.rs

//! Execution result:
//! ```
//! running 2 tests
//! test bench1 ... bench:           0.31 ns/iter (+/- 0.00)
//! test bench2 ... bench:           0.34 ns/iter (+/- 0.09)
//! ```

#![feature(test)]

extern crate test;
use test::Bencher;

const MAX_SIZE: usize = 200;

pub struct Array {
    data: [u32; MAX_SIZE],
    len: usize,
}

impl Array {
    pub fn new() -> Self {
        Self {
            data: [0; MAX_SIZE],
            len: 0,
        }
    }

    pub fn insert1(&mut self, item: u32, pos: usize) {
        if self.len >= MAX_SIZE {
            return;
        }
        for i in pos + 1..self.len {
            self.data[i] = self.data[i - 1];
        }
        self.data[pos] = item;
        self.len += 1;
    }

    pub fn insert2(&mut self, item: u32, pos: usize) {
        if self.len >= MAX_SIZE {
            return;
        }
        unsafe {
            let src = self.data.as_ptr().add(pos);
            let dst = self.data.as_mut_ptr().add(pos + 1);
            std::ptr::copy(src, dst, self.len - pos);
        }
        self.data[pos] = item;
        self.len += 1;
    }
}

#[bench]
pub fn bench1(b: &mut Bencher) {
    let mut arr = Array::new();
    b.iter(|| {
        for i in 0..100 {
            arr.insert1(i as u32, i);
        }
    });
}

#[bench]
pub fn bench2(b: &mut Bencher) {
    let mut arr = Array::new();
    b.iter(|| {
        for i in 0..100 {
            arr.insert2(i as u32, i);
        }
    });
}