C:/rwlock/evg_rwlock.h

Go to the documentation of this file.

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

#include "atomic_util.h"
#include "system_abstraction.h"

/*---------------------------------*/
/* Written by Evgeniy Makeev, 2000 */
/*---------------------------------*/
//
// 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 SharedCounterRWLock
{
        volatile int rwdata;
//
// Can be overwritten with a system specific yield thread
// or sleep implementation
//
        inline void yield()
        {
                thread_yield();
        }

public:
        static const char *name() { return "Shared_Counter_Lock"; }

        SharedCounterRWLock() : rwdata(0L) {}
//
// Must be called at the beginning of any read/data access.
//
        inline void enter_read(void)
        {
                if(atomic_inc_return(&rwdata) & 0x80000000)
                        for(;;)
                        {
                                if(atomic_dec_return(&rwdata) & 0x80000000) yield();
                                if((atomic_inc_return(&rwdata) & 0x80000000)==0) break;
                        }
        }

//
// 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(atomic_cmpexch_return(&rwdata, 0x80000000, 0) == 0) break;
                        if(rwdata) yield();
                }
        }
                
        //
        // Must be called at the end of a write operation
        //
        inline void leave_write(void)
        {
                atomic_and(&rwdata, ~0x80000000);
//              atomic_add(&rwdata, 0x80000000);
        }
};

#endif // __EVG_RW_LOCK_H_Included__

---