MTLock.h

Go to the documentation of this file.

#ifndef MTLOCK_H
#define MTLOCK_H


#ifdef WIN32
    #include <windows.h>

    //#define USE_CRITICAL_SECTIONS
        // Critical sections are faster, but cannot be used to synchronize activity
        // across different processes/DLLs.
#endif

#include <map>


namespace vrecko {


#ifdef VRECKO_LIBRARY
    #define MTLOCK_IMP_EXP __declspec(dllexport)
#else
    #define MTLOCK_IMP_EXP __declspec(dllimport)
#endif



#if 0


    // "COPTex" version.
    // As fast as a critical section, but can be used for inter-process synchronization.
    // http://www.microsoft.com/msj/0198/win32textfigs.htm#fig2
    class MTLOCK_IMP_EXP MTLock {
    public:
        MTLock();
        ~MTLock();

        bool lock();
        void unlock();

    protected:

        void SetSpinCount(DWORD dwSpinCount);
        BOOL TryEnter();

        typedef struct {
           volatile DWORD m_dwSpinCount;
           volatile long  m_lLockCount;
           volatile DWORD m_dwThreadId;
           volatile long  m_lRecurseCount;
        } SHAREDINFO, *PSHAREDINFO;
     
        BOOL        m_fUniprocessorHost;
        HANDLE      m_hevt;
        HANDLE      m_hfm;
        volatile PSHAREDINFO m_pSharedInfo;
     
        BOOL CommonConstructor(PVOID pszName, BOOL fUnicode, DWORD dwSpinCount);
    };

    typedef MTLock MTLockSingleProcess;

#else


class MTLOCK_IMP_EXP MTLock {
public:
    MTLock();
    ~MTLock();

    bool lock();
    void unlock();

    HANDLE getHandle() const { return mutex; }

protected:

#ifdef WIN32
    HANDLE mutex; 
#else
    pthread_mutex_t *mutex;
#endif
};


class MTLOCK_IMP_EXP MTAutoLock {
public:
    MTAutoLock(MTLock *lockToLock) { theLock = lockToLock; lockToLock->lock(); };
    ~MTAutoLock() { theLock->unlock(); }
protected:
    MTLock* theLock;
};

#ifdef WIN32

    class MTLOCK_IMP_EXP MTLockSingleProcess {
    public:
        MTLockSingleProcess();
        ~MTLockSingleProcess();

        bool lock();
        void unlock();

    protected:
        CRITICAL_SECTION criticalSection;
    };
#else
    typedef MTLock MTLockSingleProcess;
#endif


#endif


class MTLOCK_IMP_EXP MTReadWriteLock
{
protected:
    HANDLE m_Access;
    int    m_Readers;
    HANDLE m_WriterMutex;
    HANDLE m_CanRead;
    HANDLE m_CanWrite;

public:
    MTReadWriteLock();
    ~MTReadWriteLock();
    
    bool lockRead( DWORD Timeout = INFINITE );
    bool lockWrite( DWORD Timeout = INFINITE );
    void unlockRead( DWORD Timeout = INFINITE );
    void unlockWrite( DWORD Timeout = INFINITE );
};


class MTLOCK_IMP_EXP MTReadWriteLockEx {
    struct KThreadInfo {
        int ReadCount;
        int WriteCount;

        bool IsReader() { return ReadCount > 0; };
        bool IsWriter() { return WriteCount > 0; };
    };

    typedef std::map<DWORD, KThreadInfo> KThreadMap;
    KThreadMap m_Threads;

    // Number of reader threads; 
    // Note: writer threads are not reader threads, even if they have read locks
    int m_TotalReaderThreads; 
    int m_TotalWriterThreads; // current writer + waiting writers

    HANDLE m_Access;
    HANDLE m_WriterMutex;
    HANDLE m_CanRead;
    HANDLE m_CanWrite;

    void incReaders()
        {
            ++m_TotalReaderThreads;
            ResetEvent(m_CanWrite);
        };

    void decReaders()
        {
            if (--m_TotalReaderThreads == 0)
                SetEvent(m_CanWrite);
        };

    void incWriters()
        {
            ++m_TotalWriterThreads;
            ResetEvent(m_CanRead);
        };

    void decWriters()
        {
            if (--m_TotalWriterThreads == 0)
                SetEvent(m_CanRead);
        };

public:
    MTReadWriteLockEx();
    ~MTReadWriteLockEx();
    
    bool lockRead( DWORD Timeout = INFINITE );
    bool lockWrite( DWORD Timeout = INFINITE );
    void unlockRead( DWORD Timeout = INFINITE );
    void unlockWrite( DWORD Timeout = INFINITE );

};


// Design by Vit Kovalcik.
// Lock with two priorities. The higher one will not starve.
// Only a single thread can acquire the lock (i.e. no simultaneous high + low threads).
// WARNING - LIMITATION: The high priority part can be used only in a single thread.
//    Usage in two or more threads will result in an unexpected behaviour.
class MTLOCK_IMP_EXP MTTwoPrioLimitedLock {
protected:
    HANDLE m_AllowLowPrio;
    HANDLE m_Access;
    HANDLE m_WritersMutex;
public:
    MTTwoPrioLimitedLock();
    ~MTTwoPrioLimitedLock();

    // WARNING: lockHigh()/unlockHigh() sequence can be used only in one thread (at the same time)
    bool lockHigh();
    void unlockHigh();

    bool lockLow();
    void unlockLow();
};


};

#endif