Medir o tempo de execução de uma função em C++
quero saber quanto tempo uma determinada função leva no meu programa de C++ para executar no Linux . Depois, quero fazer uma comparação de velocidade . Vi várias funções de tempo, mas acabei com isto do boost. Chrono:
process_user_cpu_clock, captures user-CPU time spent by the current process
Agora, eu não sou claro se eu usar a função acima, eu terei o único tempo que CPU gastou nessa função?
em segundo lugar, não encontrei nenhum exemplo de Utilização da função acima. Qualquer um por favor me ajude a usar o acima função?
P. S: neste momento, estou a usar std::chrono::system_clock::now() para ter tempo em segundos, mas isto dá-me resultados diferentes devido à carga de CPU diferente de cada vez.
5 answers
É um método muito fácil de usar em C++11. Tem de usar std::chrono::high_resolution_clock do cabeçalho <chrono>.
Usa-o assim:
#include <iostream>
#include <chrono>
using namespace std;
using namespace std::chrono;
void function()
{
long long number = 0;
for( long long i = 0; i != 2000000; ++i )
{
number += 5;
}
}
int main()
{
high_resolution_clock::time_point t1 = high_resolution_clock::now();
function();
high_resolution_clock::time_point t2 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>( t2 - t1 ).count();
cout << duration;
return 0;
}
Isto irá medir a duração da função.
Nota: não é um requisito obter a mesma saída sempre porque a massa da sua máquina pode ser menos ou mais usada por outros processos que rodam no seu computador. Como você resolveria um exercício de matemática, sua mente pode estar mais ou menos concentrada para que você resolva isso em tempos diferentes. Em a mente humana, podemos lembrar a solução de um problema matemático, embora para um computador o mesmo processo será sempre algo novo, então, como eu disse, não é necessário obter o mesmo resultado sempre!
Aqui está uma função que irá medir o tempo de execução de qualquer função passada como argumento:
#include <chrono>
#include <utility>
typedef std::chrono::high_resolution_clock::time_point TimeVar;
#define duration(a) std::chrono::duration_cast<std::chrono::nanoseconds>(a).count()
#define timeNow() std::chrono::high_resolution_clock::now()
template<typename F, typename... Args>
double funcTime(F func, Args&&... args){
TimeVar t1=timeNow();
func(std::forward<Args>(args)...);
return duration(timeNow()-t1);
}
Uso de exemplo:
#include <iostream>
#include <algorithm>
typedef std::string String;
//first test function doing something
int countCharInString(String s, char delim){
int count=0;
String::size_type pos = s.find_first_of(delim);
while ((pos = s.find_first_of(delim, pos)) != String::npos){
count++;pos++;
}
return count;
}
//second test function doing the same thing in different way
int countWithAlgorithm(String s, char delim){
return std::count(s.begin(),s.end(),delim);
}
int main(){
std::cout<<"norm: "<<funcTime(countCharInString,"precision=10",'=')<<"\n";
std::cout<<"algo: "<<funcTime(countWithAlgorithm,"precision=10",'=');
return 0;
}
Resultado:
norm: 15555
algo: 2976
Programa simples para encontrar um tempo de execução da função.
#include <iostream>
#include <ctime> // time_t
#include <cstdio>
void function()
{
for(long int i=0;i<1000000000;i++)
{
// do nothing
}
}
int main()
{
time_t begin,end; // time_t is a datatype to store time values.
time (&begin); // note time before execution
function();
time (&end); // note time after execution
double difference = difftime (end,begin);
printf ("time taken for function() %.2lf seconds.\n", difference );
return 0;
}
Fácil para C++ antigo, ou C:
#include <time.h> // includes clock_t and CLOCKS_PER_SEC
int main() {
clock_t start, end;
start = clock();
// ...code to measure...
end = clock();
double duration_sec = double(end-start)/CLOCKS_PER_SEC;
return 0;
}
1.0/CLOCKS_PER_SEC
Aqui está um excelente modelo de classe só de cabeçalho para medir o tempo decorrido de uma função ou qualquer bloco de código:
#ifndef EXECUTION_TIMER_H
#define EXECUTION_TIMER_H
template<class Resolution = std::chrono::milliseconds>
class ExecutionTimer {
public:
using Clock = std::conditional_t<std::chrono::high_resolution_clock::is_steady,
std::chrono::high_resolution_clock,
std::chrono::steady_clock>;
private:
const Clock::time_point mStart = Clock::now();
public:
ExecutionTimer() = default;
~ExecutionTimer() {
const auto end = Clock::now();
std::ostringstream strStream;
strStream << "Destructor Elapsed: "
<< std::chrono::duration_cast<Resolution>( end - mStart ).count()
<< std::endl;
std::cout << strStream.str() << std::endl;
}
inline void stop() {
const auto end = Clock::now();
std::ostringstream strStream;
strStream << "Stop Elapsed: "
<< std::chrono::duration_cast<Resolution>(end - mStart).count()
<< std::endl;
std::cout << strStream.str() << std::endl;
}
}; // ExecutionTimer
#endif // EXECUTION_TIMER_H
int main() {
{ // empty scope to display ExecutionTimer's destructor's message
// displayed in milliseconds
ExecutionTimer<std::chrono::milliseconds> timer;
// function or code block here
timer.stop();
}
{ // same as above
ExecutionTimer<std::chrono::microseconds> timer;
// code block here...
timer.stop();
}
{ // same as above
ExecutionTimer<std::chrono::nanoseconds> timer;
// code block here...
timer.stop();
}
{ // same as above
ExecutionTimer<std::chrono::seconds> timer;
// code block here...
timer.stop();
}
return 0;
}
Uma vez que a classe é um modelo, podemos especificar facilmente como queremos que o nosso tempo seja medido e exibido. Este é um modelo de classe utilitário muito útil para fazer marcação de banco e é muito fácil de usar.