Thread.h

Go to the documentation of this file.

/*-------------------------------------------------------------------
Copyright 2011 Ravishankar Sundararaman

This file is part of JDFTx.

JDFTx is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

JDFTx is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with JDFTx.  If not, see <http://www.gnu.org/licenses/>.
-------------------------------------------------------------------*/

#ifndef JDFTX_CORE_THREAD_H
#define JDFTX_CORE_THREAD_H


#include <core/Util.h>
#include <thread>
#include <mutex>
#include <unistd.h>

extern int nProcsAvailable; 

bool shouldThreadOperators();

void suspendOperatorThreading(); 
void resumeOperatorThreading(); 


template<typename Callable,typename ... Args>
void threadLaunch(int nThreads, Callable* func, size_t nJobs, Args... args);

template<typename Callable,typename ... Args>
void threadLaunch(Callable* func, size_t nJobs, Args... args);


class AutoThreadCount
{
public:
        AutoThreadCount(int minThreads=1, int minStats=3, const char* name=0, FILE* fpLog=stdout);
        ~AutoThreadCount();
private:
        template<typename Callable,typename ... Args>
        friend void threadLaunch(AutoThreadCount*, Callable*, size_t, Args... args);

        int getThreadCount();
        void submitTime(int, double);
        double* time; int* count; int minThreads, nMax, nOpt, minStats; bool settled;
        char* name; FILE* fpLog;
};

template<typename Callable,typename ... Args>
void threadLaunch(AutoThreadCount*, Callable* func, size_t nJobs, Args... args);


template<typename Callable,typename ... Args>
void threadedLoop(Callable* func, size_t nIter, Args... args);


template<typename Callable,typename ... Args>
double threadedAccumulate(Callable* func, size_t nIter, Args... args);



//###################################################################################################
//####  Implementation  ####
//##########################

template<typename Callable,typename ... Args>
void threadLaunch(int nThreads, Callable* func, size_t nJobs, Args... args)
{       if(nThreads<=0) nThreads = shouldThreadOperators() ? nProcsAvailable : 1;
        if(nThreads>1) suspendOperatorThreading(); //Prevent func and anything it calls from launching nested threads
        std::thread** tArr = new std::thread*[nThreads-1];
        for(int t=0; t<nThreads; t++)
        {       size_t i1 = (nJobs>0 ? (  t   * nJobs)/nThreads : t);
                size_t i2 = (nJobs>0 ? ((t+1) * nJobs)/nThreads : nThreads);
                if(t<nThreads-1) tArr[t] = new std::thread(func, i1, i2, args...);
                else (*func)(i1, i2, args...);
        }
        for(int t=0; t<nThreads-1; t++)
        {       tArr[t]->join();
                delete tArr[t];
        }
        delete[] tArr;
        if(nThreads>1) resumeOperatorThreading(); //End nested threading guard section
}

template<typename Callable,typename ... Args>
void threadLaunch(Callable* func, size_t nJobs, Args... args)
{       threadLaunch(0, func, nJobs, args...);
}


template<typename Callable,typename ... Args>
void threadLaunch(AutoThreadCount* atc, Callable* func, size_t nJobs, Args... args)
{       if(!atc)
                threadLaunch(func, nJobs, args...);
        else
        {       int nThreads = atc->getThreadCount();
                double runTime = clock_us();
                threadLaunch(nThreads, func, nJobs, args...);
                runTime = clock_us() - runTime;
                atc->submitTime(nThreads, runTime);
        }
}


template<typename Callable,typename ... Args>
void threadedLoop_sub(size_t iMin, size_t iMax, Callable* func, Args... args)
{       for(size_t i=iMin; i<iMax; i++) (*func)(i, args...);
}
template<typename Callable,typename ... Args>
void threadedLoop(Callable* func, size_t nIter, Args... args)
{       threadLaunch(threadedLoop_sub<Callable,Args...>, nIter, func, args...);
}

template<typename Callable,typename ... Args>
void threadedAccumulate_sub(size_t iMin, size_t iMax, Callable* func, double* accumTot, std::mutex* m, Args... args)
{       double accum=0.0;
        for(size_t i=iMin; i<iMax; i++) accum += (*func)(i, args...);
        m->lock(); *accumTot += accum; m->unlock();
}
template<typename Callable,typename ... Args>
double threadedAccumulate(Callable* func, size_t nIter, Args... args)
{       double accumTot=0.0;
        std::mutex m;
        threadLaunch(threadedAccumulate_sub<Callable,Args...>, nIter, func, &accumTot, &m, args...);
        return accumTot;
}

#endif // JDFTX_CORE_THREAD_H