Comment puis-je mesurer le temps CPU et de la paroi de l'horloge temps sur Linux/Windows?

Je veux dire: comment puis-je mesurer mon temps CPU passé sur l'exécution de la fonction et de la paroi de l'horloge temps qu'il faut pour exécuter ma fonction? (Im intéressé par Linux/Windows et les versions x86 et x86_64). Voyez ce que je veux faire (Im en utilisant C++ ici, mais je préfère C):

int startcputime, endcputime, wcts, wcte;

startcputime = cputime();
function(args);
endcputime = cputime();

std::cout << "it took " << endcputime - startcputime << " s of CPU to execute this\n";

wcts = wallclocktime();
function(args);
wcte = wallclocktime();

std::cout << "it took " << wcte - wcts << " s of real time to execute this\n";

Une autre question importante: est ce type de mesure du temps d'architecture indépendant ou pas?

Je me rends compte que vous voulez le faire par programmation dans le code, mais voilà quand même: superuser.com/questions/228056/...
merci:) je sais time sous linux, mais comme vous l'avez écrit, j'ai besoin de le faire directement dans le code C
Sur Windows, clock() donne de la paroi du temps et de GetProcessTimes donne de temps processeur. Sur Linux gettimeofday() donne de la paroi du temps, et clock() donne de temps processeur.
hein! donc c'est un peu compliqué!!! Je vais essayer d'écrire un peu de code et le coller résultats par la suite (pour les deux win/lin). Mais une autre réponse est la bienvenue! 🙂
Si vous pouvez utiliser C++, boost::auto_cpu_timer (boost.org/libs/timer) est-ce que vous avez besoin. Votre code devient boost::auto_cpu_timer t; function(args); (ouais pas de cout, de rien et c'est ça, vous obtenez mur et de l'uc — j'aime cette fonctionnalité).
FWIW, OpenMP a un omp_get_wtime() minuterie que les mesures de la paroi de temps et est assez haute résolution.
En fait, j'ai deux wallclock et cpuclocks encapsulé dans une API pour l'un de mes programmes (Windows + Linux). Si personne ne donne une réponse complète avant que je rentre du travail, je vais le poster ici.
Une fois que j'ai été confrontés à la difficulté de l'horloge() peut être facilement débordé. clock_t était un 4 octets entier signé. Sa valeur maximale est de 2^31=2.147e9. CLOCKS_PER_SEC était de 1000 dans Windows et 1000000 de Linux. Ainsi, la durée maximale était de 24,8 jours de Windows et de 35,8 min dans Linux.

InformationsquelleAutor yak | 2013-07-02

c c++cpu performance time

62

Voici un copier-coller solution qui fonctionne sur Windows et Linux ainsi que le C et le C++.

Comme mentionné dans les commentaires, il y a une bibliothèque boost qui fait cela. Mais si vous ne pouvez pas utiliser boost, cela devrait fonctionner:
```
// Windows
#ifdef _WIN32
#include <Windows.h>
double get_wall_time(){
    LARGE_INTEGER time,freq;
    if (!QueryPerformanceFrequency(&freq)){
        // Handle error
        return 0;
    }
    if (!QueryPerformanceCounter(&time)){
        // Handle error
        return 0;
    }
    return (double)time.QuadPart / freq.QuadPart;
}
double get_cpu_time(){
    FILETIME a,b,c,d;
    if (GetProcessTimes(GetCurrentProcess(),&a,&b,&c,&d) != 0){
        // Returns total user time.
        // Can be tweaked to include kernel times as well.
        return
            (double)(d.dwLowDateTime |
            ((unsigned long long)d.dwHighDateTime << 32)) * 0.0000001;
    }else{
        // Handle error
        return 0;
    }
}

// Posix/Linux
#else
#include <time.h>
#include <sys/time.h>
double get_wall_time(){
    struct timeval time;
    if (gettimeofday(&time,NULL)){
        // Handle error
        return 0;
    }
    return (double)time.tv_sec + (double)time.tv_usec * .000001;
}
double get_cpu_time(){
    return (double)clock() / CLOCKS_PER_SEC;
}
#endif
```
Il y a un tas de façons de mettre en œuvre ces horloges. Mais voici ce que l'extrait ci-dessus utilise:

Pour Windows:
- Mur Du Temps: Les Compteurs De Performance
- Temps CPU: GetProcessTimes()
Pour Linux:
- Mur Du Temps: gettimeofday()
- Temps CPU: horloge()
Et voici une petite démonstration:
```
#include <math.h>
#include <iostream>
using namespace std;

int main(){

    // Start Timers
    double wall0 = get_wall_time();
    double cpu0  = get_cpu_time();

    // Perform some computation.
    double sum = 0;
#pragma omp parallel for reduction(+ : sum)
    for (long long i = 1; i < 10000000000; i++){
        sum += log((double)i);
    }

    // Stop timers
    double wall1 = get_wall_time();
    double cpu1  = get_cpu_time();

    cout << "Wall Time = " << wall1 - wall0 << endl;
    cout << "CPU Time  = " << cpu1  - cpu0  << endl;

    // Prevent Code Elimination
    cout << endl;
    cout << "Sum = " << sum << endl;

}
```
De sortie (12 threads):
```
Wall Time = 15.7586
CPU Time  = 178.719

Sum = 2.20259e+011
```
- Merci beaucoup pour cette! Juste deux questions: les méthodes sont celles indépendants de l'architecture? Est-il possible de faire la même chose (obtenir de l'uc et de la paroi du temps) à l'aide de inline asseembly (et la fonction comme, disons, rdtsc?)
- Il ne devrait pas l'être. Ils sont spécifiques aux systèmes d'exploitation. Et Windows utilise probablement rdtsc() pour mettre en œuvre les compteurs de performance. Mais si c'était sur une architecture différente, il serait le système d'exploitation de l'emploi pour mettre en œuvre ces fonctions. Autant que faire dans ces assembly en ligne, c'est difficile. Notez que rdtsc() par elle-même n'est pas suffisant pour obtenir la paroi de temps depuis que vous avez encore besoin de quelque chose pour vous donner le nombre de tiques il y a en une seconde. Et je ne suis pas au courant de quoi que ce soit à l'extérieur de l'OS qui peut vous donner le temps CPU.
- le temps écoulé (wall1 - wall0) en quelques secondes ?
- Oui, ils sont tous en quelques secondes.
- clock() fonctionne bien sous Linux, mais n'inclut pas le temps passé dans les processus enfants (par exemple, a commencé par un system() appel). Si vous avez besoin également de mesurer le temps passé dans les processus enfants, avoir un regard sur times(), qui vous donne le temps cpu et du système de temps pour le processus en cours et pour les processus enfants. Notez que les horloges par seconde n'est pas CLOCKS_PER_SEC ici, mais plutôt sysconf(_SC_CLK_TCK).
- Soyez prudent avec QueryPerformanceCounter car il peut bond en avant de façon inattendue par plusieurs secondes, de sorte que vous avez à comparer avec constamment GetTickCount: Microsoft KB274323.
- Grande réponse. Cependant, pour votre Linux/Posix versions, vous avez à #include <ctime> ou <time.h> ainsi, afin d'utiliser le clock() fonction et CLOCKS_PER_SEC.
- Merci pour cette remarque. Je l'ai ajouté.
- Exactement le même code sur ma machine windows (64-bit) de l'exécution d'un code cuda: Mur de Temps = 0.251269 Temps CPU = 0.0625 pourquoi le contraire? Je m'attendais à temps CPU pour être plus grand. Il y a quelques threads enfants engendré trop. Si je lance nvidia visual profiler, puis le temps CPU est à zéro, tandis que la paroi reste la même.
- Je ne sais pas beaucoup sur CUDA. Mais si c'est le CPU, puis il semble que le processus est bloqué ou chargé de sortir.
InformationsquelleAutor Mysticial
27

C++11. Beaucoup plus facile à écrire!

Utilisation std::chrono::system_clock pour horloge murale et std::clock pour le processeur de l'horloge
http://en.cppreference.com/w/cpp/chrono/system_clock
```
#include <cstdio>
#include <ctime>
#include <chrono>

.... 

std::clock_t startcputime = std::clock();
do_some_fancy_stuff();
double cpu_duration = (std::clock() - startcputime) / (double)CLOCKS_PER_SEC;
std::cout << "Finished in " << cpu_duration << " seconds [CPU Clock] " << std::endl;


auto wcts = std::chrono::system_clock::now();
do_some_fancy_stuff();
std::chrono::duration<double> wctduration = (std::chrono::system_clock::now() - wcts);
std::cout << "Finished in " << wctduration.count() << " seconds [Wall Clock]" << std::endl;
```
Et voilà, facile et portable! Pas besoin de #ifdef _WIN32 ou LINUX!

Vous pourriez même utiliser chrono::high_resolution_clock si vous avez besoin de plus de précision
http://en.cppreference.com/w/cpp/chrono/high_resolution_clock
- pourquoi utilisez-vous auto pour wcts puis std::chrono::duration<double> pour wctduration?
- Malheureusement std::clock travaux sur des Fenêtres d'une façon non standard, de sorte que "portable" est un peu trop optimiste.
InformationsquelleAutor carlduke
13

Pour donner un exemple concret de @lip suggestion pour l'utilisation boost::timer si vous le pouvez (testé avec Boost 1.51):
```
#include <boost/timer/timer.hpp>

//this is wallclock AND cpu time
boost::timer::cpu_timer timer;

... run some computation ...

boost::timer::cpu_times elapsed = timer.elapsed();
std::cout << " CPU TIME: " << (elapsed.user + elapsed.system) / 1e9 << " seconds"
          << " WALLCLOCK TIME: " << elapsed.wall / 1e9 << " seconds"
          << std::endl;
```
- Quel est le temps total?
- "total" dans quel sens ? Le temps CPU est généralement réparti sur tous les threads/carottes (somme de la durée de chaque cœur de PROCESSEUR est occupé à exécuter le code), wallclock temps est combien de temps vous avez dû attendre jusqu'à la fin du code. Pour le code en cours d'exécution sur plus d'un cœur de PROCESSEUR, temps de calcul peut être plus grande que la wallclock temps.
- J'ai déjà compris que c'est le mur le temps de l'horloge.
- Non vous n'avez pas à comprendre les deux sont "total" est un mur de temps de l'horloge et l'autre est le temps cpu.
InformationsquelleAutor Andre Holzner
-1

Utiliser le clock méthode dans temps.h:
```
clock_t start = clock();
/* Do stuffs */
clock_t end = clock();
float seconds = (float)(end - start) / CLOCKS_PER_SEC;
```
Malheureusement, cette méthode retourne de temps CPU sur Linux, mais renvoie l'horloge murale sur Windows (merci aux intervenants pour cette information).
- et il me donne qui de temps? horloge murale temps ou temps cpu?
- Il mesure le temps CPU, pas sur l'horloge murale, si c'est ce que vous cherchez.
- En fait, clock() donne le temps cpu sur Linux, et le mur du temps sur Windows.
- Je cherche pour les deux;) bravo pour ce, alors maintenant je cherche juste une horloge murale temps 😛
- êtes-vous sûr à 100%? pouvez-vous donner des exemples de code (pour win/lin)? toutes les docs sur ce sujet?
- Il suffit de l'essayer. Vous verrez que clock() donne en temps réel, indépendamment de l'activité du thread.
- J'ai été mal informé, désolé. Laisser Windows à vis avec les choses.
- elle est supposée retourner de temps PROCESSEUR selon la norme ISO; MS la documentation indique clairement qu'il renvoie l'horloge murale dans Windows, mais...
InformationsquelleAutor syb0rg

Vous devez vous connecter pour publier un commentaire.