How to create a TinyVec of a specific size (not capacity!), initialized to zero (or user-defined value)

[dEajL3kA]

Hello.

What is the most efficient way to create a new TinyVec of size length, which is initialized zero (or some user-defined value)?

Is there a better way than this?

#[inline(always)]
pub fn calloc_tinyvec<const N: usize>(length: usize) -> TinyVec<[u8; N]> {
    let mut vec = TinyVec::with_capacity(length);
    vec.resize(length, 0u8);
    vec
}

Is this version preferible?

#[inline(always)]
pub fn calloc_tinyvec<const N: usize>(length: usize) -> TinyVec<[u8; N]> {
    if length > N {
        let mut vec = TinyVec::with_capacity(length);
        vec.resize(length, 0u8);
        vec
    } else {
        TinyVec::from_array_len([0u8; N], length)
    }
}

Maybe it could be useful to have a method like:

TinyVec::with_size<A: Array>(length: usize, inital_value: T) -> TinyVec<A>

🤔

Best regards!

[lordmulder]

I did some performance tests:

1. #[inline(always)]
   pub fn mk_tinyvec_1<const N: usize>(length: usize) -> TinyVec<[u8; N]> {
       TinyVec::from_iter(iter::repeat_n(0u8, length))
   }

2. #[inline(always)]
   pub fn mk_tinyvec_2<const N: usize>(length: usize) -> TinyVec<[u8; N]> {
       let mut vec = TinyVec::with_capacity(length);
       vec.resize(length, 0u8);
       vec
   }

3. #[inline(always)]
   pub fn mk_tinyvec_3<const N: usize>(length: usize) -> TinyVec<[u8; N]> {
       if length > N {
           let mut vec = TinyVec::with_capacity(length);
           vec.resize(length, 0u8);
           vec
       } else {
           TinyVec::from_array_len([0u8; N], length)
       }
   }

4. #[inline(always)]
   pub fn mk_tinyvec_4<const N: usize, T: Copy + Default>(length: usize) -> TinyVec<[T; N]> {
       if length <= N {
           TinyVec::Inline(ArrayVec::from_array_len([T::default(); N], length))
       } else {
           TinyVec::Heap(vec![T::default(); length])
       }
   }

Test bench:

const LOOPS: usize = 999999999usize;
type TinyVecType = TinyVec<[u8; 256usize]>;

macro_rules! do_test_helper {
    ($func:ident, $n:literal) => {{
        {
            let start_time = Instant::now();
            for _ in 0usize..LOOPS {
                let instance: TinyVecType = $func($n);
                assert_eq!(instance.len(), $n);
                assert_eq!(instance[0usize], 0u8);
                assert_eq!(instance[$n - 1usize], 0u8);
            }
            let elapsed = start_time.elapsed();
            println!("{} - {} - {:.3}", stringify!($func), $n, elapsed.as_secs_f64());
        }
    }};
}

macro_rules! do_test {
    ($func:ident) => {{
        do_test_helper!($func, 128usize);
        do_test_helper!($func, 256usize);
        do_test_helper!($func, 512usize);
        println!();
    }};
}

fn main() {
    for i in 0..2 {
        if i > 0 {
            println!("----");
            println!();
        }
        do_test!(mk_tinyvec_1);
        do_test!(mk_tinyvec_2);
        do_test!(mk_tinyvec_3);
        do_test!(mk_tinyvec_4);
    }
}

Results:

mk_tinyvec_1 - 128 - 25.646
mk_tinyvec_1 - 256 - 36.296
mk_tinyvec_1 - 512 - 59.758

mk_tinyvec_2 - 128 - 36.814
mk_tinyvec_2 - 256 - 26.966
mk_tinyvec_2 - 512 - 39.912

mk_tinyvec_3 - 128 - 0.000
mk_tinyvec_3 - 256 - 0.000
mk_tinyvec_3 - 512 - 40.039

mk_tinyvec_4 - 128 - 0.000
mk_tinyvec_4 - 256 - 0.000
mk_tinyvec_4 - 512 - 5.359

Version #4 wins easily 🥳