Comment faire pour créer une haute résolution de la minuterie dans Linux pour mesurer le rendement du programme?

Je suis en train de comparer les GPU pour des performances de l'UC. Pour les GPU NVIDIA, j'ai été en utilisant le cudaEvent_t types d'obtenir une synchronisation précise.

Pour le CPU j'ai été en utilisant le code suivant:

//Timers
clock_t start, stop;
float elapsedTime = 0;

//Capture the start time

start = clock();

//Do something here
.......

//Capture the stop time
stop = clock();
//Retrieve time elapsed in milliseconds
elapsedTime = (float)(stop - start) / (float)CLOCKS_PER_SEC * 1000.0f;

Apparemment, ce morceau de code n'est bon si vous faites le décompte en secondes. Aussi, les résultats parfois très étrange.

Personne ne sait de manière à créer une haute résolution de la minuterie dans Linux?

Voir cette question: stackoverflow.com/questions/700392/...

InformationsquelleAutor sj755 | 2011-07-19

45

Découvrez clock_gettime, qui est une interface POSIX à haute résolution des chronomètres.

Si, après avoir lu la page de manuel, vous êtes de gauche s'interrogent sur la différence entre CLOCK_REALTIME et CLOCK_MONOTONIC, voir Différence entre CLOCK_REALTIME et CLOCK_MONOTONIC?

Voir la page suivante pour un exemple complet: http://www.guyrutenberg.com/2007/09/22/profiling-code-using-clock_gettime/
```
#include <iostream>
#include <time.h>
using namespace std;

timespec diff(timespec start, timespec end);

int main()
{
    timespec time1, time2;
    int temp;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time1);
    for (int i = 0; i< 242000000; i++)
        temp+=temp;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
    cout<<diff(time1,time2).tv_sec<<":"<<diff(time1,time2).tv_nsec<<endl;
    return 0;
}

timespec diff(timespec start, timespec end)
{
    timespec temp;
    if ((end.tv_nsec-start.tv_nsec)<0) {
        temp.tv_sec = end.tv_sec-start.tv_sec-1;
        temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
    } else {
        temp.tv_sec = end.tv_sec-start.tv_sec;
        temp.tv_nsec = end.tv_nsec-start.tv_nsec;
    }
    return temp;
}
```
- Juste si je suis clair sur ce que j'ai lu, pouvez-vous me donner un exemple sur comment vous pouvez l'utiliser clock_gettime à trouver le temps écoulé en nanosecondes?
- J'ai ajouté un lien vers un exemple complet.
- Cela devrait le faire merci!!!
- L'OP a été posté en C, mais votre réponse est C++. Toujours utile, mais pas sur mon ZedBoard qui n'a pas de C++ libs 😀 Pour fixer, préfixe de la timespec avec struct et d'en extraire les couts.
- donc la réponse mentionne explicitement les CLOCK_REALTIME et CLOCK_MONOTONIC mais nous nous retrouvons avec CLOCK_PROCESS_CPUTIME_ID dans l'exemple de code? Quelqu'un peut-il éclaircir ce point? Qu'est-ce aller?
InformationsquelleAutor NPE
18

À résumer les informations présentées jusqu'à présent, ce sont les deux fonctions requises pour des applications typiques.
```
#include <time.h>

//call this function to start a nanosecond-resolution timer
struct timespec timer_start(){
    struct timespec start_time;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start_time);
    return start_time;
}

//call this function to end a timer, returning nanoseconds elapsed as a long
long timer_end(struct timespec start_time){
    struct timespec end_time;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end_time);
    long diffInNanos = (end_time.tv_sec - start_time.tv_sec) * (long)1e9 + (end_time.tv_nsec - start_time.tv_nsec);
    return diffInNanos;
}
```
Voici un exemple de la façon de les utiliser dans le moment combien de temps il faut pour calculer la variance d'une liste d'entrée.
```
struct timespec vartime = timer_start();  //begin a timer called 'vartime'
double variance = var(input, MAXLEN);  //perform the task we want to time
long time_elapsed_nanos = timer_end(vartime);
printf("Variance = %f, Time taken (nanoseconds): %ld\n", variance, time_elapsed_nanos);
```
- N'êtes-vous pas en ignorant le tv_sec de la timespec? Aussi, pourquoi CLOCK_PROCESS_CPUTIME_ID plutôt que CLOCK_MONOTONIC?
- L'affiche est de comparer CPU du GPU de la performance. Vous êtes honnêtement donner le code d'arriver le temps de calcul. CLOCK_PROCESS_CPUTIME_ID. Cela signifie qu'il va obtenir la vitesse de l'onduleur de plusieurs ordres de grandeur. Pour le CPU/GPU de la performance (cette question) toujours utiliser le mur du temps. Supprimer cette réponse.
- Yep, en temps réel peut-être mieux dans l'affiche du cas d'utilisation. Je ne vais pas le prendre vers le bas une réponse même si, évidemment, les gens l'ont trouvé utile. Des acclamations.
- Avant d'utiliser CLOCK_PROGRESS_CPUTIME_ID vous devriez exécuter grep constant_tsc /proc/cpuinfo de comprendre comment cette horloge fonctionne. Si vous le CPU ne prend pas en charge constant_tsc, le temps de refléter les cycles d'horloge du CPU. Si l'indicateur est activé, l'horloge est ajustée pour tenir compte courant de la fréquence du PROCESSEUR. Je donne ce un -1 car time_elapsed_nanos est mal calculée. Ceci peut-être une meilleure approche.
InformationsquelleAutor Alex
1
```
struct timespec t;
clock_gettime(CLOCK_REALTIME, &t);
```
il est également CLOCK_REALTIME_HR, mais je ne suis pas sûr si cela fait une différence..
- Et je ne suis pas sûr si CLOCK_REALTIME_HR est supporté. Question.
InformationsquelleAutor Karoly Horvath
1

Êtes-vous intéressé dans le mur du temps (combien de temps réellement écoulé) ou nombre de cycles (nombre de cycles)? Dans le premier cas, vous devez utiliser quelque chose comme gettimeofday.

La résolution la plus élevée de la minuterie utilise le RDTSC x86 instructions de montage. Toutefois, ce dispositif tops d'horloge, de sorte que vous devez être sûr que le mode d'économie d'énergie est désactivé.

La page du wiki pour TSC donne quelques exemples: http://en.wikipedia.org/wiki/Time_Stamp_Counter
- Sur un PROCESSEUR récent, rdtsc corrélats 1:1 avec de l'horloge murale, pas de noyau de cycles d'horloge. Il n'a pas de pause lors de votre processus (ou de l'ensemble de la CPU) est le sommeil, et il fonctionne à fréquence constante, indépendamment de turbo / économie d'énergie. Utiliser les compteurs de performance pour mesurer âme cycles d'horloge. par exemple,perf stat awk 'BEGIN {for (i=0 ; i<10000000; i++){}}'.
- Je suis réellement intéressé dans le mur du temps. Votre réponse frappé la tache!
- Est-il possible d'établir un lien de votre réponse à mon commentaire d'origine?
InformationsquelleAutor Foo Bah

Après la lecture de ce fil, j'ai commencé à tester le code pour clock_gettime contre c++11 du chrono et ils ne semblent pas correspondre.

Il y a un énorme fossé entre eux!

La std::chrono::secondes(1) semble être équivalent à ~30,000 de la clock_gettime

#include <ctime>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <thread>
#include <chrono>
#include <iomanip>
#include <vector>
timespec diff(timespec start, timespec end);
timespec get_cpu_now_time();
std::vector<timespec> get_start_end_pairs();
void output_deltas(const std::vector<timespec> &start_end_pairs);
//=============================================================
int main()
{
std::cout << "Hello waiter" << std::endl; //flush is intentional
std::vector<timespec> start_end_pairs = get_start_end_pairs();
output_deltas(start_end_pairs);
return EXIT_SUCCESS;
}
//=============================================================
std::vector<timespec> get_start_end_pairs()
{
std::vector<timespec> start_end_pairs;
for (int i = 0; i < 20; ++i)
{
start_end_pairs.push_back(get_cpu_now_time());
std::this_thread::sleep_for(std::chrono::seconds(1));
start_end_pairs.push_back(get_cpu_now_time());
}
return start_end_pairs;
}
//=============================================================
void output_deltas(const std::vector<timespec> &start_end_pairs)
{
for (auto it_start = start_end_pairs.begin(); it_start != start_end_pairs.end(); it_start += 2)
{
auto it_end = it_start + 1;
auto delta = diff(*it_start, *it_end);
std::cout
<< "Waited ("
<< delta.tv_sec
<< "\ts\t"
<< std::setw(9)
<< std::setfill('0')
<< delta.tv_nsec
<< "\tns)"
<< std::endl;
}
}
//=============================================================
timespec diff(timespec start, timespec end)
{
timespec temp;
temp.tv_sec = end.tv_sec-start.tv_sec;
temp.tv_nsec = end.tv_nsec-start.tv_nsec;
if (temp.tv_nsec < 0) {
++temp.tv_sec;
temp.tv_nsec += 1000000000;
}
return temp;
}
//=============================================================
timespec get_cpu_now_time()
{
timespec now_time;
memset(&now_time, 0, sizeof(timespec));
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &now_time);
return now_time;
}

de sortie:

Waited (0   s   000064802   ns)
Waited (0   s   000028512   ns)
Waited (0   s   000030664   ns)
Waited (0   s   000041233   ns)
Waited (0   s   000013458   ns)
Waited (0   s   000024068   ns)
Waited (0   s   000027591   ns)
Waited (0   s   000028148   ns)
Waited (0   s   000033783   ns)
Waited (0   s   000022382   ns)
Waited (0   s   000027866   ns)
Waited (0   s   000028085   ns)
Waited (0   s   000028012   ns)
Waited (0   s   000028172   ns)
Waited (0   s   000022121   ns)
Waited (0   s   000052940   ns)
Waited (0   s   000032138   ns)
Waited (0   s   000028082   ns)
Waited (0   s   000034486   ns)
Waited (0   s   000018875   ns)

Voir: stackoverflow.com/a/7506987/576911

InformationsquelleAutor radato

0

clock_gettime(2)
- clock_gettime est préférable, car il vous obtient nanosecondes.
InformationsquelleAutor Nikolai Fetissov

epoll mise en œuvre:
https://github.com/ielife/simple-timer-for-c-language

utiliser comme ceci:

timer_server_handle_t *timer_handle = timer_server_init(1024);
if (NULL == timer_handle) {
fprintf(stderr, "timer_server_init failed\n");
return -1;
}
ctimer timer1;
timer1.count_ = 3;
timer1.timer_internal_ = 0.5;
timer1.timer_cb_ = timer_cb1;
int *user_data1 = (int *)malloc(sizeof(int));
*user_data1 = 100;
timer1.user_data_ = user_data1;
timer_server_addtimer(timer_handle, &timer1);
ctimer timer2;
timer2.count_ = -1;
timer2.timer_internal_ = 0.5;
timer2.timer_cb_ = timer_cb2;
int *user_data2 = (int *)malloc(sizeof(int));
*user_data2 = 10;
timer2.user_data_ = user_data2;
timer_server_addtimer(timer_handle, &timer2);
sleep(10);
timer_server_deltimer(timer_handle, timer1.fd);
timer_server_deltimer(timer_handle, timer2.fd);
timer_server_uninit(timer_handle);

InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.