---

Synchronization.cpp

Go to the documentation of this file.

#include "Synchronization.h"

#ifdef LINUX
#include <pthread.h>
#include <sys/timeb.h>
#include <errno.h>
#endif
#include <assert.h>
namespace rwil {
#ifdef LINUX
  void *StartThread(void * threadObject)
  {
    Thread * thread = (Thread *)threadObject;
    thread->Go();
    return NULL;
  }
#endif

  Mutex::Mutex()
  {
#ifdef _WIN32
    m_mutex = CreateMutex(NULL, TRUE, NULL);
    if(m_mutex = NULL)
      {
        throw "Unable to create mutex";
      }
#endif
#ifdef LINUX
    //m_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    attr.__mutexkind= PTHREAD_MUTEX_RECURSIVE_NP;
    //  pthread_mutexattr_setkind(&attr, PTHREAD_MUTEX_RECURSIVE);
    pthread_mutex_init(&m_mutex, &attr);
#endif
  }
  Mutex::~Mutex()
  {
#ifdef _WIN32
    CloseHandle(m_mutex);
#endif
#ifdef LINUX
    //while(pthread_mutex_destroy(&m_mutex) == EBUSY)
    //          pthread_mutex_unlock(&m_mutex);
#endif
  }
#ifdef LINUX
  void Mutex::Wait()
  {
    pthread_mutex_lock(&m_mutex);       
  }
        
  bool Mutex::TryWait()
  {
    return pthread_mutex_trylock(&m_mutex) == 0;        
  }
        
  void Mutex::Release()
  {
    pthread_mutex_unlock(&m_mutex);     
  }
#endif //LINUX

#ifdef _WIN32
  static bool WaitWithTimeout(int milli)
  {
  
    DWORD dwRet = WaitForSingleObject(m_mutex, milli);
  
    switch (dwWaitResult) 
      {
      case WAIT_OBJECT_0: 
        break;
      
        // Cannot get mutex ownership due to time-out.
      case WAIT_TIMEOUT: 
        return FALSE; 
      
        // Got ownership of the abandoned mutex object.
      case WAIT_ABANDONED: 
        break; 
      
        // Wait Failed
      case WAIT_FAILED: 
        return FALSE; 
      }
                
    return TRUE; 

  }

  void Mutex::Wait()
  {
    while(WaitWithTimeout(INFINITE) == FALSE) {}
  }

  bool Mutex::TryWait()
  {
    return WaitWithTmeout(0);
  }

  void Mutex::Release()
  {
    ReleaseMutex(m_mutex);
  }

#endif // _WIN32



  ScopedMutex::ScopedMutex(Mutex & mutex) : m_mutex(mutex) 
  { 
    m_mutex.Wait();
  }
  ScopedMutex::~ScopedMutex() 
  { 
    m_mutex.Release();
  }


  Semaphore::Semaphore(int count) : m_count(count) {}
  Semaphore::Semaphore() : m_count(0) {}

  //  They then decrement the count
  void Semaphore::Wait()
  {
    m_mutex.Wait();
    while(m_count == 0)
      {
        m_mutex.Release();
#ifdef _WIN32
        Sleep(0);
#endif
#ifdef LINUX
        sched_yield();
#endif
        m_mutex.Wait();
      }
    m_count--;
    m_mutex.Release();
  }

  bool Semaphore::TryWait()
  {
    m_mutex.Wait();
    if(m_count == 0)
      {
        return false;
      }
    m_count--;
    m_mutex.Release();
    return true;
  }

  bool Semaphore::Wait(int millisecondTimeout)
  {
#ifdef _WIN32
    int timeout = GetTickCount() + millisecondTimeout;
#endif
#ifdef LINUX
    timeb timeout;
    ftime(&timeout);
    int tempMilli = (int)timeout.millitm + millisecondTimeout;
    timeout.time = timeout.time + tempMilli/1000;
    timeout.millitm = tempMilli /1000;
#endif
    m_mutex.Wait();
    while(m_count == 0)
      {
        m_mutex.Release();
#ifdef _WIN32
        Sleep(0);
        if(GetTickCount() > timeout) return false;
#endif
#ifdef LINUX
        sched_yield();
        timeb curtime;
        ftime(&curtime);
        if((timeout.time <= curtime.time) && (timeout.millitm <= curtime.millitm))
          {
            return false;
          }
#endif
        m_mutex.Wait();
      }
    m_count--;
    m_mutex.Release();
    return true;
  }

  void Semaphore::Signal()
  {
    m_mutex.Wait();
    m_count++;
    m_mutex.Release();
  }

  Thread::Thread() {}
  Thread::~Thread() 
  {
    m_mutex.Release();
  }
  void Thread::Start()
  {
    m_mutex.Wait();
#ifdef _WIN32
    m_threadHandle = beginthread(StartThread, 0, this);
#endif
#ifdef LINUX
    pthread_create(&m_threadHandle, NULL, StartThread, this);
#endif
  }
  void Thread::Go()
  {
    Function();
    m_mutex.Release();
  }

  void Thread::Yield()
  {
#ifdef _WIN32
    Sleep(0);
#endif
#ifdef LINUX
    sched_yield();
#endif  
  }
  void Thread::Join()
  {
    if(pthread_join(m_threadHandle, NULL))
      assert(0);
  }
}

---