función pthread_getcpuclockid() en C con ejemplos

La función pthread_getcpuclockid() devuelve el ID de reloj del reloj de tiempo de la CPU de un subproceso especificado.

Sintaxis:

int pthread_getcpuclockid (pthread_t id, clockid_t* clock_id);

Parámetros: Este método acepta los siguientes parámetros:

• subproceso: la identificación del subproceso para el que desea obtener la identificación del reloj, que puede obtener cuando llama a pthread_create() o pthread_self().
• clock_id: un puntero a un objeto clockid_t donde la función puede almacenar la ID del reloj.

Valor devuelto: este método devuelve la hora del reloj de la CPU para un subproceso específico.

A continuación se muestran algunos ejemplos para mostrar la implementación del método pthread_getcpuclockid():

Ejemplo 1: el programa a continuación crea un subproceso y luego usa clock_gettime(2) para recuperar el tiempo total de CPU del proceso y el tiempo de CPU por subproceso consumido por los dos subprocesos.

// C program to implement
// the above approach
#include <errno.h>
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.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)
  
    static void* thread_start(void* arg)
    {
        printf(
            "Subthread starting infinite loop\n");
        for (;;)
            continue;
    }
  
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("%4jd.%03ld\n",
           (intmax_t)ts.tv_sec,
           ts.tv_nsec / 1000000);
}
  
// Driver code
int main(int argc,
         char* argv[])
{
    pthread_t thread;
    clockid_t cid;
    int 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 (int 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);
  
    // Terminates both threads
    exit(EXIT_SUCCESS);
}

Producción:

$./a.out Subproceso
principal inactivo
Subproceso que inicia un bucle infinito Subproceso
principal que consume algo de tiempo de CPU… Tiempo
total de CPU del proceso : 1,368 Tiempo de CPU de
subproceso principal: 0,376
Tiempo de CPU de subproceso: 0,992

Ejemplo 2: El siguiente programa crea un proceso y luego usa clock_gettime(2) para recuperar el tiempo total de CPU del proceso y el tiempo de CPU del proceso principal y secundario consumido por los dos procesos.

// C program to implement
// the above approach
#include <pthread.h>
#include <stdio.h>
#include <time.h>
  
pthread_cond_t cond2;
pthread_condattr_t cond2attr;
  
#define test(clk_id) \
    {                \
    printf("%s:%d\n",
#clk_id, clk_id);
           }
  
static void print_clock(char* msg,
                        clockid_t cid)
{
    struct timespec ts;
  
    printf("%s", msg);
  
    if (clock_gettime(cid, &ts) == -1)
        fprintf(stderr,
                "clock_gettime");
  
    printf("%4ld.%03ld\n",
           ts.tv_sec,
           ts.tv_nsec / 1000000);
}
  
void* test_task_fn(void* unused)
{
    printf("test_task_fn.\n");
  
    for (;;)
        continue;
  
    static int status = 12121;
  
    pthread_exit(&status);
    return NULL;
}
  
// Driver code
int main()
{
    int* pstatus;
    int ret;
    clockid_t clockid = 0;
    pthread_t thread_id;
  
    pthread_create(&thread_id, NULL,
                   test_task_fn, NULL);
  
    printf("Main thread sleeping\n");
    sleep(1);
  
    ret = pthread_getcpuclockid(
        thread_id, &clockid);
    print_clock("  Child", clockid);
  
    ret = pthread_getcpuclockid(
        pthread_self(), &clockid);
    print_clock(" Parent",
                clockid);
    print_clock("Process",
                CLOCK_PROCESS_CPUTIME_ID);
  
    pthread_join(thread_id,
                 (void**)&pstatus);
  
    printf("pstatus = %d\n",
           *pstatus);
  
    return 0;
}

Producción:

[root@localhost pthread]# ./compile.sh pthread_getcpuclockid.c
[root@localhost pthread]# ./a.out Subproceso
principal durmiente
test_task_fn.
Niño 0.999
Padre 0.001
Proceso 1.000