micro_benchmark_common.cpp

Go to the documentation of this file.

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


void micro_benchmarkVecToMap(MapOrderedTime & mapOrderTime, const VecEllapsedTime & vecTime){
        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;
                }
        }
}


void micro_benchmarkComputeTime(double & ellapsedTimeNs, double & ellapsedTimeErrorNs, const MapOrderedTime & mapOrderTime, size_t nbValueToBeUsed){
        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);
}

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


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


std::vector<std::string> cutStringOnChars(const std::string & strIn, const std::string & setChars){
        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;
}


int micro_benchmarkParseArg(int argc, char** argv, EvaluateTimeFct evalFunc){
        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;
}

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


int micro_benchmarkParseArg2d(int argc, char** argv, EvaluateTimeFct2d evalFunc){
        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;
}