Medir o tempo do sistema com a função getrusage em C
-
Use a função
getrusagepara medir o tempo do sistema de um programa de thread único -
Use a função
getrusagepara medir o tempo do sistema do programa multi-threaded
Este artigo irá demonstrar vários métodos sobre como medir o tempo do sistema com a função getrusage em C.
Use a função getrusage para medir o tempo do sistema de um programa de thread único
Geralmente, há dois componentes de tempo em qualquer programa em execução. O tempo do sistema representa o período que o programa executa no modo kernel e o tempo do usuário, denotando o tempo de execução decorrido no modo usuário. A soma de ambos os valores é chamada de tempo de processo, que é uma medida útil para otimizar o desempenho do programa.
A função getrusage recupera vários pontos de dados sobre o processo, e um deles é o tempo do sistema representado como objeto struc timeval. getrusage recebe um valor inteiro e um endereço do objeto struct rusage como argumentos. O inteiro especifica quais threads / processos devem ser medidos e pode ter os seguintes valores de macro predefinidos RUSAGE_SELF, RUSAGE_CHILDREN ou RUSAGE_THREAD.
Por outro lado, a estrutura rusage deve ser declarada com antecedência, e a chamada de função bem-sucedida armazena os valores correspondentes nela. Como a estrutura timeval contém dois membros de dados - segundos e microssegundos para representar o tempo, implementamos as funções diffUserTime e diffSystemTime para calcular o tempo decorrido em segundos.
#include <stdio.h>
#include <stdlib.h>
#include <sys/resource.h>
#include <unistd.h>
enum { NUM_ITERS = 1000000 };
void loopFunc1(size_t num) {
int tmp = 0;
for (int i = 0; i < num; ++i) {
tmp += 1;
}
}
void *loopFunc2(size_t num) {
for (int i = 0; i < num; ++i) {
getpid();
}
return NULL;
}
float diffUserTime(struct rusage *start, struct rusage *end) {
return (end->ru_utime.tv_sec - start->ru_utime.tv_sec) +
1e-6 * (end->ru_utime.tv_usec - start->ru_utime.tv_usec);
}
float diffSystemTime(struct rusage *start, struct rusage *end) {
return (end->ru_stime.tv_sec - start->ru_stime.tv_sec) +
1e-6 * (end->ru_stime.tv_usec - start->ru_stime.tv_usec);
}
int main() {
struct rusage start, end;
getrusage(RUSAGE_SELF, &start);
loopFunc1(NUM_ITERS);
getrusage(RUSAGE_SELF, &end);
printf("loopFunc1 stats:\n");
printf(" CPU time: %.06f sec user, %.06f sec system\n",
diffUserTime(&start, &end), diffSystemTime(&start, &end));
getrusage(RUSAGE_SELF, &start);
loopFunc1(NUM_ITERS);
getrusage(RUSAGE_SELF, &end);
printf("loopFunc2 stats:\n");
printf(" CPU time: %.06f sec user, %.06f sec system\n",
diffUserTime(&start, &end), diffSystemTime(&start, &end));
exit(EXIT_SUCCESS);
}
Resultado:
loopFunc1 stats:
CPU time: 0.002193 sec user, 0.000000 sec system
loopFunc2 stats:
CPU time: 0.002087 sec user, 0.000190 sec system
Use a função getrusage para medir o tempo do sistema do programa multi-threaded
A função getrusage também pode recuperar a hora do sistema usada por todos os threads no processo de chamada. O argumento RUSAGE_SELF especifica este recurso e é mutuamente utilizável em um programa de thread único, conforme visto no exemplo anterior.
No código de amostra a seguir, criamos 16 threads, todos os quais executam a mesma função loopFunc2 e terminam. Independentemente disso, o tempo recuperado pela chamada getrusage é igual ao tempo decorrido somado em todos os threads, incluindo aqueles que os criaram. Enquanto isso, se o usuário quiser medir o tempo do sistema consumido apenas pelo encadeamento de chamada, RUSAGE_THREAD pode ser passado como o primeiro argumento. Observe, porém, que o valor RUSAGE_THREAD é específico do Linux e _GNU_SOURCE deve ser definido antes dos arquivos de cabeçalho para incluí-lo.
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/resource.h>
#include <threads.h>
#include <unistd.h>
enum { NUM_ITERS = 1000000, NUM_THREADS = 16 };
void *loopFunc2(size_t num) {
for (int i = 0; i < num; ++i) {
getpid();
}
return NULL;
}
float diffUserTime(struct rusage *start, struct rusage *end) {
return (end->ru_utime.tv_sec - start->ru_utime.tv_sec) +
1e-6 * (end->ru_utime.tv_usec - start->ru_utime.tv_usec);
}
float diffSystemTime(struct rusage *start, struct rusage *end) {
return (end->ru_stime.tv_sec - start->ru_stime.tv_sec) +
1e-6 * (end->ru_stime.tv_usec - start->ru_stime.tv_usec);
}
int main() {
struct rusage start, end;
thrd_t threads[NUM_THREADS];
int rc;
getrusage(RUSAGE_SELF, &start);
for (int i = 0; i < NUM_THREADS; i++) {
rc = thrd_create(&threads[i], (thrd_start_t)loopFunc2, (void *)NUM_ITERS);
if (rc == thrd_error) {
perror("[ERROR] thrd_create() call failed\n");
}
}
loopFunc2(NUM_ITERS);
getrusage(RUSAGE_SELF, &end);
printf("loopFunc2 stats:\n");
printf(" CPU time: %.06f sec user, %.06f sec system\n",
diffUserTime(&start, &end), diffSystemTime(&start, &end));
exit(EXIT_SUCCESS);
}
Resultado:
loopFunc2 stats:
CPU time: 0.599556 sec user, 0.233000 sec system
Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.
LinkedIn Facebook