Comment mesurer la durée d'exécution du processeur et en temps réel sous Linux et Windows ?

Comment mesurer le processeur et la durée d'exécution en temps réel sous Linux et Windows

Déterminer le processeur d'un programme et la durée d'exécution en temps réel est crucial pour l'optimisation des performances. Voici comment y parvenir sous Linux et Windows, prenant en charge les architectures x86 et x86_64.

Exécution des fonctions et mesure du temps d'horloge murale

Pour mesurer le temps CPU dépensé par votre fonction et le temps d'exécution de l'horloge murale, utilisez le code suivant :

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

Architecture indépendante de la plate-forme

L'approche de mesure du temps présentée est indépendante de l'architecture , ce qui signifie qu'il peut être implémenté et fournir des résultats cohérents sur différentes architectures de processeur.

Implémentation

Voici une solution polyvalente qui fonctionne pour Windows et Linux en C et C :

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

//  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

Implémentation de plateforme spécifique :

• Windows :

  • Wall Time : compteurs de performances
  • Heure CPU : GetProcessTimes()

• Linux :

  • Heure murale : gettimeofday()
  • Heure CPU : clock()

Démonstration

Voici un exemple simple présentant l'implémentation :

#include <math.h>
#include <iostream>
using namespace std;

int main(){

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

    //  Computational task (e.g., numerical summation).
    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 (optimization).
    cout << endl;
    cout << "Sum = " << sum << endl;
}

Ce code mesure l'horloge murale et le temps CPU pris par une sommation numérique hypothétique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!