Вопрос оптимизации: как лучше возвращать структуры из функции, что бы не было лишних выделений и копирований областей памяти? Когда пишешь код, то кажется, что если экземпляр структуры размещается на стеке, то он должен копироваться в стек вызывающей функции и оптимальнее возвращать указатель. Но по анализу ассемблерного кода, сделанного компилятором, получается, что все не совсем так.

Простая программа с 3 вариантами (возврат значения, указателя и Option):

struct MyStruct {
    value1: i64,
    value2: i64,
    value3: i64,
}

fn create_struct_opt() -> Option<MyStruct> {
    let my_struct = MyStruct {
        value1: 1,
        value2: 2,
        value3: 3,
    };
    return Some(my_struct);
}

fn create_struct() -> MyStruct {
    let my_struct = MyStruct {
        value1: 1,
        value2: 2,
        value3: 3,
    };
    return my_struct;
}

fn create_struct_box() -> Box<MyStruct> {
    let my_struct = Box::new(MyStruct {
        value1: 1,
        value2: 2,
        value3: 3,
    });
    return my_struct;
}

fn main() {
    let my_struct = create_struct();
    let my_struct_box = create_struct_box();
    let my_struct_ref = create_struct_opt();

    println!(
        "Значение my_struct: {} {} {}",
        my_struct_ref.unwrap().value1,
        my_struct.value1,
        my_struct_box.value1
    );
}

Компилирую в Windows используя toolchain stable-x86_64-pc-windows-msvc. Для других компиляторов код может быть другой.

Собираем debug сборку и смотрим дизассемблером вызов интересующих нас функций в функции main:

lea     rcx, [rbp+120h+result] ; result
call    rustplay__create_struct

call    rustplay__create_struct_box
mov     [rbp+120h+var_130], rax

lea     rcx, [rbp+120h+var_128]
call    rustplay__create_struct_opt

Псевдокод:

rustplay::create_struct((rustplay::MyStruct *)&v0[11]);
struct_box = rustplay::create_struct_box();
rustplay::create_struct_opt(&v8);

Тут уже видно, что в функции передаются адреса на стеке вместо возврата адресов из функций.

В первом случае функция main выделяет память на стеке размером со структуру и передает адрес в функцию create_struct. Эта функция просто напрямую пишет значения по переданному адресу:

; rustplay::MyStruct *__fastcall rustplay::create_struct(rustplay::MyStruct *result)
rustplay__create_struct proc near
mov     rax, rcx
mov     qword ptr [rcx], 1
mov     qword ptr [rcx+8], 2
mov     qword ptr [rcx+10h], 3
retn
rustplay__create_struct endp

С Option действий побольше. Выделяем место в стеке размером со структуру, записываем туда наши значения, а затем копируем значения из «локального» стека функции по переданному адресу. (зачем? в релизной сборке нет этих лишних копирований):

; enum2<core::option::Option<rustplay::MyStruct> > *__fastcall rustplay::create_struct_opt(enum2<core::option::Option<rustplay::MyStruct> > *result)
rustplay__create_struct_opt proc near

var_18= qword ptr -18h
var_10= qword ptr -10h
var_8= qword ptr -8

sub     rsp, 18h
mov     rax, rcx
mov     [rsp+18h+var_18], 1
mov     [rsp+18h+var_10], 2
mov     [rsp+18h+var_8], 3
mov     rdx, [rsp+18h+var_18]
mov     [rcx+8], rdx
mov     rdx, [rsp+18h+var_10]
mov     [rcx+10h], rdx
mov     rdx, [rsp+18h+var_8]
mov     [rcx+18h], rdx
mov     qword ptr [rcx], 1
add     rsp, 18h
retn
rustplay__create_struct_opt endp

Ну и третий вариант с указателем на кучу (Box), самый медленный.

push    rbp
; инициализируем локальный стек
sub     rsp, 50h
lea     rbp, [rsp+50h]
mov     [rbp+var_8], 0FFFFFFFFFFFFFFFEh
; записываем значения структуры в локальный стек функции
mov     [rbp+var_28], 1
mov     [rbp+var_20], 2
mov     [rbp+var_18], 3
; выделяем память в куче
loc_14000194A:          ; unsigned __int64
;   try {
mov     ecx, 18h
mov     edx, 8          ; unsigned __int64
call    _ZN5alloc5alloc15exchange_malloc17hb41a2de4aa8d1871E ; alloc::alloc::exchange_malloc::hb41a2de4aa8d1871
;   } // starts at 14000194A

loc_140001959:
mov     [rbp+var_30], rax
loc_14000195F:
; копируем значения со стека в кучу
mov     rax, [rbp+var_30]
mov     rcx, [rbp+var_28]
mov     [rax], rcx
mov     rcx, [rbp+var_20]
mov     [rax+8], rcx
mov     rcx, [rbp+var_18]
mov     [rax+10h], rcx
mov     [rbp+var_10], rax
add     rsp, 50h
pop     rbp
; в rax адрес в куче
retn

;и затем еще и очистка
loc_140001990:
;   cleanup() // owned by 14000194A
mov     [rsp-8+arg_8], rdx
push    rbp
sub     rsp, 20h
lea     rbp, [rdx+50h]
add     rsp, 20h
pop     rbp
retn

В release сборке компилятор вообще делает все inline. При этом возврат указателя остается самым медленным, т.к. идет выделение куска памяти в куче.

push    rbp
sub     rsp, 0C0h
lea     rbp, [rsp+80h]
mov     [rbp+40h+var_8], 0FFFFFFFFFFFFFFFEh

; возврат структуры напрямую
mov     [rbp+40h+var_28], 1
mov     [rbp+40h+var_20], 2
mov     [rbp+40h+var_18], 3

; Box
movzx   eax, cs:__rust_no_alloc_shim_is_unstable
mov     ecx, 18h
mov     edx, 8
call    __rust_alloc
test    rax, rax
mov     qword ptr [rax], 1
mov     qword ptr [rax+8], 2
mov     qword ptr [rax+10h], 3

; Option
mov     [rbp+40h+var_40], 1
mov     [rbp+40h+var_38], 2
mov     [rbp+40h+var_30], 3

Выводы

Для простых структур оптимальнее делать возврат «по значению», даже если компилятор не за инлайнит функцию.

Не нужно делать преждевременную оптимизацию за компилятор, он сам сделает оптимальный вариант. На этапе написания кода сложно угадать правильный способ, нужно смотреть дизассемблированный код релизной сборки и только после этого делать рефакторинг.

Выбор варианта возврата значения из функций в Rust