SF_Atomic.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

/**************************************************************************

PublicHeader:   None
Filename    :   KY_Atomic.h
Content     :   Contains atomic operations and inline fastest locking
                functionality. Will contain #ifdefs for OS efficiency.
                Have non-thread-safe implementaion if not available.
Created     :   May 5, 2003
Authors     :   Michael Antonov, Andrew Reisse

**************************************************************************/

#pragma once

#include "gwnavruntime/kernel/SF_Types.h"
#include <atomic>
#include <mutex>

namespace Kaim {

// Lock is a simplest and most efficient mutual-exclusion lock class. Unlike Mutex, it cannot be waited on.
class Lock
{
    // NOTE: Locks are not allocatable and they themselves should not allocate memory by standard means. This is the case because StandardAllocator relies on this class.
    // Make 'delete' private. Don't do this for 'new' since it can be redefined.
    void operator delete(void*) {}

    std::recursive_mutex mutex;
public:
    Lock(/*unsigned spinCount = 0*/) {}
    ~Lock() {}
    void DoLock() { mutex.lock(); }
    void Unlock() { mutex.unlock(); }

public:
    // Locker class, used for automatic locking
    class Locker
    {
    public:
        Lock *lock;
        inline Locker(Lock *plock) { lock = plock; lock->DoLock(); }
        inline ~Locker() { lock->Unlock(); }
    };
};


// Safe lock for defensive design with assertion. Also contains temporary unlocker.
//-------------------------------------------
class LockSafe
{
public:
    LockSafe(/*unsigned spinCount = 0*/) : mLock(/*spinCount*/)
#ifdef KY_CONFIG_DEBUG
        , LockCount(0)
#endif
    {}

    void DoLock()
    {
#ifdef KY_CONFIG_DEBUG
        LockCount++;
#endif
        mLock.DoLock();
    }

    void Unlock()
    {
        mLock.Unlock();
#ifdef KY_CONFIG_DEBUG
        KY_ASSERT(LockCount.fetch_add(-1) > 0);
#endif
    }

#ifdef KY_CONFIG_DEBUG
    bool IsLocked() const
    {
        return LockCount != 0;
    }
#endif

    class Locker
    {
    public:
        LockSafe *pLock;
        Locker(LockSafe *lock)
        {
            pLock = lock;
            pLock->DoLock();
        }
        ~Locker()
        {
            pLock->Unlock();
        }
    };

    class TmpUnlocker
    {
    public:
        LockSafe *pLock;
        TmpUnlocker(LockSafe *lock)
        {
            pLock = lock;
            pLock->Unlock();
        }
        ~TmpUnlocker()
        {
            pLock->DoLock();
        }
    };


private:
    Lock mLock;
#ifdef KY_CONFIG_DEBUG
    std::atomic<int> LockCount;
#endif
};

}