C:/rwlock/rwlock_test/rwlock_iocompl.h

Go to the documentation of this file.

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

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

class NonblockingRWLockIOCompl
{
public:
        static const char *name() { return "NonblockingRWLockIOCompl"; }
        
        inline void take_writer_lock(void)
        {
                DWORD ln;
                ULONG_PTR key;
                LPOVERLAPPED ovlp;
                // cout << "NonblockingRWLockIOCompl taking writer lock " << writers_iocport << "\n";
                while(!GetQueuedCompletionStatus(
                        writers_iocport,
                        &ln,
                        &key,
                        &ovlp,
                        200)) 
                {
                        thread_yield();
                }
                atomic_dec(&lock_tokens);
                // cout << "NonblockingRWLockIOCompl writer lock " << writers_iocport << " taken\n";
        }

        inline void release_writer_lock(void)
        {
                assert(PostQueuedCompletionStatus(
                                writers_iocport,
                                0,
                                NULL,
                                NULL)!=0);
                atomic_inc(&lock_tokens);
        }
        NonblockingRWLockIOCompl() : readers(0L), writers(0L), lock_tokens(0)
        {
                 writers_iocport = CreateIoCompletionPort(
                         INVALID_HANDLE_VALUE, 
                         NULL,
                         NULL,
                         0);
                 release_writer_lock();
        }

        virtual ~NonblockingRWLockIOCompl()
        {
                CloseHandle(writers_iocport);
    }
//
// Must be called at the beginning of any read/data access.
//
        inline void enter_read(void)
        {
                atomic_inc(&readers);
                while(writers)
                {
                        atomic_dec(&readers);
                        take_writer_lock();
                        atomic_inc(&readers);
                        release_writer_lock();
                }
        }

//
// Must be called at the end of any read/data access.
//
        inline void leave_read(void)
        {
                atomic_dec(&readers);
        }

        //
        // Must be called at the beginning of a write operation
        //
        inline void enter_write(void)
        {
                take_writer_lock();
                atomic_inc(&writers);
                while(readers > 0L) 
                {
                        yield();
                }
        }
                
        //
        // Must be called at the end of a write operation
        //
        inline void leave_write(void)
        {
                atomic_dec(&writers);
                release_writer_lock();
        }

private:
        int                                     readers;
        int                                     writers;
        int                                     lock_tokens;
        HANDLE                          writers_iocport;
};

#endif // __RW_LOCK_IO_COMPL_H_Included__

---