Exceptions vs. Return Values

Простой случай

Выводы

Более интересный случай

Выводы

Поведение в асимптотике

int f6()
{
    int o1, o2;
    int res = 0;
    if (!constructor(&o1)) goto end;
    if (!constructor(&o2)) goto do1;
    if (!f5()) goto do2;
    res = 1;
    do2:    destructor(o2);
    do1:    destructor(o1);
    end:    return res;        
}

bool f6()
{
    obj o1, o2;
    if (!o1.init()) return false;
    if (!o2.init()) return false;
    if (!f5()) return false;
    return true;
}

bool f6()
{
    obj o1, o2;
    f5();
}

Выводы

Ещё тест

Размер кода

Тест без ресурсов

Выводы

smart_ptr vs. smart_ptr&

Выводы

Более реалистичный тест

void f6()
{
  obj o1, o2, o3;
  f5();
  f5();
}

Выводы

bool f()
{
  return true;
}

if (!f())
  ++error_count;

void f()
{
}

try
{
  f();
}
catch (...)
{
  ++error_count;
}

R>>>Ну вот собственно всё, что хотелось сказать. Коменты и замечания преведствуются Особенно интересно было бы услышать, если я пропустил какие-то важные аспекты в исследовании, которые могут сущуственно сказаться на производительности/размере кода/или ещё чём-то в разрезе исключения/возвращаемые значения.

void *p = malloc( 1024 );
if ( unlikely(!p) )
  return -ENOMEM;

    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

    mov    ebp, esp
    push    -1
    push    $callback
    mov    eax, DWORD PTR fs:__except_list
    push    eax
    mov    DWORD PTR fs:__except_list, esp

void f_ex(int i)
{
  ex2(i+1);
  ex3(i+2);
  ex4(i+3);
}

int f_rv(int i)
{
  if (!f_rv2(i+1)) return 0;
  if (!f_rv3(i+2)) return 0;
  if (!f_rv4(i+3)) return 0;
  return 1;
}

AS> Понятно. Дальше можно не продолжать.

R>>Тем более я, как инженер, больше верю своим глазам

R>>Может быть ты приведёшь какие-то замеры Мои замеры пока показывают обратную картину....

AS>>>Выложи исходники — я тебя уверяю, народ раскритикует по самые

AS>    mov    ebp, esp
AS>    push    -1
AS>    push    $callback
AS>    mov    eax, DWORD PTR fs:__except_list
AS>    push    eax
AS>    mov    DWORD PTR fs:__except_list, esp
AS>

    mov    ecx, DWORD PTR __$EHRec$[ebp+4]
    mov    DWORD PTR fs:__except_list, ecx
    mov    esp, ebp

AS>И еще не забывай про привязку к одному ядру. А вот что автор тестов ответил на все это — можешь прочитать сам

    SetProcessAffinityMask (GetCurrentProcess (),1);
    // и для гарантии контрольный в голову!!!
    SetThreadAffinityMask (GetCurrentThread (),1);

call f

call f
test eax, eax
je ...

// В этой точке мы имеем максимальный приоритет потока - 31
// Надо это для того, чтоб как можно меньше постороннего кода вщемилось в наш
// Оптимальные измерения будут на многоядерных машинах - там остальной код будет
// большей частью вытеснен на другие ядра. Для одноядерки это только несколько снизит 
// кол-во потоков.
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

// Гарантируем что ОС не перебросит поток на другое ядро - таким образом можно смело юзать
// rdtsc т.к. синхронизация TSC нас парить не будет
SetProcessAffinityMask (GetCurrentProcess (),1);

// Ну, это можно было и не делать - но пусть будет на всяк случай
SetThreadAffinityMask (GetCurrentThread (),1);

Exceptions vs. Return Values

#include <iostream>

typedef unsigned __int64 tick_t;
tick_t const max_tick = static_cast<tick_t>(-1);
__declspec(naked) tick_t get_tc()
{
    __asm rdtsc;
    __asm ret;
}

volatile int counter = 0;

struct tobj
{
    __declspec(noinline) tobj();
    __declspec(noinline) ~tobj();
    int fake;
};

__declspec(noinline) bool ctor(int*);
__declspec(noinline) void dtor(int*);

__declspec(noinline) void test_ex2()
{
    if (!++counter) throw 0;
}

__declspec(noinline) void test_ex()
{
    tobj o1, o2, o3, o4;
    test_ex2();
    test_ex2();
    test_ex2();
    test_ex2();
}

__declspec(noinline) bool test_rv2()
{
    return !!++counter;
}

__declspec(noinline) bool test_rv()
{
    int o1, o2, o3, o4;
    bool res = true;
    if (!ctor(&o1)) goto end;
    if (!ctor(&o2)) goto do1;
    if (!ctor(&o3)) goto do2;
    if (!ctor(&o4)) goto do3;
    if (!test_rv2()) goto do4;
    if (!test_rv2()) goto do4;
    if (!test_rv2()) goto do4;
    if (!test_rv2()) goto do4;
    res = true;
do4:    dtor(&o4);
do3:    dtor(&o3);
do2:    dtor(&o2);
do1:    dtor(&o1);
end:    return res;
}

int main()
{
    int const test_count = 10000;

    {
        int ec = 0;
        tick_t time = max_tick;
        tick_t start = 0;
        tick_t t = 0;
        for (int i = 0; i < test_count; ++i)
        {
            start = get_tc();
            try
            {
                test_ex();
            }
            catch (...)
            {
                ++ec;
            }
            t = get_tc() - start;
            if (t < time) time = t;
        }
        std::cout << "test_ex: " << time << "\n";
    }

    {
        int ec = 0;
        tick_t time = max_tick;
        tick_t start = 0;
        tick_t t = 0;
        for (int i = 0; i < test_count; ++i)
        {
            start = get_tc();
            if (!test_rv())
                ++ec;
            t = get_tc() - start;
            if (t < time) time = t;
        }
        std::cout << "test_rv: " << time << "\n";
    }
}

struct tobj
{
    __declspec(noinline) tobj();
    __declspec(noinline) ~tobj();
};

tobj::tobj() {}
tobj::~tobj() {}

__declspec(noinline) bool ctor(int*) {return true;}
__declspec(noinline) void dtor(int*) {}

__declspec(noinline) void test_ex()
{
// Вот создаём фрейм - 6 команд
00401040  push        0FFFFFFFFh 
00401042  push        offset __ehhandler$?test_ex@@YAXXZ (401750h) 
00401047  mov         eax,dword ptr fs:[00000000h] 
0040104D  push        eax  
0040104E  mov         dword ptr fs:[0],esp 
00401055  sub         esp,10h 
    tobj o1, o2, o3, o4;
// Вот вызываем 4 конструктора - 4 по 3 команды
00401058  lea         ecx,[esp+0Ch] 
0040105C  call        tobj::tobj (401300h) 
00401061  lea         ecx,[esp+8] 
00401065  mov         dword ptr [esp+18h],0 
0040106D  call        tobj::tobj (401300h) 
00401072  lea         ecx,[esp+4] 
00401076  mov         byte ptr [esp+18h],1 
0040107B  call        tobj::tobj (401300h) 
00401080  lea         ecx,[esp] 
00401083  mov         byte ptr [esp+18h],2 
00401088  call        tobj::tobj (401300h) 
0040108D  mov         byte ptr [esp+18h],3 
// Вот вызываем 4 функции - 4 команды
    test_ex2();
00401092  call        test_ex2 (401010h) 
    test_ex2();
00401097  call        test_ex2 (401010h) 
    test_ex2();
0040109C  call        test_ex2 (401010h) 
    test_ex2();
004010A1  call        test_ex2 (401010h) 
}
// Вызываем 4 деструктора - 4 по 3 инструкции
004010A6  lea         ecx,[esp] 
004010A9  mov         byte ptr [esp+18h],2 
004010AE  call        dtor (401320h) 
004010B3  lea         ecx,[esp+4] 
004010B7  mov         byte ptr [esp+18h],1 
004010BC  call        dtor (401320h) 
004010C1  lea         ecx,[esp+8] 
004010C5  mov         byte ptr [esp+18h],0 
004010CA  call        dtor (401320h)
// Снимаем фрейм исключений - 6 инструкций 
004010CF  lea         ecx,[esp+0Ch] 
004010D3  mov         dword ptr [esp+18h],0FFFFFFFFh 
004010DB  call        dtor (401320h) 
004010E0  mov         ecx,dword ptr [esp+10h] 
004010E4  mov         dword ptr fs:[0],ecx 
004010EB  add         esp,1Ch 
004010EE  ret

__declspec(noinline) bool test_rv()
{
    int o1, o2, o3, o4;
    bool res = true;
    if (!ctor(&o1)) goto end;
// Вызываем 4 конструктора - 4 по 6 инструкций
00401110  lea         eax,[esp-4] 
00401114  sub         esp,10h 
00401117  push        eax  
00401118  call        ctor (401310h) 
0040111D  add         esp,4 
00401120  test        al,al 
00401122  je          do1+0Dh (4011ADh) 
    if (!ctor(&o2)) goto do1;
00401128  lea         ecx,[esp+8] 
0040112C  push        ecx  
0040112D  call        ctor (401310h) 
00401132  add         esp,4 
00401135  test        al,al 
00401137  je          do1 (4011A0h) 
    if (!ctor(&o3)) goto do2;
00401139  lea         edx,[esp+4] 
0040113D  push        edx  
0040113E  call        ctor (401310h) 
00401143  add         esp,4 
00401146  test        al,al 
00401148  je          do2 (401193h) 
    if (!ctor(&o4)) goto do3;
0040114A  lea         eax,[esp] 
0040114D  push        eax  
0040114E  call        ctor (401310h) 
00401153  add         esp,4 
00401156  test        al,al 
00401158  je          do3 (401186h) 

// Вызываем 4 функции - 4 по 3 инструкции
    if (!test_rv2()) goto do4;
0040115A  call        test_rv2 (4010F0h) 
0040115F  test        al,al 
00401161  je          do4 (40117Ah) 
    if (!test_rv2()) goto do4;
00401163  call        test_rv2 (4010F0h) 
00401168  test        al,al 
0040116A  je          do4 (40117Ah) 
    if (!test_rv2()) goto do4;
0040116C  call        test_rv2 (4010F0h) 
00401171  test        al,al 
00401173  je          do4 (40117Ah) 
    if (!test_rv2()) goto do4;
00401175  call        test_rv2 (4010F0h) 
    res = true;
// Вызываем 4 деструктора - 4 по 4 инструкции
do4:    dtor(&o4);
0040117A  lea         ecx,[esp] 
0040117D  push        ecx  
0040117E  call        dtor (401320h) 
00401183  add         esp,4 
do3:    dtor(&o3);
00401186  lea         edx,[esp+4] 
0040118A  push        edx  
0040118B  call        dtor (401320h) 
00401190  add         esp,4 
do2:    dtor(&o2);
00401193  lea         eax,[esp+8] 
00401197  push        eax  
00401198  call        dtor (401320h) 
0040119D  add         esp,4 
do1:    dtor(&o1);
004011A0  lea         ecx,[esp+0Ch] 
004011A4  push        ecx  
004011A5  call        dtor (401320h) 
004011AA  add         esp,4 
end:    return res;
004011AD  mov         al,1 
}
004011AF  add         esp,10h 
004011B2  ret

Итого время выполнения:
ex — 172
rv — 184

static void test_ex()
{
    tobj o1, o2, o3, o4;
    try
    {
        test_ex2();
        test_ex2();
        test_ex2();
        test_ex2();
    }
    catch(...)
    {
    }
}

template <typename T>
static inline
bool f(T a, T a2) { return f_impl(a, a2); }

struct  { int _; };

struct kirql { uint8_t level; };

extern "C" __declspec(dllimport)
void __fastcall
  KfReleaseSpinLock(
    kspin_lock *  SpinLock,
    const kirql   NewIrql
    );

void kspin_lock::release(const kirql new_irql)
{
  KfReleaseSpinLock(this, new_irql);
}

?release@kspin_lock@km@ntl@@QAEXUkirql@23@@Z PROC   ; ntl::km::kspin_lock::release, COMDAT
; _this$ = ecx
; Line 71
    jmp DWORD PTR __imp_@KfReleaseSpinLock@8
?release@kspin_lock@km@ntl@@QAEXUkirql@23@@Z ENDP   ; ntl::km::kspin_lock::release

_this$ = -4                     ; size = 4
_new_irql$ = 8                      ; size = 1
?release@kspin_lock@km@ntl@@QAEXUkirql@23@@Z PROC   ; ntl::km::kspin_lock::release, COMDAT
; _this$ = ecx
; Line 70
    push    ebp
    mov ebp, esp
    push    ecx
    mov DWORD PTR _this$[ebp], ecx
; Line 71
    mov al, BYTE PTR _new_irql$[ebp]
    push    eax                  ; вот этот параметр следует передавать в регисте edx, а не через стек 
    mov ecx, DWORD PTR _this$[ebp]
    call    DWORD PTR __imp_@KfReleaseSpinLock@8
; Line 72
    mov esp, ebp
    pop ebp
    ret 4
?release@kspin_lock@km@ntl@@QAEXUkirql@23@@Z ENDP   ; ntl::km::kspin_lock::release
; Function compile flags: /Odtp
_TEXT   ENDS

Непосредственные результаты замеров времени исполнения программы в "сыром" виде, как было показано выше, ни на что ни годны. Очевидно, перед использованием их следует обработать. Как минимум откинуть пограничные значения, вызванные нерегулярными наведенными эффектами (ну, например, в самый ответственный для профилировки момент, операционная система принялась что-то сбрасывать на диск), а затем... Затем перед нами встает Буриданова проблема . Мы будем должны либо выбрать результат с минимальным временем исполнения — как наименее подвергнувшийся пагубному влиянию многозадачности, либо же вычислить наиболее типичное время выполнения — как время выполнения в реальных, а не идеализированных "лабораторных" условиях.

Мной опробован и успешно применяется компромиссный вариант, комбинирующий оба этих метода. Фактически, я предлагаю вам отталкиваться от среднеминимального времени исполнения. Сам алгоритм в общих чертах выглядит так: мы выполняем N повторов программы, а затем отбрасываем N/3 максимальных и N/3 минимальных результатов замеров. Для оставшихся N/3 замеров мы находим среднее арифметическое, которое и берем за основной результат. Величина N варьируется в зависимости от конкретной ситуации, но обычно с лихвой хватает 9-12 повторов, т. к. большее количество уже не увеличивает точности результатов.

int main()
{
    int const test_count = 1000000;

#if 1
    {
        int ec = 0;
        tick_t time = 0;
        tick_t start = 0;
        tick_t t = 0;
        for (int i = 0; i < test_count; ++i)
        {
            start = get_tc();
            try
            {
                test_ex();
            }
            catch (...)
            {
                ++ec;
            }
            t = get_tc() - start;
            time += t;
        }
        std::cout << "test_ex: " << time << "\n";
    }
#else
    {
        int ec = 0;
        tick_t time = 0;
        tick_t start = 0;
        tick_t t = 0;
        for (int i = 0; i < test_count; ++i)
        {
            start = get_tc();
            if (!test_rv())
                ++ec;
            t = get_tc() - start;
            time += t;
        }
        std::cout << "test_rv: " << time << "\n";
    }
#endif
}