micro_benchmark_ns_impl.h File Reference

#include <cmath>
#include "micro_benchmark_ns.h"

Include dependency graph for micro_benchmark_ns_impl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	PHOENIX_MINIMUM_TIME_NS   1000000000.0
	Minimum time for performance test in ns.

Functions
template<typename _Callable, typename... _Args>
void	micro_benchmarkAutoNs (double &ellapsedTimeNs, double &ellapsedTimeErrorNs, _Callable &&__f, _Args &&... __args)
	Do the micro benchmarking of a given function and gives performance results in ns.
template<typename _Callable, typename... _Args>
void	micro_benchmarkAutoNs (double &ellapsedTimeNs, double &ellapsedTimeErrorNs, double &timePerElement, double &timeErrorPerElement, size_t nbElement, _Callable &&__f, _Args &&... __args)
	Do the micro benchmarking of a given function and gives performance results in ns.
template<typename _Callable, typename... _Args>
void	micro_benchmarkAutoNsPrint (const std::string &testName, size_t nbElement, _Callable &&__f, _Args &&... __args)
	Do the micro benchmarking of a given function and gives performance results in ns and print the result.
template<typename _Callable, typename... _Args>
void	micro_benchmarkNs (double &ellapsedTimeNs, double &ellapsedTimeErrorNs, double &timePerElement, double &timeErrorPerElement, size_t nbTestPerf, size_t nbCallPerTest, size_t nbElement, _Callable &&__f, _Args &&... __args)
	Do the micro benchmarking of a given function and gives performance results in ns.
template<typename _Callable, typename... _Args>
void	micro_benchmarkNs (double &ellapsedTimeNs, double &ellapsedTimeErrorNs, size_t nbTestPerf, size_t nbCallPerTest, _Callable &&__f, _Args &&... __args)
	Do the micro benchmarking of a given function and gives performance results in ns.
template<typename _Callable, typename... _Args>
void	micro_benchmarkNsPrint (const std::string &testName, size_t nbTestPerf, size_t nbCallPerTest, size_t nbElement, _Callable &&__f, _Args &&... __args)
	Do the micro benchmarking of a given function and gives performance results in ns and print the result.
template<class T>
void	phoenix_doNotOptimize (T &value)
	Prevent compiler from optimising a loop.
template<class T>
void	phoenix_doNotOptimize (T const &value)
	Prevent compiler from optimising a loop.

Macro Definition Documentation

PHOENIX_MINIMUM_TIME_NS

#define PHOENIX_MINIMUM_TIME_NS   1000000000.0

Minimum time for performance test in ns.

Definition at line 14 of file micro_benchmark_ns_impl.h.

Referenced by micro_benchmarkAutoNs().

Function Documentation

micro_benchmarkAutoNs() [1/2]

template<typename _Callable, typename... _Args>

void micro_benchmarkAutoNs	(	double &	ellapsedTimeNs,
		double &	ellapsedTimeErrorNs,
		_Callable &&	__f,
		_Args &&...	__args )

Do the micro benchmarking of a given function and gives performance results in ns.

Parameters

[out]	ellapsedTimeNs	: ellapsed time in ns
[out]	ellapsedTimeErrorNs	: error on the ellapsed time in ns
	__f	: function to be called and benchmarked
	__args	: parameter of the function to be benchmarked This function tries to find automatically a relevant performance measurement

Definition at line 81 of file micro_benchmark_ns_impl.h.

                                                                                                                     {
        size_t nbTestPerf(100lu), nbCallPerTest(10lu);
        //Let's try with default values
        micro_benchmarkNs(ellapsedTimeNs, ellapsedTimeErrorNs, nbTestPerf, nbCallPerTest, __f, __args...);
//      while(std::isnan(ellapsedTimeNs)){
//              std::cout << "micro_benchmarkAutoNs : ellapsedTimeNs is NaN ! Adjusting nbTestPerf = " << nbTestPerf << std::endl;
//              nbCallPerTest += 5lu;
//              micro_benchmarkNs(ellapsedTimeNs, ellapsedTimeErrorNs, nbTestPerf, nbCallPerTest, __f, __args...);
//              std::cout << "micro_benchmarkAutoNs = nbTestPerf = "<<nbTestPerf<<", nbCallPerTest" << nbCallPerTest << std::endl;
//      }
        double fullEllapsedTime(ellapsedTimeNs*((double)nbTestPerf)*((double)nbCallPerTest));
        //Check if the total time is more than one second
        while(fullEllapsedTime < PHOENIX_MINIMUM_TIME_NS && nbCallPerTest < 1000000000lu && nbCallPerTest > 0lu){                //Let's try again if the total time is less than one second
                //If the total time is less than one second, we try to change nbTestPerf and nbCallPerTest to make it about one second
                double ratioTime((1.3*PHOENIX_MINIMUM_TIME_NS)/fullEllapsedTime);
                if(ratioTime < 1.2){
                        ratioTime = 1.2;
                }
//              double ratioSqrt(std::sqrt(ratioTime) + 1.0);
                //Let's modify the call
//              nbTestPerf *= ratioSqrt;
//              nbCallPerTest *= ratioSqrt;
                
                nbCallPerTest *= ratioTime;
                
                //Let's try again
                micro_benchmarkNs(ellapsedTimeNs, ellapsedTimeErrorNs, nbTestPerf, nbCallPerTest, __f, __args...);
                fullEllapsedTime = ellapsedTimeNs*((double)nbTestPerf)*((double)nbCallPerTest);
                //We loop until we have one second of full time measurement
        }
        std::cout << "micro_benchmarkAutoNs : nbCallPerTest = " << nbCallPerTest << std::endl;
        if(nbCallPerTest > 1000000000lu || nbCallPerTest == 0lu){
                std::cout << "micro_benchmarkAutoNs : Warning invalid number of calls per test should lead to unrelevant results!!!" << std::endl;
        }
}

References micro_benchmarkNs(), and PHOENIX_MINIMUM_TIME_NS.

Referenced by micro_benchmarkAutoNs(), and micro_benchmarkAutoNsPrint().

Here is the call graph for this function:

Here is the caller graph for this function:

micro_benchmarkAutoNs() [2/2]

template<typename _Callable, typename... _Args>

void micro_benchmarkAutoNs	(	double &	ellapsedTimeNs,
		double &	ellapsedTimeErrorNs,
		double &	timePerElement,
		double &	timeErrorPerElement,
		size_t	nbElement,
		_Callable &&	__f,
		_Args &&...	__args )

Do the micro benchmarking of a given function and gives performance results in ns.

Parameters

[out]	ellapsedTimeNs	: ellapsed time in ns
[out]	ellapsedTimeErrorNs	: error on the ellapsed time in ns
[out]	timePerElement	: time per element in ns
[out]	timeErrorPerElement	: error of time per element in ns
	nbElement	: number of element treated by the function __f
	__f	: function to be called and benchmarked
	__args	: parameter of the function to be benchmarked

Definition at line 148 of file micro_benchmark_ns_impl.h.

{
        micro_benchmarkAutoNs(ellapsedTimeNs, ellapsedTimeErrorNs, __f, __args...);
        timePerElement = ellapsedTimeNs/((double)nbElement);
        timeErrorPerElement = ellapsedTimeErrorNs/((double)nbElement);
}

References micro_benchmarkAutoNs().

Here is the call graph for this function:

micro_benchmarkAutoNsPrint()

template<typename _Callable, typename... _Args>

void micro_benchmarkAutoNsPrint	(	const std::string &	testName,
		size_t	nbElement,
		_Callable &&	__f,
		_Args &&...	__args )

Do the micro benchmarking of a given function and gives performance results in ns and print the result.

Parameters

testName	: name of the performance test
nbElement	: number of element treated by the function __f
__f	: function to be called and benchmarked
__args	: parameter of the function to be benchmarked

Definition at line 181 of file micro_benchmark_ns_impl.h.

                                                                                                                 {
        double ellapsedTimeNs(0.0), ellapsedTimeErrorNs(0.0), timePerElement(0.0), timeErrorPerElement(0.0);
        micro_benchmarkAutoNs(ellapsedTimeNs, ellapsedTimeErrorNs, timePerElement, timeErrorPerElement, nbElement, __f, __args...);
        
        std::cout << testName << " : nbElement = "<<nbElement<<", timePerElement = " << timePerElement << " ns/el ± "<<timeErrorPerElement<<", elapsedTime = " << ellapsedTimeNs << " ns ± "<<ellapsedTimeErrorNs << std::endl;
        std::cerr << nbElement << "\t" << timePerElement << "\t" << ellapsedTimeNs << "\t" << timeErrorPerElement << "\t" << ellapsedTimeErrorNs << std::endl;
}

References micro_benchmarkAutoNs().

Here is the call graph for this function:

micro_benchmarkNs() [1/2]

template<typename _Callable, typename... _Args>

void micro_benchmarkNs	(	double &	ellapsedTimeNs,
		double &	ellapsedTimeErrorNs,
		double &	timePerElement,
		double &	timeErrorPerElement,
		size_t	nbTestPerf,
		size_t	nbCallPerTest,
		size_t	nbElement,
		_Callable &&	__f,
		_Args &&...	__args )

Do the micro benchmarking of a given function and gives performance results in ns.

Parameters

[out]	ellapsedTimeNs	: ellapsed time in ns
[out]	ellapsedTimeErrorNs	: error on the ellapsed time in ns
[out]	timePerElement	: time per element in ns
[out]	timeErrorPerElement	: error of time per element in ns
	nbTestPerf	: number of performance test
	nbCallPerTest	: number of calls per performance test
	nbElement	: number of element treated by the function __f
	__f	: function to be called and benchmarked
	__args	: parameter of the function to be benchmarked

Definition at line 129 of file micro_benchmark_ns_impl.h.

{
        micro_benchmarkNs(ellapsedTimeNs, ellapsedTimeErrorNs, nbTestPerf, nbCallPerTest, __f, __args...);
        timePerElement = ellapsedTimeNs/((double)nbElement);
        timeErrorPerElement = ellapsedTimeErrorNs/((double)nbElement);
}

References micro_benchmarkNs().

Here is the call graph for this function:

micro_benchmarkNs() [2/2]

template<typename _Callable, typename... _Args>

void micro_benchmarkNs	(	double &	ellapsedTimeNs,
		double &	ellapsedTimeErrorNs,
		size_t	nbTestPerf,
		size_t	nbCallPerTest,
		_Callable &&	__f,
		_Args &&...	__args )

Do the micro benchmarking of a given function and gives performance results in ns.

Parameters

[out]	ellapsedTimeNs	: ellapsed time in ns
[out]	ellapsedTimeErrorNs	: error on the ellapsed time in ns
	nbTestPerf	: number of performance test
	nbCallPerTest	: number of calls per performance test
	__f	: function to be called and benchmarked
	__args	: parameter of the function to be benchmarked

Definition at line 45 of file micro_benchmark_ns_impl.h.

{
        VecEllapsedTime vecTimeNs;
        int res = 0;
        ::phoenix_doNotOptimize(res);
        for(size_t i(0lu); i < nbTestPerf; ++i){
                //Stating the timer
                HiPeTime beginTime = phoenix_getTime();
                for(size_t j(0lu); j < nbCallPerTest; ++j){
                        ::phoenix_doNotOptimize(res);
                        __f(__args...);
                }
                //Get the time of the nbCallPerTest calls
                NanoSecs elapsedTime(phoenix_getTime() - beginTime);
                double fullNs(elapsedTime.count()/((double)nbCallPerTest));
                vecTimeNs.push_back(fullNs);
        }
        MapOrderedTime mapOrderTime;
        micro_benchmarkVecToMap(mapOrderTime, vecTimeNs);
        size_t nbValueUsed(vecTimeNs.size()*0.7 + 1lu);
        if(nbValueUsed > vecTimeNs.size()){
                nbValueUsed = vecTimeNs.size();
        }
        micro_benchmarkComputeTime(ellapsedTimeNs, ellapsedTimeErrorNs, mapOrderTime, nbValueUsed);
}

References micro_benchmarkComputeTime(), micro_benchmarkVecToMap(), phoenix_doNotOptimize(), and phoenix_getTime().

Referenced by micro_benchmarkAutoNs(), micro_benchmarkNs(), and micro_benchmarkNsPrint().

Here is the call graph for this function:

Here is the caller graph for this function:

micro_benchmarkNsPrint()

template<typename _Callable, typename... _Args>

void micro_benchmarkNsPrint	(	const std::string &	testName,
		size_t	nbTestPerf,
		size_t	nbCallPerTest,
		size_t	nbElement,
		_Callable &&	__f,
		_Args &&...	__args )

Do the micro benchmarking of a given function and gives performance results in ns and print the result.

Parameters

testName	: name of the performance test
nbTestPerf	: number of performance test
nbCallPerTest	: number of calls per performance test
nbElement	: number of element treated by the function __f
__f	: function to be called and benchmarked
__args	: parameter of the function to be benchmarked

Definition at line 166 of file micro_benchmark_ns_impl.h.

                                                                                                                                                      {
        double ellapsedTimeNs(0.0), ellapsedTimeErrorNs(0.0), timePerElement(0.0), timeErrorPerElement(0.0);
        micro_benchmarkNs(ellapsedTimeNs, ellapsedTimeErrorNs, timePerElement, timeErrorPerElement, nbTestPerf, nbCallPerTest, nbElement, __f, __args...);
        
        std::cout << testName << " : nbElement = "<<nbElement<<", timePerElement = " << timePerElement << " ns/el ± "<<timeErrorPerElement<<", elapsedTime = " << ellapsedTimeNs << " ns ± "<<ellapsedTimeErrorNs << std::endl;
        std::cerr << nbElement << "\t" << timePerElement << "\t" << ellapsedTimeNs << "\t" << timeErrorPerElement << "\t" << ellapsedTimeErrorNs << std::endl;
}

References micro_benchmarkNs().

Here is the call graph for this function:

phoenix_doNotOptimize() [1/2]

template<class T>

void phoenix_doNotOptimize ( T & value )

inline

Prevent compiler from optimising a loop.

Parameters

value

: reference to a value

Definition at line 28 of file micro_benchmark_ns_impl.h.

                                                                  {
#if defined(__clang__)
        asm volatile("" : "+r,m"(value) : : "memory");
#else
        asm volatile("" : "+m,r"(value) : : "memory");
#endif
}

phoenix_doNotOptimize() [2/2]

template<class T>

void phoenix_doNotOptimize ( T const & value )

inline

Prevent compiler from optimising a loop.

Parameters

value

: reference to a value

Definition at line 20 of file micro_benchmark_ns_impl.h.

                                                                       {
        asm volatile("" : : "r,m"(value) : "memory");
}

Referenced by micro_benchmarkNs().

Here is the caller graph for this function: