micro_benchmark_common.h File Reference

#include <chrono>
#include <string>
#include <vector>
#include <map>
#include <iostream>
#include "pin_thread_to_core.h"

Include dependency graph for micro_benchmark_common.h:

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

Go to the source code of this file.

Typedefs
typedef void(&	EvaluateTimeFct) (size_t)
typedef double(&	EvaluateTimeFct2d) (size_t, size_t)
typedef std::map< double, size_t >	MapOrderedTime
	Map of the ordered ellapsed time.
typedef std::vector< double >	VecEllapsedTime
	Vector of ellapsed time measurement.

Functions
void	micro_benchmarkComputeTime (double &ellapsedTimeNs, double &ellapsedTimeErrorNs, const MapOrderedTime &mapOrderTime, size_t nbValueToBeUsed)
	Compute the total computing time and associated error with the given data.
int	micro_benchmarkParseArg (int argc, char **argv, EvaluateTimeFct evalFunc)
	Call the evalFunc by respect to the arguments given to the program.
int	micro_benchmarkParseArg2d (int argc, char **argv, EvaluateTimeFct2d evalFunc)
	Call the evalFunc by respect to the arguments given to the program.
void	micro_benchmarkVecToMap (MapOrderedTime &mapOrderTime, const VecEllapsedTime &vecTime)
	Fill the map of ordered time with the vector.

Typedef Documentation

EvaluateTimeFct

typedef void(& EvaluateTimeFct) (size_t)

Definition at line 23 of file micro_benchmark_common.h.

EvaluateTimeFct2d

typedef double(& EvaluateTimeFct2d) (size_t, size_t)

Definition at line 24 of file micro_benchmark_common.h.

MapOrderedTime

typedef std::map<double, size_t> MapOrderedTime

Map of the ordered ellapsed time.

Definition at line 21 of file micro_benchmark_common.h.

VecEllapsedTime

typedef std::vector<double> VecEllapsedTime

Vector of ellapsed time measurement.

Definition at line 19 of file micro_benchmark_common.h.

Function Documentation

micro_benchmarkComputeTime()

void micro_benchmarkComputeTime	(	double &	ellapsedTimeNs,
		double &	ellapsedTimeErrorNs,
		const MapOrderedTime &	mapOrderTime,
		size_t	nbValueToBeUsed )

Compute the total computing time and associated error with the given data.

Parameters

[out]	ellapsedTimeNs	: ellapsed time in ns
[out]	ellapsedTimeErrorNs	: error on the ellapsed time in ns
	mapOrderTime	: map of the ordered ellapsed times
	nbValueToBeUsed	: number of values to be used in the map to compute the performance of the function

Definition at line 32 of file micro_benchmark_common.cpp.

                                                                                                                                                   {
        double sumValue(0.0), sumSquare(0.0);
        size_t nbValue(0lu);
        for(MapOrderedTime::const_iterator it(mapOrderTime.begin()); it != mapOrderTime.end() && nbValue < nbValueToBeUsed; ++it){
                double val(it->first);
                
                sumValue += val*((double)it->second);
                sumSquare += val*val*((double)it->second);
                nbValue += it->second;
        }
        ellapsedTimeNs = sumValue/((double)nbValue);
        double meanSquare(sumSquare/((double)nbValue));
        ellapsedTimeErrorNs = std::sqrt(meanSquare - ellapsedTimeNs*ellapsedTimeNs);
}

Referenced by micro_benchmarkNs(), and micro_benchmarkRdtsc().

Here is the caller graph for this function:

micro_benchmarkParseArg()

int micro_benchmarkParseArg	(	int	argc,
		char **	argv,
		EvaluateTimeFct	evalFunc )

Call the evalFunc by respect to the arguments given to the program.

Parameters

argc	: number of arguments passed to the program
argv	: table of arguments passed to the program
evalFunc	: function which evaluates the performance of an other function

Returns

0 on success, -1 otherwise

Definition at line 92 of file micro_benchmark_common.cpp.

                                                                            {
        PIN_THREAD_TO_CORE
        if(argc != 2){
                micro_benchmarkHelpFunction();
                return -1;
        }
        std::string argument(argv[1]);
        if(argument == "--help" || argument == "-h"){
                micro_benchmarkHelpFunction();
                return 0;
        }
        std::vector<std::string> vecSize(cutStringOnChars(argument, ", \t\n"));
        for(std::vector<std::string>::iterator it(vecSize.begin()); it != vecSize.end(); ++it){
                std::stringstream converterStr(*it);
                size_t nbElement(0lu);
                converterStr >> nbElement;
                evalFunc(nbElement);
        }
        return 0;
}

References cutStringOnChars(), micro_benchmarkHelpFunction(), and PIN_THREAD_TO_CORE.

Here is the call graph for this function:

micro_benchmarkParseArg2d()

int micro_benchmarkParseArg2d	(	int	argc,
		char **	argv,
		EvaluateTimeFct2d	evalFunc )

Call the evalFunc by respect to the arguments given to the program.

Parameters

argc	: number of arguments passed to the program
argv	: table of arguments passed to the program
evalFunc	: function which evaluates the performance of an other function

Returns

0 on success, -1 otherwise

Definition at line 124 of file micro_benchmark_common.cpp.

                                                                                {
        PIN_THREAD_TO_CORE
        if(argc != 3){
                micro_benchmarkHelpFunction2d();
                return -1;
        }
        std::string argumentX(argv[1]), argumentY(argv[2]);
        
        std::vector<std::string> vecSizeX(cutStringOnChars(argumentX, ", \t\n"));
        std::vector<std::string> vecSizeY(cutStringOnChars(argumentY, ", \t\n"));
        if(vecSizeX.size() != vecSizeY.size()){
                std::cerr << "Vector X and Y must ave the same size vecSizeX("<<vecSizeX.size()<<") != vecSizeY("<<vecSizeY.size()<<")" << std::endl;
                std::cout << "Vector X and Y must ave the same size vecSizeX("<<vecSizeX.size()<<") != vecSizeY("<<vecSizeY.size()<<")" << std::endl;
                return -1;
        }
        for(std::vector<std::string>::iterator itX(vecSizeX.begin()); itX != vecSizeX.end(); ++itX){
                std::stringstream converterStrX(*itX);
                size_t nbElementX(0lu);
                converterStrX >> nbElementX;
                std::cout << "\t" << nbElementX;
        }
        std::cout << std::endl;
        
        for(std::vector<std::string>::iterator itY(vecSizeY.begin()); itY != vecSizeY.end(); ++itY){
                std::stringstream converterStrY(*itY);
                size_t nbElementY(0lu);
                converterStrY >> nbElementY;
                std::cout << nbElementY;
                for(std::vector<std::string>::iterator itX(vecSizeX.begin()); itX != vecSizeX.end(); ++itX){
                        std::stringstream converterStrX(*itX);
                        size_t nbElementX(0lu);
                        converterStrX >> nbElementX;
                        double res = evalFunc(nbElementX, nbElementY);
                        std::cerr << nbElementX << "\t" << nbElementY << "\t" << res << std::endl;
                        std::cout << "\t" << res;
                }
                std::cerr << std::endl;
                std::cout << std::endl;
        }
        return 0;
}

References cutStringOnChars(), micro_benchmarkHelpFunction2d(), and PIN_THREAD_TO_CORE.

Here is the call graph for this function:

micro_benchmarkVecToMap()

void micro_benchmarkVecToMap	(	MapOrderedTime &	mapOrderTime,
		const VecEllapsedTime &	vecTime )

Fill the map of ordered time with the vector.

Parameters

[out]	mapOrderTime	: map of the ordered ellapsed times
	vecTime	: input ellapsed times

Definition at line 15 of file micro_benchmark_common.cpp.

                                                                                            {
        for(VecEllapsedTime::const_iterator it(vecTime.begin()); it != vecTime.end(); ++it){
                MapOrderedTime::iterator itFindTime = mapOrderTime.find(*it);
                if(itFindTime != mapOrderTime.end()){
                        itFindTime->second += 1lu;
                }else{
                        mapOrderTime[*it] = 1lu;
                }
        }
}

Referenced by micro_benchmarkNs(), and micro_benchmarkRdtsc().

Here is the caller graph for this function: