Utiliser le Timer en C++

  1. Utiliser la fonction clock() pour implémenter un timer en C++
  2. Utiliser la fonction gettimeofday pour implémenter un timer en C++

Cet article présentera plusieurs méthodes d’utilisation d’un minuteur en C++.

Utiliser la fonction clock() pour implémenter un timer en C++

La fonction clock() est une méthode compatible POSIX pour récupérer le temps processeur du programme. La fonction retourne la valeur entière qui doit être divisée par une constante macro-définie appelée CLOCKS_PER_SEC pour la convertir en plusieurs secondes.

L’exemple de code suivant implémente deux fonctions pour trouver la valeur maximale dans un tableau int. La fonction max_index fait la recherche en se basant sur l’index des éléments, alors que la max_value est basée sur la valeur. Le but est de calculer combien de temps ils passent à trouver la valeur maximale int dans le tableau d’éléments 1,000,000 rempli d’entiers aléatoires.

Notez que nous appelons la fonction clock() deux fois - avant l’appel de max_index et ensuite après l’appel. Ce schéma de mesure du temps peut être utilisé en général sans tenir compte de la fonction spécifique qui récupère le temps. Dans ce cas, nous pouvons voir (selon le système matériel) que la fonction max_value fait le travail un peu plus vite que la recherche par index. Mais attention, ces algorithmes de recherche maximale sont complexes et ne devraient pas être utilisés dans un code professionnel, sauf peut-être à des fins d’expérimentation.

#include <iostream>
#include <chrono>

using std::cout; using std::endl;

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

constexpr int WIDTH = 1000000;

int main() {
    clock_t start, end;
    int max;

    int *arr = new int[WIDTH];

    std::srand(std::time(nullptr));
    for (size_t i = 0; i < WIDTH; i++) {
        arr[i] = std::rand();
    }

    start = clock();
    max = max_index(arr, WIDTH);
    end = clock();
    printf ("max_index: %0.8f sec, max = %d\n",
            ((float) end - start)/CLOCKS_PER_SEC, max);

    start = clock();
    max = max_value(arr, WIDTH);
    end = clock();
    printf ("max_value: %0.8f sec, max = %d\n",
            ((float) end - start)/CLOCKS_PER_SEC, max);

    exit(EXIT_SUCCESS);
}

Production :

max_value: 0.00131400 sec, max = 2147480499
max_value: 0.00089800 sec, max = 2147480499

Utiliser la fonction gettimeofday pour implémenter un timer en C++

Le gettimeofday est une fonction de récupération du temps très précise dans les systèmes basés sur Linux, qui peut également être appelée à partir du code source C++. La fonction a été conçue pour obtenir les données relatives à l’heure et au fuseau horaire, mais ce dernier a été déprécié depuis un certain temps, et le second argument devrait être nullptr au lieu de la struct de fuseau horaire valide. gettimeofday stocke les données de temps dans une structure spéciale appelée timeval, qui contient deux membres de données tv_sec représentant les secondes et tv_usec pour les microsecondes.

En règle générale, nous déclarons et initialisons les deux structures timeval avant d’appeler la fonction gettimeofday. Une fois que la fonction est appelée, les données doivent être stockées avec succès dans la struct correspondante si la valeur de retour de gettimeofday est 0. Sinon, l’échec est indiqué par le retour de la valeur -1. Notez qu’une fois que les structs sont remplis de données, il faut les convertir en valeur d’unité commune de temps. Cet exemple de code implémente la fonction time_diff qui retourne le temps en secondes, qui peut être sorti sur la console si nécessaire.

#include <iostream>
#include <sys/time.h>
#include <ctime>

using std::cout; using std::endl;

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

constexpr int WIDTH = 1000000;

int main() {
    struct timeval start{};
    struct timeval end{};
    int max;

    int *arr = new int[WIDTH];

    std::srand(std::time(nullptr));
    for (size_t i = 0; i < WIDTH; i++) {
        arr[i] = std::rand();
    }

    gettimeofday(&start, nullptr);
    max = max_index(arr, WIDTH);
    gettimeofday(&end, nullptr);
    printf("max_index: %0.8f sec, max = %d\n",
            time_diff(&start, &end), max);

    gettimeofday(&start, nullptr);
    max = max_value(arr, WIDTH);
    gettimeofday(&end, nullptr);
    printf("max_value: %0.8f sec, max = %d\n",
            time_diff(&start, &end), max);

    exit(EXIT_SUCCESS);
}

Production :

max_value: 0.00126000 sec, max = 2147474877
max_value: 0.00093900 sec, max = 2147474877