Rust中使用dyn Trait时如何维持并行性能？

性能损失的核心原因 #

• 动态分发的固有开销：使用Box<dyn Body>后，每次调用hit方法都会触发动态分发（通过虚表查找函数地址），CPU无法进行内联优化，分支预测的准确率也会大幅下降。相比之前Vec<Sphere>的静态分发，单线程计算效率已经降低，并行场景下这个开销会被进一步放大。
• 缓存局部性恶化：Box<dyn Body>的实例分散在堆内存的不同位置，遍历Vec<Box<dyn Body>>时会频繁出现缓存 miss；而原来的Vec<Sphere>是连续内存布局，缓存命中率极高，并行时多线程对缓存的竞争会让这个问题更严重。
• 并行调度的相对开销凸显：静态分发时计算密度高，Rayon的线程调度开销可以忽略，但动态分发后单线程处理速度变慢，调度的相对占比上升，直接抵消了并行带来的性能增益。

可行的解决方案 #

1. 使用枚举替代 trait object（最推荐） #

把所有可渲染的物体类型用枚举统一包装，既能支持多种物体，又能保留静态分发的优势：

#[derive(Debug, Clone)]
enum Primitive {
    Sphere(Sphere),
    Cube(Cube),
}

impl Body for Primitive {
    fn hit(&self, ray: &Ray, t_min: f64, t_max: f64) -> Option<HitRecord> {
        match self {
            Primitive::Sphere(s) => s.hit(ray, t_min, t_max),
            Primitive::Cube(c) => c.hit(ray, t_min, t_max),
        }
    }
}

// 后续使用 Vec<Primitive> 替代 Vec<Box<dyn Body>>

这种方式下，编译器可以对hit方法做内联和分支预测优化，内存也是连续存储的，缓存友好性和原来的Vec<Sphere>一致，Rayon的并行增益能完全发挥。

2. 按类型分组存储 #

如果枚举方案不符合设计需求，可以把不同类型的物体分开存储：

struct Scene {
    spheres: Vec<Sphere>,
    cubes: Vec<Cube>,
}

impl Scene {
    fn hit(&self, ray: &Ray, t_min: f64, t_max: f64) -> Option<HitRecord> {
        let sphere_hit = self.spheres.par_iter()
            .filter_map(|s| s.hit(ray, t_min, t_max))
            .min_by(|a, b| a.t.partial_cmp(&b.t).unwrap());
        
        let cube_hit = self.cubes.par_iter()
            .filter_map(|c| c.hit(ray, t_min, t_max))
            .min_by(|a, b| a.t.partial_cmp(&b.t).unwrap());
        
        // 比较两个结果返回最近的命中
        match (sphere_hit, cube_hit) {
            (Some(s), Some(c)) => if s.t < c.t { Some(s) } else { Some(c) },
            (Some(s), None) => Some(s),
            (None, Some(c)) => Some(c),
            (None, None) => None,
        }
    }
}

每组物体都是连续内存，静态分发，并行处理时每组都能高效利用缓存，调度开销也会降低。

3. 手动优化 trait object 的缓存局部性 #

如果必须使用 trait object，可以尝试将多个Box<dyn Body>打包成连续内存块，比如使用Vec<[Box<dyn Body>; N]>（N取16或32这类合适的大小），减少缓存 miss的频率；同时可以在hit方法上添加#[inline(always)]提示编译器尝试内联，但这个方法的收益远不如前两种。

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