PMultiThreadProgress.cpp

Go to the documentation of this file.

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


void phoenix_print_parallel_progress(PMultiThreadProgress & progress, int refreshSecond){
        while(!progress.isFinished()){        //While computation is ongoing
                progress.print();
                std::this_thread::sleep_for(std::chrono::seconds(refreshSecond));       //We check status of computation each second
        }
        progress.printSummary();
        std::cout << "PMultiThreadProgress : Done" << std::endl;
}


PMultiThreadProgress::PMultiThreadProgress(size_t nbExpectedProgressBar){
        initialisationPMultiThreadProgress(nbExpectedProgressBar);
}


PMultiThreadProgress::PMultiThreadProgress(const PMultiThreadProgress & other){
        copyPMultiThreadProgress(other);
}

PMultiThreadProgress::~PMultiThreadProgress(){
        
}


PMultiThreadProgress & PMultiThreadProgress::operator = (const PMultiThreadProgress & other){
        copyPMultiThreadProgress(other);
        return *this;
}


void PMultiThreadProgress::setNbExpectedProgressBar(size_t nbExpectedProgressBar){
        p_nbExpectedProgressBar = nbExpectedProgressBar;
}


size_t PMultiThreadProgress::addProgressBar(const PString & name, int progressMax){
        std::lock_guard<std::mutex> guard(p_currentMutex);
        size_t index = p_vecProgressElement.size();
        ProgressElement el;
        el.progress = 0;
        el.prevProgress = -1;
        el.progressMax = progressMax;
        el.name = name;
        el.isEndError = false;
        p_vecProgressElement.push_back(el);
        return index;
}


void PMultiThreadProgress::incrementProgress(size_t index){
        p_vecProgressElement[index].progress++;
}


void PMultiThreadProgress::setError(size_t index){
        p_vecProgressElement[index].isEndError = true;
}


bool PMultiThreadProgress::isFinished() const{
        return p_alreadyPrintedLine == p_vecProgressElement.size() && p_vecProgressElement.size() >= p_nbExpectedProgressBar;
}

void PMultiThreadProgress::print(){
        if(!isModified()){return;}    //No need to print
        size_t nbColTerminal = getNbColTerminal();
        //Clear all the progress bars on screen
        eraseProgressBar(nbColTerminal);
        //Check if we can print first finshed lines definitely
        printAllFinshedProgressBar();
        //Update the rest of the progress bars to print
        printProgressBar(nbColTerminal);
        //We save the previous number of progress bars, in case we print some and add other later
        p_previousNbProgressBar = p_vecProgressElement.size();
}

void PMultiThreadProgress::printSummary() const{
        size_t nbFail(0lu);
        for(VecProgressElement::const_iterator it(p_vecProgressElement.begin()); it != p_vecProgressElement.end(); ++it){
                nbFail += it->isEndError;
        }
        size_t nbSuccess(p_vecProgressElement.size() - nbFail);
        std::cout << "PMultiThreadProgress : " << p_vecProgressElement.size() << " computations, " << nbSuccess << " success, " << nbFail << " fail" << std::endl;
}


void PMultiThreadProgress::copyPMultiThreadProgress(const PMultiThreadProgress & other){
        p_vecProgressElement = other.p_vecProgressElement;
        p_alreadyPrintedLine = other.p_alreadyPrintedLine;
        p_nbExpectedProgressBar = other.p_nbExpectedProgressBar;
}


void PMultiThreadProgress::initialisationPMultiThreadProgress(size_t nbExpectedProgressBar){
        p_alreadyPrintedLine = 0lu;
        p_previousNbProgressBar = 0lu;
        p_nbExpectedProgressBar = nbExpectedProgressBar;
        p_vecProgressElement.reserve(nbExpectedProgressBar);
}


bool PMultiThreadProgress::isModified(){
        std::lock_guard<std::mutex> guard(p_currentMutex);
        bool isModif(false);
        size_t i(p_alreadyPrintedLine);
        while(!isModif && i < p_vecProgressElement.size()){
                ProgressElement & el = p_vecProgressElement[i];
                isModif = el.progress != el.prevProgress || el.isEndError;
                ++i;
        }
        return isModif;
}


void PMultiThreadProgress::eraseProgressBar(size_t nbColTerminal){
        if(p_previousNbProgressBar == 0lu){return;}
        //Advances method but can't write anyting
        std::cerr << "\33[2K\r";        //Remove a line where the cursor is
        for(size_t i(p_alreadyPrintedLine + 1u); i < p_previousNbProgressBar; ++i){
                std::cerr << "\033[A";          //Go to one line up
                std::cerr << "\33[2K\r";        //Remove a line where the cursor is
        }
}


void PMultiThreadProgress::printProgressBar(size_t nbColTerminal){
        for(size_t i(p_alreadyPrintedLine); i < p_vecProgressElement.size(); ++i){
                ProgressElement & el = p_vecProgressElement[i];
                std::cerr << el.name << " : ";
                if(el.progress >= el.progressMax || el.isEndError){        //This is a finished progress bar but not finaly drawed
                        if(el.isEndError){
                                std::cerr << "\033[31mError\033[0m";
                                for(size_t j(el.name.size() + 8lu); j < nbColTerminal; ++j){
                                        std::cerr << " ";
                                }
                        }else{
                                std::cerr << "\033[32mDone\033[0m";
                                for(size_t j(el.name.size() + 7lu); j < nbColTerminal; ++j){
                                        std::cerr << " ";
                                }
                        }
                }else{
                        int avencement = (100*el.progress)/el.progressMax;
                        std::stringstream strAvencement;
                        strAvencement << avencement;
                        std::cerr << avencement << "%";
                        for(size_t j(el.name.size() + 4lu + strAvencement.str().size()); j < nbColTerminal; ++j){
                                std::cerr << " ";
                        }
                        el.prevProgress = el.progress;      //Update previous progress
                }
        }
}

void PMultiThreadProgress::printAllFinshedProgressBar(){
        std::lock_guard<std::mutex> guard(p_currentMutex);
        size_t i(p_alreadyPrintedLine);
        while(i < p_vecProgressElement.size()){
                ProgressElement & el = p_vecProgressElement[i];
                if(el.progress >= el.progressMax || el.isEndError){        //This is a finished progress bar
                        std::cout << el.name << " : ";
                        if(el.isEndError){
                                std::cout << "\033[31mError\033[0m" << std::endl;
                        }else{
                                std::cout << "\033[32mDone\033[0m" << std::endl;
                        }
                        ++p_alreadyPrintedLine;
                }else{
                        break;
                }
                ++i;
        }
}


size_t PMultiThreadProgress::getNbColTerminal() const{
        struct winsize w;
        ioctl(0, TIOCGWINSZ, &w);
        return w.ws_col;
}