tracktion_LockFreeObject.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
#pragma once
 
namespace tracktion { inline namespace graph
{
 
//==============================================================================
//==============================================================================
template<typename ObjectType>
class LockFreeObject
{
public:
    LockFreeObject()
    {
        static_assert (std::is_default_constructible_v<ObjectType>);
        static_assert (std::is_nothrow_move_assignable_v<ObjectType>);
    }
 
    void clear()
    {
        // Obtain the locks for both the objects
        std::scoped_lock sl (clearObjectsMutex);
        std::scoped_lock sl2 (pushingObjectMutex);
 
        pendingObjectStorage = {};
        objectStorage = {};
 
        pendingObject = nullptr;
    }
 
    void pushNonRealTime (ObjectType&& newObj)
    {
        // Obtain the lock on the pending object
        std::scoped_lock sl (pushingObjectMutex);
 
        pendingObjectStorage = std::move (newObj);
        pendingObject = &pendingObjectStorage;
    }
 
    ObjectType* retainRealTime()
    {
        if (clearObjectsMutex.try_lock())
        {
            needToUnlockClearObjectsMutex = true;
        }
        else
        {
            needToUnlockClearObjectsMutex = false;
            return nullptr;
        }
 
        // If we get the lock, we can update
        if (pushingObjectMutex.try_lock())
        {
            needToUnlockPushingObjectMutex = true;
 
            // Move any penidng object in to the main objectStorage
            if (auto newObject = pendingObject.exchange (nullptr))
                std::swap (objectStorage, *newObject);
        }
        else
        {
            needToUnlockPushingObjectMutex = false;
        }
 
        // Then return the main stored object
        return &objectStorage;
    }
 
    void releaseRealTime()
    {
        if (needToUnlockClearObjectsMutex)
            clearObjectsMutex.unlock();
 
        if (needToUnlockPushingObjectMutex)
            pushingObjectMutex.unlock();
    }
 
    //==============================================================================
    class ScopedRealTimeAccess
    {
    public:
        ScopedRealTimeAccess (LockFreeObject& lfo)
            : lockFreeObject (lfo)
        {}
 
        ~ScopedRealTimeAccess()
        {
            lockFreeObject.releaseRealTime();
        }
 
        ObjectType* get() const
        {
            return object;
        }
 
    private:
        LockFreeObject& lockFreeObject;
        ObjectType* object { lockFreeObject.retainRealTime() };
    };
 
    ScopedRealTimeAccess getScopedAccess()
    {
        return ScopedRealTimeAccess { *this };
    }
 
private:
    ObjectType objectStorage, pendingObjectStorage;
    std::atomic<ObjectType*> pendingObject { nullptr };
    RealTimeSpinLock pushingObjectMutex, clearObjectsMutex;
    bool needToUnlockPushingObjectMutex = false, needToUnlockClearObjectsMutex = true;
};
 
}} // namespace tracktion_engine