MultiReadWriteLock.h

Go to the documentation of this file.

/*  ReadWriteLock.h - N readers, 1 writer problem for multiple processes

    Copyright (C) 2001 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_MultiReadWriteLock_h
#define OW32_MultiReadWriteLock_h

#include <OW32/SyncObjects.h>
#include <rpc.h>

namespace OW32
{

class OW32_LIB_EXPORT CMultiReadWriteLock
{
private:
    struct LOCKDATA
    {
        int m_readers, m_pending_readers;
        int m_writers, m_pending_writers;
    };

    CMutex* m_mtxReadWriteFlags;
    LOCKDATA* m_pLockData;
    CEvent* m_evReadDone, *m_evWriteDone;
    TCHAR m_lockName[128];

public:
    CMultiReadWriteLock(LPCTSTR lockName = NULL)
    {
        if (lockName == NULL) {
#if 0
            UUID uuid;
            UuidCreate(&uuid);
            _stprintf(m_lockName, _T("Global\\%08X%04X%04X%02X%02X%02X%02X%02X%02X%02X%02X"), 
                uuid.Data1, uuid.Data2, uuid.Data3, uuid.Data4[0], uuid.Data4[1], 
                uuid.Data4[2], uuid.Data4[3], uuid.Data4[4], uuid.Data4[5], 
                uuid.Data4[6], uuid.Data4[7]);
#endif
        } else {
            _tcsncpy(m_lockName, lockName, 128);
            m_lockName[127] = _T('\0');
        }
        CreateLockData();
    }

    ~CMultiReadWriteLock()
    {
        if (m_pLockData) {
            UnmapViewOfFile(m_pLockData);
        }
        delete m_evReadDone;
        delete m_evWriteDone;
        delete m_mtxReadWriteFlags;
    }

private:
    void CreateLockData()
    {
        TCHAR lockName[128+32];

        _tcscpy(lockName, m_lockName);
        _tcscat(lockName, _T(".mmf"));
        XHANDLE hMMF = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, lockName);
        if (!hMMF) {
            hMMF = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
                                     0, sizeof(LOCKDATA), lockName);
        }
        m_pLockData = (LOCKDATA*)MapViewOfFile(hMMF, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(LOCKDATA));
        m_pLockData->m_readers = m_pLockData->m_pending_readers = 0;
        m_pLockData->m_writers = m_pLockData->m_pending_writers = 0;
        _tcscpy(lockName, m_lockName);
        _tcscat(lockName, _T(".readDone"));
        m_evReadDone = new CEvent(TRUE,FALSE,lockName);
        _tcscpy(lockName, m_lockName);
        _tcscat(lockName, _T(".writeDone"));
        m_evWriteDone = new CEvent(TRUE,FALSE,lockName);
        _tcscpy(lockName, m_lockName);
        _tcscat(lockName, _T(".flags"));
        m_mtxReadWriteFlags = new CMutex(FALSE,lockName);
    }

public:
    BOOL ReadLock(DWORD dwTimeout=INFINITE)
    {
        DWORD dwStart = GetTickCount();
        int pend_increment=1;
        while (dwTimeout == INFINITE || (GetTickCount() - dwStart < dwTimeout)) {
            {
                CSingleLock lock(*m_mtxReadWriteFlags);
                m_pLockData->m_pending_readers += pend_increment;
                pend_increment = 0;
                if (m_pLockData->m_writers==0) {
                    m_evReadDone->Reset(); // clear read done signal
                    ++m_pLockData->m_readers;
                    --m_pLockData->m_pending_readers;
                    return TRUE;
                }
            }
            m_evWriteDone->Lock(); // wait for `write complete' signal
        }
        if (pend_increment == 0) {
            CSingleLock lock(*m_mtxReadWriteFlags);
            m_pLockData->m_pending_readers--;
        }
        return FALSE;
    }

    void ReadUnlock()
    {
        CSingleLock lock(*m_mtxReadWriteFlags);
        --m_pLockData->m_readers;
        if (m_pLockData->m_readers == 0 && m_pLockData->m_pending_writers > 0)
            m_evReadDone->Set();
    }

    BOOL WriteLock(DWORD dwTimeout=INFINITE)
    {
        DWORD dwStart = GetTickCount();
        int pend_increment=1;
        while (dwTimeout == INFINITE || (GetTickCount() - dwStart < dwTimeout)) {
            bool havereaders=0;
            {
                CSingleLock lock(*m_mtxReadWriteFlags);
                m_pLockData->m_pending_writers += pend_increment;
                pend_increment = 0;
                if (m_pLockData->m_readers==0 && m_pLockData->m_writers==0) {
                    m_evWriteDone->Reset(); // clear write done signal
                    --m_pLockData->m_pending_writers;
                    ++m_pLockData->m_writers;
                    return TRUE;
                }
                havereaders = (m_pLockData->m_readers>0);
            }
            if (havereaders)
                m_evReadDone->Lock();
            else
                m_evWriteDone->Lock();
        }
        if (pend_increment == 0) {
            CSingleLock lock(*m_mtxReadWriteFlags);
            --m_pLockData->m_pending_writers;
        }
        return FALSE;
    }

    virtual void WriteUnlock()
    {
        CSingleLock lock(*m_mtxReadWriteFlags);
        --m_pLockData->m_writers;
        if (m_pLockData->m_pending_readers != 0 || m_pLockData->m_pending_writers != 0)
            m_evWriteDone->Set();
    }

private:
    class CReadLock : public CSyncObject
    {
        virtual BOOL Lock(DWORD dwTimeout)
        {
            CMultiReadWriteLock& parent = 
                *(CMultiReadWriteLock *)((const char *)this-offsetof(CMultiReadWriteLock,m_ReadLock));
            return parent.ReadLock(dwTimeout);
        }

        virtual void Unlock()
        {
            CMultiReadWriteLock& parent = 
                *(CMultiReadWriteLock *)((const char *)this-offsetof(CMultiReadWriteLock,m_ReadLock));
            parent.ReadUnlock();
        }
    };
    friend CReadLock;

    class CWriteLock : public CSyncObject
    {
        virtual BOOL Lock(DWORD dwTimeout)
        {
            CMultiReadWriteLock& parent = 
                *(CMultiReadWriteLock *)((const char *)this-offsetof(CMultiReadWriteLock,m_WriteLock));
            return parent.WriteLock(dwTimeout);
        }

        virtual void Unlock()
        {
            CMultiReadWriteLock& parent = 
                *(CMultiReadWriteLock *)((const char *)this-offsetof(CMultiReadWriteLock,m_WriteLock));
            parent.WriteUnlock();
        }
    };
    friend CWriteLock;

public:
    CWriteLock& GetWriteLock() { return m_WriteLock; }
    CReadLock& GetReadLock() { return m_ReadLock; }

private:
    CReadLock m_ReadLock;
    CWriteLock m_WriteLock;
};

} // namespace OW32

#endif // OW32_MultiReadWriteLock_h

---