web-dev-qa-db-fra.com

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

Pour chronométrer 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, après quelques discussions sur le canal C++ de Freenode, je sais que l’horloge a une très mauvaise résolution. Le timing sera donc nul pour un algorithme (relativement) rapide. Mais qui a le meilleur temps de résolution () ou horloge ()? Ou est-ce le même?

c++clocktiming
55
blaze

Cela dépend de ce que vous voulez: time mesure le temps réel tandis que clock mesure le temps de traitement du processus en cours. Si votre processus est en veille pendant un laps de temps 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

41
David Grayson

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

#include <iostream>
#include <chrono>
#include <thread>

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<std::chrono::milliseconds>(t2-t1).count()
              << " milliseconds\n";
}

Exemple pris de ici .

44
Rapptz

La structure time_t sera probablement un entier, ce qui signifie qu’elle aura une résolution de seconde.

Le premier morceau de code: Il ne comptera que le temps pendant lequel le processeur a fait quelque chose. Ainsi, lorsque vous dormez (), il ne compte rien. Vous pouvez le contourner en comptant le temps que vous dormez (), mais il va probablement commencer à dériver après un certain temps.

La deuxième partie: seule résolution en secondes, pas si grande si vous avez besoin de lectures inférieures à une seconde.

Pour que les lectures de temps avec la meilleure résolution que vous puissiez obtenir, 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, la résolution sera réduite à quelques microsecondes, mais elle peut varier en fonction des processeurs et même des versions majeures du noyau.

9
Plecharts

<chrono> 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 <chrono>. Il peut suivre le temps du mur tout en ayant une bonne résolution (beaucoup moins qu'une seconde).

1
Hanyu Ye

Pourquoi pas gettimeofday? Lorsqu'il est appelé, il met à jour deux structures, avec des informations de minutage. Habituellement, la structure de gauche suffit, ce qui prendra du temps depuis l’époque, 01-01-1970 00:00:00 (UTC). Il peut être utilisé comme suit:

#include <time.h>

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
0
haripkannan