Nektar::Thread::ThreadWorkerStd Class Reference

Implementation class for ThreadManagerStd. More...

#include <ThreadStd.h>

Public Member Functions
	ThreadWorkerStd (ThreadManagerStd *threadManager, unsigned int workerNum)
	Constructor. More...
	~ThreadWorkerStd ()
	Destructor. More...
void	operator() ()
	This provides the interface that std::thread uses to start the worker. More...
unsigned int	GetWorkerNum ()
	Return the index of the worker thread. More...
void	Stop ()
	A signal to shut down. More...

Private Member Functions
	ThreadWorkerStd ()
	ThreadWorkerStd (const ThreadWorkerStd &)
void	MainLoop ()
void	LoadJobs ()
unsigned int	GetNumToLoad ()
void	WaitForActive ()
void	RunJobs ()

Private Attributes
ThreadManagerStd *	m_threadManager
std::queue< ThreadJob * >	m_workerQueue
bool	m_keepgoing
unsigned int	m_threadNum

Detailed Description

Implementation class for ThreadManagerStd.

Each instance of this class corresponds to a worker thread. Instances manage their own queue of jobs to run, grabbing new jobs from the master queue when it is exhausted.

Definition at line 158 of file ThreadStd.h.

Constructor & Destructor Documentation

ThreadWorkerStd() [1/3]

Nektar::Thread::ThreadWorkerStd::ThreadWorkerStd	(	ThreadManagerStd *	tm,
		unsigned int	workerNum
	)

Constructor.

Parameters

threadManager	Pointer to the ThreadManagerStd that is controlling this worker.
workerNum	Unique number from 0..(number_of_threads - 1)

Called by the ThreadManagerStd instance.

Definition at line 312 of file ThreadStd.cpp.

    : m_threadManager(tm), m_workerQueue(), m_keepgoing(true),
      m_threadNum(workerNum)
{
    // Nothing to see here
}

~ThreadWorkerStd()

Nektar::Thread::ThreadWorkerStd::~ThreadWorkerStd

(

)

Destructor.

Winds up this thread's execution. Jobs in its queue are lost.

Definition at line 322 of file ThreadStd.cpp.

{
    if (m_keepgoing)
    {
        std::cerr << "Warning: ThreadWorker: " << m_threadNum
                  << "destroyed while running!" << std::endl;
    }
    // on destuction the m_workerQueue will be destructed and that
    // will destruct any ThreadJobs still in there.
}

References m_keepgoing, and m_threadNum.

ThreadWorkerStd() [2/3]

Nektar::Thread::ThreadWorkerStd::ThreadWorkerStd ( )

private

ThreadWorkerStd() [3/3]

Nektar::Thread::ThreadWorkerStd::ThreadWorkerStd ( const ThreadWorkerStd &  )

private

Member Function Documentation

GetNumToLoad()

unsigned int Nektar::Thread::ThreadWorkerStd::GetNumToLoad ( )

private

Definition at line 370 of file ThreadStd.cpp.

{
    unsigned int numToLoad = 0;
    switch (m_threadManager->m_schedType)
    {
        case e_guided:
            numToLoad = std::max(
                static_cast<unsigned long>(m_threadManager->m_chunkSize),
                static_cast<unsigned long>(
                    m_threadManager->m_masterQueue.size() /
                    (2 * m_threadManager->m_numWorkers + 1)));
            break;
 
        case e_dynamic:
            numToLoad = m_threadManager->m_chunkSize;
            break;
 
        default:
            NEKERROR(ErrorUtil::efatal, "Invalid value for SchedType.");
            break;
    }
    return numToLoad;
}

References Nektar::Thread::e_dynamic, Nektar::Thread::e_guided, Nektar::ErrorUtil::efatal, Nektar::Thread::ThreadManagerStd::m_chunkSize, Nektar::Thread::ThreadManagerStd::m_masterQueue, Nektar::Thread::ThreadManagerStd::m_numWorkers, Nektar::Thread::ThreadManagerStd::m_schedType, m_threadManager, and NEKERROR.

Referenced by LoadJobs().

GetWorkerNum()

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

inline

Return the index of the worker thread.

Returns

Index of worker thread, an integer between 0 and (number_of_threads - 1)

Definition at line 175 of file ThreadStd.h.

    {
        return m_threadNum;
    };

References m_threadNum.

LoadJobs()

void Nektar::Thread::ThreadWorkerStd::LoadJobs ( )

private

Definition at line 336 of file ThreadStd.cpp.

{
    // Lock the master queue
    Lock masterQueueLock(m_threadManager->m_masterQueueMutex);
    m_threadManager->m_threadBusyList[m_threadNum] = false;
    m_threadManager->m_masterQueueCondVar.notify_all();
    while (m_threadManager->m_masterQueue.empty() && m_keepgoing)
    {
        // while waiting, master queue is unlocked
        m_threadManager->m_masterQueueCondVar.wait(masterQueueLock);
        // on exiting wait master queue is locked again
    }
    bool active;
    {
        Lock masterActiveLock(m_threadManager->m_masterActiveMutex);
        active = m_threadManager->m_threadActiveList[m_threadNum];
    }
    if (active && m_keepgoing)
    {
        unsigned int numToLoad = GetNumToLoad();
        while (m_workerQueue.size() < numToLoad &&
               !m_threadManager->m_masterQueue.empty())
        {
            ThreadJob *tj = m_threadManager->m_masterQueue.front();
            m_workerQueue.push(tj);
            m_threadManager->m_masterQueue.pop();
        }
    }
    m_threadManager->m_threadBusyList[m_threadNum] = !m_workerQueue.empty();
} // lock on master queue released here

References GetNumToLoad(), m_keepgoing, Nektar::Thread::ThreadManagerStd::m_masterActiveMutex, Nektar::Thread::ThreadManagerStd::m_masterQueue, Nektar::Thread::ThreadManagerStd::m_masterQueueCondVar, Nektar::Thread::ThreadManagerStd::m_masterQueueMutex, Nektar::Thread::ThreadManagerStd::m_threadActiveList, Nektar::Thread::ThreadManagerStd::m_threadBusyList, m_threadManager, m_threadNum, and m_workerQueue.

Referenced by MainLoop().

MainLoop()

void Nektar::Thread::ThreadWorkerStd::MainLoop ( )

private

Definition at line 412 of file ThreadStd.cpp.

{
    while (m_keepgoing)
    {
        WaitForActive();
        LoadJobs();
        RunJobs();
    }
} // exiting here should terminate the thread

References LoadJobs(), m_keepgoing, RunJobs(), and WaitForActive().

Referenced by operator()().

operator()()

void Nektar::Thread::ThreadWorkerStd::operator() ( )

inline

This provides the interface that std::thread uses to start the worker.

Definition at line 166 of file ThreadStd.h.

    {
        MainLoop();
    };

References MainLoop().

RunJobs()

void Nektar::Thread::ThreadWorkerStd::RunJobs ( )

private

Definition at line 425 of file ThreadStd.cpp.

{
    while (!m_workerQueue.empty() && m_keepgoing)
    {
        ThreadJob *tj;
        try
        {
            tj = m_workerQueue.front();
            tj->SetWorkerNum(m_threadNum);
            tj->Run();
            m_workerQueue.pop();
            delete tj;
        }
        catch (...)
        {
            // something bad happened, probably time to die
            // maybe signal ThreadManager
            throw;
        }
    }
}

References m_keepgoing, m_threadNum, m_workerQueue, Nektar::Thread::ThreadJob::Run(), and Nektar::Thread::ThreadJob::SetWorkerNum().

Referenced by MainLoop().

Stop()

void Nektar::Thread::ThreadWorkerStd::Stop ( )

inline

A signal to shut down.

If this method is called the worker will shut down. Used by the ThreadManagerStd to stop threading.

Definition at line 185 of file ThreadStd.h.

    {
        m_keepgoing = false;
    };

References m_keepgoing.

Referenced by Nektar::Thread::ThreadManagerStd::~ThreadManagerStd().

WaitForActive()

void Nektar::Thread::ThreadWorkerStd::WaitForActive ( )

private

Definition at line 397 of file ThreadStd.cpp.

{
    Lock masterActiveLock(m_threadManager->m_masterActiveMutex);
 
    while (!m_threadManager->m_threadActiveList[m_threadNum] && m_keepgoing)
    {
        // while waiting, master active is unlocked
        m_threadManager->m_masterActiveCondVar.wait(masterActiveLock);
        // on exiting wait master active is locked again
    }
}

References m_keepgoing, Nektar::Thread::ThreadManagerStd::m_masterActiveCondVar, Nektar::Thread::ThreadManagerStd::m_masterActiveMutex, Nektar::Thread::ThreadManagerStd::m_threadActiveList, m_threadManager, and m_threadNum.

Referenced by MainLoop().

Member Data Documentation

m_keepgoing

bool Nektar::Thread::ThreadWorkerStd::m_keepgoing

private

Definition at line 202 of file ThreadStd.h.

Referenced by LoadJobs(), MainLoop(), RunJobs(), Stop(), WaitForActive(), and ~ThreadWorkerStd().

m_threadManager

ThreadManagerStd* Nektar::Thread::ThreadWorkerStd::m_threadManager

private

Definition at line 200 of file ThreadStd.h.

Referenced by GetNumToLoad(), LoadJobs(), and WaitForActive().

m_threadNum

unsigned int Nektar::Thread::ThreadWorkerStd::m_threadNum

private

Definition at line 203 of file ThreadStd.h.

Referenced by GetWorkerNum(), LoadJobs(), RunJobs(), WaitForActive(), and ~ThreadWorkerStd().

m_workerQueue

std::queue<ThreadJob *> Nektar::Thread::ThreadWorkerStd::m_workerQueue

private

Definition at line 201 of file ThreadStd.h.

Referenced by LoadJobs(), and RunJobs().