Question

以下代码中的

static变量A_INTERSECTS_A将返回错误。这段代码应返回bool的大型1356x1356 2D数组。

use lazy_static::lazy_static; // 1.2.0

#[derive(Debug, Copy, Clone, Default)]
pub struct A {
    pub field_a: [B; 2],
    pub ordinal: i32,
}

#[derive(Debug, Copy, Clone, Default)]
pub struct B {
    pub ordinal: i32,
}

pub const A_COUNT: i32 = 1356;

lazy_static! {
    pub static ref A_VALUES: [A; A_COUNT as usize] = { [A::default(); A_COUNT as usize] };

    pub static ref A_INTERSECTS_A: [[bool; A_COUNT as usize]; A_COUNT as usize] = {
        let mut result = [[false; A_COUNT as usize]; A_COUNT as usize];

        for item_one in A_VALUES.iter() {
            for item_two in A_VALUES.iter() {
                if item_one.field_a[0].ordinal == item_two.field_a[0].ordinal
                    || item_one.field_a[0].ordinal == item_two.field_a[1].ordinal
                    || item_one.field_a[1].ordinal == item_two.field_a[0].ordinal
                    || item_one.field_a[1].ordinal == item_two.field_a[1].ordinal
                {
                    result[item_one.ordinal as usize][item_two.ordinal as usize] = true;
                }
            }
        }
        result
    };
}

fn main() {
    A_INTERSECTS_A[1][1];
}

我已经看到人们通过在大型列表中为结构实现Drop来处理这个问题，但是我的列表中没有任何结构，你不能为bool实现它。

如果我将A_INTERSECTS_A: [[bool; A_COUNT as usize]; A_COUNT as usize]更改为A_INTERSECTS_A: Box<Vec<Vec<bool>>>代码正常，但我真的想在这里使用数组。

Answer 1

这里的问题几乎肯定是result初始化代码运行时放在堆栈上的巨大A_INTERSECTS_A数组。它是1356 ²≈1.8MB，其与堆栈的大小具有相似的数量级。事实上，它比Windows＆＃39;默认大小为1 MB（我怀疑你在Windows上，因为你有错误信息）。

此处的解决方案是通过将堆栈大小移动到堆来减少堆栈大小，例如，使用Vec代替（当您指示工作时）或使用Box。这将带来额外的好处，即初始化代码不必从堆栈到A_INTERSECTS_A的内存执行2MB的复制（它只需要复制一些指针）。

直接翻译为使用Box：

pub static ref A_INTERSECTS_A: Box<[[bool; A_COUNT as usize]; A_COUNT as usize]> = {
    let mut result = Box::new([[false; A_COUNT as usize]; A_COUNT as usize]);
    // ...
}

遗憾的是，

不起作用：Box::new是一个普通的函数调用，因此它的参数直接放在堆栈上。

但是，如果您正在使用夜间编译器并且愿意使用不稳定的功能，则可以使用"placement box"，它是为此目的而设计的：它在堆上分配空间并构造值直接进入该内存，避免中间副本，并避免将数据放在堆栈上。这只需要将Box::new替换为box：

let mut result = box [[false; A_COUNT as usize]; A_COUNT as usize];

如果你（非常明智地）更喜欢坚持稳定版本，那么直到稳定的替代方法是用Vec替换数组的外部层：这保留所有数组的数据局部性好处（一切都在内存中连续排列），虽然在静态知识方面稍微弱一点（编译器不能确定长度是1356）。由于[_; A_COUNT]没有实现Clone, this cannot use the vec！`宏，因此（不幸的是）看起来像：

pub static ref A_INTERSECTS_A: Vec<[bool; A_COUNT as usize]> = {
    let mut result =
        (0..A_COUNT as usize)
            .map(|_| [false; A_COUNT as usize])
            .collect::<Vec<_>>();
    // ...
}

如果您绝对需要所有阵列，可以使用unsafe魔法将其提取到Box<[[bool; ...]; ...]>的原始Vec。它需要两个步骤（通过into_boxed_slice），因为Box<T>需要为T完美分配大小，而Vec可能需要进行分配以实现其O（ 1）摊销。这个版本看起来像：

pub static ref A_INTERSECTS_A: Box<[[bool; A_COUNT as usize]; A_COUNT as usize]> = {
    let mut result =
        (0..A_COUNT as usize)
            .map(|_| [false; A_COUNT as usize])
            .collect::<Vec<_>>();

    // ...

    // ensure the allocation is correctly sized
    let mut slice: Box<[[bool; A_COUNT as usize]]> = result.into_boxed_slice();
    // pointer to the start of the slices in memory
    let ptr: *mut [bool; A_COUNT as usize] = slice.as_mut_ptr();
    // stop `slice`'s destructor deallocating the memory
    mem::forget(slice);

    // `ptr` is actually a pointer to exactly A_COUNT of the arrays! 
    let new_ptr = ptr as *mut [[bool; A_COUNT as usize]; A_COUNT as usize];
    unsafe {
        // let this `Box` manage that memory
        Box::from_raw(new_ptr)
    }
}

我已经添加了一些明确的类型，以便进行的更加清晰。这是有效的，因为Vec<T>公开into_boxed_slice，因此我们可以将Box<[T]>（即动态长度）转换为Box<[T; len]>，因为我们知道编译时的确切长度。

线程＆＃39; <main>＆＃39;在创建一个大型数组时，它已经溢出了它的堆栈

1 个答案: