Início / coding / Perguntas / 77934697
Accepted
yushizhao
Asked: 2024-02-04 13:29:09 +0800 CST

Box::new() fará uma cópia da pilha para a pilha?

  • 772

Do documento diz:

pub fn new(x: T) -> Box Aloca memória no heap e depois coloca x nele.

Mas “lugar” é uma palavra complicada. Se escrevermos

let arr_boxed = Box::new([0;1000]);

Será [0;1000]inicializado no heap no local?

Se escrevermos

let arr = [0;1000];
let arr_boxed = Box::new(arr);

O compilador será inteligente o suficiente para inicializar o [0;1000]heap em primeiro lugar?

rust

1 respostas

  1. Best Answer

    Box::new() fará uma cópia da pilha para a pilha?

    Às vezes. A linguagem Rust não garante que essa otimização aconteça e parece deixar que o LLVM descubra isso. Por causa disso, não importa se você inicializa o array primeiro e depois o passa, pois isso é essencialmente a mesma coisa para o back-end.

    Na prática, o desempenho dependerá do caso. O exemplo que você deu é realmente especial, porque os dados são todos zeros:

    pub fn foo() -> Box<[i32; 1000]> {
    return Box::new([0; 1000]);
}

    Nos meus testes , o compilador conseguiu transformar isso em uma alocação + uma chamada para memsetos dados do heap.

    Nota : apenas com as otimizações ativadas. No modo de depuração, ele será copiado.

    Por outro lado, você pode querer inicializar seus dados com um valor conhecido:

    pub fn bar(v: i32) -> Box<[i32; 1000]> {
    return Box::new([v; 1000]);
}

    Para meu horror , o compilador decide inicializar todos os dados na pilha e depois chamar memcpy. (Pelo menos desenrolou o loop de preenchimento) :). Isso acontece mesmo para dados realmente grandes, como [v; 100000], que travarão seu programa com um estouro de pilha. Usar um literal conhecido em tempo de compilação (diferente de zero) [64; 100000]se comporta da mesma maneira.

    Se você realmente quiser ter certeza, você pode fazer algo assim:

    pub fn baz(v: i32) -> Box<[i32; 1000]>{
    unsafe {
        let b = std::alloc::alloc(
            std::alloc::Layout::array::<i32>(1000).unwrap_unchecked()
        ) as *mut i32;
        for i in 0..1000 {
            *b.add(i) = v;
        }
        Box::from_raw(b as *mut [i32; 1000])
    }
}

    que faz a coisa certa .

    Uma versão segura bazseria:

    use std::convert::TryInto;

pub fn quux(v: i32) -> Box<[i32; 1000]> {
    let mut b = Vec::with_capacity(1000);
    b.extend(std::iter::repeat(v).take(1000));
    b.into_boxed_slice().try_into().unwrap()
}

    Que o compilador otimiza muito bem , para essencialmente a mesma montagem que o baz.

    Ainda mais curto seria

    vec![v; 1000].into_boxed_slice().try_into::<Box<[i32; 1000]>>().unwrap()

    qual é provavelmente a melhor versão.

    • 17

relate perguntas