стоимость перенаправления ~ 3х умножения с плавающей точкой, правда? (с демо)

Я только что обнаружил, что косвенное обращение примерно в 3 раза больше умножения с плавающей запятой!
Чего и следовало ожидать? Мой тест неверен?

Фон

После того как я прочитал Насколько косвенность указателя влияет на эффективность?, Я начинаю паниковать по поводу стоимости косвенного обращения.

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

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

Я делаю трюк, чтобы найти приблизительное число (3х), как показано ниже:

Шаг 1

• Test1 : Без косвенности -> вычислить что-то
• Test2 : Косвенность -> вычислить что-то (то же самое)

я нашел это Test2 занимает больше времени Test1.
Ничего удивительного здесь.

Шаг 2

• Test1 : Без косвенности -> подсчитать что-то дорогое
• Test2 : Косвенность

Я пытаюсь изменить свой код в calculate something expensive быть дороже понемногу, чтобы сделать оба Тестовое задание стоит примерно столько же.

Результат

Наконец, я обнаружил, что одна из возможных функций, заставляющая оба теста использовать одинаковое количество времени (то есть безубыточность):

• Test1 : Нет косвенных -> возврат float*float*... три раза
• Test2 : Indirection -> просто вернуть float

Вот мой тестовый пример (Ideone демо): —

class C{
public: float hello;
public: float hello2s[10];
public: C(){
hello=((double) rand() / (RAND_MAX))*10;
for(int n=0;n<10;n++){
hello2s[n]= ((double) rand() / (RAND_MAX))*10;
}
}
public: float calculateCheap(){
return hello;
}
public: float calculateExpensive(){
float result=1;
result=hello2s[0]*hello2s[1]*hello2s[2]*hello2s[3]*hello2s[4];
return result;
}
};

Вот главное:

int main(){
const int numTest=10000;
C  d[numTest];
C* e[numTest];
for(int n=0;n<numTest;n++){
d[n]=C();
e[n]=new C();
}
float accu=0;
auto t1= std::chrono::system_clock::now();
for(int n=0;n<numTest;n++){
accu+=d[n].calculateExpensive();  //direct call
}
auto t2= std::chrono::system_clock::now();
for(int n=0;n<numTest;n++){
accu+=e[n]->calculateCheap();     //indirect call
}
auto t3= std::chrono::system_clock::now();
std::cout<<"direct call time ="<<(t2-t1).count()<<std::endl;
std::cout<<"indirect call time ="<<(t3-t2).count()<<std::endl;
std::cout<<"print to disable compiler cheat="<<accu<<std::endl;
}

Время прямого звонкаи Косвенное время звонка настроен так, как указано выше (через редактирование calculateExpensive).

Заключение

Стоимость косвенного обращения = 3-кратное умножение с плавающей точкой.
В моем рабочем столе (Visual Studio 2015 с -O2) это 7x.

Стоит ли ожидать, что косвенное обращение будет стоить примерно в 3 раза больше, чем умножение с плавающей точкой?
Если нет, то как мой тест не так?

(Спасибо Enzzlek за предложение улучшения, оно отредактировано.)