Algorithme de synchronisation: clock () vs time () en C ++

Pour synchroniser un algorithme (approximativement en ms), laquelle de ces deux approches est la meilleure:

clock_t start = clock(); algorithm(); clock_t end = clock(); double time = (double) (end-start) / CLOCKS_PER_SEC * 1000.0; 

Ou,

 time_t start = time(0); algorithm(); time_t end = time(0); double time = difftime(end, start) * 1000.0; 

De plus, à la suite d’une discussion sur le canal C ++ de Freenode, je sais que l’horloge a une très mauvaise résolution. Le temps sera donc nul pour un algorithme (relativement) rapide. Mais, qui a la meilleure résolution time () ou clock ()? Ou est-ce le même?

    Cela dépend de ce que vous voulez: le time mesure le temps réel alors que l’ clock mesure le temps de traitement pris par le processus en cours. Si votre processus s’endort pendant une durée appréciable ou si le système est occupé par d’autres processus, les deux seront très différents.

    http://fr.cppreference.com/w/cpp/chrono/c/clock

    serait une meilleure bibliothèque si vous utilisez C ++ 11.

     #include  #include  #include  void f() { std::this_thread::sleep_for(std::chrono::seconds(1)); } int main() { auto t1 = std::chrono::high_resolution_clock::now(); f(); auto t2 = std::chrono::high_resolution_clock::now(); std::cout << "f() took " << std::chrono::duration_cast(t2-t1).count() << " milliseconds\n"; } 

    Exemple pris ici .

    La structure time_t va probablement être un entier, ce qui signifie qu’il aura une résolution de seconde.

    Le premier morceau de code: il ne comptera que le temps pendant lequel le processeur faisait quelque chose, alors quand vous faites un sumil (), il ne comptera rien. Il peut être contourné en comptant le temps que vous dormez (), mais il commencera probablement à dériver après un certain temps.

    Le deuxième morceau: seulement la résolution des secondes, pas si grande si vous avez besoin de lectures en moins d’une seconde.

    Pour les lectures de temps avec la meilleure résolution possible, vous devriez faire quelque chose comme ceci:

     double getUnixTime(void) { struct timespec tv; if(clock_gettime(CLOCK_REALTIME, &tv) != 0) return 0; return (tv.tv_sec + (tv.tv_nsec / 1000000000.0)); } double start_time = getUnixTime(); double stop_time, difference; doYourStuff(); stop_time = getUnixTime(); difference = stop_time - start_time; 

    Sur la plupart des systèmes, sa résolution sera réduite à quelques microsecondes, mais elle peut varier en fonction des différents processeurs, et probablement même des principales versions du kernel.

    est le meilleur. Visual Studio 2013 fournit cette fonctionnalité. Personnellement, j’ai essayé toutes les méthodes mentionnées ci-dessus. Je vous recommande fortement d’utiliser la bibliothèque . Il peut suivre l’heure du mur et en même temps avoir une bonne résolution (beaucoup moins d’une seconde).

    Que diriez-vous de gettimeofday? Lorsqu’il est appelé, il met à jour deux structures, avec des informations de synchronisation. Habituellement, la structure de la main gauche suffit, ce qui portera le temps depuis l’époque, 01-01-1970 00:00:00 (UTC). Il peut être utilisé comme suit:

     #include  struct timeval start; double mtime, seconds, useconds; gettimeofday(&start, NULL); //left hand struct is usually enough seconds = start.tv_sec; //time in seconds useconds = start.tv_usec; //time in microseconds