C:/rwlock/classic_rwlock.h

Go to the documentation of this file.

#include "atomic_util.h"

#ifdef WIN32

#include <windows.h>
#include <LIMITS.H>

class ClassicRWLock
{
public:
        ClassicRWLock() : 
          activeReader(0), waitingReader(0), activeWriter(0), waitingWriter(0)
        {
                InitializeCriticalSection(&cs);
                blockedReader = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
                blockedWriter = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
        }
        ~ClassicRWLock()
        {
                DeleteCriticalSection(&cs);
        }
        void enter_read(void);
        void leave_read(void);
        void enter_write(void);
        void leave_write(void);

        static const char *name() { return "ClassicRWLock"; }

private:

        long                            activeReader;
        long                            waitingReader;
        long                            activeWriter;
        long                            waitingWriter;
        CRITICAL_SECTION        cs;          
        HANDLE                          blockedReader; 
        HANDLE                          blockedWriter; 
};

//////////////////////////////////////////////////////////////////////////////
//  FUNCTION: StartReading() 
//  PURPOSE:  Implement multiple reader policy
//////////////////////////////////////////////////////////////////////////////

inline void ClassicRWLock::enter_read(void)
{
     EnterCriticalSection(&cs);
     // if there is active reader or waiting writer, wait for next read batch
     if (activeWriter > 0 || waitingWriter > 0) 
         {
       waitingReader++;
       LeaveCriticalSection(&cs);
       WaitForSingleObject(blockedReader, INFINITE);
     }
     else 
         {
       activeReader++;
       LeaveCriticalSection(&cs);
     }
}

//////////////////////////////////////////////////////////////////////////////
//  FUNCTION: StopReading() 
//  PURPOSE:  Thread finish reading.  Release other readers or writer.
//////////////////////////////////////////////////////////////////////////////

inline void ClassicRWLock::leave_read(void)
{
     EnterCriticalSection(&cs);
     activeReader--;
     // last reader thread to finish reading needs to activate a waiting writer
     if (activeReader == 0 && waitingWriter > 0) 
         {
       activeWriter = 1;
       waitingWriter--;
       ReleaseSemaphore(blockedWriter, 1, NULL);
     }
     LeaveCriticalSection(&cs);
}

//////////////////////////////////////////////////////////////////////////////
//  FUNCTION: StartWriting() 
//  PURPOSE:  Serialize all writer threads.
//////////////////////////////////////////////////////////////////////////////

inline void ClassicRWLock::enter_write(void)
{
      EnterCriticalSection(&cs);
      if (activeReader == 0 && activeWriter == 0) 
          {
        // there is no active reader or writer, OK to start writing
        activeWriter = 1;
        LeaveCriticalSection(&cs);
      }
      else 
          {
        // there is active readers or writer, put thread on write queue
        waitingWriter++;
        LeaveCriticalSection(&cs);
        WaitForSingleObject(blockedWriter, INFINITE);
      }
}

//////////////////////////////////////////////////////////////////////////////
//  FUNCTION: StopWriting() 
//  PURPOSE:  Thread finish writing.  Release other readers or writer.
//////////////////////////////////////////////////////////////////////////////

inline void ClassicRWLock::leave_write(void)
{
     EnterCriticalSection(&cs);
     activeWriter = 0;
     if (waitingReader > 0) 
         {
        // if there are waiting readers, release them all from read queue
        while (waitingReader > 0) 
                {
           waitingReader--;
           activeReader++;
           ReleaseSemaphore(blockedReader, 1, NULL);
        }
     }
     else if (waitingWriter > 0) 
         {
        // no waiting reader and we have waiting writer,
        // release 1 writer from write queue
        waitingWriter--;
                activeWriter = 1;
        ReleaseSemaphore(blockedWriter, 1, NULL);
     }
     LeaveCriticalSection(&cs);
}

#else // #ifdef WIN32

#include <pthread.h>
// from http://www.unet.univie.ac.at/aix/aixprggd/genprogc/complex_synchronization_objects.htm
//
class ClassicRWLock
{
private:
        pthread_mutex_t lock;
        pthread_cond_t rcond;
        pthread_cond_t wcond;
        int lock_count;  /* < 0 .. held by writer             */
                         /* > 0 .. held by lock_count readers */
                         /* = 0 .. held by nobody             */
        int waiting_writers;  /* count of wating writers      */
public:
        ClassicRWLock()
        {
        pthread_mutex_init(&lock, NULL);
        pthread_cond_init(&wcond, NULL);
        pthread_cond_init(&rcond, NULL);
        lock_count = 0;
        waiting_writers = 0;
        }
        ~ClassicRWLock()
        {
        pthread_mutex_destroy(&lock);
        pthread_cond_destroy(&wcond);
        pthread_cond_destroy(&rcond);
        }
    
        void enter_write(void)
    {
        pthread_mutex_lock(&lock);
        waiting_writers++;
        while(lock_count)
            pthread_cond_wait(&wcond, &lock);
                waiting_writers--;
        lock_count = -1;
        pthread_mutex_unlock(&lock);
    }
        void leave_write(void)
    {
        pthread_mutex_lock(&lock);
        lock_count = 0;
        if(waiting_writers == 0)
            pthread_cond_broadcast(&rcond);
        else
            pthread_cond_signal(&wcond);
        pthread_mutex_unlock(&lock);
    }

        void enter_read(void)
    {
        pthread_mutex_lock(&lock);
        while(lock_count < 0)
            pthread_cond_wait(&rcond, &lock);
        lock_count++;
                pthread_mutex_unlock(&lock);
    }
        void leave_read(void)
    {
        pthread_mutex_lock(&lock);
        lock_count--;
        if (!lock_count)
            pthread_cond_signal(&wcond);
        pthread_mutex_unlock(&lock);
    }
    
        static const char *name() { return "ClassicRWLock"; }
};

/*
class ClassicRWLock
{
public:
        ClassicRWLock()
        {
        pthread_rwlock_init(&rwlock, NULL);
        }
        ~ClassicRWLock()
        {
        pthread_rwlock_destroy(&rwlock);
        }
        void enter_read(void) { pthread_rwlock_rdlock(&rwlock); }
        void leave_read(void) { pthread_rwlock_unlock(&rwlock); }
        void enter_write(void){ pthread_rwlock_unlock(&rwlock); }
        void leave_write(void){ pthread_rwlock_wrlock(&rwlock); }
        static const char *name() { return "ClassicRWLock"; }

private:
    
        pthread_rwlock_t rwlock; 
};

*/
#endif // #ifdef WIN32

---