clock

Gibt die ungefähre Prozessorzeit zurück, die vom Prozess seit Beginn einer implementationsdefinierten Ära in Bezug auf die Programmausführung genutzt wurde. Um den Ergebniswert in Sekunden umzuwandeln, teilen Sie ihn durch CLOCKS_PER_SEC .

Nur die Differenz zwischen zwei Werten, die durch verschiedene Aufrufe von clock zurückgegeben werden, ist aussagekräftig, da der Beginn der clock -Ära nicht mit dem Start des Programms übereinstimmen muss.

clock -Zeit kann schneller oder langsamer fortschreiten als die Wanduhr, abhängig von den Ausführungsressourcen, die dem Programm vom Betriebssystem zugewiesen werden. Beispielsweise, wenn die CPU von anderen Prozessen geteilt wird, kann die clock -Zeit langsamer fortschreiten als die Wanduhr. Andererseits, wenn der aktuelle Prozess multithreaded ist und mehr als ein Ausführungskern verfügbar ist, kann die clock -Zeit schneller fortschreiten als die Wanduhr.

Rückgabewert

Bisher vom Programm verwendete Prozessorzeit.

• Falls die verwendete Prozessorzeit nicht verfügbar ist, wird ( clock_t ) ( - 1 ) zurückgegeben.
• Falls der Wert der verwendeten Prozessorzeit nicht durch clock_t dargestellt werden kann, wird ein nicht spezifizierter Wert zurückgegeben.

Hinweise

Auf POSIX-kompatiblen Systemen bietet clock_gettime mit der Clock-ID CLOCK_PROCESS_CPUTIME_ID eine bessere Auflösung.

Der von clock() zurückgegebene Wert kann auf einigen Implementierungen umlaufen. Zum Beispiel wird auf einer solchen Implementierung, wenn clock_t ein vorzeichenbehafteter 32-Bit-Integer ist und CLOCKS_PER_SEC den Wert 1000000 hat, der Wert nach etwa 2147 Sekunden (etwa 36 Minuten) umlaufen.

Beispiel

#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

Referenzen

Siehe auch