std:: clock

Retourne le temps processeur approximatif utilisé par le processus depuis le début d'une ère définie par l'implémentation liée à l'exécution du programme. Pour convertir la valeur résultante en secondes, divisez-la par CLOCKS_PER_SEC .

Seule la différence entre deux valeurs renvoyées par différents appels à std::clock est significative, car le début de l'ère std::clock ne coïncide pas nécessairement avec le démarrage du programme.

std::clock peut avancer plus rapidement ou plus lentement que l'horloge murale, selon les ressources d'exécution allouées au programme par le système d'exploitation. Par exemple, si le processeur est partagé avec d'autres processus, std::clock peut avancer plus lentement que l'horloge murale. En revanche, si le processus actuel est multithreadé et que plusieurs cœurs d'exécution sont disponibles, std::clock peut avancer plus rapidement que l'horloge murale.

Valeur de retour

Temps processeur utilisé par le programme jusqu'à présent.

• Si le temps processeur utilisé n'est pas disponible, retourne ( std:: clock_t ) ( - 1 ) .
• Si la valeur du temps processeur utilisé ne peut pas être représentée par std::clock_t , retourne une valeur non spécifiée.

Exceptions

Ne lance rien.

Notes

Sur les systèmes compatibles POSIX, clock_gettime avec l'identifiant d'horloge CLOCK_PROCESS_CPUTIME_ID offre une meilleure résolution.

La valeur retournée par clock() peut boucler sur certaines implémentations. Par exemple, sur une telle implémentation, si std::clock_t est un entier signé de 32 bits et CLOCKS_PER_SEC vaut 1 '000' 000 , il bouclera après environ 2147 secondes (environ 36 minutes).

Exemple

#include <chrono>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <thread>
// The function f() does some time-consuming work.
void f()
{
    volatile double d = 0;
    for (int n = 0; n != 10000; ++n)
        for (int m = 0; m != 10000; ++m)
            d += d * n * m;
}
int main()
{
    const std::clock_t c_start = std::clock();
    auto t_start = std::chrono::high_resolution_clock::now();
    std::thread t1(f);
    std::thread t2(f); // f() is called on two threads
    t1.join();
    t2.join();
    const std::clock_t c_end = std::clock();
    const auto t_end = std::chrono::high_resolution_clock::now();
    std::cout << std::fixed << std::setprecision(2) << "CPU time used: "
              << 1000.0 * (c_end - c_start) / CLOCKS_PER_SEC << "ms\n"
              << "Wall clock time passed: "
              << std::chrono::duration<double, std::milli>(t_end - t_start) << '\n';
}

CPU time used: 1590.00ms
Wall clock time passed: 808.23ms

Voir aussi