#include <xmipp_threads.h>

Public Member Functions
void	setData (void *data, int nThread=-1)

	ThreadManager (int numberOfThreads, void *workClass=NULL)

	~ThreadManager ()

void	run (ThreadFunction function, void *data=NULL)

void	runAsync (ThreadFunction function, void *data=NULL)

void	wait ()

int	getNumberOfThreads ()

Public Attributes
int	threads
	number of working threads. More...

Friends
void *	_threadMain (void *data)

Detailed Description

Class for manage a group of threads performing one or several tasks. This class is very useful when we have some function that can be executed in parallel by threads. The threads are created in the contructor of the object and released in destructor. This way threads can execute different functions at diffent moments and exit at the end of manager life. Also, the wait() function allow in the main thread to wait until all threads have finish working on a task and maybe then execute another one. This class is supposed to be used only in the main thread.

Definition at line 239 of file xmipp_threads.h.

Constructor & Destructor Documentation

◆ ThreadManager()

ThreadManager::ThreadManager	(	int	numberOfThreads,
		void *	workClass = `NULL`
	)

Constructor, number of working threads should be supplied

Definition at line 205 of file xmipp_threads.cpp.

 {
     threads = numberOfThreads;
     barrier = new Barrier(threads + 1);
     workFunction = NULL;
     ids = new pthread_t[threads];
     arguments = new ThreadArgument[threads];
     started = false;
     this->workClass = workClass;
 }

◆ ~ThreadManager()

ThreadManager::~ThreadManager ( )

Destructor, free memory and exit threads

Definition at line 248 of file xmipp_threads.cpp.

 {
     //Destroy the threads
     workFunction = NULL;
     if (started)
     {
         wait();
         for (int i = 0; i < threads; ++i)
             pthread_join(ids[i], NULL);
     }
 
     delete barrier;
     delete[] ids;
     delete[] arguments;
 }

Member Function Documentation

◆ getNumberOfThreads()

int ThreadManager::getNumberOfThreads ( )

inline

Get number of threads

Definition at line 328 of file xmipp_threads.h.

328 {return threads;}

ThreadManager::threads

int threads

number of working threads.

Definition: xmipp_threads.h:242

◆ run()

void ThreadManager::run	(	ThreadFunction	function,
		void *	data = `NULL`
	)

Function to start working in a task. The function that you want to execute in parallel by the working threads should be passed as argument. If data is passed, then it is set to all threads. Functions that can be executed by thread should by of the type ThreadFunction, i.e., return void * and only one argument of type ThreadArgument. The call of this function will block the main thread until all workers finish their job, if you don't want to block use runAsync instead, and later can call wait for waiting until threads are done.

//Global variables, so it are visible in 'processSeveralImages()'
ParallelTaskDistributor * td;
//function to perform some operation
//to N images executed in parellel
void * processImages(ThreadArgument & data)
{
    int thread_id = arg.thread_id;
    size_t firstImage, lastImage;
    while (td->getTasks(firstImage, lastImage))
        for (int image = firstImage; image <= lastImage; ++image)
        {
            //...
            processOneImage(image);
            //...
        }
}
int main()
{
//...
//Distribute 1000 tasks in blocks of 100.
td = new ThreadTaskDistributor(1000, 100);
//Start 2 threads to work on it
ThreadManager * tm = new ThreadManager(2);
tm.run(processImages);
//...
//Same threads can work in other function
tm.run(processVolumes);
}

Definition at line 264 of file xmipp_threads.cpp.

 {
     runAsync(function, data);
     //Wait on barrier to wait for threads finish
     wait();
 }

◆ runAsync()

void ThreadManager::runAsync	(	ThreadFunction	function,
		void *	data = `NULL`
	)

Same as run but without blocking.

Definition at line 271 of file xmipp_threads.cpp.

 {
     if (data != NULL)
         setData(data);
     workFunction = function;
     if (!started)
         createThreads();
     //Wait on barrier to threads starts working
     wait();
 }

◆ setData()

void ThreadManager::setData	(	void *	data,
		int	nThread = `-1`
	)

Set data for working threads. If nThread = -1 then data is set for all threads.

Definition at line 216 of file xmipp_threads.cpp.

 {
     if (idxThread == -1)
         for (int i = 0; i < threads; ++i)
             arguments[i].data = data;
     else
         arguments[idxThread].data = data;
 }

◆ wait()

void ThreadManager::wait ( )

Function that should be called to wait until all threads finished work

Definition at line 282 of file xmipp_threads.cpp.

 {
     barrier->wait();
 }

Friends And Related Function Documentation

◆ _threadMain

void* _threadMain ( void * data )

friend

function to start running the threads. Should be external and declared as friend

This function is used in ThreadManager as the main threads function to live in.

Definition at line 173 of file xmipp_threads.cpp.

 {
     ThreadArgument * thArg = (ThreadArgument*) data;
     ThreadManager * thMgr = thArg->manager;
 
     while (true)
     {
         //Wait for start working or leave
         thMgr->wait();
         //After awaked check what to do
         if (thMgr->workFunction != NULL)
         {
             try
             {
                 thMgr->workFunction(*thArg);
                 thMgr->wait(); //wait for finish together
             }
             catch (XmippError &xe)
             {
                 std::cerr << xe.what() << std::endl
                 << "In thread " << thArg->thread_id << std::endl;
 //                pthread_exit(NULL);
                 exit(xe.__errno);
             }
         }
         else //exit thread
         {
             pthread_exit(NULL);
         }
     }
 }

Member Data Documentation

◆ threads

int ThreadManager::threads