Utiliser une minuterie en C
-
Utiliser la fonction
gettimeofdaycomme point de repère pour le timer -
Utiliser la fonction
clock_gettimecomme point de repère du chronomètre en C
Cet article présente plusieurs méthodes d’utilisation d’un minuteur en C.
Utiliser la fonction gettimeofday comme point de repère pour le timer
gettimeofday est une fonction compatible POSIX permettant de récupérer l’heure système. Elle prend deux arguments, l’un du type struct timeval et l’autre du type struct timezone, ce dernier étant maintenant obsolète. Ainsi, nous n’aurions besoin de déclarer que les structures timeval pour stocker les valeurs de temps récupérées. struct timeval se est composée de deux membres représentant respectivement les secondes et les microsecondes.
Dans l’exemple suivant, nous implémentons deux fonctions pour trouver la valeur maximale dans le tableau des entiers. L’une d’entre elles est basée sur la comparaison des valeurs, et l’autre utilise les indices pour trouver l’entier ayant la plus grande valeur. Nous utilisons gettimeofday avant et après que la fonction max_ soit appelée pour comparer la vitesse de ces fonctions.
Notez qu’il existe une fonction time_diff qui calcule le temps écoulé en secondes. Dans ce cas, nous n’effectuons le test qu’une seule fois sur un tableau d’entiers généré de façon aléatoire, mais en général, des méthodes plus statistiques devraient être utilisées pour mesurer les performances des systèmes modernes.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
int max_index(int arr[], int size) {
size_t max = 0;
for (int j = 0; j < size; ++j) {
if (arr[j] > arr[max]) {
max = j;
}
}
return arr[max];
}
int max_value(int arr[], int size) {
int max = arr[0];
for (int j = 0; j < size; ++j) {
if (arr[j] > max) {
max = arr[j];
}
}
return max;
}
float time_diff(struct timeval *start, struct timeval *end) {
return (end->tv_sec - start->tv_sec) + 1e-6 * (end->tv_usec - start->tv_usec);
}
enum { WIDTH = 100000 };
int main() {
struct timeval start;
struct timeval end;
int max;
int *arr = malloc(WIDTH * sizeof(int));
srand(time(NULL));
for (size_t i = 0; i < WIDTH; i++) {
arr[i] = rand();
}
gettimeofday(&start, NULL);
max = max_index(arr, WIDTH);
gettimeofday(&end, NULL);
printf("max_index: %0.8f sec, max = %d\n", time_diff(&start, &end), max);
gettimeofday(&start, NULL);
max = max_value(arr, WIDTH);
gettimeofday(&end, NULL);
printf("max_value: %0.8f sec, max = %d\n", time_diff(&start, &end), max);
free(arr);
exit(EXIT_SUCCESS);
}
Production :
max_index: 0.00028346 sec, max = 2147391322
max_value: 0.00022213 sec, max = 2147391322
Utiliser la fonction clock_gettime comme point de repère du chronomètre en C
Nous pouvons également utiliser clock_gettime pour atteindre des objectifs de mesure similaires. La méthode clock_gettime est une méthode plus récente et recommandée utilisée dans les bases de code plus récentes. Elle stocke la valeur du temps dans l’objet struct timespec et prend le pointeur vers celui-ci comme second paramètre. Pendant ce temps, le premier argument spécifie le type d’horloge à utiliser. Dans cet exemple, nous récupérons CLOCK_REALTIME parce qu’il mesure l’heure dite de l’horloge murale. Il est représenté en secondes et nanosecondes passées depuis l’époque, la date de début de la mesure du temps.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
int max_index(int arr[], int size) {
size_t max = 0;
for (int j = 0; j < size; ++j) {
if (arr[j] > arr[max]) {
max = j;
}
}
return arr[max];
}
int max_value(int arr[], int size) {
int max = arr[0];
for (int j = 0; j < size; ++j) {
if (arr[j] > max) {
max = arr[j];
}
}
return max;
}
float time_diff2(struct timespec *start, struct timespec *end) {
return (end->tv_sec - start->tv_sec) + 1e-9 * (end->tv_nsec - start->tv_nsec);
}
enum { WIDTH = 100000 };
int main() {
struct timespec start2, end2;
int max;
int *arr = malloc(WIDTH * sizeof(int));
srand(time(NULL));
for (size_t i = 0; i < WIDTH; i++) {
arr[i] = rand();
}
clock_gettime(CLOCK_REALTIME, &start2);
max = max_index(arr, WIDTH);
clock_gettime(CLOCK_REALTIME, &end2);
printf("max_index: %0.8f sec, max = %d\n", time_diff2(&start2, &end2), max);
clock_gettime(CLOCK_REALTIME, &start2);
max = max_value(arr, WIDTH);
clock_gettime(CLOCK_REALTIME, &end2);
printf("max_value: %0.8f sec, max = %d\n", time_diff2(&start2, &end2), max);
free(arr);
exit(EXIT_SUCCESS);
}
Production :
max_index: 0.00028346 sec, max = 2147391322
max_value: 0.00022213 sec, max = 2147391322
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