Debug模式下访问大型结构体Vector为何远慢于小型Vector？

你的代码 #

#[derive(Copy, Clone)]
pub struct Element {
    pub key: u64,
}
pub fn test1(u: usize) {
    let now = std::time::SystemTime::now();
    let tt = vec![Element { key: 0 }; u];
    for _ in 0..10000000 as u64 {
        if tt[155].key == 893472348628 {}
    }
    match now.elapsed() {
        Ok(elapsed) => {
            println!(
                "With struct, size of vec={}: Time elapsed: {}.{} seconds",
                u, elapsed.as_secs(), elapsed.subsec_nanos()
            );
        }
        Err(e) => {
            println!("Error: {:?}", e);
            panic!();
        }
    }
}
pub fn test2(u: usize) {
    let now = std::time::SystemTime::now();
    let tt = vec![0u64; u];
    for _ in 0..10000000 as u64 {
        if tt[155] == 893472348628 {}
    }
    match now.elapsed() {
        Ok(elapsed) => {
            println!(
                "With u64, size of vec={}: Time elapsed: {}.{} seconds",
                u, elapsed.as_secs(), elapsed.subsec_nanos()
            );
        }
        Err(e) => {
            println!("Error: {:?}", e);
            panic!();
        }
    }
}
fn main() {
    test1(100000);
    test1(100000000);
    test2(100000);
    test2(100000000);
}

运行结果 #

With struct, size of vec=100000: Time elapsed: 1.268881822 seconds
With struct, size of vec=100000000: Time elapsed: 12.470818140 seconds
With u64, size of vec=100000: Time elapsed: 1.171180429 seconds
With u64, size of vec=100000000: Time elapsed: 1.230393828 seconds

核心原因：Debug模式下Vec初始化方式的差异 #

你的计时包含了Vec的创建和初始化时间，这正是性能差异的关键：

• 对于vec![0u64; u]：u64是Rust的基本数值类型，在Debug模式下，编译器依然可以利用底层内存分配器的零初始化机制（比如Linux的mmap带MAP_ANONYMOUS标志，直接分配已清零的内存）。这种方式的初始化时间几乎与向量大小无关——不管是10万还是1亿元素，分配和清零的开销都极小，所以test2的总时间主要由循环部分决定，两次运行的差异可以忽略。

• 对于vec![Element { key: 0 }; u]：尽管Element实现了Copy和Clone，但在Debug模式下，编译器不会将其优化为批量零初始化。相反，它会执行逐个元素的复制初始化：循环u次，每次将Element { key: 0 }复制到向量的对应位置。当u是1亿时，这个循环要执行1亿次，带来了巨大的时间开销；而u是10万时，仅需执行10万次，因此总时间差异达到了10倍左右。

验证：隔离初始化时间 #

如果把向量的创建移到计时开始之前，你会发现两次test1的循环时间几乎一致，和test2的循环时间也差不多：

pub fn test1(u: usize) {
    // 把Vec创建移到计时前
    let tt = vec![Element { key: 0 }; u];
    let now = std::time::SystemTime::now();
    for _ in 0..10000000 as u64 {
        if tt[155].key == 893472348628 {}
    }
    // ... 输出代码不变
}

pub fn test2(u: usize) {
    let tt = vec![0u64; u];
    let now = std::time::SystemTime::now();
    for _ in 0..10000000 as u64 {
        if tt[155] == 893472348628 {}
    }
    // ... 输出代码不变
}

运行这个修改后的代码，你会看到test1的两次循环时间差异极小，和test2的结果接近——这说明循环中的元素访问性能其实没有差异，差异完全来自初始化阶段。

为什么Debug模式会有这种差异？ #

Debug模式的目标是提供清晰的调试信息和安全检查，而非性能。因此编译器会禁用大部分优化，包括针对结构体批量初始化的优化。而基本数值类型的零初始化是底层分配器的能力，不需要编译器做复杂优化，因此能保留高效的初始化方式。

你的8GB内存完全能容纳1亿个元素的向量（约763MB），所以内存容量不是问题。

内容的提问来源于stack exchange，提问作者Darius Duesentrieb