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

Question

Sur Windows, clock() retourne le temps en millisecondes, mais sur cette machine sous Linux, je suis en train de travailler sur le, il arrondit le plus proche de 1000, donc la précision est seulement à la "deuxième" niveau et de ne pas les millisecondes.

J'ai trouvé une solution avec Qt à l'aide de l' QTime classe, l'instanciation d'un objet et en appelant start() sur il puis de l'appel d' elapsed() pour obtenir le nombre de millisecondes écoulées.

J'ai obtenu le genre 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,

Il n'existe pas de méthode standard pour ce faire?

Mise à JOUR

Merci de ne pas recommander de Boost ..

Si de pouce et de l'intervalle Qt peut le faire, ce n'est sûrement pas de la magie, il doit y avoir quelque chose de standard qu'ils utilisent!

Answer 1

#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;
}

Answer 2

Veuillez noter que l' clock ne pas mesurer le temps horloge murale. Cela signifie que si votre programme prend que 5 secondes, clock ne permet pas de mesurer de 5 secondes nécessairement, mais pourrait plus (votre programme peut exécuter plusieurs threads et donc consomme plus de CPU que du temps réel) ou moins. Il mesure un rapprochement de temps CPU utilisé. Pour voir la différence considérer 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;
}

C'sorties sur mon système

$ difference: 0

Parce que nous n'avons fait que dormir et de ne pas utiliser tout le temps CPU! Cependant, l'utilisation d' gettimeofday nous 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 veulent faire passer le temps CPU, alors vous pouvez envisager d'utiliser l' getrusage fonction.

Answer 3

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;
}
 

Answer 4

Je recommande également les outils offerts par Boost. Le mentionné Stimuler la Minuterie, ou pirater quelque chose qui sort de Boost.DateTime ou il y a de nouveau proposé de la bibliothèque dans le bac à sable - Boost.Chrono: Ce dernier va être un remplacement pour le Timer, et mettra en vedette:

• Le C++0x Bibliothèque Standard du temps d'utilitaires, y compris:
  • Modèle de classe duration
  • Modèle de classe time_point
  • Horloges:
    • system_clock
    • monotonic_clock
    • high_resolution_clock
• Modèle de classe timer, avec des typedefs:
  • system_timer
  • monotonic_timer
  • high_resolution_timer
• Processus d'horloges et minuteries:
  • process_clock, la capture réel, l'utilisateur de la CPU, et le système de temps de calcul.
  • process_timer, la capture écoulé réel, l'utilisateur de la CPU, et le système de temps de calcul.
  • run_timer, pratique de rapports de |process_timer| résultats.
• Le C++0x Standard de la Bibliothèque au moment de la compilation rationnelle de l'arithmétique.

Ici est la source de la liste des fonctionnalités

Answer 5

J'ai écrit une classe Timer basée 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 oeuvre:

 #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);
    }
};