devel/libmdw/trunk/libmdw/src/ThreadStatic.cpp

#include "ThreadStatic.h"

namespace mdw
{
ThreadStatic::thread_attr_t ThreadStatic::our_default_thread_attr;
ThreadStatic::mutex_attr_t ThreadStatic::our_default_mutex_attr;
ThreadStatic::cond_attr_t ThreadStatic::our_default_cond_attr;
ThreadStatic::rwlock_attr_t ThreadStatic::our_default_rwlock_attr;

ThreadStatic::Guard::Guard (mutex_t &mutex) : myMutex (mutex)
{
    mutex_lock (myMutex);
}

ThreadStatic::Guard::~Guard()
{
    mutex_unlock (myMutex);
}

ThreadStatic::GuardRead::GuardRead (rwlock_t &lock) : myLock (lock)
{
    rwlock_rdlock (myLock);
}

ThreadStatic::GuardRead::~GuardRead()
{
    rwlock_unlock (myLock);
}

ThreadStatic::GuardWrite::GuardWrite (rwlock_t &lock) : myLock (lock)
{
    rwlock_wrlock (myLock);
}

ThreadStatic::GuardWrite::~GuardWrite()
{
    rwlock_unlock (myLock);
}

// Important, must be called before anything else
void ThreadStatic::initialise()
{
    thread_attr_init (our_default_thread_attr);
    mutex_attr_init (our_default_mutex_attr);
    cond_attr_init (our_default_cond_attr);
    rwlock_attr_init (our_default_rwlock_attr);
}

// Call that function at the end, to dealocate all static stuff
void ThreadStatic::finalize()
{
    thread_attr_destroy (our_default_thread_attr);
    mutex_attr_destroy (our_default_mutex_attr);
    cond_attr_destroy (our_default_cond_attr);
    rwlock_attr_destroy (our_default_rwlock_attr);
}

// ThreadStatic manipulation functions:

// create a thread
int ThreadStatic::create (ThreadStatic::thread_t &thread,
                          void * (*start_routine) (void*),
                          void *arg,
                          ThreadStatic::thread_attr_t &attr)
{
    return pthread_create (&thread, &attr, start_routine, arg);
}

// terminate current thread
void ThreadStatic::exit (void * result)
{
    return pthread_exit (result);
}

// cancel execution of another thread
int ThreadStatic::cancel (ThreadStatic::thread_t thread)
{
    return pthread_cancel (thread);
}

// block current thread until another one terminates
int ThreadStatic::join (ThreadStatic::thread_t thread, void ** result)
{
    return pthread_join (thread, result);
}

// set the detachstate attribute (whether thread can be joined on termination)
int ThreadStatic::setdetachstate (ThreadStatic::thread_attr_t &attr, AttachedState_t state)
{
    return pthread_attr_setdetachstate (&attr, state);
}

// get the detachstate attribute
int ThreadStatic::getdetachstate (const ThreadStatic::thread_attr_t &attr, AttachedState_t &state)
{
    return pthread_attr_getdetachstate (&attr, (int*) &state);
}


// Synchronization functions: for mutexes and condition variables

// initialize mutex lock
int ThreadStatic::mutex_init (ThreadStatic::mutex_t &mutex, const ThreadStatic::mutex_attr_t &attr)
{
    return pthread_mutex_init (&mutex, &attr);
}

// pthread_mutex_destroy()
int ThreadStatic::mutex_destroy (ThreadStatic::mutex_t &mutex)
{
    return pthread_mutex_destroy (&mutex);
}

// acquire mutex lock (blocking)
int ThreadStatic::mutex_lock (ThreadStatic::mutex_t &mutex)
{
    return pthread_mutex_lock (&mutex);
}

// acquire mutex lock (non-blocking)
int ThreadStatic::mutex_trylock (ThreadStatic::mutex_t &mutex)
{
    return pthread_mutex_trylock (&mutex);
}

// release mutex lock
int ThreadStatic::mutex_unlock (ThreadStatic::mutex_t &mutex)
{
    return pthread_mutex_unlock (&mutex);
}

// pthread_cond_init()
int ThreadStatic::cond_init (ThreadStatic::cond_t &cond, const ThreadStatic::cond_attr_t &attr)
{
    return pthread_cond_init (&cond, &attr);
}

// pthread_cond_destroy()
int ThreadStatic::cond_destroy (ThreadStatic::cond_t &cond)
{
    return pthread_cond_destroy (&cond);
}

// signal a condition
int ThreadStatic::cond_signal (ThreadStatic::cond_t &cond)
{
    return pthread_cond_signal (&cond);
}

// wait on a condition
int ThreadStatic::cond_wait (ThreadStatic::cond_t &cond, ThreadStatic::mutex_t &mutex)
{
    return pthread_cond_wait (&cond, &mutex);
}

// wait on a condition with timeout
int ThreadStatic::cond_timedwait (ThreadStatic::cond_t &cond, ThreadStatic::mutex_t &mutex, const struct timespec &time)
{
    return pthread_cond_timedwait (&cond, &mutex, &time);
}

// ThreadStatic-local storage (or thread-specific data, in Pthreads nomenclature):

// creates a key that can later be associated with thread specific data
int ThreadStatic::key_create (ThreadStatic::key_t &key, void (*func) (void *))
{
    return pthread_key_create (&key, func);
}

// associate a key with thread-specific data
int ThreadStatic::setspecific (ThreadStatic::key_t key, const void *value)
{
    return pthread_setspecific (key, value);
}

// retrieve the data associated with a key
void *ThreadStatic::getspecific (ThreadStatic::key_t key)
{
    return pthread_getspecific (key);
}

// destroy the key
int ThreadStatic::key_delete (ThreadStatic::key_t key)
{
    return pthread_key_delete (key);
}


// Some utility functions useful when working with Pthreads

// test two threads IDs for equality
bool ThreadStatic::equal (ThreadStatic::thread_t thread1, ThreadStatic::thread_t thread2)
{
    return (pthread_equal (thread1, thread2) != 0);
}

// set thread to release resources
int ThreadStatic::detach (ThreadStatic::thread_t thread)
{
    return pthread_detach (thread);
}

// find out own thread ID
ThreadStatic::thread_t ThreadStatic::self()
{
    return pthread_self();
}

// Read/Write locks

// Create a RW lock
int ThreadStatic::rwlock_init (ThreadStatic::rwlock_t &rwlock, const ThreadStatic::rwlock_attr_t &attr)
{
    return pthread_rwlock_init (&rwlock, &attr);
}

// Destroy a RW lock
int ThreadStatic::rwlock_destroy (ThreadStatic::rwlock_t &rwlock)
{
    return pthread_rwlock_destroy (&rwlock);
}

// Get the RW lock in read mode (blocking)
int ThreadStatic::rwlock_rdlock (ThreadStatic::rwlock_t &rwlock)
{
    return pthread_rwlock_rdlock (&rwlock);
}

// Get the RW lock in read mode (non blocking)
int ThreadStatic::rwlock_tryrdlock (ThreadStatic::rwlock_t &rwlock)
{
    return pthread_rwlock_tryrdlock (&rwlock);
}

// Get the RW lock in write mode (blocking)
int ThreadStatic::rwlock_wrlock (ThreadStatic::rwlock_t &rwlock)
{
    return pthread_rwlock_wrlock (&rwlock);
}

// Get the RW lock in write mode (non blocking)
int ThreadStatic::rwlock_trywrlock (ThreadStatic::rwlock_t &rwlock)
{
    return pthread_rwlock_trywrlock (&rwlock);
}

// Release RW the lock
int ThreadStatic::rwlock_unlock (ThreadStatic::rwlock_t &rwlock)
{
    return pthread_rwlock_unlock (&rwlock);
}

// Attribute functions

// initialize attributes
int ThreadStatic::thread_attr_init (ThreadStatic::thread_attr_t &attr)
{
    return pthread_attr_init (&attr);
}
int ThreadStatic::mutex_attr_init (ThreadStatic::mutex_attr_t &attr)
{
    return pthread_mutexattr_init (&attr);
}
int ThreadStatic::cond_attr_init (ThreadStatic::cond_attr_t &attr)
{
    return pthread_condattr_init (&attr);
}
int ThreadStatic::rwlock_attr_init (ThreadStatic::rwlock_attr_t &attr)
{
    return pthread_rwlockattr_init (&attr);
}

// destroy attributes
int ThreadStatic::thread_attr_destroy (ThreadStatic::thread_attr_t &attr)
{
    return pthread_attr_destroy (&attr);
}
int ThreadStatic::mutex_attr_destroy (ThreadStatic::mutex_attr_t &attr)
{
    return pthread_mutexattr_destroy (&attr);
}
int ThreadStatic::cond_attr_destroy (ThreadStatic::cond_attr_t &attr)
{
    return pthread_condattr_destroy (&attr);
}
int ThreadStatic::rwlock_attr_destroy (ThreadStatic::rwlock_attr_t &attr)
{
    return pthread_rwlockattr_destroy (&attr);
}
}

---