Misura il tempo di esecuzione di una funzione in C++ STL

1. Usa std::chrono::high_resolution_clock::now e std::chrono::duration_cast<std::chrono::seconds> per misurare il tempo di esecuzione di una funzione
2. Usa std::chrono::high_resolution_clock::now e std::chrono::duration<double, std::milli> per misurare il tempo di esecuzione di una funzione

Questo articolo illustrerà più metodi su come misurare il tempo di esecuzione di una funzione in C++.

Usa std::chrono::high_resolution_clock::now e std::chrono::duration_cast<std::chrono::seconds> per misurare il tempo di esecuzione di una funzione

Lo spazio dei nomi std::chrono consolida tutte le utilità di data e ora fornite dalla libreria C++ STL. Quest’ultimo offre molteplici implementazioni di clock, una delle quali è std::chrono::high_resolution_clock che corrisponde all’orologio con il periodo di tick più piccolo. Nota però, questo orologio dipende dalla piattaforma hardware e anche le implementazioni di più librerie standard differiscono, quindi è meglio leggere la documentazione del compilatore e assicurarsi che questa sia adatta ai requisiti del problema. L’idea per misurare il tempo di esecuzione di una funzione è recuperare due volte l’ora corrente dall’orologio dato: prima della chiamata della funzione e dopo, e calcolare la differenza tra i valori. L’ora corrente viene recuperata utilizzando il metodo integrato now. Una volta calcolata la differenza, dovrebbe essere interpretata in una certa unità di tempo, che viene eseguita utilizzando l’utility std::chrono::duration_cast. Nell’esempio seguente, eseguiamo il cast del risultato in unità std::chrono::seconds e restituiamo il valore con la funzione incorporata count. Si noti che funcSleep nell’esempio di codice sospende l’esecuzione del programma per 3 secondi e quindi restituisce il controllo alla funzione 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;
}

Produzione:

funcSleep() elapsed time is 3 seconds

Usa std::chrono::high_resolution_clock::now e std::chrono::duration<double, std::milli> per misurare il tempo di esecuzione di una funzione

In contrasto con il codice precedente, dove l’unità di tempo è stata salvata in un valore intero, l’esempio successivo memorizza il valore dell’intervallo come un numero a virgola mobile in std::chrono::duration<double, std::milli> Tipo oggetto. std::chrono::duration è un modello di classe generale per rappresentare l’intervallo di tempo. Infine, il valore dell’intervallo viene recuperato utilizzando la funzione count, a quel punto può essere stampato nel flusso 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;
}

Produzione:

funcSleep() elapsed time is 3000.27 milliseconds

Gli ultimi due esempi hanno misurato una funzione che richiede per lo più un tempo costante, ma un approccio simile può essere utilizzato per calcolare il tempo di esecuzione di un dato blocco di codice. Ad esempio, il frammento di codice seguente mostra la funzione di generazione di numeri interi casuali che richiede più intervalli variabili per essere eseguita. Si noti che, questa volta, abbiamo utilizzato entrambi i metodi per visualizzare l’ora con precisione in millisecondi e secondi.

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

Produzione:

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