Threads

Collaboration diagram for Threads:

Classes
class	Mutex
class	Condition
class	Barrier
class	Thread
class	ThreadManager
class	ThreadArgument
class	ParallelTaskDistributor
class	ThreadTaskDistributor
struct	mybarrier_t

Functions
void *	_singleThreadMain (void *data)
void *	_threadMain (void *data)

Old parallel stuff.
typedef struct mybarrier_t	barrier_t
int	barrier_init (barrier_t *barrier, int needed)
int	barrier_destroy (barrier_t *barrier)
int	barrier_wait (barrier_t *barrier)

Detailed Description

Typedef Documentation

barrier_t

typedef struct mybarrier_t barrier_t

Barrier structure

Function Documentation

_singleThreadMain()

void* _singleThreadMain

(

void *

data

)

This function is used from the Thread class to provide a wrapper over pthreads. This will be the real function called from pthread_create and from this the function thread.run() will be called.

Definition at line 146 of file xmipp_threads.cpp.

                                     {
  Thread * thread = (Thread*) data;
  thread->run();
  return NULL;
}

_threadMain()

void* _threadMain

(

void *

data

)

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

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

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);
        }
    }
}

barrier_destroy()

int barrier_destroy

(

barrier_t *

barrier

)

Barrier destruction

Definition at line 375 of file xmipp_threads.cpp.

{
    pthread_mutex_destroy(&barrier->mutex);
    pthread_cond_destroy(&barrier->cond);
    return 0;
}

barrier_init()

int barrier_init	(	barrier_t *	barrier,
		int	needed
	)

Barrier initialization

Definition at line 366 of file xmipp_threads.cpp.

{
    barrier->needed = needed;
    barrier->called = 0;
    pthread_mutex_init(&barrier->mutex, NULL);
    pthread_cond_init(&barrier->cond, NULL);
    return 0;
}

barrier_wait()

int barrier_wait

(

barrier_t *

barrier

)

Wait at the barrier

Definition at line 382 of file xmipp_threads.cpp.

{
    pthread_mutex_lock(&barrier->mutex);
    barrier->called++;
    if (barrier->called == barrier->needed)
    {
        barrier->called = 0;
        pthread_cond_broadcast(&barrier->cond);
    }
    else
    {
        pthread_cond_wait(&barrier->cond,&barrier->mutex);
    }
    pthread_mutex_unlock(&barrier->mutex);
    return 0;
}