A pool of threads running tasks ThreadPool runs AbstractTasks, possibly in multiple threads. More...

#include <thread_pool.hpp>

Classes
class	AnotherThreadFailed

class	EventListener
	Event listener class. More...

struct	JobContext

class	TaskThreadImpl

Public Types
enum class	TaskExecutionMode { NORMAL , PERSISTENT }
	Way how to the task should be run in the pool. More...

Public Member Functions
	ThreadPool (const PoolIndex index, const ThreadIndex limitThreadCount, EventListener &listener)

	~ThreadPool ()

void	check ()
	Checks if the thread pool is doing great. More...

void	resize (ThreadIndex newThreadCount)
	Resizes the pool. More...

Job	submitTask (AbstractTask &task, const TaskExecutionMode mode)
	Adds a new task to the jobs queue. More...

Job	repeatTask (AbstractTask &task, bool abortCurrent)
	Ensures a given task executed at least once. More...

void	waitForJob (Job job)
	Blocks until a given job finishes if not yet. More...

bool	abortJob (Job job)
	Aborts a given submitted job. More...

void	wait ()
	Blocks until all the submitted jobs are executed. More...

bool	busy ()
	Checks whether the pool has jobs. More...

bool	isGpuQueried () const

bool	isGpuReady () const

bool	isManagingThread () const

ThreadIndex	getThreadCount () const

Static Public Member Functions
static ThreadIndex	hardwareConcurrency ()
	Returns optimal number of threads depending on the hardware capabilities. More...

Public Attributes
const PoolIndex	myIndex
	the index of the current pool More...

Private Member Functions
	ThreadPool (const ThreadPool &)=delete

void	managingThreadFunc (TaskThreadImpl &thread)
	Managing (#0) worker thread function. More...

void	workerThreadFunc (TaskThreadImpl &thread)
	Ordinary worker thread function. More...

void	synchronizeThread (TaskThreadImpl &thread)

Private Attributes
TaskThreadImpl **	workers
	workers instances More...

GraphicPipeline *	gpu
	THE graphic pipeline to run tasks on GPU. More...

std::deque< JobContext >	jobs
	jobs queue More...

std::deque< std::exception_ptr >	exceptions
	exceptions thrown in this pool More...

JobContext	currentJob
	job being run at the moment More...

Job	jobCounter

ThreadIndex	threadCount
	actual number of workers More...

ThreadIndex	currentWorkerCount

ThreadIndex	remainingWorkers
	number of workers performing the current task right now More...

std::condition_variable	synchroCvar
	gets notified about workers synchronization More...

std::condition_variable	jobsCvar
	gets notified about the jobs queue updates More...

std::condition_variable	workersCvar
	gets notified about workers lifecycle updates More...

std::mutex	synchro
	workers synchronization control within the current task More...

std::mutex	workersAccess
	workers lifecycle access control More...

std::mutex	jobsAccess
	jobs queue access control More...

std::mutex	exceptionsAccess
	exceptions queue access control More...

int	syncHitsCount
	number of times synchronization is hit so far by all workers together More...

int	syncHitsBound
	last sync hits count when all the workers were synchronized More...

bool	isGpuTested
	if `true`, there was an attempt to warm up the GPU More...

bool	abortExternally
	if `true`, the task is aborted externally More...

bool	abortInternally
	if `true`, the task aborts itself: beforeProcessing(), process() or processOnGPU() returned `false` More...

bool	failFlag
	communicates to all the threads that the current task is to skip because of a problem More...

bool	repeatFlag
	if `true`, the current task is asked to be repeated More...

EventListener &	eventListener

Detailed Description

A pool of threads running tasks ThreadPool runs AbstractTasks, possibly in multiple threads.

Every time a task is submitted to the thread pool, it is scheduled for execution and gets attributed a corresponding Job number. Jobs are used to cancel the scheduled runs and track whether they have been conducted or not. Exceptions thrown during the tasks execution in different threads are rethrown in the caller threads.

Definition at line 36 of file thread_pool.hpp.

Member Enumeration Documentation

◆ TaskExecutionMode

enum Beatmup::ThreadPool::TaskExecutionMode

strong

Way how to the task should be run in the pool.

Enumerator
NORMAL	normal task, should be run it once
PERSISTENT	persistent task, run process() until it returns `false`

Definition at line 78 of file thread_pool.hpp.

                                  {
         NORMAL,         //!< normal task, should be run it once
         PERSISTENT      //!< persistent task, run process() until it returns `false`
     };

Constructor & Destructor Documentation

◆ ThreadPool() [1/2]

Beatmup::ThreadPool::ThreadPool ( const ThreadPool & )

privatedelete

◆ ThreadPool() [2/2]

Beatmup::ThreadPool::ThreadPool	(	const PoolIndex	index,
		const ThreadIndex	limitThreadCount,
		EventListener &	listener
	)

inline

Definition at line 454 of file thread_pool.hpp.

                                                                                                            :
         gpu(nullptr),
         currentJob{0, nullptr},
         jobCounter(1),
         threadCount(limitThreadCount),
         currentWorkerCount(0), remainingWorkers(0),
         syncHitsCount(0), syncHitsBound(0),
         isGpuTested(false),
         abortExternally(false), abortInternally(false),
         failFlag(false), repeatFlag(false),
         eventListener(listener),
         myIndex(index)
     {
         workers = new TaskThreadImpl*[threadCount];
         // spawning workers
         for (ThreadIndex t = 0; t < threadCount; t++)
             workers[t] = new TaskThreadImpl(t, *this);
     }

◆ ~ThreadPool()

Beatmup::ThreadPool::~ThreadPool ( )

inline

Definition at line 474 of file thread_pool.hpp.

                          {
         // set termination flags
         {
             std::lock_guard<std::mutex> lockJobs(jobsAccess), lockWorkers(workersAccess), lockSync(synchro);
             abortExternally = true;
             for (ThreadIndex t = 0; t < threadCount; t++)
                 workers[t]->isTerminating = true;
         }
         synchroCvar.notify_all();
         jobsCvar.notify_all();
         workersCvar.notify_all();
         // no wait here!
         for (ThreadIndex t = 0; t < threadCount; t++) {
             workers[t]->internalThread.join();
             delete workers[t];
         }
         delete[] workers;
     }

Member Function Documentation

◆ managingThreadFunc()

void Beatmup::ThreadPool::managingThreadFunc ( TaskThreadImpl & thread )

inlineprivate

Managing (#0) worker thread function.

Definition at line 141 of file thread_pool.hpp.

                                                            {
         eventListener.threadCreated(myIndex);
  
         // locks
         std::unique_lock<std::mutex> lock(jobsAccess, std::defer_lock);
         std::unique_lock<std::mutex> workersLock(workersAccess, std::defer_lock);
  
         while (!thread.isTerminating) {
             // wait while a task is got
             lock.lock();
             while (jobs.empty() && !thread.isTerminating)
                 jobsCvar.wait(lock);
  
             if (thread.isTerminating) {
                 lock.unlock();
                 break;
             }
  
             // fetch a task
             syncHitsCount = 0;
             syncHitsBound = 0;
             abortExternally = abortInternally = false;
             failFlag = false;
             repeatFlag = false;
             if (!jobs.empty()) {
                 currentJob = jobs.front();
                 currentWorkerCount = remainingWorkers = std::min(currentJob.task->getMaxThreads(), threadCount);
             }
             else
                 currentJob.task = nullptr;
  
             // release queue access
             lock.unlock();
  
             // test execution mode
             AbstractTask::TaskDeviceRequirement exTarget;
             bool useGpuForCurrentTask = false;
             if (currentJob.task) {
                 exTarget = currentJob.task->getUsedDevices();
  
                 if (exTarget != AbstractTask::TaskDeviceRequirement::CPU_ONLY && myIndex == 0) {
                     // test GPU if not yet
                     if (!isGpuTested) {
                         try {
                             gpu = new GraphicPipeline();
                         }
                         catch (...) {
                             eventListener.gpuInitFail(myIndex, std::current_exception());
                             std::lock_guard<std::mutex> lock(exceptionsAccess);
                             exceptions.push_back(std::current_exception());
                             gpu = nullptr;
                         }
                         isGpuTested = true;
                     }
  
                     useGpuForCurrentTask = (gpu != nullptr);
                 }
  
                 // run beforeProcessing
                 try {
                     if (!useGpuForCurrentTask && exTarget == AbstractTask::TaskDeviceRequirement::GPU_ONLY)
                         throw Beatmup::RuntimeError(
                             myIndex == 0 ?
                             "A task requires GPU, but GPU init is failed" :
                             "A task requiring GPU may only be run in the main pool"
                         );
                     currentJob.task->beforeProcessing(currentWorkerCount, useGpuForCurrentTask ? ProcessingTarget::GPU : ProcessingTarget::CPU, gpu);
                 }
                 catch (...) {
                     eventListener.taskFail(myIndex, *currentJob.task, std::current_exception());
                     std::lock_guard<std::mutex> lock(exceptionsAccess);
                     exceptions.push_back(std::current_exception());
                     failFlag = true;
                 }
  
                 // drop the task if failed
                 if (failFlag) {
                     lock.lock();
                     jobs.pop_front();
                     lock.unlock();
                 }
             }
  
             // if failed, go to next iteration
             if (failFlag) {
                 // send a signal to threads waiting for the task to finish
                 jobsCvar.notify_all();
                 continue;
             }
  
             // wake up workers
             workersLock.lock();
             for (ThreadIndex t = 0; t < threadCount; t++)
                 workers[t]->isRunning = true;
             workersLock.unlock();
             workersCvar.notify_all();    // go!
  
             // do the job
             if (currentJob.task)
                 try {
                     do {
                         bool result = useGpuForCurrentTask ? currentJob.task->processOnGPU(*gpu, thread) : currentJob.task->process(thread);
                         if (!result) {
                             abortInternally = true;
                         }
                     } while (currentJob.mode == TaskExecutionMode::PERSISTENT && !abortInternally && !abortExternally);
                 }
                 catch (AnotherThreadFailed) {
                     // nothing special to do here
                 }
                 catch (...) {
                     eventListener.taskFail(myIndex, *currentJob.task, std::current_exception());
                     std::lock_guard<std::mutex> lock(exceptionsAccess);
                     exceptions.push_back(std::current_exception());
                     failFlag = true;
                 }
  
             // finalizing
             workersLock.lock();
  
             // decrease remaining workers count
             remainingWorkers--;
  
             // notify other workers if they're waiting for synchro
             synchroCvar.notify_all();
  
             // wait until all the workers stop
             while (remainingWorkers > 0 && !thread.isTerminating)
                 workersCvar.wait(workersLock);
  
             // call afterProcessing
             if (currentJob.task)
                 try {
                     currentJob.task->afterProcessing(currentWorkerCount, useGpuForCurrentTask ? gpu : nullptr, abortExternally);
                 }
                 catch (...) {
                     eventListener.taskFail(myIndex, *currentJob.task, std::current_exception());
                     std::lock_guard<std::mutex> lock(exceptionsAccess);
                     exceptions.push_back(std::current_exception());
                     failFlag = true;
                 }
  
             workersLock.unlock();
  
             // unlock graphic pipeline, if used
             if (useGpuForCurrentTask && gpu) {
                 gpu->flush();
             }
  
             // call taskDone, ask if want to repeat
             bool internalRepeatFlag = false;
             if (!failFlag)
                 internalRepeatFlag = eventListener.taskDone(myIndex, *currentJob.task, abortExternally);
  
             // drop the task
             lock.lock();
             if (!(repeatFlag || internalRepeatFlag) || failFlag) {
                 jobs.pop_front();
  
                 // send a signal to threads waiting for the task to finish
                 jobsCvar.notify_all();
             }
  
             lock.unlock();
         }
         eventListener.threadTerminating(myIndex);
  
         // deleting graphic pipeline instance
         if (gpu && myIndex == 0)
             delete gpu;
     }

◆ workerThreadFunc()

void Beatmup::ThreadPool::workerThreadFunc ( TaskThreadImpl & thread )

inlineprivate

Ordinary worker thread function.

Definition at line 317 of file thread_pool.hpp.

                                                          {
         eventListener.threadCreated(myIndex);
         std::unique_lock<std::mutex> lock(workersAccess);
         Job myLastJob = (Job)-1;
         while (!thread.isTerminating) {
             // wait for a job
             while ((!thread.isRunning || thread.index >= currentWorkerCount || myLastJob - currentJob.id >= 0)
                     && !thread.isTerminating)
             {
                 std::this_thread::yield();
                 workersCvar.wait(lock);
             }
             if (thread.isTerminating) {
                 lock.unlock();
                 break;
             }
  
             // do the job
             JobContext job = currentJob;
             lock.unlock();
  
             /* UNLOCKED SECTION */
             try {
                 do {
                     if (!job.task->process(thread)) {
                         abortInternally = true;
                     }
                 } while (job.mode == TaskExecutionMode::PERSISTENT && !abortInternally && !abortExternally && !thread.isTerminating);
             }
             catch (AnotherThreadFailed) {
                 // nothing special to do here
             }
             catch (...) {
                 eventListener.taskFail(myIndex, *job.task, std::current_exception());
                 std::lock_guard<std::mutex> lock(exceptionsAccess);
                 exceptions.push_back(std::current_exception());
                 failFlag = true;
             }
  
             // finalizing
             lock.lock();
  
             // decrease remaining workers count
             myLastJob = job.id;
             remainingWorkers--;
  
             // notify other workers if they're waiting for synchro
             synchroCvar.notify_all();
  
             // stop
             thread.isRunning = false;
  
             // send a signal to other workers
             workersCvar.notify_all();
         }
  
         eventListener.threadTerminating(myIndex);
     }

◆ synchronizeThread()

void Beatmup::ThreadPool::synchronizeThread ( TaskThreadImpl & thread )

inlineprivate

Definition at line 377 of file thread_pool.hpp.

                                                           {
         std::unique_lock<std::mutex> lock(synchro);    //<------- LOCKING HERE
         syncHitsCount++;
  
         // check if this thread is the last one passing the synchronization point
         if (syncHitsCount >= syncHitsBound + remainingWorkers) {
             syncHitsBound = syncHitsCount;
             lock.unlock();    //<------- UNLOCKING HERE
             // do not block, wake up the others
             synchroCvar.notify_all();
         }
  
         else {
             // Wait while other threads reach this synchronization point or the remaining number of workers drops
             // (at the end of the task), or pool is terminating.
             // Do not check if the task aborted here to keep threads synchronized.
             const int myBound = syncHitsBound;
             while (!thread.isTerminating  &&  !failFlag  &&  myBound + remainingWorkers - syncHitsCount > 0)
                 synchroCvar.wait(lock);
  
             lock.unlock();    //<------- UNLOCKING HERE
         }
  
         if (failFlag)
             throw AnotherThreadFailed();
     }

◆ check()

void Beatmup::ThreadPool::check ( )

inline

Checks if the thread pool is doing great.

If not, i.e., if there was an exception, rethrows the exception. There might be multiple exceptions in the queue. They are thrown one by one every time this function is called.

Definition at line 499 of file thread_pool.hpp.

                         {
         std::lock_guard<std::mutex> lock(exceptionsAccess);
         if (!exceptions.empty()) {
             std::exception_ptr pointer(exceptions.front());
             exceptions.pop_front();
             std::rethrow_exception(pointer);
         }
     }

◆ resize()

void Beatmup::ThreadPool::resize ( ThreadIndex newThreadCount )

inline

Resizes the pool.

Blocking if there is a task running.

Parameters

newThreadCount The new number of worker threads

Definition at line 514 of file thread_pool.hpp.

                                                    {
         if (newThreadCount == threadCount)
             return;
         std::unique_lock<std::mutex> jobsLock(jobsAccess);
         // wait for task, if any
         while (!jobs.empty())
             jobsCvar.wait(jobsLock);
  
         std::unique_lock<std::mutex> workersLock(workersAccess);
         // set termination flags for threads to be stopped, if any
         for (ThreadIndex t = newThreadCount; t < threadCount; t++)
             workers[t]->isTerminating = true;
  
         // unlock and notify
         workersLock.unlock();
         synchroCvar.notify_all();
         jobsCvar.notify_all();
         workersCvar.notify_all();
  
         // join
         for (ThreadIndex t = newThreadCount; t < threadCount; t++) {
             workers[t]->internalThread.join();
             delete workers[t];
         }
  
         // spawn new threads if needed
         workersLock.lock();
         if (threadCount < newThreadCount) {
             TaskThreadImpl** newWorkers = new TaskThreadImpl*[newThreadCount];
             for (ThreadIndex t = 0; t < threadCount; t++)
                 newWorkers[t] = workers[t];
             for (ThreadIndex t = threadCount; t < newThreadCount; t++)
                 newWorkers[t] = new TaskThreadImpl(t, *this);
             delete[] workers;
             workers = newWorkers;
         }
         // update thread count
         threadCount = newThreadCount;
  
         workersLock.unlock();
         jobsLock.unlock();
     }

◆ submitTask()

Job Beatmup::ThreadPool::submitTask	(	AbstractTask &	task,
		const TaskExecutionMode	mode
	)

inline

Adds a new task to the jobs queue.

Definition at line 561 of file thread_pool.hpp.

                                                                             {
         std::unique_lock<std::mutex> lock(jobsAccess);
         const Job job = jobCounter++;
  
         // add new job
         jobs.emplace_back(JobContext{job, &task, mode});
  
         lock.unlock();
         jobsCvar.notify_all();
         return job;
     }

◆ repeatTask()

Job Beatmup::ThreadPool::repeatTask	(	AbstractTask &	task,
		bool	abortCurrent
	)

inline

Ensures a given task executed at least once.

Parameters

task	The task
abortCurrent	if `true` and the task is currently running, abort signal is sent.

Definition at line 579 of file thread_pool.hpp.

                                                                  {
         std::unique_lock<std::mutex> lock(jobsAccess);
  
         // check if the rask is running now, ask for repeat if it is
         if (!jobs.empty() && jobs.front().task == &task) {
             repeatFlag = true;
             if (abortCurrent)
                 abortExternally = true;
             return jobs.front().id;
         }
  
         // check whether it is in the queue
         for (const JobContext& _ : jobs)
             if (_.task == &task) {
                 return _.id;
             }
  
         // otherwise submit the task
         const Job job = jobCounter++;
         jobs.emplace_back(JobContext{
             job,
             &task,
             TaskExecutionMode::NORMAL
         });
  
         // unlock the jobs access, notify workers
         lock.unlock();
         jobsCvar.notify_all();
         return job;
     }

◆ waitForJob()

void Beatmup::ThreadPool::waitForJob ( Job job )

inline

Blocks until a given job finishes if not yet.

Definition at line 614 of file thread_pool.hpp.

                                     {
         std::unique_lock<std::mutex> lock(jobsAccess);
 #ifdef BEATMUP_DEBUG
         if (currentJob.task && currentJob.id != job && currentJob.mode == TaskExecutionMode::PERSISTENT && !abortExternally) {
             class BlockingOnPersistentJob : public Exception {
             public:
                 BlockingOnPersistentJob(): Exception("Waiting for a persistent job to finish: potential deadlock") {}
             };
             throw BlockingOnPersistentJob();
         }
 #endif
         while (true) {
             // check if the job is in the queue
             bool found = false;
             for (const JobContext& _ : jobs)
                 if (_.id == job) {
                     found = true;
                     break;
                 }
  
             // if not, done
             if (!found)
                 return;
  
             // otherwise wait a round and check again
             jobsCvar.wait(lock);
         }
     }

◆ abortJob()

bool Beatmup::ThreadPool::abortJob ( Job job )

inline

Aborts a given submitted job.

Returns: true if the job was interrupted while running.

Definition at line 648 of file thread_pool.hpp.

                            {
         std::unique_lock<std::mutex> lock(jobsAccess);
  
         // check if the rask is running now, abort if it is
         if (currentJob.task && currentJob.id == job) {
             abortExternally = true;
             while (!jobs.empty() && currentJob.task && currentJob.id == job)
                 jobsCvar.wait(lock);
             return true;
         }
  
         for (auto it = jobs.begin(); it != jobs.end(); it++)
             if (it->id == job) {
                 jobs.erase(it);
                 return false;
             }
  
         return false;
     }

◆ wait()

void Beatmup::ThreadPool::wait ( )

inline

Blocks until all the submitted jobs are executed.

Definition at line 672 of file thread_pool.hpp.

                 {
         std::unique_lock<std::mutex> lock(jobsAccess);
         while (!jobs.empty())
             jobsCvar.wait(lock);
     }

◆ busy()

bool Beatmup::ThreadPool::busy ( )

inline

Checks whether the pool has jobs.

Definition at line 682 of file thread_pool.hpp.

                        {
         std::lock_guard<std::mutex> lock(jobsAccess);
         return !jobs.empty();
     }

◆ hardwareConcurrency()

static ThreadIndex Beatmup::ThreadPool::hardwareConcurrency ( )

inlinestatic

Returns optimal number of threads depending on the hardware capabilities.

Definition at line 691 of file thread_pool.hpp.

                                                     {
         unsigned int N = std::thread::hardware_concurrency();
         RuntimeError::check(N > 0, "Unable to determine hardware concurrency capabilities.");
         return N > MAX_THREAD_INDEX ? MAX_THREAD_INDEX : (ThreadIndex)N;
     }

◆ isGpuQueried()

bool Beatmup::ThreadPool::isGpuQueried ( ) const

inline

Returns: true if GPU was queried.

Definition at line 701 of file thread_pool.hpp.

                                      {
         return isGpuTested;
     }

◆ isGpuReady()

bool Beatmup::ThreadPool::isGpuReady ( ) const

inline

Returns: true if GPU is ready to use.

Definition at line 709 of file thread_pool.hpp.

                                    {
         return gpu != nullptr;
     }

◆ isManagingThread()

bool Beatmup::ThreadPool::isManagingThread ( ) const

inline

Returns: true if invoked from the manager thread

Definition at line 716 of file thread_pool.hpp.

                                          {
         if (!workers)
             return false;
         return std::this_thread::get_id() == workers[0]->internalThread.get_id();
     }

◆ getThreadCount()

ThreadIndex Beatmup::ThreadPool::getThreadCount ( ) const

inline

Definition at line 722 of file thread_pool.hpp.

722 { return threadCount; }

Member Data Documentation

◆ workers

TaskThreadImpl** Beatmup::ThreadPool::workers

private

workers instances

Definition at line 410 of file thread_pool.hpp.

◆ gpu

GraphicPipeline* Beatmup::ThreadPool::gpu

private

THE graphic pipeline to run tasks on GPU.

Definition at line 412 of file thread_pool.hpp.

◆ jobs

std::deque<JobContext> Beatmup::ThreadPool::jobs

private

jobs queue

Definition at line 414 of file thread_pool.hpp.

◆ exceptions

std::deque<std::exception_ptr> Beatmup::ThreadPool::exceptions

private

exceptions thrown in this pool

Definition at line 416 of file thread_pool.hpp.

◆ currentJob

JobContext Beatmup::ThreadPool::currentJob

private

job being run at the moment

Definition at line 418 of file thread_pool.hpp.

◆ jobCounter

Job Beatmup::ThreadPool::jobCounter

private

Definition at line 419 of file thread_pool.hpp.

◆ threadCount

ThreadIndex Beatmup::ThreadPool::threadCount

private

actual number of workers

Definition at line 421 of file thread_pool.hpp.

◆ currentWorkerCount

ThreadIndex Beatmup::ThreadPool::currentWorkerCount

private

Definition at line 424 of file thread_pool.hpp.

◆ remainingWorkers

ThreadIndex Beatmup::ThreadPool::remainingWorkers

private

number of workers performing the current task right now

Definition at line 425 of file thread_pool.hpp.

◆ synchroCvar

std::condition_variable Beatmup::ThreadPool::synchroCvar

private

gets notified about workers synchronization

Definition at line 428 of file thread_pool.hpp.

◆ jobsCvar

std::condition_variable Beatmup::ThreadPool::jobsCvar

private

gets notified about the jobs queue updates

Definition at line 429 of file thread_pool.hpp.

◆ workersCvar

std::condition_variable Beatmup::ThreadPool::workersCvar

private

gets notified about workers lifecycle updates

Definition at line 430 of file thread_pool.hpp.

◆ synchro

std::mutex Beatmup::ThreadPool::synchro

private

workers synchronization control within the current task

Definition at line 433 of file thread_pool.hpp.

◆ workersAccess

std::mutex Beatmup::ThreadPool::workersAccess

private

workers lifecycle access control

Definition at line 434 of file thread_pool.hpp.

◆ jobsAccess

std::mutex Beatmup::ThreadPool::jobsAccess

private

jobs queue access control

Definition at line 435 of file thread_pool.hpp.

◆ exceptionsAccess

std::mutex Beatmup::ThreadPool::exceptionsAccess

private

exceptions queue access control

Definition at line 436 of file thread_pool.hpp.

◆ syncHitsCount

int Beatmup::ThreadPool::syncHitsCount

private

number of times synchronization is hit so far by all workers together

Definition at line 439 of file thread_pool.hpp.

◆ syncHitsBound

int Beatmup::ThreadPool::syncHitsBound

private

last sync hits count when all the workers were synchronized

Definition at line 440 of file thread_pool.hpp.

◆ isGpuTested

bool Beatmup::ThreadPool::isGpuTested

private

if true, there was an attempt to warm up the GPU

Definition at line 443 of file thread_pool.hpp.

◆ abortExternally

bool Beatmup::ThreadPool::abortExternally

private

if true, the task is aborted externally

Definition at line 444 of file thread_pool.hpp.

◆ abortInternally

bool Beatmup::ThreadPool::abortInternally

private

if true, the task aborts itself: beforeProcessing(), process() or processOnGPU() returned false

Definition at line 445 of file thread_pool.hpp.

◆ failFlag

bool Beatmup::ThreadPool::failFlag

private

communicates to all the threads that the current task is to skip because of a problem

Definition at line 446 of file thread_pool.hpp.

◆ repeatFlag

bool Beatmup::ThreadPool::repeatFlag

private

if true, the current task is asked to be repeated

Definition at line 447 of file thread_pool.hpp.

◆ eventListener

EventListener& Beatmup::ThreadPool::eventListener

private

Definition at line 449 of file thread_pool.hpp.

◆ myIndex

const PoolIndex Beatmup::ThreadPool::myIndex

the index of the current pool

Definition at line 452 of file thread_pool.hpp.

The documentation for this class was generated from the following file:

core/thread_pool.hpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ TaskExecutionMode

Constructor & Destructor Documentation

◆ ThreadPool() [1/2]

◆ ThreadPool() [2/2]

◆ ~ThreadPool()

Member Function Documentation

◆ managingThreadFunc()

◆ workerThreadFunc()

◆ synchronizeThread()

◆ check()

◆ resize()

◆ submitTask()

◆ repeatTask()

◆ waitForJob()

◆ abortJob()

◆ wait()

◆ busy()

◆ hardwareConcurrency()

◆ isGpuQueried()

◆ isGpuReady()

◆ isManagingThread()

◆ getThreadCount()

Member Data Documentation

◆ workers

◆ gpu

◆ jobs

◆ exceptions

◆ currentJob

◆ jobCounter

◆ threadCount

◆ currentWorkerCount

◆ remainingWorkers

◆ synchroCvar

◆ jobsCvar

◆ workersCvar

◆ synchro

◆ workersAccess

◆ jobsAccess

◆ exceptionsAccess

◆ syncHitsCount

◆ syncHitsBound

◆ isGpuTested

◆ abortExternally

◆ abortInternally

◆ failFlag

◆ repeatFlag

◆ eventListener

◆ myIndex