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"

#ifndef LOCKS_H_INCLUDED
#define LOCKS_H_INCLUDED

namespace MPMA
{

    //  -- Atomic Operations safe for multiprocessor operations

    void AtomicIntInc(volatile uint *pint);

    void AtomicIntDec(volatile uint *pint);

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

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


    // -- Locking constructs

    class RWSleepLock
    {
        friend class TakeRWSleepLock;

    public:
        RWSleepLock();
        ~RWSleepLock();

    protected:
        uint cntRead, cntWrite; //lock count for read/write access
        uint cntWritePend, cntReadPend; //pending access counter

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

    class TakeRWSleepLock
    {
    public:
        inline TakeRWSleepLock(RWSleepLock &rwsSection, bool writeAccess=true, bool takeNow=true): crit((RWSleepLock&)rwsSection), meIn(false)
            {if (takeNow) Take(writeAccess); }
        inline ~TakeRWSleepLock()
            {  if (meIn) Leave(); }

        void Take(bool writeAccess);
        void Leave();

    private:
        mutable RWSleepLock &crit;

        bool meIn;
        bool meWrite;

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


    class MutexLock
    {
        friend class TakeMutexLock;

    public:
        MutexLock();
        ~MutexLock();

    protected:
        void *crit;
        bool isMemManaged; //special case, since memory manager uses us

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

    class TakeMutexLock
    {
    public:
        TakeMutexLock(MutexLock &critSection);
        ~TakeMutexLock();

    private:
        MutexLock &crit;

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


    class SpinLock
    {
        friend class TakeSpinLock;
    protected:
        volatile uint taken;
        bool collision;
    public:
        inline SpinLock(): taken(0), collision(false) {}

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

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

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

    private:
        SpinLock &locker;
        bool taken;

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


    // -- Signal-based blocking constructs

    class BlockingObject
    {
    public:
        BlockingObject();
        ~BlockingObject();

        void Clear();

        void Set();

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

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

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

} //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
#ifdef WIN32
    #include "win32/LocksWin32.h"
#else
    #include "linux/LocksLin32.h"
#endif

#endif //LOCKS_H_INCLUDED