clock

Devuelve el tiempo aproximado de procesador utilizado por el proceso desde el comienzo de una era definida por la implementación relacionada con la ejecución del programa. Para convertir el valor resultante a segundos, divídalo por CLOCKS_PER_SEC .

Solo la diferencia entre dos valores devueltos por diferentes llamadas a clock es significativa, ya que el inicio de la era del clock no tiene que coincidir con el comienzo del programa.

clock puede avanzar más rápido o más lento que el reloj de pared, dependiendo de los recursos de ejecución que el sistema operativo otorgue al programa. Por ejemplo, si la CPU es compartida por otros procesos, clock puede avanzar más lento que el reloj de pared. Por otro lado, si el proceso actual es multihilo y hay más de un núcleo de ejecución disponible, clock puede avanzar más rápido que el reloj de pared.

Valor de retorno

Tiempo de procesador utilizado por el programa hasta ahora.

• Si el tiempo de procesador utilizado no está disponible, devuelve ( clock_t ) ( - 1 ) .
• Si el valor del tiempo de procesador utilizado no puede ser representado por clock_t , devuelve un valor no especificado.

Notas

En sistemas compatibles con POSIX, clock_gettime con el identificador de reloj CLOCK_PROCESS_CPUTIME_ID ofrece una mejor resolución.

El valor devuelto por clock() puede desbordarse en algunas implementaciones. Por ejemplo, en dicha implementación, si clock_t es un entero con signo de 32 bits y CLOCKS_PER_SEC es 1000000 , se desbordará después de aproximadamente 2147 segundos (aproximadamente 36 minutos).

Ejemplo

#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

Referencias

Véase también