DetachPool.cpp

Go to the documentation of this file.

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


std::string phoenix_statusToString(int exitStatus){
        if(exitStatus == PEXIT_STATUS_NOT_FIHISHED){return "\033[33mStill Running\033[0m";}
        else if(exitStatus == PEXIT_STATUS_OK){return "\033[32mSUCCESS\033[0m";}
        else{
                return "\033[31mFAIL\033[0m";
        }
}


void phoenix_printThreadStatus(const ListThreadDetachInfo & listThreadInfo, std::ostream & out){
        out << "ListThreadDetachInfo : number of remaning threads  : " << listThreadInfo.size() << std::endl;
        size_t i(0lu);
        for(ListThreadDetachInfo::const_iterator it(listThreadInfo.begin()); it != listThreadInfo.end(); ++it){
                out << "\tthread("<<i<<") '"<<it->description<<"' has status " << phoenix_statusToString(it->exitStatus) << std::endl;
                ++i;
        }
}

DetachPool::DetachPool(){
        initialisationDetachPool();
}


DetachPool::DetachPool(const DetachPool & other){
        copyDetachPool(other);
}

DetachPool::~DetachPool(){
        waitUntilAllFinish(p_destructorWaitTime);
}


DetachPool & DetachPool::operator = (const DetachPool & other){
        copyDetachPool(other);
        return *this;
}


void DetachPool::setRefreshTime(PEllapsedTime refreshTime){
        p_refreshTime = refreshTime;
}


PEllapsedTime DetachPool::getRefreshTime() const{
        return p_refreshTime;
}


void DetachPool::setDestructionWaitTime(PEllapsedTime destructorWaitTime){
        p_destructorWaitTime = destructorWaitTime;
}


PEllapsedTime DetachPool::getDestructorWaitTime() const{
        return p_destructorWaitTime;
}


ListThreadDetachInfo DetachPool::getListThreadInfo(){
        p_mtx.lock();
        ListThreadDetachInfo tmp = p_listThreadInfo;
        p_mtx.unlock();
        return tmp;
}


void DetachPool::removeFinishedThread(std::ostream & out){
        if(p_listThreadInfo.size() == 0lu){return;}
        p_mtx.lock();
        std::list<ThreadDetachInfo>::iterator it(p_listThreadInfo.begin());
        while(it != p_listThreadInfo.end()){
                if(it->exitStatus != PEXIT_STATUS_NOT_FIHISHED){       //Thread is finished (in good or bad), so we can remove its informations
                        if(it->description != ""){
                                out << "DetachPool : thread '"<<it->description<<"' finished with status " << phoenix_statusToString(it->exitStatus) << std::endl;
                        }
                        it = p_listThreadInfo.erase(it);
                }else{
                        ++it;
                }
        }
        p_mtx.unlock();
}

void DetachPool::refresh(){
        PEllapsedTime ellapsedTimeRefresh = phoenix_ellapsedTime<PNanoSecond>(p_timeLastRefresh)/1000l;
        if(ellapsedTimeRefresh < p_refreshTime){
                return;         //Not time yet
        }
        removeFinishedThread();
        p_timeLastRefresh = phoenix_thread_clock();
}


void DetachPool::waitUntilAllFinish(PEllapsedTime maxWaitTime){
        if(p_listThreadInfo.size() == 0lu){return;}
        
        PhoenixTime startWaitingUnitThreadEnd = phoenix_thread_clock();
        
        while(phoenix_ellapsedTime<PNanoSecond>(startWaitingUnitThreadEnd)/1000l < maxWaitTime && p_listThreadInfo.size() != 0lu){
                removeFinishedThread();
                usleep(p_refreshTime);     //Let's wait a bit until next check
        }
}


void DetachPool::copyDetachPool(const DetachPool & other){
        p_refreshTime = other.p_refreshTime;
        p_timeLastRefresh = other.p_timeLastRefresh;
        p_destructorWaitTime = other.p_destructorWaitTime;
}

void DetachPool::initialisationDetachPool(){
        p_refreshTime = 1000000lu; //Refresh every second by default
        p_timeLastRefresh = phoenix_thread_clock();
        p_destructorWaitTime = 0l;
}