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 à clock est significative, car le début de l'ère clock ne coïncide pas nécessairement avec le démarrage du programme.

clock le temps peut avancer plus rapidement ou plus lentement que l'horloge murale, selon les ressources d'exécution accordées au programme par le système d'exploitation. Par exemple, si le CPU est partagé par d'autres processus, clock le temps peut avancer plus lentement que l'horloge murale. D'autre part, si le processus actuel est multithreadé et que plusieurs cœurs d'exécution sont disponibles, clock le temps 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 ( clock_t ) ( - 1 ) .
• Si la valeur du temps processeur utilisé ne peut pas être représentée par clock_t , retourne une valeur non spécifiée.

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 clock_t est un entier signé de 32 bits et CLOCKS_PER_SEC vaut 1000000 , il bouclera après environ 2147 secondes (environ 36 minutes).

Exemple

#ifndef __STDC_NO_THREADS__
    #include <threads.h>
#else
    // POSIX alternative
    #define _POSIX_C_SOURCE 199309L
    #include <pthread.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// the function f() does some time-consuming work
int f(void* thr_data) // return void* in POSIX
{
    (void) thr_data;
    volatile double d = 0;
    for (int n = 0; n < 10000; ++n)
       for (int m = 0; m < 10000; ++m)
           d += d * n * m;
    return 0;
}
int main(void)
{
    struct timespec ts1, tw1; // both C11 and POSIX
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts1); // POSIX
    clock_gettime(CLOCK_MONOTONIC, &tw1); // POSIX; use timespec_get in C11
    clock_t t1 = clock();
#ifndef __STDC_NO_THREADS__
    thrd_t thr1, thr2;  // C11; use pthread_t in POSIX
    thrd_create(&thr1, f, NULL); // C11; use pthread_create in POSIX
    thrd_create(&thr2, f, NULL);
    thrd_join(thr1, NULL); // C11; use pthread_join in POSIX
    thrd_join(thr2, NULL);
#endif
    struct timespec ts2, tw2;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts2);
    clock_gettime(CLOCK_MONOTONIC, &tw2);
    clock_t t2 = clock();
    double dur = 1000.0 * (t2 - t1) / CLOCKS_PER_SEC;
    double posix_dur = 1000.0 * ts2.tv_sec + 1e-6 * ts2.tv_nsec
                           - (1000.0 * ts1.tv_sec + 1e-6 * ts1.tv_nsec);
    double posix_wall = 1000.0 * tw2.tv_sec + 1e-6 * tw2.tv_nsec
                            - (1000.0 * tw1.tv_sec + 1e-6 * tw1.tv_nsec);
    printf("CPU time used (per clock()): %.2f ms\n", dur);
    printf("CPU time used (per clock_gettime()): %.2f ms\n", posix_dur);
    printf("Wall time passed: %.2f ms\n", posix_wall);
}

CPU time used (per clock()): 1580.00 ms
CPU time used (per clock_gettime()): 1582.76 ms
Wall time passed: 792.13 ms

Références

Voir aussi