PFunctionTimer.cpp

Go to the documentation of this file.

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


PFunctionTimer::PFunctionTimer(size_t nbMeasure, size_t nbElement){
        initialisationPFunctionTimer(nbMeasure, nbElement);
}


PFunctionTimer::PFunctionTimer(const PFunctionTimer & other){
        copyPFunctionTimer(other);
}

PFunctionTimer::~PFunctionTimer(){
        
}


PFunctionTimer & PFunctionTimer::operator = (const PFunctionTimer & other){
        copyPFunctionTimer(other);
        return *this;
}


void PFunctionTimer::setNbElement(size_t nbElement){
        p_nbElement = nbElement;
}


void PFunctionTimer::resize(size_t nbMeasure){
        p_nbMeasure = nbMeasure;
        p_vecEllapsedTimeNs.resize(p_nbMeasure);
        p_vecEllapsedTimeCycle.resize(p_nbMeasure);
}


void phoenix_vectorToToml(std::ofstream & fs, const std::vector<double> & vecValue, const std::string & tableName, double nbElement){
        std::string comma("");
        fs << tableName << " = [" << std::endl;
        for(double value : vecValue){
                fs << comma << "\t" << value/nbElement;
                comma = ",\n";
        }
        fs << "\n]" << std::endl;
}


bool PFunctionTimer::savePerf(const std::string & fileName) const{
        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;
}


void PFunctionTimer::getSortedPerf(std::vector<double> & orderPerfNs, std::vector<double> & orderPerfCy) const{
        orderPerfNs = p_vecEllapsedTimeNs;
        orderPerfCy = p_vecEllapsedTimeCycle;
        std::sort(orderPerfNs.begin(), orderPerfNs.end());
        std::sort(orderPerfCy.begin(), orderPerfCy.end());
}


size_t PFunctionTimer::getNbElement() const{
        return p_nbElement;
}


void PFunctionTimer::copyPFunctionTimer(const PFunctionTimer & other){
        p_nbMeasure = other.p_nbMeasure;
        p_nbElement = other.p_nbElement;
        p_vecEllapsedTimeNs = other.p_vecEllapsedTimeNs;
        p_vecEllapsedTimeCycle = other.p_vecEllapsedTimeCycle;
}


void PFunctionTimer::initialisationPFunctionTimer(size_t nbMeasure, size_t nbElement){
        setNbElement(nbElement);
        resize(nbMeasure);
}


void PFunctionTimer::saveQuantilePerf(std::ofstream & fs, const std::vector<double> & orderPerfNs, const std::vector<double> & orderPerfCy,
                        const std::string & name, size_t valueIndex) const
{
        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;
}