mutex_pos.cpp

Go to the documentation of this file.

 
/*****************************************************************************
 ** Platform Check
 *****************************************************************************/
 
#include <ecl/config/ecl.hpp>
#if defined(ECL_IS_POSIX)
 
/*****************************************************************************
 ** Includes
 *****************************************************************************/
 
#include <errno.h>
#include <ecl/exceptions/standard_exception.hpp>
#include "../../include/ecl/threads/mutex.hpp"
 
/*****************************************************************************
 ** Namespaces
 *****************************************************************************/
 
namespace ecl {
 
/*****************************************************************************
 * Mutex Class Methods
 *****************************************************************************/
 
Mutex::Mutex(const bool locked) :
    number_locks(0)
{
 
  pthread_mutexattr_t attr;
  int result;
 
  result = pthread_mutexattr_init(&attr);
  ecl_assert_throw(result == 0, threads::throwMutexAttrException(LOC,result));
 
  #if defined(NDEBUG) || defined(ECL_NDEBUG)
    result = pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_NORMAL);
  #else
    result = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
  #endif
  ecl_assert_throw(result == 0, threads::throwMutexAttrException(LOC,result));
 
  if (result == 0) {
    result = pthread_mutex_init(&mutex, &attr);
  }
  ecl_assert_throw(result == 0, threads::throwMutexInitException(LOC,result));
  result = pthread_mutexattr_destroy(&attr);
  ecl_assert_throw(result == 0, threads::throwMutexAttrException(LOC,result));
 
  if (locked) {
    this->lock();
  }
}
;
 
Mutex::~Mutex()
{
  pthread_mutex_destroy(&mutex);
  // Spank! Destructor exceptions are bad.
  // ecl_assert_throw( result == 0, threads::throwMutexDestroyException(LOC,result));
}
 
void Mutex::lock()
{
  ++number_locks;
  int result = pthread_mutex_lock(&mutex);
  ecl_assert_throw(result == 0, threads::throwMutexLockException(LOC,result));
}
;
 
bool Mutex::trylock(Duration &duration)
{
  #if defined(_POSIX_TIMEOUTS) && (_POSIX_TIMEOUTS - 200112L) >= 0L
    timespec timeout;
    timeout.tv_sec = duration.sec();
    timeout.tv_nsec = duration.nsec();
    int result = pthread_mutex_timedlock(&mutex, &timeout);
    if (result == ETIMEDOUT) {
      return false;
    }
    ecl_assert_throw(result == 0, threads::throwMutexTimedLockException(LOC,result));
    ++number_locks;
  #else
    return trylock(); // fallback option
  #endif
  return true;
}
;
 
bool Mutex::trylock()
{
  int result = pthread_mutex_trylock(&mutex);
 
  // result will typically be EBUSY if already locked, so filter it from the assert check.
  if (result == EBUSY) {
    return false;
  }
 
  ecl_assert_throw(result == 0, threads::throwMutexLockException(LOC,result));
 
  // If we made it here, it means the attempt locked the mutex.
  ++number_locks;
  return true;
}
;
 
void Mutex::unlock()
{
  --number_locks;
  int result = pthread_mutex_unlock(&mutex);
  ecl_assert_throw(result == 0, threads::throwMutexUnLockException(LOC,result));
}
;
 
}
;
// namespace ecl
 
#endif /* ECL_IS_POSIX */