Тернарный оператор в два раза медленнее, чем блок if-else?

EDIT: все изменения... увидеть ниже.

Я не могу воспроизвести ваши результаты на x64 CLR, но я can на x86. На x64 я вижу маленький разница (менее 10%) между условным оператором и if/else, но она намного меньше, чем вы видите.

Я сделал следующие изменения:

• запуск в консольном приложении
• построить с /o+ /debug-, и выбежал на улицу отладчик
• запустите оба фрагмента кода один раз, чтобы JIT их, а затем много раз для большей точности
• использовать Stopwatch

результаты /platform:x64 (без строк" игнорировать"):

if/else with 1 iterations: 17ms
conditional with 1 iterations: 19ms
if/else with 1000 iterations: 17875ms
conditional with 1000 iterations: 19089ms

результаты /platform:x86 (без строк" игнорировать"):

if/else with 1 iterations: 18ms
conditional with 1 iterations: 49ms
if/else with 1000 iterations: 17901ms
conditional with 1000 iterations: 47710ms

сведения о моей системе:

• 64-разрядных процессоров i7-2720QM на CPU @2.20 ГГц
• 64-разрядная ОС Windows 8
• .NET 4.5

так не похоже раньше, я думаю, вы are видя реальную разницу-и все это связано с x86 JIT. Я бы не хотел сказать точно что вызывает разницу - я могу обновить сообщение позже с более подробной информацией, если я могу потрудиться войти в cordbg:)

интересно, что без сортировки массива сначала я получаю тесты, которые занимают около 4.5 x столько же времени, по крайней мере, на x64. Думаю, это связано с Бранчем. предсказание.

код:

using System;
using System.Diagnostics;

class Test
{
    static void Main()
    {
        Random r = new Random(0);
        int[] array = new int[20000000];
        for(int i = 0; i < array.Length; i++)
        {
            array[i] = r.Next(int.MinValue, int.MaxValue);
        }
        Array.Sort(array);
        // JIT everything...
        RunIfElse(array, 1);
        RunConditional(array, 1);
        // Now really time it
        RunIfElse(array, 1000);
        RunConditional(array, 1000);
    }

    static void RunIfElse(int[] array, int iterations)
    {        
        long value = 0;
        Stopwatch sw = Stopwatch.StartNew();

        for (int x = 0; x < iterations; x++)
        {
            foreach (int i in array)
            {
                if (i > 0)
                {
                    value += 2;
                }
                else
                {
                    value += 3;
                }
            }
        }
        sw.Stop();
        Console.WriteLine("if/else with {0} iterations: {1}ms",
                          iterations,
                          sw.ElapsedMilliseconds);
        // Just to avoid optimizing everything away
        Console.WriteLine("Value (ignore): {0}", value);
    }

    static void RunConditional(int[] array, int iterations)
    {        
        long value = 0;
        Stopwatch sw = Stopwatch.StartNew();

        for (int x = 0; x < iterations; x++)
        {
            foreach (int i in array)
            {
                value += i > 0 ? 2 : 3;
            }
        }
        sw.Stop();
        Console.WriteLine("conditional with {0} iterations: {1}ms",
                          iterations,
                          sw.ElapsedMilliseconds);
        // Just to avoid optimizing everything away
        Console.WriteLine("Value (ignore): {0}", value);
    }
}

разница действительно не имеет большого отношения к if / else vs ternary.

глядя на jitted disassemblies (я не буду переупаковывать здесь, пожалуйста, см. ответ @280Z28), оказывается, что вы сравнение яблок и апельсинов. В одном случае вы создаете два разных += операции с постоянными значениями и которые вы выбираете, зависят от условия, а в другом случае вы создаете += здесь значение, чтобы добавить зависит от состояние.

если вы хотите действительно сравнить if / else vs ternary, это было бы более справедливое сравнение (теперь оба будут одинаково "медленными", или мы могли бы даже сказать, что ternary немного быстрее):

int diff;
if (i > 0) 
    diff = 2;
else 
    diff = 3;
value += diff;

и

value += i > 0 ? 2 : 3;

теперь разборка для if/else становится, как показано ниже. Обратите внимание, что это немного хуже, чем троичный случай, так как он перестал использовать регистры для переменной цикла (i), а также.

                if (i > 0)
0000009d  cmp         dword ptr [ebp-20h],0 
000000a1  jle         000000AD 
                {
                    diff = 2;
000000a3  mov         dword ptr [ebp-24h],2 
000000aa  nop 
000000ab  jmp         000000B4 
                }
                else
                {
                    diff = 3;
000000ad  mov         dword ptr [ebp-24h],3 
                }
                value += diff;
000000b4  mov         eax,dword ptr [ebp-18h] 
000000b7  mov         edx,dword ptr [ebp-14h] 
000000ba  mov         ecx,dword ptr [ebp-24h] 
000000bd  mov         ebx,ecx 
000000bf  sar         ebx,1Fh 
000000c2  add         eax,ecx 
000000c4  adc         edx,ebx 
000000c6  mov         dword ptr [ebp-18h],eax 
000000c9  mov         dword ptr [ebp-14h],edx 
000000cc  inc         dword ptr [ebp-28h] 

Edit:

добавлен пример, который можно сделать с помощью оператора if-else, но не условного оператора.

перед ответом, пожалуйста, посмотрите [что быстрее?] в блоге Мистера Липперта. И я думаю ... --17-->ответ г-на Эрсенмеса самый правильный здесь.

Я пытаюсь упомянуть то, что мы должны иметь в виду, с языка программирования высокого уровня.

первый off, я никогда не слышал, что условный оператор должен быть быстрее или одинаково работать с оператором if-else в C♯.

причина проста: что делать, если нет операции с оператором if-else:

if (i > 0)
{
    value += 2;
}
else
{
}

требование условного оператора должно быть значение С любой стороны, и в C♯ он также требует, чтобы обе стороны : имеет тот же тип. Это просто делает его отличным от if-else заявление. Таким образом, ваш вопрос становится вопросом о том, как генерируется инструкция машинного кода, чтобы разница в производительности.

с условным оператором семантически это:

что выражение вычисляется, есть ценность.

но с утверждением if-else:

если выражение оценивается как true, сделайте что-нибудь; если нет, сделайте другое.

A значение не обязательно связано с утверждением if-else. ваше предположение возможно только при оптимизации.

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

var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };

if(i>0)
    array1[0]=4;
else
    array2[0]=4;

код выше компилируется, однако замените оператор if-else условным оператором просто не будет компилироваться:

var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };
(i>0?array1[0]:array2[0])=4; // incorrect usage 

условный оператор и операторы if-else концептуальны одинаково, когда вы делаете то же самое, возможно, еще быстрее с условным оператором в C, так как C ближе к сборке платформы.

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

public static class TestClass {
    public static void TestConditionalOperator(int i) {
        long value=0;
        value+=i>0?2:3;
    }

    public static void TestIfElse(int i) {
        long value=0;

        if(i>0) {
            value+=2;
        }
        else {
            value+=3;
        }
    }

    public static void TestMethod() {
        TestConditionalOperator(0);
        TestIfElse(0);
    }
}

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

(Нажмите, чтобы увидеть полноразмерное изображение.)

в обеих версиях кода IL условного оператора выглядит короче, чем оператор if-else, и по-прежнему существует сомнение в окончательно сгенерированном машинном коде. Ниже приведены инструкции обоих методов, и первое изображение не оптимизировано, последнее является оптимизированным:

• не оптимизированные инструкции: (Нажмите, чтобы увидеть полноразмерное изображение.)

• оптимизированные инструкции: (Нажмите, чтобы увидеть полноразмерное изображение.)

в последнем случае желтый блок является кодом, выполняемым только если i<=0, и синий блок-это когда i>0. В любой из версий инструкций оператор if-else короче.

обратите внимание, что для разных инструкций [индекс потребительских цен] не обязательно то же самое. Логически, для идентичной инструкции, больше инструкций стоят более длинный цикл. Но если учитывать время выборки инструкций и канал / кэш, то реальное общее время выполнения зависит от процессора. Процессор также может предсказывать ветви.

современные процессоры имеют еще больше ядер, с этим все может быть сложнее. Если бы ты был ... Пользователь процессора Intel, вы можете посмотреть [справочное руководство по оптимизации архитектур Intel® 64 и IA-32].

Я не знаю, была ли реализована аппаратная среда CLR, но если да, вы, вероятно, быстрее с условным оператором, потому что IL явно меньше.

_{Примечание: весь машинный код x86.}

Я сделал то, что сделал Джон Скит, и пробежал 1 итерацию и 1,000 итераций и получил другой результат как от OP, так и от Джона. У меня троица немного быстрее. Ниже приведен точный код:

static void runIfElse(int[] array, int iterations)
    {
        long value = 0;
        Stopwatch ifElse = new Stopwatch();
        ifElse.Start();
        for (int c = 0; c < iterations; c++)
        {
            foreach (int i in array)
            {
                if (i > 0)
                {
                    value += 2;
                }
                else
                {
                    value += 3;
                }
            }
        }
        ifElse.Stop();
        Console.WriteLine(String.Format("Elapsed time for If-Else: {0}", ifElse.Elapsed));
    }

    static void runTernary(int[] array, int iterations)
    {
        long value = 0;
        Stopwatch ternary = new Stopwatch();
        ternary.Start();
        for (int c = 0; c < iterations; c++)
        {
            foreach (int i in array)
            {
                value += i > 0 ? 2 : 3;
            }
        }
        ternary.Stop();


        Console.WriteLine(String.Format("Elapsed time for Ternary: {0}", ternary.Elapsed));
    }

    static void Main(string[] args)
    {
        Random r = new Random();
        int[] array = new int[20000000];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = r.Next(int.MinValue, int.MaxValue);
        }
        Array.Sort(array);

        long value = 0;

        runIfElse(array, 1);
        runTernary(array, 1);
        runIfElse(array, 1000);
        runTernary(array, 1000);

        Console.ReadLine();
    }

вывод из моей программы:

прошедшее время для If-Else: 00:00: 00.0140543

прошедшее время для Троицы: 00:00: 00.0136723

прошедшее время для If-Else: 00:00: 14.0167870

прошедшее время Троица: 00: 00: 13.9418520

еще один запуск в миллисекундах:

прошедшее время для If-Else: 20

прошедшее время для Троицы: 19

прошедшее время для If-Else: 13854

прошедшее время для Троицы: 13610

это работает в 64-битной XP, и я бежал без отладки.

Edit-работает в x86:

существует большая разница в использовании x86. Этот был выполнен без отладки на той же 64-битной машине xp, что и раньше, но построен для процессоров x86. Это больше похоже на OP.

прошедшее время для If-Else: 18

прошедшее время для Троицы: 35

прошедшее время для If-Else: 20512

прошедшее время для Троицы: 32673

сгенерированный код ассемблера расскажет историю:

a = (b > c) ? 1 : 0;

выдает:

mov  edx, DWORD PTR a[rip]
mov  eax, DWORD PTR b[rip]
cmp  edx, eax
setg al

при этом:

if (a > b) printf("a");
else printf("b");

выдает:

mov edx, DWORD PTR a[rip]
mov eax, DWORD PTR b[rip]
cmp edx, eax
jle .L4
    ;printf a
jmp .L5
.L4:
    ;printf b
.L5:

Итак, троица can быть короче и быстрее просто из-за использования меньшего количества инструкций и никаких скачков если вы ищете true / false. Если вы используете значения, отличные от 1 и 0, вы получите тот же код, что и if / else, для пример:

a = (b > c) ? 2 : 3;

выдает:

mov edx, DWORD PTR b[rip]
mov eax, DWORD PTR c[rip]
cmp edx, eax
jle .L6
    mov eax, 2
jmp .L7
.L6:
    mov eax, 3
.L7:

который такой же, как if/else.

Run без отладки ctrl+F5 кажется, что отладчик значительно замедляет как ifs, так и ternary, но кажется, что он замедляет тернарный оператор намного больше.

когда я запускаю следующий код, вот мои результаты. Я думаю, что небольшая миллисекундная разница вызвана компилятором, оптимизирующим max=max и удаляющим его, но, вероятно, не делает эту оптимизацию для тернарного оператора. Если бы кто-то мог проверить сборку и подтвердить это, это было бы потрясающий.

--Run #1--
Type   | Milliseconds
Ternary 706
If     704
%: .9972
--Run #2--
Type   | Milliseconds
Ternary 707
If     704
%: .9958
--Run #3--
Type   | Milliseconds
Ternary 706
If     704
%: .9972

код

  for (int t = 1; t != 10; t++)
        {
            var s = new System.Diagnostics.Stopwatch();
            var r = new Random(123456789);   //r
            int[] randomSet = new int[1000]; //a
            for (int i = 0; i < 1000; i++)   //n
                randomSet[i] = r.Next();     //dom
            long _ternary = 0; //store
            long _if = 0;      //time
            int max = 0; //result
            s.Start();
            for (int q = 0; q < 1000000; q++)
            {
                for (int i = 0; i < 1000; i++)
                    max = max > randomSet[i] ? max : randomSet[i];
            }
            s.Stop();
            _ternary = s.ElapsedMilliseconds;
            max = 0;
            s = new System.Diagnostics.Stopwatch();
            s.Start();
            for (int q = 0; q < 1000000; q++)
            {
                for (int i = 0; i < 1000; i++)
                    if (max > randomSet[i])
                        max = max; // I think the compiler may remove this but not for the ternary causing the speed difference.
                    else
                        max = randomSet[i];
            }

            s.Stop();
            _if = s.ElapsedMilliseconds;
            Console.WriteLine("--Run #" + t+"--");
            Console.WriteLine("Type   | Milliseconds\nTernary {0}\nIf     {1}\n%: {2}", _ternary, _if,((decimal)_if/(decimal)_ternary).ToString("#.####"));
        }

глядя на сгенерированный IL, в этом меньше операций, чем в операторе if/else (копирование и вставка кода @JonSkeet). Однако это не означает, что это должен быть более быстрый процесс!

чтобы суммировать различия в IL, метод if / else переводится почти так же, как код C# читает (выполняя добавление в ветви), тогда как условный код загружает 2 или 3 в стек (в зависимости от значения), а затем добавляет его к значению вне условного.

другое отличие-используемая инструкция ветвления. Метод if/else использует brtrue (ветвь, если true) для перехода через первое условие и безусловную ветвь для перехода из первого оператора if. Условный код использует BGT (ветвь, если больше) вместо brtrue, что может быть более медленным сравнением.

также (только что прочитав о предсказании ветви) может быть штраф за производительность для ветви будучи меньше. Условная ветвь имеет только 1 инструкцию внутри ветви, но if/else имеет 7. Это также объясняет, почему существует разница между использованием long и int, потому что изменение на int уменьшает количество инструкций в ветвях if/else на 1 (делая чтение вперед меньше)

в следующем коде if / else кажется примерно в 1,4 раза быстрее, чем тернарный оператор. Однако я обнаружил, что введение временной переменной уменьшает время выполнения троичного оператора примерно в 1,4 раза:

If / Else: 98 ms

тройной: 141 МС

Тройной с temp var: 100 мс

using System;
using System.Diagnostics;

namespace ConsoleApplicationTestIfElseVsTernaryOperator
{
    class Program
    {
        static void Main(string[] args)
        {
            Random r = new Random(0);
            int[] array = new int[20000000];
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = r.Next(int.MinValue, int.MaxValue);
            }
            Array.Sort(array);
            long value;
            Stopwatch stopwatch = new Stopwatch();

            value = 0;
            stopwatch.Restart();
            foreach (int i in array)
            {
                if (i > 0)
                {
                    value += 2;
                }
                else
                {
                    value += 3;
                }
                // 98 ms
            }
            stopwatch.Stop();
            Console.WriteLine("If/Else: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");

            value = 0;
            stopwatch.Restart();
            foreach (int i in array)
            {
                value += (i > 0) ? 2 : 3; 
                // 141 ms
            }

            stopwatch.Stop();
            Console.WriteLine("Ternary: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");

            value = 0;
            int tempVar = 0;
            stopwatch.Restart();
            foreach (int i in array)
            {
                tempVar = (i > 0) ? 2 : 3;
                value += tempVar; 
                // 100ms
            }
            stopwatch.Stop();
            Console.WriteLine("Ternary with temp var: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");

            Console.ReadKey(true);
        }
    }
}