Initialize Rc in-place and skip memcpy

Question

use std::rc::Rc;

pub fn test() -> Rc<[usize; 1024]> {
    Rc::new([42; 1024])
}

If I compile this code, I can see that Rust fills up an array with 42 on the stack, then allocates on the heap and invokes memcpy to copy over the values from the stack to the newly allocated area which is wasteful.

What's the easiest way to ask Rust to initialize the array directly on the heap without initializing it on the stack first to avoid the memcpy?

There is a very similar question at https://stackoverflow.com/questions/30242770/how-to-allocate-arrays-on-the-heap-in-rust-1-0 — tla, Mar 16 '23 at 19:21
Also somewhat similar to https://stackoverflow.com/questions/41710952 — Dhaval Purohit, Mar 16 '23 at 19:24

score 0 · Answer 1 · answered Mar 16 '23 at 20:41

As far as I know there is currently no way to allocate an Rc<[T; N]> directly without copying the data from the stack on stable. On nightly one can initialize the Rc in place by hand with something like this:

#![feature(new_uninit)]
use std::rc::Rc;
use std::mem::MaybeUninit;

pub fn test<const N: usize>() -> Rc<[usize; N]> {
    let mut r: Rc<[MaybeUninit<usize>]> = Rc::new_uninit_slice(N);
    for f in Rc::get_mut(&mut r).unwrap().iter_mut() {
        f.write(42);
    }
    // SAFETY:
    // * all elements are initialized
    // * the metadata can safely be dropped since it's encoded in the returned type
    // * layout of `MaybeUninit<T>` is the same as `T`
    unsafe { Rc::from_raw(Rc::into_raw(r).cast()) }
}

score 0 · Answer 2 · answered Mar 17 '23 at 06:12

No need to reach for nightly, this can be done on stable (note: this only does not copy with optimizations enabled):

use std::mem::MaybeUninit;
use std::rc::Rc;

pub fn test() -> Rc<[usize; 1024]> {
    let mut rc = Rc::new(MaybeUninit::<[usize; 1024]>::uninit());
    // SAFETY: `MaybeUninit<[T; N]>` and `[MaybeUninit<T>; N]` have the same layout,
    // and both can stay uninitialized.
    let data = unsafe {
        &mut *(Rc::get_mut(&mut rc).unwrap() as *mut MaybeUninit<[usize; 1024]>
            as *mut [MaybeUninit<usize>; 1024])
    };
    for item in data {
        item.write(42);
    }
    // SAFETY: `MaybeUninit<T>` and `T` have the same layout, and we initialized it above.
    unsafe { Rc::from_raw(Rc::into_raw(rc).cast::<[usize; 1024]>()) }
}

score 0 · Answer 3 · answered Mar 17 '23 at 09:13

Building on this answer, you can first create a Box<[usize; 1024]>, then convert that to Rc since Rc<T> implements From<Box<T>>:

use std::rc::Rc;

pub fn test() -> Rc<[usize; 1024]> {
    let boxed_slice = vec![42; 1024].into_boxed_slice();
    let ptr = Box::into_raw(boxed_slice) as *mut [usize; 1024];
    // SAFETY: the data of a `[T; N]` has the same layout as that of
    // a `[T]` and we allocated a slice of the right size.
    let b = unsafe { Box::from_raw(ptr) };
    b.into()
}

Godbolt

Initialize Rc in-place and skip memcpy

3 Answers3