Nektar::Thread::ThreadManagerBoost Class Reference

Implementation of ThreadManager using Boost threads. More...

#include <ThreadBoost.h>

Inheritance diagram for Nektar::Thread::ThreadManagerBoost:

Public Member Functions
	ThreadManagerBoost (unsigned int numWorkers)
	Constructs a ThreadManagerBoost. More...
virtual	~ThreadManagerBoost ()
	Shuts down threading. More...
virtual void	QueueJobs (std::vector< ThreadJob * > &joblist)
	Pass a list of tasklets to the master queue. More...
virtual void	QueueJob (ThreadJob *job)
	Pass a single job to the master queue. More...
virtual unsigned int	GetNumWorkers ()
	Return the number of active workers. More...
virtual unsigned int	GetWorkerNum ()
	Returns the worker number of the executing thread. More...
virtual void	SetNumWorkers (const unsigned int num)
	Sets the number of active workers. More...
virtual void	SetNumWorkers ()
	Sets the number of active workers to the maximum. More...
virtual unsigned int	GetMaxNumWorkers ()
	Gets the maximum available number of threads. More...
virtual void	Wait ()
	Waits until all queued jobs are finished. More...
virtual void	SetChunkSize (unsigned int chnk)
	Controls how many jobs are sent to each worker at a time. More...
virtual void	SetSchedType (SchedType s)
	Sets the current scheduling algorithm. More...
virtual bool	InThread ()
	Indicates whether the code is in a worker thread or not. More...
virtual void	Hold ()
	A calling threads holds until all active threads call this method. More...
virtual const std::string &	GetType () const
	Returns a description of the type of threading. More...
Public Member Functions inherited from Nektar::Thread::ThreadManager
virtual	~ThreadManager ()
	Destructor. More...
virtual bool	IsInitialised ()
	ThreadManager implementation. More...
int	GetThrFromPartition (int pPartition)
int	GetRankFromPartition (int pPartition)
int	GetPartitionFromRankThr (int pRank, unsigned int pThr)

Static Public Member Functions
static ThreadManagerSharedPtr	Create (unsigned int numT)
	Called by the factory method. More...

Private Member Functions
	ThreadManagerBoost ()
	ThreadManagerBoost (const ThreadManagerBoost &)
bool	IsWorking ()
void	SetNumWorkersImpl (const unsigned int num)

Private Attributes
const unsigned int	m_numThreads
unsigned int	m_numWorkers
std::queue< ThreadJob * >	m_masterQueue
boost::mutex	m_masterQueueMutex
boost::mutex	m_masterActiveMutex
boost::condition_variable	m_masterQueueCondVar
boost::condition_variable	m_masterActiveCondVar
ThreadWorkerBoost **	m_threadList
boost::thread **	m_threadThreadList
boost::thread::id	m_masterThreadId
bool *	m_threadBusyList
bool *	m_threadActiveList
unsigned int	m_chunkSize
SchedType	m_schedType
boost::barrier *	m_barrier
std::map< boost::thread::id, unsigned int >	m_threadMap
std::string	m_type

Static Private Attributes
static std::string	className

Friends
class	ThreadWorkerBoost

Detailed Description

Implementation of ThreadManager using Boost threads.

Definition at line 58 of file ThreadBoost.h.

Constructor & Destructor Documentation

ThreadManagerBoost() [1/3]

Nektar::Thread::ThreadManagerBoost::ThreadManagerBoost

(

unsigned int

numT

)

Constructs a ThreadManagerBoost.

Parameters

numWorkers

The number of threads to start (including master thread).

Note

Do not use, use factory instead.

Definition at line 55 of file ThreadBoost.cpp.

                                                        :
        m_numThreads(numT), m_numWorkers(numT), m_masterQueue(),
        m_masterQueueMutex(), m_masterActiveMutex(), m_masterQueueCondVar(),
        m_masterActiveCondVar(), m_chunkSize(1), m_schedType(e_dynamic),
        m_threadMap()
{
    using namespace std;
    try
    {
        m_threadList = new ThreadWorkerBoost*[m_numThreads];
        m_threadThreadList = new boost::thread*[m_numThreads];
        m_threadBusyList = new bool[m_numThreads];
        m_threadActiveList = new bool[m_numThreads];
    }
    catch (exception &e)
    {
        cerr << "Exception while allocating thread storage: "
             << e.what() << endl;
        abort();
    }
    unsigned int i = 0;
    while (i < m_numThreads)
    {
        ThreadWorkerBoost *tw;
        try
        {
            tw = new ThreadWorkerBoost(this, i);
        }
        catch (exception &e)
        {
            cerr << "Exception while allocating worker threads: "
                    << e.what() << endl;
            abort();
        }
 
        m_threadList[i] = tw;
        m_threadBusyList[i] = false;
        m_threadActiveList[i] = true;
 
        try
        {
            m_threadThreadList[i] = new boost::thread(boost::ref(*tw));
            boost::thread::id id = m_threadThreadList[i]->get_id();
            m_threadMap[id] = i;
        }
        catch (...)
        {
            std::cerr << "Exception while creating worker threads" << std::endl;
            abort();
        }
        i++;
    }
    m_masterThreadId = boost::this_thread::get_id();
    m_barrier = new boost::barrier(m_numWorkers > 0 ? m_numWorkers : 1);
    m_type = "Threading with Boost";
}

References m_barrier, m_masterThreadId, m_numThreads, m_numWorkers, m_threadActiveList, m_threadBusyList, m_threadList, m_threadMap, m_threadThreadList, m_type, and ThreadWorkerBoost.

~ThreadManagerBoost()

Nektar::Thread::ThreadManagerBoost::~ThreadManagerBoost ( )

virtual

Shuts down threading.

Terminates all running threads (they will finish their current job), releases resources and destructs.

Definition at line 117 of file ThreadBoost.cpp.

{
    // This is an immediate teardown.  We attempt to kill everything.
    // we daren't lock anything as we may cause a deadlock
    for (unsigned int i=0; i<m_numThreads; i++)
    {
        m_threadList[i]->Stop();
    }
 
    m_masterQueueCondVar.notify_all();
    m_masterActiveCondVar.notify_all();
    for (unsigned int i=0; i<m_numThreads; i++)
    {
        m_threadThreadList[i]->join();
        delete m_threadThreadList[i];
        delete m_threadList[i];
    }
 
    delete []m_threadList;
    delete []m_threadThreadList;
    delete []m_threadActiveList;
    delete []m_threadBusyList;
    delete m_barrier;
}

References m_barrier, m_masterActiveCondVar, m_masterQueueCondVar, m_numThreads, m_threadActiveList, m_threadBusyList, m_threadList, m_threadThreadList, and Nektar::Thread::ThreadWorkerBoost::Stop().

ThreadManagerBoost() [2/3]

Nektar::Thread::ThreadManagerBoost::ThreadManagerBoost ( )

private

Referenced by Create().

ThreadManagerBoost() [3/3]

Nektar::Thread::ThreadManagerBoost::ThreadManagerBoost ( const ThreadManagerBoost &  )

private

Member Function Documentation

Create()

static ThreadManagerSharedPtr Nektar::Thread::ThreadManagerBoost::Create ( unsigned int  numT )

inlinestatic

Called by the factory method.

Definition at line 86 of file ThreadBoost.h.

        {
            return std::shared_ptr<ThreadManager>(
                new ThreadManagerBoost(numT));
        }

References ThreadManagerBoost().

GetMaxNumWorkers()

unsigned int Nektar::Thread::ThreadManagerBoost::GetMaxNumWorkers ( )

virtual

Gets the maximum available number of threads.

Returns

The maximum number of workers.

Implements Nektar::Thread::ThreadManager.

Definition at line 299 of file ThreadBoost.cpp.

{
    return m_numThreads;
}

References m_numThreads.

GetNumWorkers()

unsigned int Nektar::Thread::ThreadManagerBoost::GetNumWorkers ( )

virtual

Return the number of active workers.

Active workers are threads that are either running jobs or are waiting for jobs to be queued.

Implements Nektar::Thread::ThreadManager.

Definition at line 235 of file ThreadBoost.cpp.

{
    return m_numWorkers;
}

References m_numWorkers.

GetType()

const std::string & Nektar::Thread::ThreadManagerBoost::GetType ( ) const

virtual

Returns a description of the type of threading.

E.g. "Threading with Boost"

Implements Nektar::Thread::ThreadManager.

Definition at line 317 of file ThreadBoost.cpp.

{
    return m_type;
}

References m_type.

GetWorkerNum()

unsigned int Nektar::Thread::ThreadManagerBoost::GetWorkerNum ( )

virtual

Returns the worker number of the executing thread.

Returns an unsigned int between 0 and N-1 where N is the number of active worker threads. Repeated calls from within this thread will always return the same value and the value will be the same as returned from ThreadJob.GetWorkerNum(). The same thread will run a job until it finishes.

Although if there are active threads then thread 0 is always one of them, it is possible that thread 0 does not run for a given set of jobs. For example, if there are 4 active threads and 3 jobs are submitted with a e_static scheduling strategy and a chunksize of 1, then it is possible that threads 1,2, and 3 pick up the jobs and thread 0 remains idle.

Returns 0 if called by non-thread.

Implements Nektar::Thread::ThreadManager.

Definition at line 244 of file ThreadBoost.cpp.

{
    boost::thread::id id = boost::this_thread::get_id();
    return m_threadMap[id];
}

References m_threadMap.

Hold()

void Nektar::Thread::ThreadManagerBoost::Hold ( )

virtual

A calling threads holds until all active threads call this method.

When called, the calling thread will sleep until all active workers have called this method. Once all have done so all threads awake and continue execution.

Note

Behaviour is likely undefined if the number of active workers is altered after a thread has called this method. It is only safe to call SetNumWorkers() when no threads are holding.

Implements Nektar::Thread::ThreadManager.

Definition at line 308 of file ThreadBoost.cpp.

{
    m_barrier->wait();
}

References m_barrier.

InThread()

bool Nektar::Thread::ThreadManagerBoost::InThread ( )

virtual

Indicates whether the code is in a worker thread or not.

Returns

True if the caller is in a worker thread.

Implements Nektar::Thread::ThreadManager.

Definition at line 205 of file ThreadBoost.cpp.

{
    boost::thread::id id = boost::this_thread::get_id();
    return (id != m_masterThreadId);
}

References m_masterThreadId.

IsWorking()

bool Nektar::Thread::ThreadManagerBoost::IsWorking ( )

private

Definition at line 170 of file ThreadBoost.cpp.

{
    bool working = false;
    Lock masterActiveLock(m_masterActiveMutex);
    for (unsigned int i = 0; i < m_numWorkers; i++)
    {
        working = working || m_threadBusyList[i];
    }
    return working;
}

References m_masterActiveMutex, m_numWorkers, and m_threadBusyList.

Referenced by Wait().

QueueJob()

void Nektar::Thread::ThreadManagerBoost::QueueJob ( ThreadJob *  job )

virtual

Pass a single job to the master queue.

Parameters

job	A pointer to a ThreadJob subclass.

The job may become available for running immediately. If this is an issue then suspend the workers with SetNumWorkers(0) until the jobs are queued.

Implements Nektar::Thread::ThreadManager.

Definition at line 159 of file ThreadBoost.cpp.

{
    Lock masterQueueLock(m_masterQueueMutex); // locks the queue
    m_masterQueue.push(job);
    m_masterQueueCondVar.notify_all(); // alert a waiting thread.
}   // queue unlocked

References m_masterQueue, m_masterQueueCondVar, and m_masterQueueMutex.

Referenced by QueueJobs().

QueueJobs()

void Nektar::Thread::ThreadManagerBoost::QueueJobs ( std::vector< ThreadJob * > &  joblist )

virtual

Pass a list of tasklets to the master queue.

Parameters

joblist

Vector of ThreadJob pointers.

The list of jobs is copied into the master queue. Jobs may be available for running immediately, even before the list has been fully copied. This can have consequences for the scheduling. If this is an issue then suspend the workers with SetNumWorkers(0) until the jobs are queued.

See also

SchedType

Implements Nektar::Thread::ThreadManager.

Definition at line 146 of file ThreadBoost.cpp.

{
    std::vector<ThreadJob *>::iterator it;
    for (it=joblist.begin(); it<joblist.end(); ++it)
    {
        QueueJob(*it);
    }
}

References QueueJob().

SetChunkSize()

void Nektar::Thread::ThreadManagerBoost::SetChunkSize ( unsigned int  chnk )

virtual

Controls how many jobs are sent to each worker at a time.

The exact meaning of this parameter depends on the current scheduling algorithm.

See also

SchedType

SetSchedType()

Implements Nektar::Thread::ThreadManager.

Definition at line 185 of file ThreadBoost.cpp.

{
    Lock masterQueueLock(m_masterQueueMutex); // locks the queue
    m_chunkSize = std::max(chnk, 1U);
}

References m_chunkSize, and m_masterQueueMutex.

SetNumWorkers() [1/2]

void Nektar::Thread::ThreadManagerBoost::SetNumWorkers ( )

virtual

Sets the number of active workers to the maximum.

Sets the number of active workers to the maximum available.

Implements Nektar::Thread::ThreadManager.

Definition at line 290 of file ThreadBoost.cpp.

{
    SetNumWorkersImpl(m_numThreads);
}

References m_numThreads, and SetNumWorkersImpl().

SetNumWorkers() [2/2]

void Nektar::Thread::ThreadManagerBoost::SetNumWorkers ( const unsigned int  num )

virtual

Sets the number of active workers.

Parameters

num	The number of active workers.

Active workers are threads that are either running jobs or are waiting for jobs to be queued.

If num is greater than the maximum allowed number of active workers, then the maximum value will be used instead.

Implements Nektar::Thread::ThreadManager.

Definition at line 278 of file ThreadBoost.cpp.

{
    unsigned int n;
    n = std::min(num, m_numThreads);
    n = std::max(n,   static_cast<unsigned int>(0));
    SetNumWorkersImpl(n);
}

References m_numThreads, and SetNumWorkersImpl().

SetNumWorkersImpl()

void Nektar::Thread::ThreadManagerBoost::SetNumWorkersImpl ( const unsigned int  num )

private

Definition at line 254 of file ThreadBoost.cpp.

{
    Lock masterActiveLock(m_masterActiveMutex); // locks the active
 
    if (m_numWorkers == num)
    {
        return;
    }
 
    delete m_barrier;
    m_barrier = new boost::barrier(num > 0 ? num : 1);
 
    m_numWorkers = num;
    for (unsigned int i = 0; i < m_numThreads; i++)
    {
        m_threadActiveList[i] = i < m_numWorkers ? true : false;
    }
    m_masterActiveCondVar.notify_all();
} // Lock on active released here

References m_barrier, m_masterActiveCondVar, m_masterActiveMutex, m_numThreads, m_numWorkers, and m_threadActiveList.

Referenced by SetNumWorkers().

SetSchedType()

void Nektar::Thread::ThreadManagerBoost::SetSchedType ( SchedType  s )

virtual

Sets the current scheduling algorithm.

See also

SetChunkSize()

Implements Nektar::Thread::ThreadManager.

Definition at line 195 of file ThreadBoost.cpp.

{
    Lock masterQueueLock(m_masterQueueMutex); // locks the queue
    m_schedType = s;
}

References m_masterQueueMutex, and m_schedType.

Wait()

void Nektar::Thread::ThreadManagerBoost::Wait ( )

virtual

Waits until all queued jobs are finished.

If there are no jobs running or queued this method returns immediately. Otherwise it blocks until the queue is empty and the worker threads are idle.

Implementations must ensure that trivial deadlocks are not possible from this method, that is, that this code:

// assume ThreadManager* tm
// assume SomeJob is subclass of ThreadJob
// assume SomeJob job
 
tm->SetNumWorkers(0);
tm->QueueJob(job);
tm->Wait();

does not wait forever. Since the master thread is counted in the number of worker threads, implementations should increase the number of active workers by 1 on entering Wait().

Implements Nektar::Thread::ThreadManager.

Definition at line 215 of file ThreadBoost.cpp.

{
    bool working;
    Lock masterQueueLock(m_masterQueueMutex); // locks the queue
    working = IsWorking();
    m_masterActiveCondVar.notify_all();
    m_masterQueueCondVar.notify_all();
    while (!m_masterQueue.empty() || working)
    {
        // while waiting, master queue is unlocked
        m_masterQueueCondVar.wait(masterQueueLock);
        // on exiting wait master queue is locked again
        working = IsWorking();
    }
}

References IsWorking(), m_masterActiveCondVar, m_masterQueue, m_masterQueueCondVar, and m_masterQueueMutex.

Friends And Related Function Documentation

ThreadWorkerBoost

friend class ThreadWorkerBoost

friend

So the workers can access the master queue and locks.

Definition at line 63 of file ThreadBoost.h.

Referenced by ThreadManagerBoost().

Member Data Documentation

className

std::string Nektar::Thread::ThreadManagerBoost::className

staticprivate

Initial value:

=
    GetThreadManagerFactory().RegisterCreatorFunction("ThreadManagerBoost",
            ThreadManagerBoost::Create, "Threading using Boost.")

Definition at line 115 of file ThreadBoost.h.

m_barrier

boost::barrier* Nektar::Thread::ThreadManagerBoost::m_barrier

private

Definition at line 113 of file ThreadBoost.h.

Referenced by Hold(), SetNumWorkersImpl(), ThreadManagerBoost(), and ~ThreadManagerBoost().

m_chunkSize

unsigned int Nektar::Thread::ThreadManagerBoost::m_chunkSize

private

Definition at line 111 of file ThreadBoost.h.

Referenced by Nektar::Thread::ThreadWorkerBoost::GetNumToLoad(), and SetChunkSize().

m_masterActiveCondVar

boost::condition_variable Nektar::Thread::ThreadManagerBoost::m_masterActiveCondVar

private

Definition at line 105 of file ThreadBoost.h.

Referenced by SetNumWorkersImpl(), Wait(), Nektar::Thread::ThreadWorkerBoost::WaitForActive(), and ~ThreadManagerBoost().

m_masterActiveMutex

boost::mutex Nektar::Thread::ThreadManagerBoost::m_masterActiveMutex

private

Definition at line 103 of file ThreadBoost.h.

Referenced by IsWorking(), Nektar::Thread::ThreadWorkerBoost::LoadJobs(), SetNumWorkersImpl(), and Nektar::Thread::ThreadWorkerBoost::WaitForActive().

m_masterQueue

std::queue<ThreadJob*> Nektar::Thread::ThreadManagerBoost::m_masterQueue

private

Definition at line 101 of file ThreadBoost.h.

Referenced by Nektar::Thread::ThreadWorkerBoost::GetNumToLoad(), Nektar::Thread::ThreadWorkerBoost::LoadJobs(), QueueJob(), and Wait().

m_masterQueueCondVar

boost::condition_variable Nektar::Thread::ThreadManagerBoost::m_masterQueueCondVar

private

Definition at line 104 of file ThreadBoost.h.

Referenced by Nektar::Thread::ThreadWorkerBoost::LoadJobs(), QueueJob(), Wait(), and ~ThreadManagerBoost().

m_masterQueueMutex

boost::mutex Nektar::Thread::ThreadManagerBoost::m_masterQueueMutex

private

Definition at line 102 of file ThreadBoost.h.

Referenced by Nektar::Thread::ThreadWorkerBoost::LoadJobs(), QueueJob(), SetChunkSize(), SetSchedType(), and Wait().

m_masterThreadId

boost::thread::id Nektar::Thread::ThreadManagerBoost::m_masterThreadId

private

Definition at line 108 of file ThreadBoost.h.

Referenced by InThread(), and ThreadManagerBoost().

m_numThreads

const unsigned int Nektar::Thread::ThreadManagerBoost::m_numThreads

private

Definition at line 99 of file ThreadBoost.h.

Referenced by GetMaxNumWorkers(), SetNumWorkers(), SetNumWorkersImpl(), ThreadManagerBoost(), and ~ThreadManagerBoost().

m_numWorkers

unsigned int Nektar::Thread::ThreadManagerBoost::m_numWorkers

private

Definition at line 100 of file ThreadBoost.h.

Referenced by Nektar::Thread::ThreadWorkerBoost::GetNumToLoad(), GetNumWorkers(), IsWorking(), SetNumWorkersImpl(), and ThreadManagerBoost().

m_schedType

SchedType Nektar::Thread::ThreadManagerBoost::m_schedType

private

Definition at line 112 of file ThreadBoost.h.

Referenced by Nektar::Thread::ThreadWorkerBoost::GetNumToLoad(), and SetSchedType().

m_threadActiveList

bool* Nektar::Thread::ThreadManagerBoost::m_threadActiveList

private

Definition at line 110 of file ThreadBoost.h.

Referenced by Nektar::Thread::ThreadWorkerBoost::LoadJobs(), SetNumWorkersImpl(), ThreadManagerBoost(), Nektar::Thread::ThreadWorkerBoost::WaitForActive(), and ~ThreadManagerBoost().

m_threadBusyList

bool* Nektar::Thread::ThreadManagerBoost::m_threadBusyList

private

Definition at line 109 of file ThreadBoost.h.

Referenced by IsWorking(), Nektar::Thread::ThreadWorkerBoost::LoadJobs(), ThreadManagerBoost(), and ~ThreadManagerBoost().

m_threadList

ThreadWorkerBoost** Nektar::Thread::ThreadManagerBoost::m_threadList

private

Definition at line 106 of file ThreadBoost.h.

Referenced by ThreadManagerBoost(), and ~ThreadManagerBoost().

m_threadMap

std::map<boost::thread::id, unsigned int> Nektar::Thread::ThreadManagerBoost::m_threadMap

private

Definition at line 114 of file ThreadBoost.h.

Referenced by GetWorkerNum(), and ThreadManagerBoost().

m_threadThreadList

boost::thread** Nektar::Thread::ThreadManagerBoost::m_threadThreadList

private

Definition at line 107 of file ThreadBoost.h.

Referenced by ThreadManagerBoost(), and ~ThreadManagerBoost().

m_type

std::string Nektar::Thread::ThreadManagerBoost::m_type

private

Definition at line 116 of file ThreadBoost.h.

Referenced by GetType(), and ThreadManagerBoost().