Opérateur de synchronisation +, opérateur-, opérateur * et opérateur/

Question

J'ai une simple classe de vecteurs mathématiques avec des opérateurs surchargés. Je voudrais obtenir des résultats de synchronisation pour mes opérateurs. Je peux facilement chronométrer mon + =, - =, * = et/= en chronométrant le code suivant:

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

Ensuite, je peux soustraire le temps qu'il faut pour générer des vecteurs aléatoires iter. Dans mes tests, Vector est en 3 dimensions, iter = 10,000,000.

J'ai essayé de faire la même chose avec +, -, *, /:

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

Ensuite soustrayez le temps qu'il faut pour générer des vecteurs aléatoires iter et effectuer des missions iter, mais cela donne un « négatif » temps, ce qui m'amène à croire soit que le compilateur optimise l'opération, soit qu'il se passe quelque chose d'étrange. J'utilise gcc-4.7.2 en utilisant -O3 sur une machine Fedora Linux.

Voici mon code de synchronisation:

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; 

Ici F est un objet de fonction qui exécute le code ci-dessus. time_iter_rand_v est le temps qu'il faut pour créer des vecteurs aléatoires iter et time_iter_ass est le temps qu'il a fallu pour les opérations d'assignation d'iter.

Ma question est alors comment obtenir un timing précis de seulement l'opérateur + la fonction pas d'assignations ou la génération de vecteurs aléatoires?

Answer 1

Vous ne pouvez vraiment pas obtenir un calendrier précis pour quelque chose comme ça lorsque l'optimisation est activée. La raison est due au fait que le compilateur a la capacité de déplacer le code.

Si vous faites en sorte que les variables de stockage de temps soient volatiles, leurs positions respectives ne sont pas optimisées en raison du déplacement. Cependant, le code qui les entoure est, sauf s'ils affectent ou appellent des fonctions qui prennent des variables volatiles (cela inclut une fonction membre volatile qui rend *this volatile).

L'optimisation peut faire beaucoup de choses étranges au code si vous attendez une exécution linéaire.

Answer 2

Une méthode d'étalonnage de base est d'utiliser 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

Il suffit de créer un vecteur de RandVector() s et parcourir à travers eux. Cela résoudra le problème de la mesure du temps de génération. En ce qui concerne l'affectation, je pense que cela revient à la façon dont le compilateur l'optimise.