Mesurer le temps d'exécution d'une fonction en C++ STL

1. Utilisez std::chrono::high_resolution_clock::now et std::chrono::duration_cast<std::chrono::seconds> pour mesurer le temps d’exécution d’une fonction
2. Utilisez std::chrono::high_resolution_clock::now et std::chrono::duration<double, std::milli> pour mesurer le temps d’exécution d’une fonction

Cet article présente plusieurs méthodes sur la façon de mesurer le temps d’exécution d’une fonction en C++.

Utilisez std::chrono::high_resolution_clock::now et std::chrono::duration_cast<std::chrono::seconds> pour mesurer le temps d’exécution d’une fonction

L’espace de noms std::chrono consolide tous les utilitaires de date et d’heure fournis par la bibliothèque C++ STL. Ce dernier offre plusieurs implémentations d’horloge, dont l’une est std::chrono::high_resolution_clock qui correspond à l’horloge avec la plus petite période de ticks. Notez cependant que cette horloge dépend de la plate-forme matérielle et que même plusieurs implémentations de bibliothèques standard diffèrent, il est donc préférable de lire la documentation du compilateur et de vous assurer que celle-ci est adaptée aux exigences du problème. L’idée pour mesurer le temps d’exécution d’une fonction est de récupérer l’heure actuelle à partir de l’horloge donnée deux fois: avant l’appel de la fonction et après, et de calculer la différence entre les valeurs. L’heure actuelle est récupérée à l’aide de la méthode intégrée now. Une fois la différence calculée, elle doit être interprétée dans une certaine unité de temps, ce qui est fait en utilisant l’utilitaire std::chrono::duration_cast. Dans l’exemple suivant, nous convertissons le résultat en unités std::chrono::seconds et sortons la valeur avec la fonction intégrée count. Notez que le funcSleep dans l’exemple de code suspend l’exécution du programme pendant 3 secondes, puis retourne le contrôle à la fonction main.

#include <chrono>
#include <iostream>
#include <thread>

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

void funcSleep() { std::this_thread::sleep_for(std::chrono::seconds(3)); }

int main() {
  auto start = std::chrono::high_resolution_clock::now();
  funcSleep();
  auto end = std::chrono::high_resolution_clock::now();

  auto int_s = std::chrono::duration_cast<std::chrono::seconds>(end - start);

  std::cout << "funcSleep() elapsed time is " << int_s.count() << " seconds )"
            << std::endl;

  return EXIT_SUCCESS;
}

Production:

funcSleep() elapsed time is 3 seconds

Utilisez std::chrono::high_resolution_clock::now et std::chrono::duration<double, std::milli> pour mesurer le temps d’exécution d’une fonction

Contrairement au code précédent, où l’unité de temps était sauvegardée dans une valeur entière, l’exemple suivant stocke la valeur de l’intervalle sous forme de nombre à virgule flottante dans le fichier std::chrono::duration<double, std::milli> Objet de type. std::chrono::duration est un modèle de classe général pour représenter l’intervalle de temps. Enfin, la valeur de l’intervalle est récupérée à l’aide de la fonction count, à quel point elle peut être imprimée dans le flux cout.

#include <chrono>
#include <iostream>
#include <thread>

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

void funcSleep() { std::this_thread::sleep_for(std::chrono::seconds(3)); }

int main() {
  auto start = std::chrono::high_resolution_clock::now();
  funcSleep();
  auto end = std::chrono::high_resolution_clock::now();

  std::chrono::duration<double, std::milli> float_ms = end - start;

  std::cout << "funcSleep() elapsed time is " << float_ms.count()
            << " milliseconds" << std::endl;

  return EXIT_SUCCESS;
}

Production:

funcSleep() elapsed time is 3000.27 milliseconds

Les deux derniers exemples ont mesuré une fonction qui prend principalement un temps constant, mais une approche similaire peut être utilisée pour calculer le temps d’exécution du bloc de code donné. À titre d’exemple, l’extrait de code suivant illustre la fonction de génération d’entiers aléatoires qui prend plus d’intervalles variables pour s’exécuter. Notez que, cette fois, nous avons utilisé les deux méthodes pour afficher l’heure avec une précision en millisecondes et en secondes.

#include <chrono>
#include <iostream>
#include <thread>

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

constexpr int WIDTH = 1000000;

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

int main() {
  int *arr = new int[WIDTH];

  auto start = std::chrono::high_resolution_clock::now();
  generateNumbers(arr);
  auto end = std::chrono::high_resolution_clock::now();

  std::chrono::duration<double, std::milli> float_ms = end - start;
  auto int_ms =
      std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

  std::chrono::duration<long, std::micro> int_usec = int_ms;

  std::cout << "generateNumbers() elapsed time is " << float_ms.count()
            << " ms "
            << "( " << int_ms.count() << " milliseconds )" << std::endl;

  delete[] arr;
  return EXIT_SUCCESS;
}

Production:

generateNumbers() elapsed time is 30.7443 ms ( 30 milliseconds )