C ++ obtenant du temps en millisecondes sous Linux - clock () ne semble pas fonctionner correctement

Sous Windows, clock()renvoie le temps en millisecondes, mais sur cette machine Linux sur laquelle je travaille, il l'arrondit au 1000 le plus proche, donc la précision est uniquement au niveau "deuxième" et non au niveau des millisecondes.

J'ai trouvé une solution avec Qt en utilisant la QTimeclasse, en instanciant un objet et en l'appelant start(), puis en appelant elapsed()pour obtenir le nombre de millisecondes écoulées.

J'ai eu de la chance parce que je travaille avec Qt pour commencer, mais j'aimerais une solution qui ne repose pas sur des bibliothèques tierces,

N'y a-t-il pas de moyen standard de le faire?

METTRE À JOUR

Veuillez ne pas recommander Boost.

Si Boost et Qt peuvent le faire, ce n'est sûrement pas magique, il doit y avoir quelque chose de standard qu'ils utilisent!

Vous pouvez utiliser gettimeofday au début et à la fin de votre méthode, puis différencier les deux structures de retour. Vous obtiendrez une structure comme celle-ci:

struct timeval {
  time_t tv_sec;
  suseconds_t tv_usec;
}

EDIT: Comme le suggèrent les deux commentaires ci-dessous, clock_gettime (CLOCK_MONOTONIC) est un bien meilleur choix si vous l'avez disponible, ce qui devrait être presque partout ces jours-ci.

EDIT: Quelqu'un d'autre a commenté que vous pouvez également utiliser le C ++ moderne avec std :: chrono :: high_resolution_clock, mais cela n'est pas garanti pour être monotone. Utilisez plutôt regular_clock.

#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
    struct timeval start, end;

    long mtime, seconds, useconds;    

    gettimeofday(&start, NULL);
    usleep(2000);
    gettimeofday(&end, NULL);

    seconds  = end.tv_sec  - start.tv_sec;
    useconds = end.tv_usec - start.tv_usec;

    mtime = ((seconds) * 1000 + useconds/1000.0) + 0.5;

    printf("Elapsed time: %ld milliseconds\n", mtime);

    return 0;
}

Veuillez noter que clockne mesure pas l' heure de l'horloge murale. Cela signifie que si votre programme prend 5 secondes, clockne mesurera pas nécessairement 5 secondes, mais pourrait plus (votre programme pourrait exécuter plusieurs threads et pourrait donc consommer plus de CPU que le temps réel) ou moins. Il mesure une approximation du temps CPU utilisé. Pour voir la différence, considérez ce code

#include <iostream>
#include <ctime>
#include <unistd.h>

int main() {
    std::clock_t a = std::clock();
    sleep(5); // sleep 5s
    std::clock_t b = std::clock();

    std::cout << "difference: " << (b - a) << std::endl;
    return 0;
}

Il sort sur mon système

$ difference: 0

Parce que tout ce que nous avons fait était de dormir et de ne pas utiliser de temps CPU! Cependant, en utilisant gettimeofdaynous obtenons ce que nous voulons (?)

#include <iostream>
#include <ctime>
#include <unistd.h>
#include <sys/time.h>

int main() {
    timeval a;
    timeval b;

    gettimeofday(&a, 0);
    sleep(5); // sleep 5s
    gettimeofday(&b, 0);

    std::cout << "difference: " << (b.tv_sec - a.tv_sec) << std::endl;
    return 0;
}

Sorties sur mon système

$ difference: 5

Si vous avez besoin de plus de précision mais que vous souhaitez obtenir du temps CPU , vous pouvez envisager d'utiliser la getrusagefonction.

Je recommande également les outils proposés par Boost. Soit le Boost Timer mentionné, soit pirater quelque chose de Boost.DateTime ou il y a une nouvelle bibliothèque proposée dans le bac à sable - Boost.Chrono : Ce dernier remplacera le Timer et comprendra:

• Les utilitaires de temps de la bibliothèque standard C ++ 0x, notamment:
  • Modèle de classe duration
  • Modèle de classe time_point
  • Horloges:
    • system_clock
    • monotonic_clock
    • high_resolution_clock
• timerModèle de classe , avec typedefs:
  • system_timer
  • monotonic_timer
  • high_resolution_timer
• Horloges et minuteries de processus:
  • process_clock, capturant les temps réels, CPU utilisateur et CPU système.
  • process_timer, capturant les temps réels écoulés entre l'UC utilisateur et l'UC système.
  • run_timer, rapport pratique de | process_timer | résultats.
• L'arithmétique rationnelle à la compilation de la bibliothèque standard C ++ 0x.

Voici la source de la liste des fonctionnalités

J'ai écrit un Timercours basé sur la réponse de CTT . Il peut être utilisé de la manière suivante:

Timer timer = Timer();
timer.start();
/* perform task */
double duration = timer.stop();
timer.printTime(duration);

Voici sa mise en œuvre:

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
using namespace std;

class Timer {
private:

    timeval startTime;

public:

    void start(){
        gettimeofday(&startTime, NULL);
    }

    double stop(){
        timeval endTime;
        long seconds, useconds;
        double duration;

        gettimeofday(&endTime, NULL);

        seconds  = endTime.tv_sec  - startTime.tv_sec;
        useconds = endTime.tv_usec - startTime.tv_usec;

        duration = seconds + useconds/1000000.0;

        return duration;
    }

    static void printTime(double duration){
        printf("%5.6f seconds\n", duration);
    }
};

Si vous n'avez pas besoin que le code soit portable sur les anciens unices, vous pouvez utiliser clock_gettime (), qui vous donnera l'heure en nanosecondes (si votre processeur prend en charge cette résolution). C'est POSIX, mais depuis 2001.

clock () a une résolution souvent assez médiocre. Si vous souhaitez mesurer le temps au niveau de la milliseconde, une alternative consiste à utiliser clock_gettime (), comme expliqué dans cette question.

(N'oubliez pas que vous devez créer un lien avec -lrt sous Linux).

Avec C ++ 11 et std::chrono::high_resolution_clockvous pouvez le faire:

#include <iostream>
#include <chrono>
#include <thread>
typedef std::chrono::high_resolution_clock Clock;

int main()
{
    std::chrono::milliseconds three_milliseconds{3};

    auto t1 = Clock::now();
    std::this_thread::sleep_for(three_milliseconds);
    auto t2 = Clock::now();

    std::cout << "Delta t2-t1: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count()
              << " milliseconds" << std::endl;
}

Production:

Delta t2-t1: 3 milliseconds

Lien vers la démo: http://cpp.sh/2zdtu

clock () ne renvoie pas les millisecondes ou les secondes sous Linux. Habituellement, clock () renvoie des microsecondes sur un système Linux. La bonne façon d'interpréter la valeur renvoyée par clock () est de la diviser par CLOCKS_PER_SEC pour savoir combien de temps s'est écoulé.

Cela devrait fonctionner ... testé sur un mac ...

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

int main() {
        struct timeval tv;
        struct timezone tz;
        struct tm *tm;
        gettimeofday(&tv,&tz);
        tm=localtime(&tv.tv_sec);
        printf("StartTime: %d:%02d:%02d %d \n", tm->tm_hour, tm->tm_min, tm->tm_sec, tv.tv_usec);
}

Ouais ... lancez-le deux fois et soustrayez ...

Dans la norme POSIX, clocksa valeur de retour est définie en termes du symbole CLOCKS_PER_SEC et une implémentation est libre de la définir de n'importe quelle manière appropriée. Sous Linux, j'ai eu de la chance avec la times()fonction.

gettimeofday - le problème est qu'il peut avoir des valeurs inférieures si vous changez votre horloge matérielle (avec NTP par exemple) Boost - non disponible pour ce projet clock () - renvoie généralement un entier de 4 octets, ce qui signifie que sa capacité est faible, et après un certain temps, il renvoie des nombres négatifs.

Je préfère créer ma propre classe et la mettre à jour toutes les 10 millisecondes, donc cette façon est plus flexible, et je peux même l'améliorer pour avoir des abonnés.

class MyAlarm {
static int64_t tiempo;
static bool running;
public:
static int64_t getTime() {return tiempo;};
static void callback( int sig){
    if(running){
        tiempo+=10L;
    }
}
static void run(){ running = true;}
};

int64_t MyAlarm::tiempo = 0L;
bool MyAlarm::running = false;

pour le rafraîchir, j'utilise setitimer:

int main(){
struct sigaction sa; 
struct itimerval timer; 

MyAlarm::run();
memset (&sa, 0, sizeof (sa)); 
sa.sa_handler = &MyAlarm::callback; 

sigaction (SIGALRM, &sa, NULL); 


timer.it_value.tv_sec = 0; 
timer.it_value.tv_usec = 10000; 



timer.it_interval.tv_sec = 0; 
timer.it_interval.tv_usec = 10000; 


setitimer (ITIMER_REAL, &timer, NULL); 
.....

Regardez setitimer et les ITIMER_VIRTUAL et ITIMER_REAL.

N'utilisez pas les fonctions d'alarme ou d'ualarm, vous aurez une faible précision lorsque votre processus sera dur.

Je préfère la bibliothèque Boost Timer pour sa simplicité, mais si vous ne voulez pas utiliser de bibliothèques tierces, utiliser clock () semble raisonnable.

En tant que mise à jour, apparaît que sur windows clock () mesure l'heure de l'horloge murale (avec la précision CLOCKS_PER_SEC)

 http://msdn.microsoft.com/en-us/library/4e2ess30(VS.71).aspx

tandis que sous Linux, il mesure le temps CPU à travers les cœurs utilisés par le processus actuel

http://www.manpagez.com/man/3/clock

et (il semble, et comme indiqué par l'affiche originale) en fait avec moins de précision que CLOCKS_PER_SEC, bien que cela dépende peut-être de la version spécifique de Linux.

J'aime la méthode Hola Soy de ne pas utiliser gettimeofday (). Cela m'est arrivé sur un serveur en cours d'exécution, l'administrateur a changé le fuseau horaire. L'horloge a été mise à jour pour afficher la même valeur locale (correcte). Cela a provoqué un décalage de 2 heures de la fonction time () et gettimeofday () et tous les horodatages de certains services sont restés bloqués.

J'ai écrit une C++classe en utilisant timeb.

#include <sys/timeb.h>
class msTimer 
{
public:
    msTimer();
    void restart();
    float elapsedMs();
private:
    timeb t_start;
};

Fonctions des membres:

msTimer::msTimer() 
{ 
    restart(); 
}

void msTimer::restart() 
{ 
    ftime(&t_start); 
}

float msTimer::elapsedMs() 
{
    timeb t_now;
    ftime(&t_now);
    return (float)(t_now.time - t_start.time) * 1000.0f +
           (float)(t_now.millitm - t_start.millitm);
}

Exemple d'utilisation:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char** argv) 
{
    msTimer t;
    for (int i = 0; i < 5000000; i++)
        ;
    std::cout << t.elapsedMs() << endl;
    return 0;
}

La sortie sur mon ordinateur est «19». La précision de la msTimerclasse est de l'ordre de la milliseconde. Dans l'exemple d'utilisation ci-dessus, le temps total d'exécution occupé par la forboucle -loop est suivi. Cette fois, le système d'exploitation entre et sort du contexte d'exécution en main()raison du multitâche.