更有效的方法来遍历展平的 2D Vec 列

Question

所以我有一个Vec<bool> 存储在self.board.data 中，它代表一个二维网格。逐行遍历它并在其索引和 x,y 坐标之间进行转换很容易，但是要逐列索引它，我需要使用嵌套的 for 循环。有没有更有效的方法来做到这一点？我有与这个类似的函数，它们会运行一堆次，所以我想让它们尽可能高效。

    ///returns average height of all columns
    fn calc_avg_height(&self) -> f32 {
        let mut heights = 0;
        for x in 0..self.board.width {
            for y in 0..self.board.height {
                if self.board.data[(y*self.board.width)+x] {
                    heights+=self.board.height-y;
                    break
                }
            }
        }
        heights as f32/self.board.width as f32
    }

Answer 1

无论你做什么，逐列读取数据都会很慢，因为你会在内存中跳跃。与此相比，计算索引是一种噪音。

有没有更有效的方法来做到这一点？

一个想法是将位放在一起以减少 8 个内存。另一个想法是逐列保存数据，仅在需要时更新（这取决于您的访问模式）。

Answer 2

您可以预加载索引，因此您只需要遍历它们。这可能在时间上更有效，但在空间上却没有：

fn preload_indexes(row_size: usize, column_size: usize) -> Vec<usize> {
    let mut indexes = Vec::new();
    for x in 0..row_size {
        for y in 0..column_size {
            let i = y*row_size+x;
            indexes.push(i);
        }
    }
    indexes
}

作为一个完整的例子：

use std::fmt::Display;

struct Matrix<T: Display> {
    row_size: usize,
    column_size: usize,
    data: Vec<T>,
    columns_indexes: Vec<usize>,
}


fn preload_indexes(row_size: usize, column_size: usize) -> Vec<usize> {
    let mut indexes = Vec::new();
    for x in 0..row_size {
        for y in 0..column_size {
            let i = y*row_size+x;
            indexes.push(i);
        }
    }
    indexes
}

impl<T: Display> Matrix<T> {
    fn new(data: Vec<T>, row_size: usize, column_size: usize) -> Self {
        assert_eq!(data.len(), row_size*column_size);
        
        Self {
            row_size,
            column_size,
            data,
            columns_indexes: preload_indexes(row_size, column_size),
        }
    }
    
    fn print_rows(&self) {
        for e in self.data.iter() {
            println!("{}", e);
        }
    }
    
    fn print_columns(&self) {
        for i in self.columns_indexes.iter() {
            println!("{}", self.data[*i]);
        }
    }
}


fn main() {
    let matrix = Matrix::new(vec![1, 2, 3, 4], 2, 2);
    println!("Rows");
    matrix.print_rows();
    println!("Columns");
    matrix.print_columns();
}

Playground

Answer 3

围绕着你的例子，我很惊讶地看到 索引计算（y*width+x）似乎不是 由优化器简化。 此外，我虽然内存访问更重要 比索引计算中删除的乘法。 但是当谈到时间安排时，我可以看到很大的不同 （具有各种网格大小和真/假初始化）。

编辑

看了下面的一些cmets，对比了两个版本， _v1 和 _v2，在编译器资源管理器 (godbolt) 中。 它们看起来非常相似，除了 _v1 使用 lea 指令和 _v2 使用 add 和 inc 代替。 根据vtune-amplifier，_v1的大部分时间是 花费在这个确切的lea 指令上。 所以，至少在我的电脑上，在这个具体的例子上， 与直觉相反，选择 lea 而不是 add 和 inc 似乎比不规则的内存访问更有害 模式。

/*
  $ rustc -C opt-level=3 prog.rs && ./prog
  avg1=50.5
    v1: 4453 ms
  avg2=50.5
    v2: 2361 ms
*/

pub struct Board {
    width: usize,
    height: usize,
    data: Vec<bool>,
}

impl Board {
    pub fn new(
        width: usize,
        height: usize,
    ) -> Self {
        Self {
            width,
            height,
            data: vec![false; width * height],
        }
    }

    pub fn calc_avg_height_v1(&self) -> f32 {
        let mut heights = 0;
        for x in 0..self.width {
            for y in 0..self.height {
                if self.data[(y * self.width) + x] {
                    heights += self.height - y;
                    break;
                }
            }
        }
        heights as f32 / self.width as f32
    }

    pub fn calc_avg_height_v2(&self) -> f32 {
        let mut heights = 0;
        for x in 0..self.width {
            let mut idx = x;
            for y in 0..self.height {
                if self.data[idx] {
                    heights += self.height - y;
                    break;
                }
                idx += self.width;
            }
        }
        heights as f32 / self.width as f32
    }
}

pub fn run<F>(
    name: &str,
    repeat: usize,
    fnct: F,
) -> u128
where
    F: Fn() -> f32,
{
    let mut prev = -1.0_f32;
    let warmup = repeat / 10;
    for _ in 0..warmup {
        let avg = fnct();
        if avg != prev {
            println!("{}={}", name, avg);
            prev = avg;
        }
    }
    let now = std::time::Instant::now();
    for _ in 0..repeat {
        let avg = fnct();
        if avg != prev {
            println!("{}={}", name, avg);
            prev = avg;
        }
    }
    now.elapsed().as_millis()
}

pub fn main() {
    let mut board = Board::new(100, 100);
    for y in 0..board.height {
        for x in 0..board.width {
            board.data[y * board.width + x] = x == y;
        }
    }
    let repeat = 1_000_000;
    println!(
        "  v1: {} ms",
        run("avg1", repeat, || board.calc_avg_height_v1())
    );
    println!(
        "  v2: {} ms",
        run("avg2", repeat, || board.calc_avg_height_v2())
    );
}