micro_benchmark_ns_impl.h

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#ifndef __MICRO_BENCHMARK_NS_IMPL_H__
#define __MICRO_BENCHMARK_NS_IMPL_H__
 
#include <cmath>
#include "micro_benchmark_ns.h"

#define PHOENIX_MINIMUM_TIME_NS 1000000000.0


template <class T>
[[gnu::always_inline]] inline void phoenix_doNotOptimize(T const& value) {
        asm volatile("" : : "r,m"(value) : "memory");
}


template <class T>
[[gnu::always_inline]] inline void phoenix_doNotOptimize(T & value) {
#if defined(__clang__)
        asm volatile("" : "+r,m"(value) : : "memory");
#else
        asm volatile("" : "+m,r"(value) : : "memory");
#endif
}


template<typename _Callable, typename... _Args>
void micro_benchmarkNs(double & ellapsedTimeNs, double & ellapsedTimeErrorNs, size_t nbTestPerf, size_t nbCallPerTest,
                        _Callable&& __f, _Args&&... __args)
{
        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);
}
 


template<typename _Callable, typename... _Args>
void micro_benchmarkAutoNs(double & ellapsedTimeNs, double & ellapsedTimeErrorNs, _Callable&& __f, _Args&&... __args){
        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;
        }
}


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)
{
        micro_benchmarkNs(ellapsedTimeNs, ellapsedTimeErrorNs, nbTestPerf, nbCallPerTest, __f, __args...);
        timePerElement = ellapsedTimeNs/((double)nbElement);
        timeErrorPerElement = ellapsedTimeErrorNs/((double)nbElement);
}


template<typename _Callable, typename... _Args>
void micro_benchmarkAutoNs(double & ellapsedTimeNs, double & ellapsedTimeErrorNs,
                        double & timePerElement, double & timeErrorPerElement, size_t nbElement,
                        _Callable&& __f, _Args&&... __args)
{
        micro_benchmarkAutoNs(ellapsedTimeNs, ellapsedTimeErrorNs, __f, __args...);
        timePerElement = ellapsedTimeNs/((double)nbElement);
        timeErrorPerElement = ellapsedTimeErrorNs/((double)nbElement);
}


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


template<typename _Callable, typename... _Args>
void micro_benchmarkAutoNsPrint(const std::string & testName, size_t nbElement, _Callable&& __f, _Args&&... __args){
        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;
}
 
#endif