Какой самый быстрый способ обновить переменную в условии?

void reset_if_true(void*& ptr, bool cond)
{
    if (cond)
        ptr = nullptr;
}

наивное решение, несомненно, будет самым быстрым в большинстве случаев. Хотя он имеет ветвь, которая может быть медленной на современных конвейерных процессорах, это только медленно, если ветвь неверно истолковано. Поскольку предсказатели ветвей очень хороши в настоящее время, если только значение cond крайне непредсказуемо, вполне вероятно, что простая условная ветвь является самым быстрым способом написания кода.

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

а это хороший совет в целом, иногда это слишком далеко. Если вы действительно заботитесь о скорости этого кода, вам нужно проверить и посмотреть, что компилятор на самом деле делает с ним. Проверьте код объекта что он генерирует, и убедитесь, что это разумно и что код функции становится встроенным.

такое исследование может быть весьма показательным. Например, рассмотрим x86-64, где ветви могут быть довольно дорогими в тех случаях, когда предсказание ветвей сорвано (что действительно единственный раз, когда это интересный вопрос, поэтому давайте предположим, что cond совершенно непредсказуемо). Почти все компиляторы собираются генерировать следующее для наивных реализация:

reset_if_true(void*&, bool):
    test   sil, sil              ; test 'cond'
    je     CondIsFalse
    mov    QWORD PTR [rdi], 0    ; set 'ptr' to nullptr, and fall through
  CondIsFalse:
    ret

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

reset_if_true(void*&, bool):
    xor    eax, eax              ; pre-zero the register RAX
    test   sil, sil              ; test 'cond'
    cmove  rax, QWORD PTR [rdi]  ; if 'cond' is false, set the register RAX to 'ptr'
    mov    QWORD PTR [rdi], rax  ; set 'ptr' to the value in the register RAX
    ret                          ;  (which is either 'ptr' or 0)

условные перемещения имеют относительно высокую задержку, поэтому они значительно медленнее, чем хорошо предсказанная ветвь, но они могут быть быстрее, чем совершенно непредсказуемая ветвь. Вы ожидаете, что компилятор будет знать это при таргетинге на x86 архитектура, но она не имеет (по крайней мере, в этом простом примере) никаких знаний о cond'ы предсказуемость. Он предполагает простой случай, что предсказание ветвей будет на вашей стороне, и генерирует код A вместо кода B.

если вы решили, что хотите побудить компилятор к созданию кода без ветвей из-за непредсказуемого состояния, вы можете попробовать следующее:

void reset_if_true_alt(void*& ptr, bool cond)
{
    ptr = (cond) ? nullptr : ptr;
}

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

void reset_if_true(void*& ptr, bool cond)
{
    void* p[] = { ptr, nullptr };
    ptr = p[cond];
}

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

reset_if_true_alt(void*&, bool):
    mov     rax, QWORD PTR [rdi]
    movzx   esi, sil
    mov     QWORD PTR [rsp-16], 0
    mov     QWORD PTR [rsp-24], rax
    mov     rax, QWORD PTR [rsp-24+rsi*8]
    mov     QWORD PTR [rdi], rax
    ret

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

если бы вы все еще отчаянно пытались устранить ветку на MSVC или GCC, вам пришлось бы сделать что-то более уродливое с участием переинтерпретация битов указателя и их скручивание. Что-то вроде:

void reset_if_true_alt(void*& ptr, bool cond)
{
    std::uintptr_t p = reinterpret_cast<std::uintptr_t&>(ptr);
    p &= -(!cond);
    ptr = reinterpret_cast<void*>(p);
}

это даст вам следующее:

reset_if_true_alt(void*&, bool):
    xor   eax, eax
    test  sil, sil
    sete  al
    neg   eax
    cdqe
    and   QWORD PTR [rdi], rax
    ret

опять же, здесь у нас есть больше инструкций, чем простая ветвь, но, по крайней мере, это инструкции с относительно низкой задержкой. Ориентир на реалистичные данные скажет вам, стоит ли компромисс. И дайте вам обоснование, которое вам нужно поместить в комментарий, если вы собираетесь на самом деле проверить код, как это.

как только я пошел вниз по кроличьей дыре, я смог заставить MSVC и GCC использовать условные инструкции по перемещению. По-видимому, они не делали эту оптимизацию, потому что мы имели дело с указателем:

void reset_if_true_alt(void*& ptr, bool cond)
{
    std::uintptr_t p = reinterpret_cast<std::uintptr_t&>(ptr);
    ptr = reinterpret_cast<void*>(cond ? 0 : p);
}

reset_if_true_alt(void*&, bool):
    mov    rax, QWORD PTR [rdi]
    xor    edx, edx
    test   sil, sil
    cmovne rax, rdx
    mov    QWORD PTR [rdi], rax
    ret

учитывая задержку CMOVNE и аналогичное количество инструкций, я не уверен, что это будет на самом деле быстрее, чем предыдущая версия. Тест, который вы запустили, сказал бы вам, если бы это было так.

аналогично, если мы немного скрутим условие, мы сохраним мы сами один доступ к памяти:

void reset_if_true_alt(void*& ptr, bool cond)
{
   std::uintptr_t c = (cond ? 0 : -1);
   reinterpret_cast<std::uintptr_t&>(ptr) &= c;
}

reset_if_true_alt(void*&, bool):
     xor    esi, 1
     movzx  esi, sil
     neg    rsi
     and    QWORD PTR [rdi], rsi
     ret

(это GCC. MSVC делает что-то немного другое, предпочитая свою характерную последовательность neg,sbb,neg и dec инструкции, но эти два морально эквивалентны. Clang преобразует его в тот же условный ход, который мы видели выше.) Это может быть лучший код, если нам нужно избегать ветвей, учитывая, что он генерирует разумный вывод на всех тестируемых компиляторах при сохранении (некоторые степень) читабельности в исходном коде.