11 Optimizations

// This method is usually instantiated many times. So we want it to be as
// small as possible, to improve compile times. But we also want as much of
// its contents to be statically computable as possible, to make the
// generated code run faster. Therefore, this method is carefully written
// so that all of the code that depends on `T` is within it, while as much
// of the code that doesn’t depend on `T` as possible is in functions that
// are non-generic over `T`.
fn grow_amortized(&mut self, len: usize, additional: usize) ->
Result<(), TryReserveError> {
    // This is ensured by the calling contexts.
    debug_assert!(additional > 0);
 
    if mem::size_of::<T>() == 0 {
        // Since we return a capacity of `usize::MAX` when `elem_size` is
        // 0, getting to here necessarily means the `RawVec` is overfull.
        return Err(CapacityOverflow.into());
    }
 
    // Nothing we can really do about these checks, sadly.
    let required_cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
 
    // This guarantees exponential growth. The doubling cannot overflow
    // because `cap <= isize::MAX` and the type of `cap` is `usize`.
    let cap = cmp::max(self.cap * 2, required_cap);                    ❶
    let cap = cmp::max(Self::MIN_NON_ZERO_CAP, cap);                   ❷
 
    let new_layout = Layout::array::<T>(cap);
 
    // `finish_grow` is non-generic over `T`.
    let ptr = finish_grow(new_layout, self.current_memory(),
    ➥ &mut self.alloc)?;
    self.set_ptr_and_cap(ptr, cap);
    Ok(())
}

let big_vec = vec![0; 10_000_000];
let now = Instant::now();
for i in big_vec {
    if i < 0 {
        println!("this never prints");
    }
}
println!("First loop took {}s", now.elapsed().as_secs_f32());
 
let big_vec = vec![0; 10_000_000];
let now = Instant::now();
big_vec.iter().for_each(|i| {
    if *i < 0 {
        println!("this never prints");
    }
});
println!("Second loop took {}s", now.elapsed().as_secs_f32());

pub fn copy_from_slice(&mut self, src: &[T])
    where
        T: Copy,
    {
        // ... snip ...
        unsafe {
            ptr::copy_nonoverlapping(src.as_ptr(), self.as_mut_ptr(),
            ➥ self.len());
        }
    }

let big_vec_source = vec![0; 10_000_000];
let mut big_vec_target = Vec::<i32>:: 
➥ with_capacity(10_000_000);           ❶
let now = Instant::now();
big_vec_source
    .into_iter()
    .for_each(|i| big_vec_target.push(i));
println!("Naive copy took {}s", now.elapsed().as_secs_f32());
 
let big_vec_source = vec![0; 10_000_000];
let mut big_vec_target = vec![0; 10_000_000];
let now = Instant::now();
big_vec_target.copy_from_slice(&big_vec_source);
println!("Fast copy took {}s", now.elapsed().as_secs_f32());

#![feature(portable_simd, array_zip)]             ❶
 
fn initialize() -> ([u64; 64], [u64; 64]) {
    let mut a = [0u64; 64];
    let mut b = [0u64; 64];
    (0..64).for_each(|n| {
        a[n] = u64::try_from(n).unwrap();
        b[n] = u64::try_from(n + 1).unwrap();
    });
    (a, b)
}
 
fn main() {
    use std::simd::Simd;
    use std::time::Instant;
 
    let (mut a, b) = initialize();                ❷
 
    let now = Instant::now();                     ❸
    for _ in 0..100_000 {
        let c = a.zip(b).map(|(l, r)| l * r);
        let d = a.zip(c).map(|(l, r)| l + r);
        let e = c.zip(d).map(|(l, r)| l * r);
        a = e.zip(d).map(|(l, r)| l ^ r);         ❹
    }
    println!("Without SIMD took {}s", now.elapsed().as_secs_f32());
 
    let (a_vec, b_vec) = initialize();            ❺
 
    let mut a_vec = Simd::from(a_vec);            ❻
    let b_vec = Simd::from(b_vec);
 
    let now = Instant::now();                     ❼
    for _ in 0..100_000 {
        let c_vec = a_vec * b_vec;
        let d_vec = a_vec + c_vec;
        let e_vec = c_vec * d_vec;
        a_vec = e_vec ^ d_vec;                    ❽
    }
    println!("With SIMD took {}s", now.elapsed().as_secs_f32());
 
    assert_eq!(&a, a_vec.as_array());             ❾
}