如何在Rust函数中返回数组且避免复制（no_std嵌入式场景）

我有一串生成数组并沿调用栈返回的函数，大致函数签名如下：

fn solutions(...) -> [[u64; M]; N] {                         /* 遍历大量问题集 */ }
fn generate_solutions(...) -> impl Iterator<Item=[u64; M]> { /* 针对不同问题集调用find_solution */ }
fn find_solution(...) -> [u64; M] {                          /* 尝试不同候选值调用validate_candidate以找到解 */ }
fn validate_candidate(...) -> Option<[u64; M]> { 
    let mut table = [0; M];
    // 执行计算密集型任务
    if works { Some(table) } else { None }
 }

我原本认为Rust会优化掉数组在调用栈中的复制操作，但实际情况并非如此。当我将[u64;M]替换为Vec<u64>后，程序速度提升了20倍，这说明数组确实在反复被复制。

由于处于嵌入式环境，需使用no_std，因此无法改用Vec。请问如何让Rust优化掉这些数组复制操作？

1. 改用可变引用传递，直接写入预分配数组 #

避免返回数组，让上层函数提前分配好栈上数组，通过可变引用传递给下层函数直接修改，彻底消除复制：

fn solutions(...) -> [[u64; M]; N] {
    let mut result = [[0; M]; N];
    for (idx, problem) in problem_sets.iter().enumerate() {
        find_solution_into(problem, &mut result[idx]);
    }
    result
}

fn find_solution_into(problem: ..., output: &mut [u64; M]) {
    // 生成候选值并验证，直接写入output
    loop {
        if validate_candidate_into(problem, output) {
            break;
        }
        // 生成下一个候选值
    }
}

fn validate_candidate_into(problem: ..., output: &mut [u64; M]) -> bool {
    // 直接修改output内的元素，无需初始化
    // 执行计算密集型任务
    // 验证通过返回true，否则false
}

2. 用MaybeUninit跳过默认初始化开销 #

如果M较大，[0; M]的默认初始化本身会占用时间，用MaybeUninit可以延迟初始化，只在验证通过后确认内存安全：

use core::mem::MaybeUninit;

fn validate_candidate(...) -> Option<[u64; M]> {
    let mut table = MaybeUninit::<[u64; M]>::uninit();
    let table_slice = unsafe { &mut *table.as_mut_ptr() };
    // 直接向table_slice写入计算结果，无需先设为0
    // 执行计算密集型任务
    if works {
        unsafe { Some(table.assume_init()) }
    } else {
        None
    }
}

注意：必须确保数组所有元素都被正确初始化后再调用assume_init()，否则会触发未定义行为。

3. 强制内联与简化控制流，触发返回值优化 #

Rust的返回值优化（RVO）可能因复杂控制流失效，用#[inline(always)]标记关键函数，同时简化返回路径，帮助编译器直接将数组构造到上层栈空间：

#[inline(always)]
fn validate_candidate(...) -> Option<[u64; M]> {
    let mut table = [0; M];
    // 单一逻辑路径完成计算
    // 执行计算密集型任务
    works.then_some(table)
}

#[inline(always)]
fn find_solution(...) -> [u64; M] {
    loop {
        if let Some(sol) = validate_candidate(...) {
            return sol;
        }
        // 生成下一个候选值
    }
}

内联后编译器更容易识别出可以省略数组复制，直接在调用方的栈帧上构造结果。

4. 数组包装类型辅助优化 #

如果必须返回数组，可定义一个包装类型并实现Copy，帮助编译器识别类型的可传递性，减少复制开销：

#[derive(Copy, Clone)]
struct Solution([u64; M]);

fn validate_candidate(...) -> Option<Solution> {
    let mut table = [0; M];
    // 执行计算密集型任务
    works.then_some(Solution(table))
}

这种方式优化效果弱于前几种，但能在无法修改传递方式时提供一定帮助。

内容的提问来源于stack exchange，提问作者user1002430