Rust中Vec相邻元素批量更新（性能优化需求）

一、Vec的批量连续元素更新 #

Rust标准库的Vec原生支持高效的批量连续元素更新，无需自定义方法：

1. copy_from_slice：直接批量替换 #

这是最常用的方式，要求源切片与目标区间长度一致，且元素实现Copy trait（像素类型如u32天然满足）。

示例代码：

// 初始化帧缓冲区（1000个像素）
let mut frame_buffer: Vec<u32> = vec![0; 1000];
// 准备一行100个紫色像素（0xFF00FF）
let new_row: Vec<u32> = vec![0xFF00FF; 100];

// 从索引200开始，批量替换100个元素
frame_buffer[200..300].copy_from_slice(&new_row);

2. split_at_mut：灵活拆分区间赋值 #

如果需要拆分缓冲区进行多段批量操作，可先用split_at_mut拆分可变切片，再对目标区间赋值：

let mut buf = vec![1,2,3,4,5,6];
// 从索引2处拆分缓冲区
let (_left, right) = buf.split_at_mut(2);
// 批量替换右侧前3个元素
right[0..3].copy_from_slice(&[7,8,9]);
// 最终buf为 [1,2,7,8,9,6]

二、Texture之间的按行批量Blit #

针对基于Vec实现的Texture，核心优化思路是按行处理连续像素块，替代逐像素循环：

1. 基础批量Blit实现 #

假设Texture结构体定义如下，实现按行批量复制的Blit方法：

struct Texture {
    width: usize,
    height: usize,
    pixels: Vec<u32>,
}

impl Texture {
    // 将src纹理绘制到self的(x, y)位置
    fn blit(&mut self, src: &Texture, x: usize, y: usize) {
        // 计算有效绘制区域，避免越界
        let dst_start_x = x.clamp(0, self.width);
        let dst_start_y = y.clamp(0, self.height);
        let src_start_x = if x > self.width { x - self.width } else { 0 };
        let src_start_y = if y > self.height { y - self.height } else { 0 };
        
        let draw_width = (src.width - src_start_x).min(self.width - dst_start_x);
        let draw_height = (src.height - src_start_y).min(self.height - dst_start_y);
        
        if draw_width == 0 || draw_height == 0 {
            return;
        }
        
        // 按行批量复制像素
        for row in 0..draw_height {
            // 源纹理当前行的像素切片
            let src_row_start = (src_start_y + row) * src.width + src_start_x;
            let src_slice = &src.pixels[src_row_start..src_row_start + draw_width];
            
            // 目标纹理当前行的像素切片
            let dst_row_start = (dst_start_y + row) * self.width + dst_start_x;
            let dst_slice = &mut self.pixels[dst_row_start..dst_row_start + draw_width];
            
            // 批量复制整行
            dst_slice.copy_from_slice(src_slice);
        }
    }
}

2. 极致性能优化：直接调用memcpy #

若追求最高性能，可使用std::ptr::copy_nonoverlapping（对应C的memcpy），跳过Rust的部分安全检查（需确保源/目标切片无内存重叠）：

// 替换上述循环内的copy_from_slice为：
unsafe {
    std::ptr::copy_nonoverlapping(
        src_slice.as_ptr(),
        dst_slice.as_mut_ptr(),
        draw_width,
    );
}

三、额外性能建议 #

• 优先选择Copy类型作为像素存储（如u32），避免复杂结构体带来的拷贝开销
• 提前计算所有固定偏移量，避免在循环内重复计算
• 直接操作minifb帧缓冲区的底层切片，减少中间数据拷贝

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