TripleBufferedData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Templates/Atomic.h"
#include "Templates/SharedPointer.h"
 
namespace Chaos
{
    template <class DataType>
    class TTripleBufferedData
    {
    public:
        TTripleBufferedData()
            : ProducerThreadBuffer(&Buffers[0])
            , ConsumerThreadBuffer(&Buffers[1])
            , Interchange(&Buffers[2])
            , Counter(0)
            , LastId(0)
        {}
 
        DataType* ExchangeProducerBuffer()
        {
            ProducerThreadBuffer = Interchange.Exchange(ProducerThreadBuffer);
            if (!ProducerThreadBuffer->Value)
            {
                ProducerThreadBuffer->Value = TUniquePtr<DataType>(new DataType());
            }
            ProducerThreadBuffer->Id = ++Counter; // First value is 1, will overflow.
            return ProducerThreadBuffer->Value.Get();
        }
 
        DataType* ExchangeConsumerBuffer()
        {
            ConsumerThreadBuffer = Interchange.Exchange(ConsumerThreadBuffer);
            if (ConsumerThreadBuffer->Id <= LastId && 
                LastId - ConsumerThreadBuffer->Id < TNumericLimits<uint32>::Max()) // Detect overflows
            {
                return nullptr;
            }
            LastId = ConsumerThreadBuffer->Id;
            return ConsumerThreadBuffer->Value.Get();
        }
 
    private:
        // Non-copyable and non-movable, due to TAtomic member.
        TTripleBufferedData(TTripleBufferedData&& Other) = delete;
        TTripleBufferedData(const TTripleBufferedData&) = delete;
        TTripleBufferedData& operator=(TTripleBufferedData&&) = delete;
        TTripleBufferedData& operator=(const TTripleBufferedData&) = delete;
 
        struct DataTypeWrapper
        {
            DataTypeWrapper()
              : Value(nullptr)
              , Id(0)
            {}
            DataTypeWrapper(const DataTypeWrapper&) = delete;
            DataTypeWrapper(DataTypeWrapper&& Other)
                : Value(MoveTemp(Other.Value))
                , Id(MoveTemp(Other.Id))
            {}
 
            void operator=(const DataTypeWrapper& Other) = delete;
 
            // Depending on the use case, it may be useful to store DataType 
            // instances via shared pointer so that the thread that doesn't
            // own the TripleBufferedData instance, can retain ownership of 
            // this memory after this class goes out of scope.
            TUniquePtr<DataType> Value;
            uint64 Id;
        };
 
        DataTypeWrapper Buffers[3] = { DataTypeWrapper(), DataTypeWrapper(), DataTypeWrapper() };
        DataTypeWrapper* ProducerThreadBuffer;
        DataTypeWrapper* ConsumerThreadBuffer;
        TAtomic<DataTypeWrapper*> Interchange;
        uint64 Counter; // Only accessed by producer thread
        uint64 LastId; // Only accessed by consumer thread
    };
} // namespace Chaos