Obtenir une exécution exacte de temps en C++ (micro secondes)

Je veux obtenir une exécution exacte de temps en micro-secondes de mon programme mis en œuvre avec le C++.
J'ai essayé d'obtenir le temps d'exécution avec clock_t mais il n'est pas précis.

  • pourquoi pensez-vous, ce n'est pas précis?
  • Étant donné que le temps d'exécution est soumis à la charge sur le CPU, la disponibilité de la mémoire, cache, toutes les I/O, planificateur de threads, etc. Êtes-vous sûr que vous avez besoin de ce niveau de précision?
  • Si l'une des réponses ici résolu votre problème, veuillez le marquer comme acceptée. De cette façon, votre question cessera d'apparaître dans la réponse à la section.
  • J'ai besoin d'un temps d'exécution avec des micro-secondes et clock_t se permettre un temps d'exécution avec des millisecondes....
InformationsquelleAutor user3323616 | 2014-02-18
  1. 68

    Si vous êtes à l'aide de c++11 ou tard, vous pourriez utiliser std::chrono::high_resolution_clock.

    Un cas simple d'utilisation :

    auto start = std::chrono::high_resolution_clock::now();
...
auto elapsed = std::chrono::high_resolution_clock::now() - start;

long long microseconds = std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();

    Cette solution a l'avantage d'être portable.

    • Remarque: Dans g++ nanosecondes sont disponibles depuis GCC 4.8.1.
    • -1: c'est bon à la fois une fonction, mais pas à temps un programme car il manque le set-up et de la destruction de la partie du programme par le système d'exploitation.
    • pour tester les performances d'un programme à l'échelle de la microseconde, la mise en place et la destruction de la partie doit être ignoré.
    • ce qui fait de vous le dire? la lecture du fichier exécutable à partir du disque vers la mémoire peut être coûteux. En outre, les différents OS ont différents systèmes, pouvez-vous confirmer que tous charger le programme en moins d'une microseconde?. Il pourrait être hors de propos, à la fin, mais je ne pense pas que nous devrions ignorer.
    • Exactement, les différents OS ont différents temps de mise en place. C'est pourquoi. Vous n'êtes pas en mesure de les applications de la performance, mais l'OS de la performance, si vous incluez un peu. Pourquoi voudriez-vous faire cela? Sauf si vous êtes un OS développeur, vous ne pouvez rien faire sur le temps. Même sur un OS, le disque dur peut avoir besoin de faire tourner afin de lire le fichier exécutable. Voulez-vous vraiment à la mesure d'une microseconde de précision?
    • hm, par exemple, je pourrais vouloir le faire parce que je suis un développeur de jeu et je veux savoir combien de temps il faut pour que mon jeu pour démarrer spécifiquement sur Windows 8, par exemple. En tant que développeur, j'ai un impact sur la taille de l'exécutable est: je peux intégrer des ressources dans le fichier binaire exécutable de sections, bande de symboles, pour optimiser l'espace, etc. Je pense que la question doit être clarifiée pour que ce qui est exactement à être mesurée.
    • Droit, qui est une application. Mais voulez-vous vraiment faire cela en mesurant le temps? Vous avez sûrement besoin d'un profiler pour identifier les ce une partie des causes de la haute-temps. La start-up de tout programme doit "sentir instantanée". Vous n'avez pas vraiment besoin de mesurer ce que mon humble avis.
    • btw, si je ne peux pas utiliser auto, le type de données dois-je utiliser pour std::chrono::high_resolution_clock::now()?
    • Je vois. Répondre à moi-même. Devrait être: high_resolution_clock::time_point (exemple ici: cplusplus.com/reference/chrono/high_resolution_clock/now ) ou std::chrono::high_resolution_clock::time_point en cas de non utilisation de l'espace de noms.
    • À l'aide d'eclipse sous windows et je reçois "Fonction" maintenant "n'a pas pu être résolu" sur cette première ligne: auto start = std::chrono::high_resolution_clock::now(); Cependant, il fonctionne très bien sous linux. Quel est le problème?

    InformationsquelleAutor OlivierLi
  2. 7

    Si vous êtes à la recherche de savoir combien de temps est consommé dans l'exécution de votre programme de shell Unix, l'utilisation de Linux le temps comme ci-dessous,

    time ./a.out 

real    0m0.001s
user    0m0.000s
sys     0m0.000s

    Deuxièmement, si vous voulez le temps pris dans l'exécution de nombre de déclarations dans le code du programme (C) essayez de faire usage de gettimeofday() comme ci-dessous,

    #include <sys/time.h>
struct timeval  tv1, tv2;
gettimeofday(&tv1, NULL);
/* Program code to execute here */
gettimeofday(&tv2, NULL);
printf("Time taken in execution = %f seconds\n",
     (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
     (double) (tv2.tv_sec - tv1.tv_sec));
    • Utilisation clock_gettime() à la place - dans Les Pages Man, dis - Le temps retourné par gettimeofday() est affectée par sauts discontinus dans le temps système (par exemple, si l'administrateur système manuellement les modifications de l'heure du système). Si vous avez besoin d'un monotone croissante de l'horloge, voir clock_gettime(2). Le Opengroup dit - Applications doivent utiliser les clock_gettime() à la place de la vétusté des gettimeofday() fonction. <<
    InformationsquelleAutor Sunil Bojanapally
  3. 3

    Le nouveau C++11 std::chrono de la bibliothèque est l'un des plus complexes tas de bordel j'ai jamais vu ou essayé de comprendre comment les utiliser, mais au moins il est multi-plateforme!

    Donc, si vous souhaitez simplifier et de le rendre plus "C-like", y compris la suppression de tous les type-safe classe des trucs qu'il fait, voici 3 simple et très facile à utiliser des fonctions pour obtenir des horodateurs, en millisecondes, de la microseconde, et nanosecondes...qui ne m'a pris qu'environ 12 heures pour écrire*:

    #include <chrono>

//NB: ALL OF THESE 3 FUNCTIONS BELOW USE SIGNED VALUES INTERNALLY AND WILL EVENTUALLY OVERFLOW (AFTER 200+ YEARS OR
//SO), AFTER WHICH POINT THEY WILL HAVE *SIGNED OVERFLOW*, WHICH IS UNDEFINED BEHAVIOR (IE: A BUG) FOR C/C++.
//But...that's ok...this "bug" is designed into the C++11 specification, so whatever. Your machine won't run for 200
//years anyway...

//Get time stamp in milliseconds.
uint64_t millis()
{
    uint64_t ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::
                  now().time_since_epoch()).count();
    return ms; 
}

//Get time stamp in microseconds.
uint64_t micros()
{
    uint64_t us = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::
                  now().time_since_epoch()).count();
    return us; 
}

//Get time stamp in nanoseconds.
uint64_t nanos()
{
    uint64_t ns = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::
                  now().time_since_epoch()).count();
    return ns; 
}

    * (Désolé, j'ai été plus d'un développeur embarqué qu'un programmeur informatique donc tout cela de haut niveau, résumé statique-membre à l'intérieur de la classe-à l'intérieur de l'espace de noms à l'intérieur de l'espace de noms à l'intérieur de l'espace de noms trucs me confond. Ne vous inquiétez pas, je vais aller mieux.)

    Et voici quelques références:

    InformationsquelleAutor Gabriel Staples
  4. 1

    Si vous êtes sur Windows, vous pouvez utiliser QueryPerformanceCounter

    Voir Comment utiliser la fonction QueryPerformanceCounter à l'heure de code dans Visual C++

    __int64 ctr1 = 0, ctr2 = 0, freq = 0;
int acc = 0, i = 0;

//Start timing the code.
if (QueryPerformanceCounter((LARGE_INTEGER *)&ctr1)!= 0)
{
    //Code segment is being timed.
    for (i=0; i<100; i++) acc++;

    //Finish timing the code.
    QueryPerformanceCounter((LARGE_INTEGER *)&ctr2);

    Console::WriteLine("Start Value: {0}",ctr1.ToString());
    Console::WriteLine("End Value: {0}",ctr2.ToString());

    QueryPerformanceFrequency((LARGE_INTEGER *)&freq);

    Console::WriteLine(S"QueryPerformanceCounter minimum resolution: 1/{0} Seconds.",freq.ToString());
    //In Visual Studio 2005, this line should be changed to:     Console::WriteLine("QueryPerformanceCounter minimum resolution: 1/{0} Seconds.",freq.ToString()); 
    Console::WriteLine("100 Increment time: {0} seconds.",((ctr2 - ctr1) * 1.0 / freq).ToString());
}
else
{
    DWORD dwError = GetLastError();
    Console::WriteLine(S"Error value = {0}",dwError.ToString());//In Visual Studio 2005, this line should be changed to: Console::WriteLine("Error value = {0}",dwError.ToString());
}

//Make the console window wait.
Console::WriteLine();
Console::Write("Press ENTER to finish.");
Console::Read();

return 0;

    Vous pouvez le mettre autour d'un appel à CreateProcess(...) et WaitForSingleObject(...) pour l'ensemble de la durée de vie des processus, autrement autour de la principale fonction de votre code.

    • Mais il veut que le temps d'exécution de la programme, pas une fonction. Cela comprend la mise en place de la partie que vous ne pouvez pas généralement accès.
    • Il peut mettre autour d'un appel à CreateProcess(...) et WaitForSingleObject(...) pour l'ensemble de la durée de vie des processus, sinon autour de sa fonction principale. C'est une solution raisonnable, je ne pense pas qu'il mérite vraiment downvotes si...
    • +1, bien qu'étant dépendants de la plateforme. Pourquoi? Facile: sur plusieurs compilateurs pour cette plate-forme, soit std::chrono::high_resolution_clock n'est pas disponible ou est fixé à un pas-si-haut-que-possible de la minuterie. Cette solution spécifique est nécessaire.
    • bon point, si vous modifiez votre réponse à inclure que je vais faire de mon downvote dans un upvote
    • Merci
    • Coup de pouce.Chrono a un décent de haute résolution de l'horloge de Windows.

    InformationsquelleAutor parrowdice