Search  

---

C:/temp/src/j2k/Posix/Mutex.cpp

Go to the documentation of this file.

// Started by Harry
// Finished by Fred

#ifndef __J2K__PThread_Mutex_CPP__
#define __J2K__PThread_Mutex_CPP__

#include <j2k/445/Posix/Mutex.hpp>

// Uses:
// pthread_mutex_t
// pthread_mutex_attr_t
// pthread_cond_t
// pthread_cond_attr_t

/***********************************************
  Description of pthread_mutex_attr_t arguments.

  Attribute         Default Value
  =========         =============
  detachstate       PTHREAD_CREATE_JOINABLE
  schedpolicy       PTHREAD_INHERIT_SCHED
  schedparam        Inherited from parent thread
  contentionscope   PTHREAD_SCOPE_SYSTEM
  stacksize         4096
  stackaddr         NULL
*/

  // Default Constructor
  inline PThread_Mutex::PThread_Mutex() 
  {
    // Fill structure with 0
    memset( &attr,        0, sizeof( pthread_mutexattr_t ) );
    memset( &mutex,       0, sizeof( pthread_mutex_t     ) );
//    memset( &cond,        0, sizeof( pthread_cond_t ) );
//    memset( &cond_attr,   0, sizeof( pthread_condattr_t  ) );

    int err = pthread_mutexattr_init( &attr );
    MC_OnError( err, Error, "An unknown error happened while initializing a mutex attribute." )

    err = pthread_mutex_init( &mutex, &attr );
    MC_OnError( err,  Error, "An error happened while initializing a mutex." )

//    err = pthread_condattr_init( &cond_attr );
//    MC_OnError( err,  Error, "An error happened while initializing the condition variable attribute" )
//
//    err = pthread_cond_init( &cond, &cond_attr );
//    MC_OnError( err,  Error, "An error happened while initializing the condition variable." )
  }

  // Copy Constructor
  inline PThread_Mutex::PThread_Mutex( const PThread_Mutex& src ) {
    memcpy( &attr,        &src.attr,        sizeof( pthread_mutexattr_t ) );
    memcpy( &mutex,       &src.mutex,       sizeof( pthread_mutex_t     ) );
//    memcpy( &cond,        &src.cond,        sizeof( pthread_cond_t      ) );
//    memcpy( &cond_attr,   &src.cond_attr,   sizeof( pthread_condattr_t  ) );
  }

  // Assign Operator
  inline const PThread_Mutex& PThread_Mutex::operator=( const PThread_Mutex& src ) 
  {
    memcpy( &attr,        &src.attr,        sizeof( pthread_mutexattr_t ) );
    memcpy( &mutex,       &src.mutex,       sizeof( pthread_mutex_t     ) );
//    memcpy( &cond,        &src.cond,        sizeof( pthread_cond_t      ) );
//    memcpy( &cond_attr,   &src.cond_attr,   sizeof( pthread_condattr_t  ) );
    return *this;
  }

  // Virtual Destructor
  inline PThread_Mutex::~PThread_Mutex() 
  {
    int err = pthread_mutex_destroy( &mutex );
    MC_OnError( err, Error, "An error happened while deleting a mutex." )

 
    // Make sure the mutex is Unlock... 

    // WARNING:  Make sure that Mutex destroy
    // ========  don't destroy attribute, 
    //           so that there is no double destroy on attr.

    err = pthread_mutexattr_destroy( &attr );
    MC_OnError( err,  Error, "An error happened while deleting a mutex attribute." )

//  err = pthread_cond_destroy( &cond );
//  MC_OnError( err,  Error, "An error happened while deleting a condition variable.")
//
//  err = pthread_condattr_destroy( &cond_attr );
//  MC_OnError( err,  Error, "An error happened while deleting a condition variable attribute." )
  }

  // Lock the mutex
  inline void PThread_Mutex::lock()
  {
    int err = pthread_mutex_lock( &mutex );
    MC_OnError( err, Error, "An error happened while locking a mutex." )
  }

  // Unlock the mutex
  inline void PThread_Mutex::unlock()
  {
    int err = pthread_mutex_unlock( &mutex );
    MC_OnError( err, Error, "An error happened while unlocking a mutex." )
  }

  // Try to lock a mutex
  inline void PThread_Mutex::tryLock()
  {
    int err = pthread_mutex_trylock( &mutex );
    MC_OnError( err, Error, "An error happened while trying to lock a mutex." )
  }

  // Get the maximum priority (ceiling value) for the mutex
  inline int PThread_Mutex::getPriorityCeiling()
  {
    int ceiling = 0;
    int err = pthread_mutex_getprioceiling( &mutex, &ceiling );
    MC_OnError( err, Error, "An error happened while retrieving the priority ceiling of a mutex." )

    return ceiling;
  }

  // Set the maximum priority (ceiling value) for the mutex  
  inline int PThread_Mutex::setPriorityCeiling( int new_ceiling )
  {
    int old_ceiling = 0;

    int err = pthread_mutex_setprioceiling( &mutex, new_ceiling, &old_ceiling );
    MC_OnError( err, Error, "An error happened while setting the priority ceiling of a mutex." )

    return old_ceiling;
  }

  // Get the mutex attribute type
  inline int PThread_Mutex::getType()
  {
    int mtype = 0;

    int err = pthread_mutexattr_gettype( &attr, &mtype );
    MC_OnError( err, Error, "An error happened while getting the mutex type." )

    return mtype;
  }

  // Get the mutex attribute protocol
  inline int PThread_Mutex::getProtocol()
  {
    int err = pthread_mutexattr_getprotocol( &attr, &protocol );
    MC_OnError( err, Error, "while getting the mutex attribute protocol.")
  
    return protocol;
  }

#if 0
  // Wait for a mutex
  inline void PThread_Mutex::wait() 
  {
//    pthread_cond_wait( &cond, &mutex );
  }

  // Send a notify signal for other process waiting for the mutex
  inline void PThread_Mutex::notify() 
  {
    pthread_cond_signal( &cond );
  }

  // Send a notifyAll broadcast signal for other process waiting for the mutex
  inline void PThread_Mutex::notifyAll() 
  {
//    pthread_cond_broadcast( &cond );
  }
#endif

#endif

---