PFunctionPerf.cpp

Go to the documentation of this file.

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


PFunctionPerf::PFunctionPerf(const std::string & name){
        initialisationPFunctionPerf(name);
}


PFunctionPerf::PFunctionPerf(const PFunctionPerf & other){
        copyPFunctionPerf(other);
}

PFunctionPerf::~PFunctionPerf(){
        
}


PFunctionPerf & PFunctionPerf::operator = (const PFunctionPerf & other){
        copyPFunctionPerf(other);
        return *this;
}


void PFunctionPerf::setName(const std::string & name){
        p_name = name;
}


void PFunctionPerf::resize(size_t nbThread){
        p_timeBegin.resize(nbThread);
        p_nbCall.resize(nbThread);
        p_fullTime.resize(nbThread);
        p_fullSqrTime.resize(nbThread);
        p_minTime.resize(nbThread);
        p_maxTime.resize(nbThread);
        reset();
}


void PFunctionPerf::start(size_t threadIndex){
        p_timeBegin[threadIndex] = phoenix_hardware_rdtsc();
}


void PFunctionPerf::stop(size_t threadIndex){
        size_t elapsedTime = phoenix_hardware_rdtsc() - p_timeBegin[threadIndex];
        double dTime = elapsedTime;
        p_fullTime[threadIndex] += dTime;
        p_fullSqrTime[threadIndex] += dTime*dTime;
        if(elapsedTime > p_maxTime[threadIndex]){p_maxTime[threadIndex] = elapsedTime;}
        if(elapsedTime < p_minTime[threadIndex]){p_minTime[threadIndex] = elapsedTime;}
        ++(p_nbCall[threadIndex]);
}


void PFunctionPerf::reset(size_t threadIndex){
        p_timeBegin[threadIndex] = 0lu;
        p_nbCall[threadIndex] = 0lu;
        p_fullTime[threadIndex] = 0.0;
        p_fullSqrTime[threadIndex] = 0.0;
        p_minTime[threadIndex] = -1lu;
        p_maxTime[threadIndex] = 0lu;
}

void PFunctionPerf::reset(){
        for(size_t i(0lu); i < p_timeBegin.size(); ++i){
                reset(i);
        }
}


template<typename T>
T reduceVectorVale(const std::vector<T> & vec){
        T sum(0);
        for(typename std::vector<T>::const_iterator it(vec.begin()); it != vec.end(); ++it){
                sum += *it;
        }
        return sum;
}


void PFunctionPerf::getPerf(size_t & nbCall, double & fullTime, double & averageTime, double & stdTime, size_t & minTime, size_t & maxTime) const{
        nbCall = reduceVectorVale(p_nbCall);
        if(nbCall != 0lu){
                fullTime = reduceVectorVale(p_fullTime);
                averageTime = fullTime/((double)nbCall);
                stdTime = sqrt((reduceVectorVale(p_fullSqrTime)/((double)nbCall)) - (averageTime*averageTime));
                minTime = reduceVectorVale(p_minTime)*0.5;
                maxTime = reduceVectorVale(p_maxTime)*0.5;
        }else{
                fullTime = 0.0;
                averageTime = 0.0;
                stdTime = 0.0;
                minTime = 0.0;
                maxTime = 0.0;
        }
}


const std::string & PFunctionPerf::getName() const{
        return p_name;
}


void PFunctionPerf::print(std::ostream & out) const{
        size_t nbCall(0lu);
        double fullTime(0.0), averageTime(0.0), stdTime(0.0);
        size_t minTime(0lu), maxTime(0lu);
        getPerf(nbCall, fullTime, averageTime, stdTime, minTime, maxTime);
        out << "Function "<<p_name<<"(nbCall = " << nbCall << ", fullTime = " << fullTime << " cy, averageTime = " << averageTime << " cy, stdTime = " << stdTime << " cy, minTime = " << minTime << " cy, maxTime = " << maxTime << " cy)" << std::endl;
}


void PFunctionPerf::printCsv(std::ostream & out) const{
        size_t nbCall(0lu);
        double fullTime(0.0), averageTime(0.0), stdTime(0.0);
        size_t minTime(0lu), maxTime(0lu);
        getPerf(nbCall, fullTime, averageTime, stdTime, minTime, maxTime);
        out <<p_name<<"," << nbCall << "," << fullTime << "," << averageTime << "," << stdTime << "," << minTime << "," << maxTime << std::endl;
}


void PFunctionPerf::copyPFunctionPerf(const PFunctionPerf & other){
        p_name = other.p_name;
        p_timeBegin = other.p_timeBegin;
        p_nbCall = other.p_nbCall;
        p_fullTime = other.p_fullTime;
        p_fullSqrTime = other.p_fullSqrTime;
        p_minTime = other.p_minTime;
        p_maxTime = other.p_maxTime;
}

void PFunctionPerf::initialisationPFunctionPerf(const std::string & name){
        p_name = name;
        resize(1lu);
}