Производительность операций

#include<iostream>
#include<vector>
 
int main()
{
    setlocale( LC_ALL, "Russian" );
    std::cout.width(5);
 
    typedef std::vector<double> proportions;
    proportions rezults;
    for (int q = 0; q != 200; ++q) { rezults.push_back(0); }
    unsigned long long iterationCounter = 0;
 
    while ( true || false )
    {
        int a, b, c, i = 0;
        
        //Инициализация и присваивание
        __asm
        {
            rdtsc
            mov a, eax
        }
        double n1;
        n1 = 0x55e100;
        __asm
        {
            rdtsc
            mov b, eax
        }
        double n2 = 0x55e100;
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
 
        //Префиксный или постфиксный инткримент
        int e = 0;
        __asm
        {
            rdtsc
            mov a, eax
        }
        e++;
        __asm
        {
            rdtsc
            mov b, eax
        }
        ++e;
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
 
        /*Насколько быстрее разименование указателя на double, чем итератора std::vector<double>*/
        std::vector<double> arr(1);
        arr[0] = asin(static_cast<double>(1)) * 2;//pi
        std::vector<double>::iterator it = arr.begin();
        double* val = new double;
        *val = arr[0];
        __asm
        {
            rdtsc
            mov a, eax
        }
        *it;
        __asm
        {
            rdtsc
            mov b, eax
        }
        *val;
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
 
        /*Обращение к элементу вектора и массива*/
        __asm
        {
            rdtsc
            mov a, eax
        }
        arr[0];
        __asm
        {
            rdtsc
            mov b, eax
        }
        val[0];
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
 
        //Сложение и умножение целочисленно
        int x = 23, y = 1234;
        __asm
        {
            rdtsc
            mov a, eax
        }
        x *= y;
        __asm
        {
            rdtsc
            mov b, eax
        }
        x += y;
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
 
        //Вещественно
        double f = log(static_cast<double>(55e12)), g = sqrt(f);
        __asm
        {
            rdtsc
            mov a, eax
        }
        f *= g;
        __asm
        {
            rdtsc
            mov b, eax
        }
        f += g;
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
        
        //Извлечение корня и умножение вещественно
        __asm
        {
            rdtsc
            mov a, eax
        }
        sqrt(f);
        __asm
        {
            rdtsc
            mov b, eax
        }
        f *= g;
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
 
 
        //Разименование или обращение по индексу для массива
        __asm
        {
            rdtsc
            mov a, eax
        }
        val[0];
        __asm
        {
            rdtsc
            mov b, eax
        }
        *val;
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
 
        
        //Разименование или обращение по индексу для вектора
        __asm
        {
            rdtsc
            mov a, eax
        }
        arr[0];
        __asm
        {
            rdtsc
            mov b, eax
        }
        *it;
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
 
        //Меньше или неравно
        __asm
        {
            rdtsc
            mov a, eax
        }
        x < y;
        __asm
        {
            rdtsc
            mov b, eax
        }
        x != y;
        __asm
        {
            rdtsc
            mov c, eax
        }
        rezults[i] = ( rezults[i] * iterationCounter + static_cast<double>( b - a ) / ( c - b ) ) / ( iterationCounter + 1 );
        ++i;
 
        
        if( !(++iterationCounter % 10000) )
        {
            std::cout << "Усреднение №" << iterationCounter << ":\n";
            std::cout << "Инициализация в " << rezults[0] << " раз быстрее, чем обявление+присвоение.\n";
            std::cout << "Префиксный инткримент в " << rezults[1] << " раз быстрее, чем постфиксный.\n";
            std::cout << "Разименование указателя в " << rezults[2] << " раз быстрее, чем итератора.\n";
            std::cout << "Обращение к элементу массива в " << rezults[3] << " раз быстрее, чем к элементу вектора.\n";
            std::cout << "Целочисленное сложение в " << rezults[4] << " раз быстрее, чем умножение.\n";
            std::cout << "Вещественное сложение в " << rezults[5] << " раз быстрее, чем умножение.\n";
            std::cout << "Умнжение в " << rezults[5] << " раз быстрее, чем извлечение корня.\n";
            std::cout << "Указатель в " << rezults[6] << " раз быстрее, чем индекс.\n";
            std::cout << "Итератор в " << rezults[7] << " раз быстрее, чем индекс.\n";
            std::cout << "Неравно в " << rezults[8] << " раз быстрее, чем меньше.\n";
        }
    }
}

for ( int i = 0; i < 10; i++ );
for ( int i = 0; i < 10; ++i );