mutex_pthread.h

#include <pthread.h>
#include <iostream>
#include <errno.h>
 
namespace cgv {
        namespace os {
 
unsigned& ref_debug_lock_counter()
{
        static unsigned counter = 0;
        return counter;
}
 
mutex& ref_debug_mutex()
{
        static mutex m;
        return m;
}
 
unsigned mutex::get_debug_lock_counter()
{
        return ref_debug_lock_counter();
}
 
mutex::mutex()
{
        pthread_mutex_init (&(pthread_mutex_t&)pmutex, NULL);
}
 
mutex::~mutex()
{
        pthread_mutex_destroy (&(pthread_mutex_t&)pmutex);
}
 
void mutex::lock()
{
        pthread_mutex_lock (&(pthread_mutex_t&)pmutex); 
}
 
void mutex::unlock()
{
        pthread_mutex_unlock (&(pthread_mutex_t&)pmutex);       
}
 
void mutex::debug_lock(const std::string& info)
{
        ref_debug_mutex().lock();
        std::cout << info << ": wait for lock [" << this << ":" << get_debug_lock_counter() << "]" << std::endl;
        ++ref_debug_lock_counter();
        ref_debug_mutex().unlock();
        lock();
        ref_debug_mutex().lock();
        std::cout << info << ": received lock [" << this << "]" << std::endl;
        ref_debug_mutex().unlock();
}
void mutex::debug_unlock(const std::string& info)
{
        unlock();
        ref_debug_mutex().lock();
        std::cout << info << ": unlock        [" << this << "]" << std::endl;
        ref_debug_mutex().unlock();
}
 
 
bool mutex::try_lock()
{
        return pthread_mutex_trylock(&(pthread_mutex_t&)pmutex) != EBUSY;
}
 
condition_mutex::condition_mutex()
{
        pthread_cond_init(&(pthread_cond_t&)pcond, NULL);
}
 
condition_mutex::~condition_mutex()
{
        pthread_cond_destroy(&(pthread_cond_t&)pcond);
}
 
void condition_mutex::send_signal()
{
        pthread_cond_signal(&(pthread_cond_t&)pcond);
}
 
void condition_mutex::send_signal_with_lock()
{
        lock();
        send_signal();
        unlock();
}
 
void condition_mutex::broadcast_signal()
{
        pthread_cond_broadcast(&(pthread_cond_t&)pcond);
}
 
void condition_mutex::broadcast_signal_with_lock()
{
        lock();
        broadcast_signal();
        unlock();
}
 
        }
}