Оператор синхронизации +, оператор, оператор * и оператор/

Question

У меня есть простой математический векторный класс с перегруженными операторами. Я хотел бы получить некоторые результаты синхронизации для моих операторов. Я могу легко раз мой + =, - =, * = и/= по времени следующий код:

Vector sum; 
for(size_t i = 0; i<iter; ++i) 
    sum += RandVector(); 
cout << sum << endl; 

Тогда я могу вычесть время, необходимое для создания ИТЭР случайных векторов. В моих тестах Vector является 3-мерным, iter = 10 000 000.

Я пытался сделать нечто подобное с +, -, *, /:

Vector sum; 
for(size_t i = 0; i<iter; ++i) 
    sum = sum + RandVector(); 
cout << sum << endl; 

Затем вычесть время, необходимое для создания ИТЭР случайных векторов и выполнять ITER задания, однако это дает «негативный» время, заставившее меня поверить, что компилятор каким-то образом оптимизирует операцию, или что-то странное происходит.

Я использую gcc-4.7.2 с использованием -O3 на компьютере Fedora Linux.

Вот мой код синхронизации:

clock_t start, k = clock(); 
do start = clock(); 
while(start == k); 

F()(); 

clock_t end = clock(); 

double time = double(end-start)/double(CLOCKS_PER_SEC); 
cout << time - time_iter_rand_v - time_iter_ass; 

Здесь F является функцией объект, который выполняет код, указанный выше. time_iter_rand_v - это время, необходимое для создания случайных векторов iter, а time_iter_ass - время, затрачиваемое на операции присвоения итераций.

Мой вопрос заключается в том, как получить точное время только для функции «оператор +», а не для каких-либо назначений или генерации случайного вектора?

Answer 1

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

Если вы изменяете временные переменные хранения, положение их относительно друг друга не подлежит оптимизации из-за перемещения. Тем не менее, код вокруг них, если только они не назначают или не вызывают функции, которые принимают изменчивые переменные (это включает в себя изменчивую функцию-член, которая делает *this летучей).

Оптимизация может сделать много нечетных вещей для кода, если вы ожидаете линейного выполнения.

Answer 2

Один основной метод бенчмаркинга заключается в использовании gettimeofday:

#include <stdio.h> 
#include <stdlib.h> 
#include <sys/time.h> 
#include <sys/types.h> 

#include <cstring> 



//------------------- Handle time in milliseconds ----------------------// 

/* 
* Return 1 if the difference is negative, otherwise 0. 
*/ 
int timeval_subtract(struct timeval *result, struct timeval *t2, struct timeval *t1) 
{ 
    long int diff = (t2->tv_usec + 1000000 * t2->tv_sec) - (t1->tv_usec + 1000000 * t1->tv_sec); 
    result->tv_sec = diff/1000000; 
    result->tv_usec = diff % 1000000; 

    return (diff<0); 
} 

void timeval_print(struct timeval *tv) 
{ 
    char buffer[30]; 
    time_t curtime; 

    printf("%ld.%06ld", tv->tv_sec, tv->tv_usec); 
    curtime = tv->tv_sec; 
    strftime(buffer, 30, "%m-%d-%Y %T", localtime(&curtime)); 
    printf(" = %s.%06ld\n", buffer, tv->tv_usec); 
} 

// usage : 
/* 

    struct timeval tvBegin, tvEnd, tvDiff; 

    // begin 
    gettimeofday(&tvBegin, NULL); 

    // lengthy operation 
    int i,j; 
    for(i=0;i<999999L;++i) { 
     j=sqrt(i); 
    } 

    //end 
    gettimeofday(&tvEnd, NULL); 

    // diff 
    timeval_subtract(&tvDiff, &tvEnd, &tvBegin); 
    printf("%ld.%06ld\n", tvDiff.tv_sec, tvDiff.tv_usec); 


*/ 

Answer 3

Просто создайте вектор RandVector() и пройдите через них. Это решит проблему измерения времени генерации. Что касается назначения, я думаю, что дело доходит до того, как компилятор его оптимизирует.