Comment obtenir le temps d’exécution d’un programme en millisecondes en C?

Actuellement, je reçois en quelques secondes le temps d’exécution de mon programme en appelant:

time_t startTime = time(NULL); //section of code time_t endTime = time(NULL); double duration = difftime(endTime, startTime); 

Est-il possible d’obtenir l’heure du mur en millisecondes ? Si c’est le cas, comment?

Si vous êtes sur une machine POSIX-ish, utilisez gettimeofday() ; cela vous donne une portabilité raisonnable et une résolution en microsecondes.

Un peu plus ésotérique, mais aussi dans POSIX, est la fonction clock_gettime() , qui vous donne une résolution en nanosecondes.

Sur de nombreux systèmes, vous trouverez une fonction ftime() qui vous renvoie le temps en secondes et en millisecondes. Cependant, il ne figure plus dans la spécification Single Unix (à peu près identique à POSIX). Vous avez besoin de l’en-tête :

 struct timeb mt; if (ftime(&mt) == 0) { mt.time ... seconds mt.millitime ... milliseconds } 

Cela remonte à la version 7 (ou 7ème édition) Unix au moins, donc il a été très largement disponible.

J’ai aussi des notes dans times() et clock() , qui utilisent à nouveau d’autres structures et en-têtes dans le code de timer inférieur à la seconde. J’ai aussi des notes sur Windows utilisant clock() avec 1000 ticks par seconde ( GetTickCount() millisecondes), ainsi qu’une interface plus ancienne, GetTickCount() notée comme nécessaire sous Windows 95 mais pas sous NT.

Si vous pouvez le faire en dehors du programme lui-même, sous Linux, vous pouvez utiliser la commande time ./my_program ( time ./my_program ).

J’ai récemment écrit un article de blog qui explique comment obtenir le temps multiplate-forme en millisecondes .

Cela fonctionnera comme le temps (NULL), mais renverra le nombre de millisecondes au lieu de secondes à partir de l’époque unix sur Windows et Linux.

Voici le code

 #ifdef WIN32 #include  #else #include  #include  #endif /* Returns the amount of milliseconds elapsed since the UNIX epoch. Works on both * windows and linux. */ int64 GetTimeMs64() { #ifdef WIN32 /* Windows */ FILETIME ft; LARGE_INTEGER li; uint64 ret; /* Get the amount of 100 nano seconds intervals elapsed since January 1, 1601 (UTC) and copy it * to a LARGE_INTEGER structure. */ GetSystemTimeAsFileTime(&ft); li.LowPart = ft.dwLowDateTime; li.HighPart = ft.dwHighDateTime; ret = li.QuadPart; ret -= 116444736000000000LL; /* Convert from file time to UNIX epoch time. */ ret /= 10000; /* From 100 nano seconds (10^-7) to 1 millisecond (10^-3) intervals */ return ret; #else /* Linux */ struct timeval tv; uint64 ret; gettimeofday(&tv, NULL); ret = tv.tv_usec; /* Convert from micro seconds (10^-6) to milliseconds (10^-3) */ ret /= 1000; /* Adds the seconds (10^0) after converting them to milliseconds (10^-3) */ ret += (tv.tv_sec * 1000); return ret; #endif } 

Vous pouvez le modifier pour renvoyer des microsecondes au lieu de millièmes de secondes si vous le souhaitez.

La bibliothèque GLib à source ouverte comporte un système GTimer qui prétend fournir une précision à la microseconde. Cette bibliothèque est disponible sur Mac OS X, Windows et Linux. Je l’utilise actuellement pour effectuer des synchronisations de performances sous Linux, et il semble fonctionner parfaitement.

gprof , qui fait partie de la boîte à outils GNU, est une option. Il sera installé sur la plupart des systèmes POSIX et sera disponible sous Cygwin pour Windows. Suivre vous-même le temps en utilisant gettimeofday() fonctionne bien, mais cela équivaut à utiliser les instructions print pour le débogage. C’est bien si vous voulez juste une solution rapide et sale, mais ce n’est pas aussi élégant que d’utiliser des outils appropriés.

Pour utiliser gprof , vous devez spécifier l’option -pg lors de la compilation avec gcc comme gcc :

 gcc -o prg source.c -pg 

Ensuite, vous pouvez exécuter gprof sur le programme généré comme suit:

 gprof prg > gprof.out 

Par défaut, gprof générera le temps d’exécution global de votre programme, ainsi que le temps passé dans chaque fonction, le nombre d’appels de chaque fonction, le temps moyen passé dans chaque appel de fonction et des informations similaires.

Il existe un grand nombre d’options que vous pouvez définir avec gprof . Si vous êtes intéressé, il y a plus d’informations dans les pages de manuel ou via Google.

Sous Windows, utilisez QueryPerformanceCounter et la requête QueryPerformanceFrequency associée. Ils ne vous donnent pas une heure qui peut être traduite en heure calendaire, donc si vous en avez besoin, demandez-lui l’heure à l’aide d’une API CRT, puis utilisez immédiatement QueryPerformanceCounter. Vous pouvez ensuite effectuer quelques additions / soustractions simples pour calculer la durée du calendrier, avec des erreurs dues au temps nécessaire à l’exécution consécutive de l’API. Hé, c’est un PC, qu’attendais-tu ???