NEW BOT Телеграм, страница

В СМЫСЛЕ УЖЕ НОЯ то есть ДЕКАБРЬ

👍5

639 views23:10

#prog #cpp #моё В C++ есть такая вещь, как strict aliasing. Если коротко, то это предположение компилятора о том, что доступы по указателям (и ссылкам) существенно разных типов не пересекаются между собой. Подробнее про это можно прочитать, например, тут…

В комментариях сказали, что не хватает демонстрации того, что Rust лучше. Что ж, исправляю.

Вот как выглядит идиоматичная функция с аналогичным функционалом (с поправкой на то, что, как и в коде на C++ в постах выше, идиоматично было бы принимать value вообще по значению):

fn increment(arr: &mut [i32], value: &i32) {
    for x in arr {
        *x += *value;
    }
}

Rust 1.65.0 с флагом -C opt-level=1 выдаёт следующий код:

        test    rsi, rsi
        sete    al
        je      .LBB3_4
        lea     rsi, [rdi + 4*rsi]
        mov     ecx, dword ptr [rdx]
.LBB3_2:
        not     al
        movzx   eax, al
        add     dword ptr [rdi], ecx
        and     eax, 1
        lea     rdi, [rdi + 4*rax]
        cmp     rdi, rsi
        sete    al
        je      .LBB3_4
        test    rdi, rdi
        jne     .LBB3_2
.LBB3_4:
        ret

Вывод несколько шумный (эти манипуляции с al и eax явно излишни), но самое главное: доступ к содержимому value осуществляется через

        mov     ecx, dword ptr [rdx]

— инструкцию вне цикла! И это вполне ожидаемо: в Rust есть более тонкие способы отслеживать aliasing, чем просто через типы. Тот факт, что набор чисел передаётся через ссылку &mut (и, в отличие от span в C++, это действительно именно ссылка, а не value-тип с ссылочной семантикой), уже позволяет считать все остальные доступы к памяти, как непересекающиеся. поскольку в Rust &mut — это уникальная ссылка. При кодогенерации компилятор может рассчитывать на этот факт, а при создании ссылок проверяет, что ссылка действительно уникальна.

(также можно было бы переписать эту функцию через доступы по индексам вместо прямого for x in arr, но, хотя тело цикла в этом случае чище, компилятор частично раскручивает цикл, что генерировало несколько больше ассемблерного кода, чем имеет смысл помещать в пост)

Возможно ли повторить на Rust семантику из C++? Да... С сигнатурой вида

fn increment(arr: *mut [UnsafeCell<MaybeUninit<i32>>], value: *mut MaybeUninit<i32>)

...Ладно, ладно, если что-то не столь страшное, а всё-таки более идиоматичное, но с возможностью пересечения доступа:

fn increment(arr: &[Cell<i32>], value: &Cell<i32>) {
    for x in arr {
        x.set(x.get() + value.get());
    }
}

И действительно, если скомпилировать этот код с теми же флагами, то получится вот это:

        test    rsi, rsi
        sete    cl
        je      .LBB4_4
        lea     rax, [rdi + 4*rsi]
.LBB4_2:
        not     cl
        movzx   ecx, cl
        mov     esi, dword ptr [rdx]
        add     dword ptr [rdi], esi
        and     ecx, 1
        lea     rdi, [rdi + 4*rcx]
        cmp     rdi, rax
        sete    cl
        je      .LBB4_4
        test    rdi, rdi
        jne     .LBB4_2
.LBB4_4:
        ret

Снова кучка лишних операций, но главное — это вот эти две операции в теле цикла:

        mov     esi, dword ptr [rdx]
        add     dword ptr [rdi], esi

То есть значение читается по ссылке каждый раз, как мы и (не) хотели.

👍12🔥1

753 views01:35