Locks.h

Go to the documentation of this file.

//Luke Lenhart, 2007
//See /docs/License.txt for details on how this code may be used.

#include "Types.h"
#include "ReferenceCount.h"

#include <set>

#ifndef LOCKS_H_INCLUDED
#define LOCKS_H_INCLUDED

namespace MPMA
{

    //  -- Atomic Operations safe for multiprocessor operations

    void AtomicIntInc(volatile nuint *pint);

    void AtomicIntDec(volatile nuint *pint);

    nsint AtomicIntAdd(volatile nsint *pint, nsint addValue);

    bool AtomicCompareExchange(volatile nuint *pInt, nuint expectedValue, nuint newValue, volatile nuint &outResultValue);


    // -- Locking constructs

    //used by MutexLock
    struct InternalMutexLockData
    {
        void *crit;
    };

    class MutexLock: public ReferenceCountedData<InternalMutexLockData>
    {
    public:
        MutexLock();
        ~MutexLock();

        friend class TakeMutexLock;
    };

    class TakeMutexLock
    {
    public:
        TakeMutexLock(MutexLock &critSection, bool takeNow=true);
        ~TakeMutexLock();

        void Take();
        void Leave();

    private:
        MutexLock crit;
        bool taken;

        //you cannot duplicate this
        TakeMutexLock(const TakeMutexLock&);
        const TakeMutexLock& operator=(const TakeMutexLock&);
    };


    //used by SpinLock
    struct InternalSpinLockData
    {
        volatile nuint taken;
        bool collision;

        inline InternalSpinLockData(): taken(0), collision(false)
            {}
    };

    class SpinLock: public ReferenceCountedData<InternalSpinLockData>
    {
        friend class TakeSpinLock;
    };

    class TakeSpinLock
    {
    public:
        inline TakeSpinLock(SpinLock &slock, bool takeNow=true): locker(slock), taken(false)
            { if (takeNow) Take(); }
        inline ~TakeSpinLock()
            { Leave(); }

        inline void Take();
        inline void Leave();

    private:
        SpinLock locker;
        bool taken;

        //you cannot duplicate this
        TakeSpinLock(const TakeSpinLock&);
        const TakeSpinLock& operator=(const TakeSpinLock&);
    };

    //used by RWSleepLock
    struct InternalRWSleepLockData
    {
        volatile nuint readerCount;
        volatile nuint writerCount;

        std::multiset<nuint> readerThreadList;
        std::multiset<nuint> writerThreadList;
        SpinLock threadListLock;

        inline InternalRWSleepLockData(): readerCount(0), writerCount(0)
            {}
    };

    class RWSleepLock: public ReferenceCountedData<InternalRWSleepLockData>
    {
    public:
        friend class TakeRWSleepLock;
    };

    class TakeRWSleepLock
    {
    public:
        TakeRWSleepLock(RWSleepLock &rwsLock, bool writeAccessIfTakenNow=true, bool takeNow=true);
        ~TakeRWSleepLock();

        void TakeWrite();
        void LeaveWrite();

        void TakeRead();
        void LeaveRead();

    private:
        RWSleepLock lock;

        bool hasRead, hasWrite;

        //you cannot duplicate this
        TakeRWSleepLock(const TakeRWSleepLock&);
        const TakeRWSleepLock& operator=(const TakeRWSleepLock&);
    };

    // -- Signal-based blocking constructs

    struct InternalBlockingObjectData
    {
        InternalBlockingObjectData();
        ~InternalBlockingObjectData();

        volatile int clearCount;
        volatile bool isSet;
        void *pdata; //platform-specific container
    };

    class BlockingObject: public ReferenceCountedData<InternalBlockingObjectData>
    {
    public:
        void Clear();

        void Set();

        bool WaitUntilClear(bool setOnReturn=false, nuint timeToWait=0xffffffff);
    };

} //namespace MPMA

//include the templated and inline code
#ifndef LOCKS_INCLUDE_INLINE
    #define LOCKS_INCLUDE_INLINE
    #include "Locks.cpp"
#endif

//include the platform-specific headers
#if defined(_WIN32) || defined(_WIN64)
    #include "win32/LocksWin32.h"
#else
    #include "linux/LocksLin32.h"
#endif

#endif //LOCKS_H_INCLUDED