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