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

Voici une fonction qui permettra de mesurer le temps d'exécution d'une fonction passée en argument:

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

Exemple d'utilisation:

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

De sortie:

norm: 15555
algo: 2976

De Scott Meyers livre que j'ai trouvé un exemple de générique universel expression lambda qui peut être utilisé pour la fonction de mesure du temps d'exécution. (C++14)

auto timeFuncInvocation = 
    [](auto&& func, auto&&... params) {
        //get time before function invocation
        const auto& start = high_resolution_clock::now();
        //function invocation using perfect forwarding
        std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
        //get time after function invocation
        const auto& stop = high_resolution_clock::now();
        return stop - start;
     };

Le problème est que vous ne mesurer qu'une exécution afin que les résultats peuvent être très différents. Pour obtenir un résultat fiable, vous devriez mesurer un grand nombre de l'exécution.
Selon Andrei Alexandrescu à la conférence de code::plongée 2015 de la conférence de Rédaction de Rapide Code que j'ai:

Temps mesuré: tm = t + tq + tn + à

où:

tm - mesuré (observé) temps

t - le temps réel de l'intérêt

tq - temps ajouté par quantification du bruit

tn - temps ajouté par diverses sources de bruit

de tête de temps (mesure, les boucles, les fonctions d'appel)

Selon ce qu'il a dit plus tard dans le cours, vous devriez prendre un minimum de ce grand nombre de de l'exécution de votre résultat.
Je vous encourage à regarder la conférence, dans lequel il explique pourquoi.

Il y a aussi une très bonne bibliothèque à partir de google - https://github.com/google/benchmark.
Cette bibliothèque est très simple à utiliser et puissant. Vous pouvez payer quelques cours de Chandler Carruth sur youtube où il est l'utilisation de cette bibliothèque dans la pratique. Par exemple CppCon 2017: Chandler Carruth “Va Nulle part plus Vite”;

Exemple d'utilisation:

#include <iostream>
#include <chrono>
#include <vector>
auto timeFuncInvocation = 
[](auto&& func, auto&&... params) {
//get time before function invocation
const auto& start = high_resolution_clock::now();
//function invocation using perfect forwarding
for(auto i = 0; i < 100000/*largeNumber*/; ++i) {
std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
}
//get time after function invocation
const auto& stop = high_resolution_clock::now();
return (stop - start)/100000/*largeNumber*/;
};
void f(std::vector<int>& vec) {
vec.push_back(1);
}
void f2(std::vector<int>& vec) {
vec.emplace_back(1);
}
int main()
{
std::vector<int> vec;
std::vector<int> vec2;
std::cout << timeFuncInvocation(f, vec).count() << std::endl;
std::cout << timeFuncInvocation(f2, vec2).count() << std::endl;
std::vector<int> vec3;
vec3.reserve(100000);
std::vector<int> vec4;
vec4.reserve(100000);
std::cout << timeFuncInvocation(f, vec3).count() << std::endl;
std::cout << timeFuncInvocation(f2, vec4).count() << std::endl;
return 0;
}

EDIT:
Bien sûr, vous avez toujours besoin de vous rappeler que votre compilateur peut optimiser quelque chose ou pas. Des outils comme perf peuvent être utiles dans de tels cas.

• Il est un très facile à utiliser la méthode en C++11.
• Nous pouvons utiliser std::chrono::high_resolution_clock à partir de l'en-tête
• Nous pouvons écrire une méthode pour imprimer l'exécution de la méthode du temps dans une bien lisible.

Par exemple, pour trouver tous les nombres premiers entre 1 et 100 millions de dollars, il faut environ 1 minute et 40 secondes.
Si le temps d'exécution est imprimée comme:

Execution Time: 1 Minutes, 40 Seconds, 715 MicroSeconds, 715000 NanoSeconds

Le code est ici:

#include <iostream>
#include <chrono>
using namespace std;
using namespace std::chrono;
typedef high_resolution_clock Clock;
typedef Clock::time_point ClockTime;
void findPrime(long n, string file);
void printExecutionTime(ClockTime start_time, ClockTime end_time);
int main()
{
long n = long(1E+8);  //N = 100 million
ClockTime start_time = Clock::now();
//Write all the prime numbers from 1 to N to the file "prime.txt"
findPrime(n, "C:\\prime.txt"); 
ClockTime end_time = Clock::now();
printExecutionTime(start_time, end_time);
}
void printExecutionTime(ClockTime start_time, ClockTime end_time)
{
auto execution_time_ns = duration_cast<nanoseconds>(end_time - start_time).count();
auto execution_time_ms = duration_cast<microseconds>(end_time - start_time).count();
auto execution_time_sec = duration_cast<seconds>(end_time - start_time).count();
auto execution_time_min = duration_cast<minutes>(end_time - start_time).count();
auto execution_time_hour = duration_cast<hours>(end_time - start_time).count();
cout << "\nExecution Time: ";
if(execution_time_hour > 0)
cout << "" << execution_time_hour << " Hours, ";
if(execution_time_min > 0)
cout << "" << execution_time_min % 60 << " Minutes, ";
if(execution_time_sec > 0)
cout << "" << execution_time_sec % 60 << " Seconds, ";
if(execution_time_ms > 0)
cout << "" << execution_time_ms % long(1E+3) << " MicroSeconds, ";
if(execution_time_ns > 0)
cout << "" << execution_time_ns % long(1E+6) << " NanoSeconds, ";
}