[Linux] [C] Obtenir le temps CPU par processus / thread

J'ai eu la chance de le rechercher, alors je l'ai résumé un peu plus en détail.

Obtenir du temps CPU pour le processus

clock_gettime (CLOCK_PROCESS_CPUTIME_ID)

Exemple d'utilisation

struct timespec ts;
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts)

getrusage (RUSAGE_SELF) Renvoie l'utilisation des ressources du processus appelant, la somme des ressources utilisées par tous les threads de ce processus.

Exemple d'utilisation

struct rusage usg;
getrusage(RUSAGE_THREAD, &usg);

Obtenir le temps CPU pour le thread

clock_gettime (CLOCK_THREAD_CPUTIME_ID)

Exemple d'utilisation

struct timespec ts;
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts)

Dans le cas de l'acquisition ci-dessus, seul son propre temps CPU peut être acquis dans chaque thread. Si vous voulez gagner de l'argent en dehors du thread, obtenez-le en combinaison avec le pthread_getcpuclockid suivant.

pthread_getcpuclockid + clock_gettime

Exemple d'utilisation

//Création de fil
pthread_t thread;
pthread_create(&thread, NULL, thread_start, NULL);

clockid_t cid;
pthread_getcpuclockid(pthread_self(), &cid); //Pour obtenir l'ID d'horloge du thread principal
pthread_getcpuclockid(thread, &cid); //Pour obtenir l'ID d'horloge d'un thread spécifique

struct timespec ts;
clock_gettime(cid, &ts)

getrusage (RUSAGE_THREAD) Renvoie les statistiques d'utilisation des ressources pour le thread appelant

Exemple d'utilisation

struct rusage usg;
getrusage(RUSAGE_THREAD, &usg);

Exemple d'utilisation

Ceci est un exemple de mise en œuvre. Il s'agit d'une version légèrement modifiée de l'exemple de code de page de manuel ci-dessous. Man page of PTHREAD_GETCPUCLOCKID Je voulais utiliser des variables atomiques (stdatomic.h), donc je dois construire avec C11.

Exemple d'implémentation

// to use RUSAGE_THREAD
#define _GNU_SOURCE
#include <sys/resource.h>

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#include <errno.h>

// C11 only
#include <stdatomic.h>

#define handle_error(msg) \
        do { perror(msg); exit(EXIT_FAILURE); } while (0)

#define handle_error_en(en, msg) \
        do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

_Atomic int thread_end_flag = ATOMIC_VAR_INIT(0);

static void
pclock(char *msg, clockid_t cid)
{
    struct timespec ts;

    printf("%s", msg);
    if (clock_gettime(cid, &ts) == -1)
        handle_error("clock_gettime");
    printf("%4ld.%03ld\n", ts.tv_sec, ts.tv_nsec / 1000000);
}

static void *
thread_start(void *arg)
{
    printf("Subthread starting infinite loop\n");

    for (;;)
    {
        if (thread_end_flag) break;
        continue;
    }

    pclock("SubThread CPU time: ", CLOCK_PROCESS_CPUTIME_ID);
    // rusage
    int s;
    struct rusage usg;
    s = getrusage(RUSAGE_THREAD, &usg);
    if (s != 0)
        handle_error_en(s, "getrusage(thread)");
    printf("getrusage(thread) : user ");
    printf("%4ld.%03ld, ", usg.ru_utime.tv_sec, usg.ru_utime.tv_usec / 1000);
    printf("system ");
    printf("%4ld.%03ld\n", usg.ru_stime.tv_sec, usg.ru_stime.tv_usec / 1000);
}

int
main(int argc, char *argv[])
{
    pthread_t thread;
    clockid_t cid;
    int j, s;

    s = pthread_create(&thread, NULL, thread_start, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_create");

    printf("Main thread sleeping\n");
    sleep(1);

    printf("Main thread consuming some CPU time...\n");
    for (j = 0; j < 2000000; j++)
        getppid();

    pclock("Process total CPU time: ", CLOCK_PROCESS_CPUTIME_ID);

    s = pthread_getcpuclockid(pthread_self(), &cid);
    if (s != 0)
        handle_error_en(s, "pthread_getcpuclockid");
    pclock("Main thread CPU time:   ", cid);

    /* The preceding 4 lines of code could have been replaced by:
       pclock("Main thread CPU time:   ", CLOCK_THREAD_CPUTIME_ID); */

    s = pthread_getcpuclockid(thread, &cid);
    if (s != 0)
        handle_error_en(s, "pthread_getcpuclockid");
    pclock("Subthread CPU time: 1    ", cid);

    // rusage
    struct rusage usg;
    s = getrusage(RUSAGE_SELF, &usg);
    if (s != 0)
        handle_error_en(s, "getrusage(process)");
    printf("getrusage(process) : user ");
    printf("%4ld.%03ld, ", usg.ru_utime.tv_sec, usg.ru_utime.tv_usec / 1000);
    printf("system ");
    printf("%4ld.%03ld\n", usg.ru_stime.tv_sec, usg.ru_stime.tv_usec / 1000);

    thread_end_flag = 1;
    pthread_join(thread, NULL);
}

Courir

koara@ubuntu:~/work$ gcc -pthread -std=c11 test.c 
koara@ubuntu:~/work$ ./a.out 
Main thread sleeping
Subthread starting infinite loop
Main thread consuming some CPU time...
Process total CPU time:    1.143
Main thread CPU time:      0.078
Subthread CPU time: 1       1.064
getrusage(process) : user    1.076, system    0.064
SubThread CPU time:    1.143
getrusage(thread) : user    1.060, system    0.004

• La raison pour laquelle il est divisé par 1000 est qu'il correspond à l'échantillon de page de manuel. On dirait que vous perdez des chiffres.

référence

Man page of CLOCK_GETRES Man page of PTHREAD_GETCPUCLOCKID Man page of GETRUSAGE Présentation atomique du langage C Copie atomique entre le journal des variables atomiques-yohhoy