C:/rwlock/evg_w32_rwlock.h

Go to the documentation of this file.

/* ****************************************************************************
 * Owner:               Evgeniy Makeev
 * Created by:  Evgeniy Makeev
 * ****************************************************************************
 */
#ifndef __EVG_W32_RW_LOCK_H_Included__
#define __EVG_W32_RW_LOCK_H_Included__ 

#include <Windows.h>
#include "atomic_util.h"


/*---------------------------------*/
/* Written by Evgeniy Makeev, 2004 */
/*---------------------------------*/
//
// Multiple readers - one writer interface class.
// Implements multiple readers one writer mechanism.
// Optimizes readers speed, provides fast readers
// synchronization when no writers are waiting.
// Useful when data is needed to be written/changed
// only occasionally but it is read often by multiple
// threads.
// 

class EvgW32RWLock
{
        volatile long rwdata;
        volatile long waiting_readers;
        volatile long waiting_writers;
        HANDLE readers_iocport;
        HANDLE writers_iocport;
//
// Can be overwritten with a system specific yield thread
// or sleep implementation
//
        inline void yield()
        {
                Sleep(0);
        }

        inline void reader_wait(long milliseconds)
        {
                DWORD ln;
                ULONG_PTR key;
                LPOVERLAPPED ovlp;
                GetQueuedCompletionStatus(
                        readers_iocport,
                        &ln,
                        &key,
                        &ovlp,
                        milliseconds);
        }
        inline void signal_readers(void)
        {
                long i, w=waiting_readers;
                for(i=0; i<w; i++)
                {
                        PostQueuedCompletionStatus(
                                readers_iocport,
                                0,
                                NULL,
                                NULL);
                }
        }
        inline void writer_wait(long milliseconds)
        {
                DWORD ln;
                ULONG_PTR key;
                LPOVERLAPPED ovlp;
                GetQueuedCompletionStatus(
                        writers_iocport,
                        &ln,
                        &key,
                        &ovlp,
                        milliseconds);
        }
        inline void signal_writers(void)
        {
                long i, w=waiting_writers;
                //InterlockedExchangeAdd(&waiting_writers, -w);
                for(i=0; i<w; w++)
                {
                        PostQueuedCompletionStatus(
                                writers_iocport,
                                0,
                                NULL,
                                NULL);
                }
        }
public:
        static const char *name() { return "Evgeniy's W32 RW Lock"; }

        EvgW32RWLock() : rwdata(0L), waiting_readers(0), waiting_writers(0)
        {
                 readers_iocport = CreateIoCompletionPort(
                         INVALID_HANDLE_VALUE, 
                         NULL,
                         NULL,
                         0);
                 writers_iocport = CreateIoCompletionPort(
                         INVALID_HANDLE_VALUE, 
                         NULL,
                         NULL,
                         0);
        }

        virtual ~EvgW32RWLock()
        {
                CloseHandle(readers_iocport);
                CloseHandle(writers_iocport);
    }
//
// Must be called at the beginning of any read/data access.
//
        inline void enter_read(void)
        {
//              for(;;)
//              {
                        if((atomic_inc(rwdata) & 0x80000000) == 0) break;
                        if(atomic_dec(rwdata) & 0x80000000)
                        {
                                take_writer_lock();
                                atomic_inc(rwdata);
                                release_writer_lock();
                        }
//              }
        }
//
// Must be called at the end of any read/data access.
//
        inline void leave_read(void)
        {
                atomic_dec(rwdata);
        }
        //
        // Must be called at the beginning of a write operation
        //
        inline void enter_write(void)
        {
                for(;;)
                {
                        if(InterlockedCompareExchange(&rwdata, 0x80000000, 0) == 0) break;
                        writer_wait(100);
                }
                atomic_dec(waiting_writers);
        }
                
        //
        // Must be called at the end of a write operation
        //
        inline void leave_write(void)
        {
                InterlockedExchangeAdd(&rwdata, 0x80000000);
                signal_readers();
        }
};

#endif // __EVG_W2_RW_LOCK_H_Included__

---