Repeatedly creating new Vec vs reusing a mutable Vec - rust

Question

I recently started working on a new Rust project which requires a lot of attention to performance stats. We are processing millions of rows and there is a code path that creates a small Vec for each row. I wanted to see whether it makes sense to have a mutable Vec instead of creating a new Vec for each row, so I did this test:
fn main() {
understand_create_vec_cost();
understand_mut_vec_cost();
}
fn understand_mut_vec_cost() {
let timer = std::time::Instant::now();
let mut v1 = Vec::<(usize, usize, usize, usize)>::new();
let mut v2 = Vec::<(usize, usize, usize, usize)>::new();
for _ in 0..100000000 {
let random_val1 = rand::random::<usize>();
let random_val2 = rand::random::<usize>();
v1.clear();
v1.push((random_val1, random_val2, random_val1, random_val2));
v1.push((random_val2, random_val1, random_val2, random_val1));
v2.clear();
v2.push((random_val2, random_val1, random_val2, random_val1));
v2.push((random_val1, random_val2, random_val1, random_val2));
if v1.len() != 2 && v1[0].0 != random_val1 {
println!("v1 is empty");
}
if v2.len() != 2 && v2[0].0 != random_val2 {
println!("v2 is empty");
}
}
println!("Mut Vec: Completed in {:?}", timer.elapsed().as_millis());
}
fn understand_create_vec_cost() {
let timer = std::time::Instant::now();
for _ in 0..100000000 {
let random_val1 = rand::random::<usize>();
let random_val2 = rand::random::<usize>();
let v1 = vec![
(random_val1, random_val2, random_val1, random_val2),
(random_val2, random_val1, random_val2, random_val1),
];
let v2 = vec![
(random_val2, random_val1, random_val2, random_val1),
(random_val1, random_val2, random_val1, random_val2),
];
if v1.len() != 2 && v1[0].0 != random_val1 {
println!("v1 is empty");
}
if v2.len() != 2 && v2[0].0 != random_val2 {
println!("v2 is empty");
}
}
println!("New Vec: Completed in {:?}", timer.elapsed().as_millis());
}
The results always showed that mutable version is around half a second slower. Below is a sample result, but all were mostly similar. These were measured using release build.
New Vec: Completed in 1187 ms.
Mut Vec: Completed in 1568 ms.
So my questions are
Does this code make sense for the purpose? Are there any compiler optimizations that happen under the hood because the code was simple? (I added those if conditions thinking that might avoid any compiler optimizations that might favor one implementation)
Do these results make sense? And why is that? Naive me thinks that each Vec creation means a lot of allocations, and that should cost more than calling clear on the mutable vector.
I don't have industrial experience in Assembly/C++. What is the right way to start learning about performance-based coding in Rust? What are some starting points?

Answer 1

The flaw in your test lies in the way the vec! macro is constructed. when called with arguments, it pre-allocates the space the arguments take in memory immediately. As a hobbyist Rustacean, I would personally recommend using the new vectors so the data can still be borrowed again, since you'll be doing lots of borrowing in rust, but if you have a use case for a mutable vector, (would test myself, but have potato computer) try running it again with let mut let mut v1 = Vec::<usize,usize,usize,usize>::with_capacity(2); which will preallocate the space of two (usize,usize,usize,usize) tuples on the stack. By the way, if you want performance and are using the same sized thing every time with the same type (as in the example) you'll be best off using a fixed-size array- declared like [usize;4], i.e let v1 = Vec::<[usize;4]>::with_capacity(2); which will instead store it on the stack, making your memory much safer and your program much faster since the computer doesn't have to go searching for data.
Forgive me if you were already aware of this resource, but if you are new to rust I reccomend the book for quickly grasping the basics of rust in a manner oriented towards devs moving from other languages (like C)