micro_benchmark_common.cpp File Reference

#include <cmath>
#include <sstream>
#include "micro_benchmark_common.h"

Include dependency graph for micro_benchmark_common.cpp:

Go to the source code of this file.

Functions
std::vector< std::string >	cutStringOnChars (const std::string &strIn, const std::string &setChars)
	Cut a string on determined chars.
bool	findCharInString (const std::string &str, char ch)
	Tells if a chararacter is in a string.
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.
void	micro_benchmarkHelpFunction ()
	Help function of the micro benchmarking program argument parse.
void	micro_benchmarkHelpFunction2d ()
	Help function of the micro benchmarking program argument parse.
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.

Function Documentation

cutStringOnChars()

std::vector< std::string > cutStringOnChars	(	const std::string &	strIn,
		const std::string &	setChars )

Cut a string on determined chars.

Parameters

strIn	: input string
setChars	: set of characters on which to cut

Returns

vector of cutted string

Definition at line 71 of file micro_benchmark_common.cpp.

                                                                                          {
        std::vector<std::string> vecOut;
        std::string strTmp("");
        for(std::string::const_iterator it(strIn.begin()); it != strIn.end(); ++it){
                if(findCharInString(setChars, *it)){
                        if(strTmp != ""){vecOut.push_back(strTmp);}
                        strTmp = "";
                }else{
                        strTmp += *it;
                }
        }
        if(strTmp != ""){vecOut.push_back(strTmp);}
        return vecOut;
}

References findCharInString().

Referenced by micro_benchmarkParseArg(), and micro_benchmarkParseArg2d().

Here is the call graph for this function:

Here is the caller graph for this function:

findCharInString()

bool findCharInString	(	const std::string &	str,
		char	ch )

Tells if a chararacter is in a string.

Parameters

str	: string to be analysed
ch	: char to be searched in str

Returns

true if ch is in str, false otherwise

Definition at line 57 of file micro_benchmark_common.cpp.

                                                    {
        std::string::const_iterator it = str.begin();
        while(it != str.end()){
                if(*it == ch) return true;
                ++it;
        }
        return false;
}

Referenced by cutStringOnChars().

Here is the caller graph for this function:

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_benchmarkHelpFunction()

void micro_benchmarkHelpFunction

(

)

Help function of the micro benchmarking program argument parse.

Definition at line 48 of file micro_benchmark_common.cpp.

                                  {
        std::cout << "micro_benchmarkParseArg : expect only a list of INT such as: \"1000,2000,3000,4000\"" << std::endl;
}

Referenced by micro_benchmarkParseArg().

Here is the caller graph for this function:

micro_benchmarkHelpFunction2d()

void micro_benchmarkHelpFunction2d

(

)

Help function of the micro benchmarking program argument parse.

Definition at line 114 of file micro_benchmark_common.cpp.

                                    {
        std::cout << "micro_benchmarkParseArg2d : expect only two list of INT such as: \"1000,2000,3000,4000\"" << std::endl;
}

Referenced by micro_benchmarkParseArg2d().

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: