Question

因此，我有一个Vec<bool>存储在self.board.data中，它代表一个2D网格。逐行迭代并在其索引和x，y坐标之间进行转换很容易，但是要逐列对其进行索引，我需要使用嵌套的for循环。有没有更有效的方法可以做到这一点？我具有与此功能类似的功能，这些功能将运行 bunch 多次，因此我想使它们尽可能高效。

    ///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）似乎不是由优化器简化。而且，尽管我的内存访问更为重要比删除索引计算中的乘法要好。但是在计时方面，我可以看到很大的不同（具有各种网格大小和正确/错误的初始化）。

修改

阅读下面的一些评论后，我比较了两个版本， _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())
    );
}

遍历扁平化2D Vec列的更有效方法

3 个答案: