ana::ThreadPool Class Reference

A very simple thread pool for use by Surface. More...

#include <ThreadPool.h>

Classes
struct	Task

Public Member Functions
	ThreadPool (unsigned int maxThreads=0)
virtual	~ThreadPool ()
void	ShowProgress (const std::string &title)
void	Finish ()
	Wait for all threads to complete before returning. More...
template<class F , class... A>
void	AddTask (F func, A...args)
	Add task with arguments. More...
template<class T , class M , class... A>
void	AddMemberTask (T *obj, M meth, A...args)
	Add member function task, with arguments. More...

Protected Types
typedef std::function< void(void)>	func_t
	The type of the user's worker functions. More...

Protected Member Functions
void	AddTaskHelper (func_t func)

Static Protected Member Functions
static void *	WorkerFunc (void *arg)

Protected Attributes
unsigned int	fMaxThreads
pthread_mutex_t	fTasksLock
std::deque< func_t >	fTasks
	Actually, this is protecting fNumLiveThreads. More...
pthread_mutex_t	fThreadsLock
std::vector< pthread_t >	fThreads
	All threads we ever created. More...
unsigned int	fNumLiveThreads
	Number of threads that are running. More...
pthread_mutex_t	fProgressLock
	Protects fTasksCompleted and fTotalTasks too. More...
int	fTasksCompleted
int	fTotalTasks
	How many tasks have we ever seen? More...
Progress *	fProgress

Detailed Description

A very simple thread pool for use by Surface.

With great power comes great responsibility. Use caution on the grid or on shared interactive machines before you get yelled at or banned.

Definition at line 17 of file ThreadPool.h.

Member Typedef Documentation

typedef std::function<void(void)> ana::ThreadPool::func_t

protected

The type of the user's worker functions.

Use std::bind etc to pass arguments

Definition at line 43 of file ThreadPool.h.

Constructor & Destructor Documentation

ana::ThreadPool::ThreadPool ( unsigned int  maxThreads = 0 )

explicit

Parameters

maxThreads

Maximum number of threads to use at one time. If unspecified, uses number of cores in machine. Use great caution on the grid or on shared interactive machines.

Definition at line 11 of file ThreadPool.cxx.

    : fMaxThreads(maxThreads), fNumLiveThreads(0),
      fTasksCompleted(0), fTotalTasks(0), fProgress(0)
  {
    if(maxThreads == 0){
      fMaxThreads = sysconf(_SC_NPROCESSORS_ONLN);
    }

    pthread_mutex_init(&fTasksLock, 0);
    pthread_mutex_init(&fThreadsLock, 0);
    pthread_mutex_init(&fProgressLock, 0);
  }

ana::ThreadPool::~ThreadPool ( )

virtual

Definition at line 25 of file ThreadPool.cxx.

  {
    // This is safe, even if it's already been explicitly called
    Finish();

    pthread_mutex_destroy(&fTasksLock);
    pthread_mutex_destroy(&fThreadsLock);
    pthread_mutex_destroy(&fProgressLock);

    delete fProgress;
  }

Member Function Documentation

template<class T , class M , class... A>

void ana::ThreadPool::AddMemberTask ( T *  obj, M  meth, A...  args  )

inline

Add member function task, with arguments.

Definition at line 78 of file ThreadPool.h.

{
  AddTaskHelper(std::bind(meth, obj, args...));
}

template<class F , class... A>

void ana::ThreadPool::AddTask ( F  func, A...  args  )

inline

Add task with arguments.

Definition at line 72 of file ThreadPool.h.

{
  AddTaskHelper(std::bind(func, args...));
}

void ana::ThreadPool::AddTaskHelper ( func_t  func )

protected

Definition at line 92 of file ThreadPool.cxx.

  {
    pthread_mutex_lock(&fTasksLock);
    fTasks.push_back(func);
    pthread_mutex_unlock(&fTasksLock);

    pthread_mutex_lock(&fProgressLock);
    ++fTotalTasks;
    pthread_mutex_unlock(&fProgressLock);

    pthread_mutex_lock(&fThreadsLock);
    if(fNumLiveThreads < fMaxThreads){
      fThreads.push_back(pthread_t());
      pthread_create(&fThreads.back(), 0, WorkerFunc, this);
      ++fNumLiveThreads;
    }
    pthread_mutex_unlock(&fThreadsLock);
  }

void ana::ThreadPool::Finish

(

)

Wait for all threads to complete before returning.

Definition at line 44 of file ThreadPool.cxx.

  {
    void* junk;
    for(pthread_t& th: fThreads) pthread_join(th, &junk);

    assert(fNumLiveThreads == 0);

    fThreads.clear(); // Make it safe to call a second time

    if(fProgress) fProgress->Done();
  }

void ana::ThreadPool::ShowProgress

(

const std::string &

title

)

Definition at line 38 of file ThreadPool.cxx.

  {
    if(!fProgress) fProgress = new Progress(title);
  }

void * ana::ThreadPool::WorkerFunc ( void *  arg )

staticprotected

Definition at line 57 of file ThreadPool.cxx.

  {
    // We smuggle essentially the this pointer in through the argument
    ThreadPool* pool = (ThreadPool*)arg;

    while(true){
      pthread_mutex_lock(&pool->fTasksLock);
      if(pool->fTasks.empty()){
        // Nothing to do, commit suicide
        pthread_mutex_unlock(&pool->fTasksLock);

        pthread_mutex_lock(&pool->fThreadsLock);
        --pool->fNumLiveThreads;
        pthread_mutex_unlock(&pool->fThreadsLock);

        return 0;
      }
      // Get a task to do
      func_t task = pool->fTasks.front();
      pool->fTasks.pop_front();
      pthread_mutex_unlock(&pool->fTasksLock);

      // Actually do the user's work
      task();

      pthread_mutex_lock(&pool->fProgressLock);
      ++pool->fTasksCompleted;

      if(pool->fProgress)
        pool->fProgress->SetProgress(pool->fTasksCompleted/double(pool->fTotalTasks));
      pthread_mutex_unlock(&pool->fProgressLock);
    }
  }

Member Data Documentation

unsigned int ana::ThreadPool::fMaxThreads

protected

Definition at line 50 of file ThreadPool.h.

unsigned int ana::ThreadPool::fNumLiveThreads

protected

Number of threads that are running.

Definition at line 60 of file ThreadPool.h.

Progress* ana::ThreadPool::fProgress

protected

Definition at line 66 of file ThreadPool.h.

pthread_mutex_t ana::ThreadPool::fProgressLock

protected

Protects fTasksCompleted and fTotalTasks too.

Definition at line 63 of file ThreadPool.h.

std::deque<func_t> ana::ThreadPool::fTasks

protected

Actually, this is protecting fNumLiveThreads.

Definition at line 55 of file ThreadPool.h.

int ana::ThreadPool::fTasksCompleted

protected

Definition at line 64 of file ThreadPool.h.

pthread_mutex_t ana::ThreadPool::fTasksLock

protected

Definition at line 54 of file ThreadPool.h.

std::vector<pthread_t> ana::ThreadPool::fThreads

protected

All threads we ever created.

Definition at line 59 of file ThreadPool.h.

pthread_mutex_t ana::ThreadPool::fThreadsLock

protected

Definition at line 58 of file ThreadPool.h.

int ana::ThreadPool::fTotalTasks

protected

How many tasks have we ever seen?

Definition at line 65 of file ThreadPool.h.

---

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

• ThreadPool.h
• ThreadPool.cxx