Problema:
Alguma parte de seu código C++ está sofrendo de problemas de performance. Você está procurando por uma solução leve que permite que você facilmente grave diferentes pontos no tempo e adaptivamente imprima os resultados (ou seja, você não quer saber que algo rodou por 1102564643 nanosegundos, você apenas quer saber que levou 1.102 segundos)
Solução
Eu escrevi AutoBenchmark para que você possa ter a experiência C++11 mais sem-problemas possível para suas necessidades de micro-benchmarking.
AutoBenchmark permite que você grave diferentes pontos no tempo, cada um com um rótulo. O primeiro ponto no tempo é gravado quando esta instância é construída. AutoBenchmark suporta um número arbitrário de pontos no tempo.
Quando uma instância desta classe é destruída, ela automaticamente imprimirá todos os resultados de benchmark, mas apenas se uma quantidade configurável de tempo passou desde sua construção - isso é extremamente útil especialmente se você tem múltiplos pontos de saída em sua função que de outra forma requereria chamar Print() múltiplas vezes.
Isso permite que você ignore o benchmark quando algum objetivo de performance é atingido (ex.: se você tem um loop for que é lento apenas para alguns pontos de dados, você pode configurar AutoBenchmark para imprimir infos apenas para as execuções lentas).
O comportamento padrão (ou seja, construtor com parâmetros padrão) é desabilitar impressão automática - neste caso, você pode chamar Print() você mesmo.
Header (AutoBenchmark.hpp):
/**
* AutoBenchmark v1.1
* Written by Uli Köhler
* https://techoverflow.net
*
* https://techoverflow.net/2018/03/31/autobenchmark-automatic-multi-interval-benchmarking-in-c-using-stdchrono/
*
* Published under CC0 1.0 Universal
*/
#pragma once
#include <chrono>
#include <string>
#include <limits>
#include <vector>
using namespace std;
/**
* Benchmark automático: Permite registrar diferentes pontos no tempo,
* cada um com um rótulo. O primeiro ponto no tempo é registrado quando esta instância
* é construída. Esta classe suporta um número arbitrário de pontos no tempo.
*
* Quando uma instância desta classe é destruída, ela automaticamente
* imprimirá todos os resultados do benchmark, mas apenas se uma quantidade configurável
* de tempo tiver passado desde sua construção, permitindo que você automaticamente
*/
class AutoBenchmark {
public:
/**
* Inicializar um benchmark que automaticamente imprime seus registros
* na destruição se o tempo total consumido for >= autoPrintThreshold
* no momento da destruição. Apenas o tempo até o último rótulo
* Record()ed é impresso.
* @param autoPrintThreshold: Quantos segundos precisarão ter passado
* para que o destrutor imprima automaticamente. O padrão é nunca imprimir.
* @param benchmarkLabel: Um rótulo que será impresso uma vez, antes de todos os resultados
* @param lineLabel: Um rótulo (ex. indentação) que será impresso antes de cada linha de resultado
*/
AutoBenchmark(double autoPrintThreshold=std::numeric_limits<double>::max(), const std::string& benchmarkLabel = "", const std::string& lineLabel = " ");
~AutoBenchmark();
/**
* Registrar um ponto de dados
*/
void Record(const std::string& label = "");
void Record(const char *label = "");
/**
* Imprimir todas as deltas de tempo
*/
void Print();
/**
* Reiniciar o benchmark, como se fosse uma nova instância.
*/
void Reset();
/**
* Retornar now() - primeiro ponto no tempo em segundos.
*/
double TotalSeconds();
private:
vector<std::chrono::system_clock::time_point> times;
vector<std::string> labels;
double autoPrintThreshold;
std::string benchmarkLabel;
std::string lineLabel;
};Source (AutoBenchmark.cpp):
#include "AutoBenchmark.hpp"
#include <iostream>
AutoBenchmark::AutoBenchmark(double autoPrintThreshold, const std::string& benchmarkLabel, const std::string& lineLabel)
: autoPrintThreshold(autoPrintThreshold), benchmarkLabel(benchmarkLabel), lineLabel(lineLabel) {
times.push_back(chrono::system_clock::now());
labels.emplace_back("Begin"); // Apenas para manter os índices iguais
}
AutoBenchmark::~AutoBenchmark() {
if(TotalSeconds() >= autoPrintThreshold) {
Print();
}
}
void AutoBenchmark::Record(const std::string &label) {
times.push_back(chrono::system_clock::now());
labels.emplace_back(label); // Apenas para manter os índices iguais
}
void AutoBenchmark::Record(const char *label) {
Record(string(label));
}
void AutoBenchmark::Print() {
if(benchmarkLabel.length()) {
cout << benchmarkLabel << '\n';
}
for (size_t i = 1; i < times.size(); i++) {
// Calcular intervalo de tempo para comparação de tamanho
chrono::duration<double, std::nano> ns = times[i] - times[i - 1];
chrono::duration<double, std::micro> us = times[i] - times[i - 1];
chrono::duration<double, std::milli> ms = times[i] - times[i - 1];
chrono::duration<double> s = times[i] - times[i - 1];
chrono::duration<double, std::ratio<60>> min = times[i] - times[i - 1];
chrono::duration<double, std::ratio<3600>> hrs = times[i] - times[i - 1];
// Imprimir
if(ns.count() < 1000.0) {
cout << lineLabel << labels[i] << " levou " << ns.count() << " ns\n";
} else if(us.count() < 1000.0) {
cout << lineLabel << labels[i] << " levou " << us.count() << " μs\n";
} else if (ms.count() < 1000.0) {
cout << lineLabel << labels[i] << " levou " << ms.count() << " ms\n";
} else if (s.count() < 60.0) {
cout << lineLabel << labels[i] << " levou " << s.count() << " segundos\n";
} else if (min.count() < 1000.0) {
cout << lineLabel << labels[i] << " levou " << min.count() << " minutos\n";
} else {
cout << lineLabel << labels[i] << " levou " << hrs.count() << " horas\n";
}
}
cout << flush;
}
void AutoBenchmark::Reset() {
times.clear();
labels.clear();
times.push_back(chrono::system_clock::now());
labels.emplace_back("Begin");
}
double AutoBenchmark::TotalSeconds() {
chrono::duration s = chrono::system_clock::now() - times[0];
return s.count();
}Exemplo de uso:
#include "AutoBenchmark.hpp"
void MySlowFunction() {
// Toda execução que leva >= 0.3 segundos auto-imprimirá
AutoBenchmark myBenchmark(0.3, "Resultados da execução de MySlowFunction():");
// .. fazer tarefa 1 ...
myBenchmark.Record("Executando tarefa 1"); // imprimirá como: Executando tarefa 1 levou 1.2ms
// .. fazer tarefa 2 ...
myBenchmark.Record("Executando tarefa 2");
// Exemplo de loop
for(size_t i = 0; ....) {
// ... fazer tarefa de iteração de loop aqui ...
myBenchmark.Record("Iteração do loop " + std::to_string(i));
}
// myBenchmark será destruído aqui, então se MySlowFunction() levou
// mais que 0.3s para executar até retornar, o resultado será impresso
// para cout automaticamente.
}Se MySlowFunction() levou mais que 0.3s para executar ao todo, AutoBenchmark imprimirá os resultados quando ele é destruído - i.e. quando MySlowFunction( ) retorna:
Resultados da execução de MySlowFunction():
Executando tarefa 1 levou 260.826 ms
Executando tarefa 2 levou 36.148 μs
Iteração do loop 0 levou 2.5522 segundos
Iteração do loop 1 levou 664.059 ms
Iteração do loop 2 levou 22.2772 ms
Iteração do loop 3 levou 57.4024 ms
Iteração do loop 4 levou 16.9928 ms
Iteração do loop 5 levou 14.0497 ms
Iteração do loop 6 levou 62.5218 ms