[Linux] [C] CPU-Zeit pro Prozess / Thread abrufen

Ich hatte die Gelegenheit, es nachzuschlagen, also habe ich es etwas detaillierter zusammengefasst.

Holen Sie sich CPU-Zeit für den Prozess

clock_gettime (CLOCK_PROCESS_CPUTIME_ID)

Anwendungsbeispiel

struct timespec ts;
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts)

getrusage (RUSAGE_SELF) Gibt die Ressourcennutzung des aufrufenden Prozesses zurück, die Summe der Ressourcen, die von allen Threads in diesem Prozess verwendet werden.

Anwendungsbeispiel

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

Holen Sie sich die CPU-Zeit für den Thread

clock_gettime (CLOCK_THREAD_CPUTIME_ID)

Anwendungsbeispiel

struct timespec ts;
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts)

Im Fall der obigen Erfassung kann in jedem Thread nur seine eigene CPU-Zeit erfasst werden. Wenn Sie Geld von außerhalb des Threads verdienen möchten, erhalten Sie es in Kombination mit dem folgenden pthread_getcpuclockid.

pthread_getcpuclockid + clock_gettime

Anwendungsbeispiel

//Thread-Erstellung
pthread_t thread;
pthread_create(&thread, NULL, thread_start, NULL);

clockid_t cid;
pthread_getcpuclockid(pthread_self(), &cid); //Um die Uhr des Hauptthreads zu erhalten
pthread_getcpuclockid(thread, &cid); //Um die Uhr eines bestimmten Threads zu erhalten

struct timespec ts;
clock_gettime(cid, &ts)

getrusage (RUSAGE_THREAD) Gibt Statistiken zur Ressourcennutzung für den aufrufenden Thread zurück

Anwendungsbeispiel

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

Anwendungsbeispiel

Dies ist ein Implementierungsbeispiel. Dies ist eine leicht modifizierte Version des folgenden Manpage-Beispielcodes. Man page of PTHREAD_GETCPUCLOCKID Ich wollte atomare Variablen (stdatomic.h) verwenden, also muss ich mit C11 bauen.

Implementierungsbeispiel

// 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);
}

Lauf

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

• Der Grund, warum es durch 1000 geteilt wird, ist, dass es mit der Stichprobe von Man Page übereinstimmt. Es sieht so aus, als würden Sie Ziffern fallen lassen.

Referenz

Man page of CLOCK_GETRES Man page of PTHREAD_GETCPUCLOCKID Man page of GETRUSAGE Atomic-Einführung in die C-Sprache Atomkopie zwischen atomaren Variablen - Yohhoys Tagebuch