PFunctionTimer Class Reference

Timer used to time a function call multiple times. More...

#include <PFunctionTimer.h>

Public Member Functions
template<typename _Callable, typename... _Args>
void	evalPerf (_Callable &&__f, _Args &&... __args)
	Method which evaluate performance of the given function.
size_t	getNbElement () const
	Get the number of elements computed in the performance test.
void	getSortedPerf (std::vector< double > &orderPerfNs, std::vector< double > &orderPerfCy) const
	Get the ordered performances.
PFunctionTimer &	operator= (const PFunctionTimer &other)
	Definition of equal operator of PFunctionTimer.
	PFunctionTimer (const PFunctionTimer &other)
	Copy constructor of PFunctionTimer.
	PFunctionTimer (size_t nbMeasure=0lu, size_t nbElement=0lu)
	Default constructor of PFunctionTimer.
void	resize (size_t nbMeasure)
	Resize the number of possible measures.
bool	savePerf (const std::string &fileName) const
	Save the performance of the function in a file.
void	setNbElement (size_t nbElement)
	Set the number of elements to consider for the function timing.
virtual	~PFunctionTimer ()
	Destructor of PFunctionTimer.

Protected Member Functions
void	copyPFunctionTimer (const PFunctionTimer &other)
	Copy function of PFunctionTimer.

Private Member Functions
void	initialisationPFunctionTimer (size_t nbMeasure, size_t nbElement)
	Initialisation function of the class PFunctionTimer.
void	saveQuantilePerf (std::ofstream &fs, const std::vector< double > &orderPerfNs, const std::vector< double > &orderPerfCy, const std::string &name, size_t valueIndex) const
	Save the performance of the given quantile.

Private Attributes
size_t	p_nbElement
	Number of elements the function is computing (supposed to be constant for all the performance tests).
size_t	p_nbMeasure
	Number of performance measures we want on this function.
std::vector< double >	p_vecEllapsedTimeCycle
	Ellapsed time of the function in cycles.
std::vector< double >	p_vecEllapsedTimeNs
	Ellapsed time of the function in nanoseconds.

Detailed Description

Timer used to time a function call multiple times.

Definition at line 15 of file PFunctionTimer.h.

Constructor & Destructor Documentation

PFunctionTimer() [1/2]

PFunctionTimer::PFunctionTimer	(	size_t	nbMeasure = 0lu,
		size_t	nbElement = 0lu )

Default constructor of PFunctionTimer.

Parameters

nbMeasure	: number of performance measures we want on this function
nbElement	: number of elements the function is computing (supposed to be constant for all the performance tests)

Definition at line 17 of file PFunctionTimer.cpp.

                                                                {
        initialisationPFunctionTimer(nbMeasure, nbElement);
}

References initialisationPFunctionTimer().

Referenced by copyPFunctionTimer(), operator=(), and PFunctionTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

PFunctionTimer() [2/2]

PFunctionTimer::PFunctionTimer

(

const PFunctionTimer &

other

)

Copy constructor of PFunctionTimer.

Parameters

other

: class to copy

Definition at line 24 of file PFunctionTimer.cpp.

                                                          {
        copyPFunctionTimer(other);
}

References copyPFunctionTimer(), and PFunctionTimer().

Here is the call graph for this function:

~PFunctionTimer()

PFunctionTimer::~PFunctionTimer ( )

virtual

Destructor of PFunctionTimer.

Definition at line 29 of file PFunctionTimer.cpp.

                               {
        
}

Member Function Documentation

copyPFunctionTimer()

void PFunctionTimer::copyPFunctionTimer ( const PFunctionTimer & other )

protected

Copy function of PFunctionTimer.

Parameters

other

: class to copy

Definition at line 142 of file PFunctionTimer.cpp.

                                                                   {
        p_nbMeasure = other.p_nbMeasure;
        p_nbElement = other.p_nbElement;
        p_vecEllapsedTimeNs = other.p_vecEllapsedTimeNs;
        p_vecEllapsedTimeCycle = other.p_vecEllapsedTimeCycle;
}

References p_nbElement, p_nbMeasure, p_vecEllapsedTimeCycle, p_vecEllapsedTimeNs, and PFunctionTimer().

Referenced by operator=(), and PFunctionTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

evalPerf()

template<typename _Callable, typename... _Args>

void PFunctionTimer::evalPerf	(	_Callable &&	__f,
		_Args &&...	__args )

Method which evaluate performance of the given function.

Parameters

__f	: function to be evaluated
__args	: arguments of the function The function will be called nbMeasure times (set by the resize method)

Definition at line 33 of file PFunctionTimer_impl.h.

                                                               {
        PIN_THREAD_TO_CORE
        int dummy = 0;
        ::benchmark_doNotOptimize(dummy);
        for(size_t i(0lu); i < p_nbMeasure; ++i){
                //Start chrono
                HiPeTime startNs = phoenix_getTime();
                size_t startCy = phoenix_rdtsc();
                //Call function
                ::benchmark_doNotOptimize(dummy);
                __f(__args...);
                //Compute ellapsed time
                size_t ellapsedTimeCy(phoenix_rdtsc() - startCy);
                p_vecEllapsedTimeNs[i] = (double)ellapsedTimeCy;
                NanoSecs elapsedTimeNs(phoenix_getTime() - startNs);
                double fullNs((double)elapsedTimeNs.count());
                p_vecEllapsedTimeCycle[i] = fullNs;
        }
}

References benchmark_doNotOptimize(), p_nbMeasure, p_vecEllapsedTimeCycle, p_vecEllapsedTimeNs, phoenix_getTime(), phoenix_rdtsc(), and PIN_THREAD_TO_CORE.

Here is the call graph for this function:

getNbElement()

size_t PFunctionTimer::getNbElement

(

)

const

Get the number of elements computed in the performance test.

Returns

number of elements computed in the performance test

Definition at line 135 of file PFunctionTimer.cpp.

                                         {
        return p_nbElement;
}

References p_nbElement.

getSortedPerf()

void PFunctionTimer::getSortedPerf	(	std::vector< double > &	orderPerfNs,
		std::vector< double > &	orderPerfCy ) const

Get the ordered performances.

Parameters

[out]	orderPerfNs	: sorted performance in nanoseconds
[out]	orderPerfCy	: sorted performance in cycles

Definition at line 125 of file PFunctionTimer.cpp.

                                                                                                        {
        orderPerfNs = p_vecEllapsedTimeNs;
        orderPerfCy = p_vecEllapsedTimeCycle;
        std::sort(orderPerfNs.begin(), orderPerfNs.end());
        std::sort(orderPerfCy.begin(), orderPerfCy.end());
}

References p_vecEllapsedTimeCycle, and p_vecEllapsedTimeNs.

Referenced by savePerf().

Here is the caller graph for this function:

initialisationPFunctionTimer()

void PFunctionTimer::initialisationPFunctionTimer ( size_t nbMeasure, size_t nbElement )

private

Initialisation function of the class PFunctionTimer.

Parameters

nbMeasure	: number of performance measures we want on this function
nbElement	: number of elements the function is computing (supposed to be constant for all the performance tests)

Definition at line 153 of file PFunctionTimer.cpp.

                                                                                   {
        setNbElement(nbElement);
        resize(nbMeasure);
}

References resize(), and setNbElement().

Referenced by PFunctionTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

PFunctionTimer & PFunctionTimer::operator=

(

const PFunctionTimer &

other

)

Definition of equal operator of PFunctionTimer.

Parameters

other

: class to copy

Returns

copied class

Definition at line 37 of file PFunctionTimer.cpp.

                                                                      {
        copyPFunctionTimer(other);
        return *this;
}

References copyPFunctionTimer(), and PFunctionTimer().

Here is the call graph for this function:

resize()

void PFunctionTimer::resize

(

size_t

nbMeasure

)

Resize the number of possible measures.

Parameters

nbMeasure

: number of performance measures we want on this function

Definition at line 52 of file PFunctionTimer.cpp.

                                           {
        p_nbMeasure = nbMeasure;
        p_vecEllapsedTimeNs.resize(p_nbMeasure);
        p_vecEllapsedTimeCycle.resize(p_nbMeasure);
}

References p_nbMeasure, p_vecEllapsedTimeCycle, and p_vecEllapsedTimeNs.

Referenced by initialisationPFunctionTimer().

Here is the caller graph for this function:

savePerf()

bool PFunctionTimer::savePerf

(

const std::string &

fileName

)

const

Save the performance of the function in a file.

Parameters

fileName

: name of the file to be saved with our function performances

Returns

true on success, false otherwise

Definition at line 78 of file PFunctionTimer.cpp.

                                                             {
        if(p_vecEllapsedTimeCycle.size() == 0lu || p_vecEllapsedTimeNs.size() == 0lu){
                std::cerr << "PFunctionTimer::savePerf : cannot save empty vector in file '"<<fileName<<"'" << std::endl;
                return false;
        }
        std::ofstream fs;
        fs.open(fileName);
        if(!fs.is_open()){
                std::cerr << "PFunctionTimer::savePerf : cannot save file '"<<fileName<<"'" << std::endl;
                return false;
        }
        fs << "#Global performances" << std::endl;
        fs << "[Performance]" << std::endl;
        fs << "nb_element = " << p_nbElement << std::endl;
        fs << "nb_measure = " << p_nbMeasure << std::endl;
        fs << std::endl;
        std::vector<double> orderPerfNs, orderPerfCy;
        getSortedPerf(orderPerfNs, orderPerfCy);
        
        //Let's save the best performances
        saveQuantilePerf(fs, orderPerfNs, orderPerfCy, "best", 0lu);
        //Let's save the median performances
        saveQuantilePerf(fs, orderPerfNs, orderPerfCy, "median", p_nbMeasure/2lu);
        
        fs << std::endl;
        fs << "#Detailed performances" << std::endl;
        fs << "[Detail]" << std::endl;
        phoenix_vectorToToml(fs, p_vecEllapsedTimeNs, "measure_nanosecond", 1.0);
        phoenix_vectorToToml(fs, p_vecEllapsedTimeCycle, "measure_cycles", 1.0);
        phoenix_vectorToToml(fs, p_vecEllapsedTimeNs, "measure_nanosecond_per_element", (double)p_nbElement);
        phoenix_vectorToToml(fs, p_vecEllapsedTimeCycle, "measure_cycles_per_element", (double)p_nbElement);
        //Let's save the ratio of cycles over nanoseconds
        std::vector<double> vecCyPerNs(p_vecEllapsedTimeCycle.size());
        std::transform(p_vecEllapsedTimeCycle.begin(), p_vecEllapsedTimeCycle.end(),
                        p_vecEllapsedTimeNs.begin(), vecCyPerNs.begin(),
                        [](double cy, double ns){
                                return cy/ns;
                        });
        phoenix_vectorToToml(fs, vecCyPerNs, "cycles_over_nanosecond", 1.0);
        fs.close();
        return true;
}

References getSortedPerf(), p_nbElement, p_nbMeasure, p_vecEllapsedTimeCycle, p_vecEllapsedTimeNs, phoenix_vectorToToml(), and saveQuantilePerf().

Here is the call graph for this function:

saveQuantilePerf()

void PFunctionTimer::saveQuantilePerf ( std::ofstream & fs, const std::vector< double > & orderPerfNs, const std::vector< double > & orderPerfCy, const std::string & name, size_t valueIndex ) const

private

Save the performance of the given quantile.

Parameters

[out]	fs	: stream to be updated
	orderPerfNs	: ordered performances in nanoseconds
	orderPerfCy	: ordered performances in cycles
	name	: name of the variable
	valueIndex	: index of the value in the tables

Definition at line 165 of file PFunctionTimer.cpp.

{
        fs << "#"<<name<<" performance in nano seconds" << std::endl;
        fs << name << "_nanosecond = " << orderPerfNs[valueIndex] << std::endl;
        fs << "#Best performance in cycles" << std::endl;
        fs << name << "_cycle = " << orderPerfCy[valueIndex] << std::endl;
        fs << std::endl;
        fs << "#"<<name<<" performance in nano seconds per elements" << std::endl;
        fs << name << "_nanosecond_per_element = " << orderPerfNs[valueIndex]/p_nbElement << std::endl;
        fs << "#"<<name<<" performance in cycles per elements" << std::endl;
        fs << name << "_cycle_per_element = " << orderPerfCy[valueIndex]/p_nbElement << std::endl;
        fs << "#"<<name<<" performance in Giga Elements per second" << std::endl;
        fs << name << "_giga_element_per_second = " << p_nbElement/orderPerfNs[valueIndex] << std::endl;
        fs << std::endl;
}

References p_nbElement.

Referenced by savePerf().

Here is the caller graph for this function:

setNbElement()

void PFunctionTimer::setNbElement

(

size_t

nbElement

)

Set the number of elements to consider for the function timing.

Parameters

nbElement

: number of elements the function is computing (supposed to be constant for all the performance tests)

Definition at line 45 of file PFunctionTimer.cpp.

                                                 {
        p_nbElement = nbElement;
}

References p_nbElement.

Referenced by initialisationPFunctionTimer().

Here is the caller graph for this function:

Member Data Documentation

p_nbElement

size_t PFunctionTimer::p_nbElement

private

Number of elements the function is computing (supposed to be constant for all the performance tests).

Definition at line 44 of file PFunctionTimer.h.

Referenced by copyPFunctionTimer(), getNbElement(), savePerf(), saveQuantilePerf(), and setNbElement().

p_nbMeasure

size_t PFunctionTimer::p_nbMeasure

private

Number of performance measures we want on this function.

Definition at line 41 of file PFunctionTimer.h.

Referenced by copyPFunctionTimer(), evalPerf(), resize(), and savePerf().

p_vecEllapsedTimeCycle

std::vector<double> PFunctionTimer::p_vecEllapsedTimeCycle

private

Ellapsed time of the function in cycles.

Definition at line 48 of file PFunctionTimer.h.

Referenced by copyPFunctionTimer(), evalPerf(), getSortedPerf(), resize(), and savePerf().

p_vecEllapsedTimeNs

std::vector<double> PFunctionTimer::p_vecEllapsedTimeNs

private

Ellapsed time of the function in nanoseconds.

Definition at line 46 of file PFunctionTimer.h.

Referenced by copyPFunctionTimer(), evalPerf(), getSortedPerf(), resize(), and savePerf().

---

The documentation for this class was generated from the following files:

• /builds/CTA-LAPP/PHOENIX_LIBS2/test-benchmark/PhoenixMicroBenchmark/src/PFunctionTimer.h
• /builds/CTA-LAPP/PHOENIX_LIBS2/test-benchmark/PhoenixMicroBenchmark/src/PFunctionTimer.cpp
• /builds/CTA-LAPP/PHOENIX_LIBS2/test-benchmark/PhoenixMicroBenchmark/src/PFunctionTimer_impl.h