Являются ли If Then быстрее, чем умножение и присваивание?

если мы говорим о C и мля не в вашей власти, то просто сделайте это:

if(blah) number += (1<<n);

На самом деле в C нет логического значения, и оно не должно быть, false равно нулю, а true не равно нулю, поэтому вы не можете предполагать, что не ноль равно 1, что вам нужно для вашего решения, и вы не можете предполагать, что какой-либо конкретный установлен бит в blah, например:

number += (blah&1)<<n;

Не обязательно будет работать, потому что 0x2 или 0x4 или что-либо ненулевое с очищенным нулевым битом считается истинным. Обычно вы обнаружите, что 0xFFF...FFFF (минус один или все единицы) используются как истинные, но вы не можете полагаться на типичный.

Теперь, если вы полностью контролируете значение в blah и держите его строго равным 0 для false и 1 для true, тогда вы можете сделать то, о чем спрашивали:

number += blah<<n;

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

Однако вернемся к общему случаю, взяв это общее решение:

unsigned int fun ( int blah, unsigned int n, unsigned int number )
{
    if(blah) number += (1<<n);
    return(number);
}

И компиляция для двух самых популярных/используемых платформ:

    testl   %edi, %edi
    movl    %edx, %eax
    je  .L2
    movl    $1, %edx
    movl    %esi, %ecx
    sall    %cl, %edx
    addl    %edx, %eax
.L2:

В приведенном выше примере используется условная ветвь.

Приведенный ниже использует условное выполнение, без ветвления, без сброса конвейера, является детерминированным.

  cmp   r0,#0
  movne r3,#1
  addne r2,r2,r3,asl r1
  mov   r0,r2
  bx    lr

Можно было бы сохранить инструкцию mov r0,r2, переставив аргументы в вызове функции, но это академично, вы бы не записали вызов функции на этом обычно.

РЕДАКТИРОВАТЬ:

Как было предложено:

unsigned int fun ( int blah, unsigned int n, unsigned int number )
{
    number += ((blah!=0)&1)<<n;
    return(number);
}

  subs  r0, r0, #0
  movne r0, #1
  add   r0, r2, r0, asl r1
  bx    lr

Конечно, дешевле, и код выглядит хорошо, но я бы не стал делать предположений, что результат blah!=0, который равен нулю или тому, что компилятор определил как true, всегда имеет установленный lsbit. Компилятору не обязательно устанавливать этот бит для генерации рабочего кода. Возможно, стандарты диктуют конкретное значение true. путем перестановки параметров функции число if(blah) +=... также приведет к трем одиночным тактовым инструкциям и не будет иметь предположений.

РЕДАКТИРОВАТЬ2:

Глядя на то, что я понимаю под стандартом C99:

Операторы == (равно) и != (не равно) аналогичны операторам отношения, за исключением их более низкого приоритета. Каждый из операторов возвращает 1, если указанное отношение истинно, и 0, если оно ложно.

Это объясняет, почему приведенное выше редактирование работает и почему вы получаете movne r0,#1, а не какое-то другое случайное число.

Плакат задавал вопрос относительно C, но также отметил, что ADA является текущим языком, с независимой от языка точки зрения вы не должны предполагать «функции», такие как функция C выше, и использовать if (бла) число = число + (1 ‹‹н). Но это было задано с помощью тега C, поэтому в целом (независимо от процессора) самый быстрый результат для C, я думаю, это number += (blah!=0)‹‹n; Так что комментарий Стивена Райта был правильным, и он должен получить за это признание.

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

На такой вопрос нет общего ответа, это во многом зависит от вашего компилятора и процессора. Современные процессоры имеют инструкции условного перемещения, так что все возможно.

Единственные способы узнать здесь - проверить созданный ассемблер (обычно -S в качестве опции компилятора) и измерить.

В Аде...

Первоначальная формулировка:

if Blah then
  Number := Number + (2 ** N);
end if;

Альтернативная общая формулировка, предполагающая, что Blah имеет тип Boolean, а Number и N — подходящие типы:

Number := Number + (Boolean'pos(Blah) * (2 ** N));

(Для N и Number определенных пользователем целочисленных типов или типов с плавающей запятой могут потребоваться подходящие определения и преобразования типов, ключевым моментом здесь является конструкция Boolean'pos(), которая, как гарантирует Ада, даст вам 0 или 1 для предопределенного логического типа.)

Что касается того, быстрее это или нет, я согласен с @Cthutu:

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

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

number += (blah ? 2^n : 0);

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

В C относительно blah*2^n: есть ли у вас основания полагать, что blah принимает значения 0 и 1? Язык только обещает, что 0 ‹-> FALSE и (все остальное) ‹-> TRUE. C позволяет вам умножать "логическое" временное значение на другое число, но результат не определен, за исключением случаев, когда результат=0 ‹=> логическое значение было ложным или число было равно нулю.

В Аде относительно blah*2^n: язык не определяет оператор умножения для типа Boolean. Таким образом, blah не может быть логическим значением и не может быть умножено.

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

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

У разных процессоров разные потребности, и они могут быть безумно сложными. Например, в этом случае то, что быстрее, во многом зависит от настройки конвейера вашего ЦП, того, что находится в кеше в данный момент, и как работает его модуль прогнозирования ветвлений. Часть работы вашего компилятора состоит в том, чтобы быть экспертом в этих вещах, и он справится с этой задачей лучше, чем все, кроме самых лучших программистов на ассемблере. Конечно лучше, чем вы (или я).

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

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

nth степень 2 может быть вычислена с помощью оператора << как 1 << n при условии, что n меньше количества битов значения в int.

Если blah является логическим значением, а именно int со значением 0 или 1, фрагмент кода можно записать так:

number += blah << n;

Если blah является любым скалярным типом, значение истинности которого можно проверить как if (blah), выражение будет несколько более сложным:

number += !!blah << n;

что эквивалентно number += (blah != 0) << n;

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

В любом случае вы не сможете избежать ответвления (внутри), так что даже не пытайтесь!

In

number = number + blah*2^n

полное выражение всегда должно быть оценено, если только компилятор не достаточно умен, чтобы остановиться, когда blah равен 0. Если это так, вы получите ветвь, если blah равно 0. Если это не так, вы всегда получите дорогое умножение. В случае, если blah ложно, вы также получите ненужное добавление и присвоение.

В операторе «if then» оператор будет выполнять сложение и присваивание только в том случае, если blah истинно.

Короче говоря, ответ на ваш вопрос в данном случае «да».

Этот код показывает, что они работают одинаково, но умножение обычно немного быстрее.

@Test
public void manual_time_trial()
{
    Date beforeIfElse = new Date();
    if_else_test();
    Date afterIfElse = new Date();
    long ifElseDifference = afterIfElse.getTime() - beforeIfElse.getTime();
    System.out.println("If-Else Diff: " + ifElseDifference);

    Date beforeMultiplication = new Date();
    multiplication_test();
    Date afterMultiplication = new Date();
    long multiplicationDifference = afterMultiplication.getTime() - beforeMultiplication.getTime();
    System.out.println("Mult Diff   : " + multiplicationDifference);

}

private static long loopFor = 100000000000L;
private static short x = 200;
private static short y = 195;
private static int z;

private static void if_else_test()
{
    short diff = (short) (y - x);
    for(long i = 0; i < loopFor; i++)
    {
        if (diff < 0)
        {
            z = -diff;
        }
        else
        {
            z = diff;
        }
    }
}

private static void multiplication_test()
{
    for(long i = 0; i < loopFor; i++)
    {
        short diff = (short) (y - x);
        z = diff * diff;
    }
}