堆栈分配与重新分配 - 性能成本

Question

我正在编写一个单线程 Rust 程序，我需要定期将元素推送到向量中。我在处理函数中有以下 2 个代码选择：

1. 保持静态对象分配并在每次处理中重新分配它的函数
2. 在每次处理中在堆栈中分配一个新对象的函数

鉴于对象类型没有动态大小的元素（它将在堆栈中分配），process1 是否仍然比下面的 process2 具有性能优势？

   #[derive(Debug, Clone, PartialEq, Eq, Copy, Hash)]
   pub struct MyObj {
    mem1: u32,
    mem2: u32,
    // .
    // .
    // .
    mem500: u32,
   }

   impl MyObj {
    pub const fn default() -> MyObj {
        MyObj {
            mem1: 0,
            mem2: 0,
            // .
            // .
            // .
            mem500: 0,
        }
   }

    pub fn reset(&mut self) {
        self.mem1 = 0;
        self.mem2 = 0;
        // .
        // .
        // .
        self.mem500 = 0;
    }
   }

   pub fn process1(vec: &mut Vec<MyObj>) {
    static mut static_obj: MyObj = MyObj::default();

    unsafe {
        static_obj.reset();

        // assign some members of static_obj

        vec.push(static_obj);
    }
   }

   pub fn process2(vec: &mut Vec<MyObj>) {
    let mut obj = MyObj::default();

    // assign some members of obj

    vec.push(obj);
   }