Накладные расходы try/finally на С#?

Мы видели много вопросов о том, когда и почему использовать try/catch и try/catch/finally. И я знаю, что определенно используется прецедент для try/finally (тем более, что это так, как выполняется оператор using).

Мы также видели вопросы о накладных расходах на try/catch и исключения.

Вопрос, который я связал, однако, не говорит о накладных расходах, когда JUST try-finally.

Предполагая, что нет исключений из всего, что происходит в блоке try, что накладные расходы на выполнение операторов finally выполняются при выходе из блока try (иногда, возвращаясь из функции)?

Опять же, я спрашиваю ТОЛЬКО о try/finally, no catch, не бросая исключений.

Спасибо!

РЕДАКТИРОВАТЬ: Хорошо, я попытаюсь немного улучшить свой вариант использования.

Что я должен использовать, DoWithTryFinally или DoWithoutTryFinally?

public bool DoWithTryFinally()
{
  this.IsBusy = true;

  try
  {
    if (DoLongCheckThatWillNotThrowException())
    {
      this.DebugLogSuccess();
      return true;
    }
    else
    {
      this.ErrorLogFailure();
      return false;
    }
  }
  finally
  {
    this.IsBusy = false;
  }
}

public bool DoWithoutTryFinally()
{
  this.IsBusy = true;

  if (DoLongCheckThatWillNotThrowException())
  {
    this.DebugLogSuccess();

    this.IsBusy = false;
    return true;
  }
  else
  {
    this.ErrorLogFailure();

    this.IsBusy = false;
    return false;
  }
}

Этот случай слишком упрощен, потому что есть только две точки возврата, но представьте, если бы было четыре... или десять... или сто.

В какой-то момент я хотел бы использовать try/finally по следующим причинам:

  • Сохраняйте принципы DRY (особенно по мере увеличения количества точек выхода)
  • Если окажется, что я ошибаюсь в том, что моя внутренняя функция не выбрасывает исключение, то я хочу убедиться, что для параметра this.Working установлено значение false.

Итак, гипотетически, учитывая характеристики производительности, ремонтопригодность и СУХИЕ принципы,, для какого количества точек выхода (особенно если я может предположить, что все внутренние исключения пойманы) do Я хочу взять на себя любое ограничение производительности, связанное с try/finally?

EDIT # 2: Я изменил имя this.Working на this.IsBusy. Извините, забыл упомянуть, что это многопоточность (хотя только один поток действительно вызовет метод); другие потоки будут опроса, чтобы узнать, выполняет ли объект свою работу. Возвращаемое значение - это просто успех или неудача, если работа пошла так, как ожидалось.

Ответ 1

Почему бы не посмотреть, что вы на самом деле получаете?

Вот простой фрагмент кода в С#:

    static void Main(string[] args)
    {
        int i = 0;
        try
        {
            i = 1;
            Console.WriteLine(i);
            return;
        }
        finally
        {
            Console.WriteLine("finally.");
        }
    }

И вот результат IL в сборке отладки:

.method private hidebysig static void Main(string[] args) cil managed
{
    .entrypoint
    .maxstack 1
    .locals init ([0] int32 i)
    L_0000: nop 
    L_0001: ldc.i4.0 
    L_0002: stloc.0 
    L_0003: nop 
    L_0004: ldc.i4.1 
    L_0005: stloc.0 
    L_0006: ldloc.0 // here the WriteLine of i 
    L_0007: call void [mscorlib]System.Console::WriteLine(int32)
    L_000c: nop 
    L_000d: leave.s L_001d // this is the flavor of branch that triggers finally
    L_000f: nop 
    L_0010: ldstr "finally."
    L_0015: call void [mscorlib]System.Console::WriteLine(string)
    L_001a: nop 
    L_001b: nop 
    L_001c: endfinally 
    L_001d: nop 
    L_001e: ret 
    .try L_0003 to L_000f finally handler L_000f to L_001d
}

и здесь сборка, сгенерированная JIT при запуске в debug:

00000000  push        ebp 
00000001  mov         ebp,esp 
00000003  push        edi 
00000004  push        esi 
00000005  push        ebx 
00000006  sub         esp,34h 
00000009  mov         esi,ecx 
0000000b  lea         edi,[ebp-38h] 
0000000e  mov         ecx,0Bh 
00000013  xor         eax,eax 
00000015  rep stos    dword ptr es:[edi] 
00000017  mov         ecx,esi 
00000019  xor         eax,eax 
0000001b  mov         dword ptr [ebp-1Ch],eax 
0000001e  mov         dword ptr [ebp-3Ch],ecx 
00000021  cmp         dword ptr ds:[00288D34h],0 
00000028  je          0000002F 
0000002a  call        59439E21 
0000002f  xor         edx,edx 
00000031  mov         dword ptr [ebp-40h],edx 
00000034  nop 
        int i = 0;
00000035  xor         edx,edx 
00000037  mov         dword ptr [ebp-40h],edx 
        try
        {
0000003a  nop 
            i = 1;
0000003b  mov         dword ptr [ebp-40h],1 
            Console.WriteLine(i);
00000042  mov         ecx,dword ptr [ebp-40h] 
00000045  call        58DB2EA0 
0000004a  nop 
            return;
0000004b  nop 
0000004c  mov         dword ptr [ebp-20h],0 
00000053  mov         dword ptr [ebp-1Ch],0FCh 
0000005a  push        4E1584h 
0000005f  jmp         00000061 
        }
        finally
        {
00000061  nop 
            Console.WriteLine("finally.");
00000062  mov         ecx,dword ptr ds:[036E2088h] 
00000068  call        58DB2DB4 
0000006d  nop 
        }
0000006e  nop 
0000006f  pop         eax 
00000070  jmp         eax 
00000072  nop 
    }
00000073  nop 
00000074  lea         esp,[ebp-0Ch] 
00000077  pop         ebx 
00000078  pop         esi 
00000079  pop         edi 
0000007a  pop         ebp 
0000007b  ret 
0000007c  mov         dword ptr [ebp-1Ch],0 
00000083  jmp         00000072 

Теперь, если я прокомментирую попытку и, наконец, и возвращение, я получаю почти идентичную сборку из JIT. Различия, которые вы увидите, - это прыжок в блок finally и некоторый код, чтобы выяснить, куда идти после завершения. Итак, вы говорите о различиях TINY. В выпуске прыжок в конечном итоге будет оптимизирован - фигурные скобки являются инструкциями nop, так что это станет переходом к следующей команде, которая также является nop, что упрощает оптимизацию глазок. Поп-экс, а затем jmp eax также дешево.

    {
00000000  push        ebp 
00000001  mov         ebp,esp 
00000003  push        edi 
00000004  push        esi 
00000005  push        ebx 
00000006  sub         esp,34h 
00000009  mov         esi,ecx 
0000000b  lea         edi,[ebp-38h] 
0000000e  mov         ecx,0Bh 
00000013  xor         eax,eax 
00000015  rep stos    dword ptr es:[edi] 
00000017  mov         ecx,esi 
00000019  xor         eax,eax 
0000001b  mov         dword ptr [ebp-1Ch],eax 
0000001e  mov         dword ptr [ebp-3Ch],ecx 
00000021  cmp         dword ptr ds:[00198D34h],0 
00000028  je          0000002F 
0000002a  call        59549E21 
0000002f  xor         edx,edx 
00000031  mov         dword ptr [ebp-40h],edx 
00000034  nop 
        int i = 0;
00000035  xor         edx,edx 
00000037  mov         dword ptr [ebp-40h],edx 
        //try
        //{
            i = 1;
0000003a  mov         dword ptr [ebp-40h],1 
            Console.WriteLine(i);
00000041  mov         ecx,dword ptr [ebp-40h] 
00000044  call        58EC2EA0 
00000049  nop 
        //    return;
        //}
        //finally
        //{
            Console.WriteLine("finally.");
0000004a  mov         ecx,dword ptr ds:[034C2088h] 
00000050  call        58EC2DB4 
00000055  nop 
        //}
    }
00000056  nop 
00000057  lea         esp,[ebp-0Ch] 
0000005a  pop         ebx 
0000005b  pop         esi 
0000005c  pop         edi 
0000005d  pop         ebp 
0000005e  ret 

Итак, вы говорите очень, очень крошечные затраты на попытку/наконец. В этом очень мало проблем. Если вы делаете что-то вроде memcpy и ставите try/finally вокруг каждого байта, который копируется, а затем приступайте к копированию сотен МБ данных, я мог видеть, что это проблема, но в большинстве случаев использования? Незначительно.

Ответ 2

Так что допустим накладные расходы. Вы собираетесь прекратить использовать finally, затем? Надеюсь, что нет.

Показатели эффективности IMO релевантны только в том случае, если вы можете выбирать между различными параметрами. Я не вижу, как вы можете получить семантику finally без использования finally.

Ответ 3

try/finally очень легкий. На самом деле, так же, как и try/catch/finally, пока не будет выбрано исключение.

У меня было приложение для быстрого профиля, которое я сделал некоторое время назад, чтобы проверить его; в плотной петле, он действительно ничего не добавил к времени выполнения.

Я бы опубликовал его снова, но это было очень просто; просто запустите замкнутый цикл, сделав что-то, с try/catch/finally, который не выкидывает никаких исключений внутри цикла и время результатов против версии без try/catch/finally.

Ответ 4

Позвольте на самом деле поставить некоторые эталонные числа. То, что показывает этот тест, состоит в том, что на самом деле время, когда try/наконец-то примерно так же мало, как накладные расходы на вызов пустой функции (возможно, лучше поставить: "переход к следующей инструкции", как сказал эксперт IL выше).

            static void RunTryFinallyTest()
            {
                int cnt = 10000000;

                Console.WriteLine(TryFinallyBenchmarker(cnt, false));
                Console.WriteLine(TryFinallyBenchmarker(cnt, false));
                Console.WriteLine(TryFinallyBenchmarker(cnt, false));
                Console.WriteLine(TryFinallyBenchmarker(cnt, false));
                Console.WriteLine(TryFinallyBenchmarker(cnt, false));

                Console.WriteLine(TryFinallyBenchmarker(cnt, true));
                Console.WriteLine(TryFinallyBenchmarker(cnt, true));
                Console.WriteLine(TryFinallyBenchmarker(cnt, true));
                Console.WriteLine(TryFinallyBenchmarker(cnt, true));
                Console.WriteLine(TryFinallyBenchmarker(cnt, true));

                Console.ReadKey();
            }

            static double TryFinallyBenchmarker(int count, bool useTryFinally)
            {
                int over1 = count + 1;
                int over2 = count + 2;

                if (!useTryFinally)
                {
                    var sw = Stopwatch.StartNew();
                    for (int i = 0; i < count; i++)
                    {
                        // do something so optimization doesn't ignore whole loop. 
                        if (i == over1) throw new Exception();
                        if (i == over2) throw new Exception();
                    }
                    return sw.Elapsed.TotalMilliseconds;
                }
                else
                {
                    var sw = Stopwatch.StartNew();
                    for (int i = 0; i < count; i++)
                    {
                        // do same things, just second in the finally, make sure finally is 
                        // actually doing something and not optimized out
                        try
                        {
                            if (i == over1) throw new Exception();
                        } finally
                        {
                            if (i == over2) throw new Exception();
                        }
                    }
                    return sw.Elapsed.TotalMilliseconds;
                }
            }

Результат: 33,33,32,35,32 63,64,69,66,66 (миллисекунды, убедитесь, что у вас включена оптимизация кода)

Итак, около 33 миллисекунд накладных расходов для try/finally в 10 миллионов циклов.

В попытке/наконец, тогда мы говорим 0.033/10000000 =

3,3 наносекунды или 3,3 млрд. секунд второй накладной попытки/наконец.

Ответ 5

Что сказал Эндрю Барбер. Фактические инструкции TRY/CATCH не добавляют/незначительные накладные расходы, если не выбрано исключение. В конце концов, ничего особенного. Ваш код просто всегда перескакивает, наконец, после завершения кода в операциях try + catch

Ответ 6

В нижних уровнях finally так же дорого, как else, если условие не выполнено. Это на самом деле скачок в ассемблере (IL).