TripleBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "HAL/PlatformAtomics.h"
#include "HAL/PlatformMisc.h"
 
template<typename BufferType>
class TTripleBuffer
{
    enum EBufferFlag
    {
        Dirty = 0x40,
 
        Initial = 0x06,
 
        ReaderMask = 0x03,
 
        TempMask = 0x30,
 
        TempShift = 4,
 
        WriterMask = 0x0c,
 
        WriterShift = 2,
    };
 
public:
 
    [[nodiscard]] TTripleBuffer()
    {
        Initialize();
        Buffers[0] = Buffers[1] = Buffers[2] = BufferType();
    }
 
    [[nodiscard]] explicit TTripleBuffer(ENoInit)
    {
        Initialize();
    }
 
    [[nodiscard]] explicit TTripleBuffer(const BufferType& InValue)
    {
        Initialize();
        Buffers[0] = Buffers[1] = Buffers[2] = InValue;
    }
 
    [[nodiscard]] TTripleBuffer(BufferType (&InBuffers)[3])
    {
        Buffers = &InBuffers[0];
        Flags = EBufferFlag::Initial | EBufferFlag::Dirty;
        OwnsMemory = false;
    }
 
    ~TTripleBuffer()
    {
        if (OwnsMemory)
        {
            delete[] Buffers;
        }
    }
 
public:
 
    [[nodiscard]] bool IsDirty() const
    {
        return ((Flags & EBufferFlag::Dirty) != 0);
    }
 
    [[nodiscard]] BufferType& Read()
    {
        return Buffers[Flags & EBufferFlag::ReaderMask];
    }
 
    void SwapReadBuffers()
    {
        if (!IsDirty())
        {
            return;
        }
 
        int32 CurrentFlags = 0;
 
        do
        {
            CurrentFlags = Flags;
        }
        while (FPlatformAtomics::InterlockedCompareExchange(&Flags, SwapReadWithTempFlags(CurrentFlags), CurrentFlags) != CurrentFlags);
    }
 
public:
 
    [[nodiscard]] BufferType& GetWriteBuffer()
    {
        return Buffers[(Flags & EBufferFlag::WriterMask) >> EBufferFlag::WriterShift];
    }
 
    void SwapWriteBuffers()
    {
        int32 CurrentFlags = 0;
 
        do
        {
            CurrentFlags = Flags;
        }
        while (FPlatformAtomics::InterlockedCompareExchange(&Flags, SwapWriteWithTempFlags(CurrentFlags), CurrentFlags) != CurrentFlags);
    }
 
    void Write(const BufferType Value)
    {
        Buffers[(Flags & EBufferFlag::WriterMask) >> EBufferFlag::WriterShift] = Value;
    }
 
public:
 
    void Reset()
    {
        Flags = EBufferFlag::Initial;
        FPlatformMisc::MemoryBarrier();
    }
 
    [[nodiscard]] const BufferType& SwapAndRead()
    {
        SwapReadBuffers();
        return Read();
    }
 
    void WriteAndSwap(const BufferType Value)
    {
        Write(Value);
        SwapWriteBuffers();
    }
 
protected:
 
    void Initialize()
    {
        Buffers = new BufferType[3];
        Flags = EBufferFlag::Initial;
        OwnsMemory = true;
    }
 
private:
 
    [[nodiscard]] static UE_FORCEINLINE_HINT int32 SwapReadWithTempFlags(int32 Flags)
    {
        return ((Flags & EBufferFlag::ReaderMask) << 4) | ((Flags & EBufferFlag::TempMask) >> 4) | (Flags & EBufferFlag::WriterMask);
    }
 
    [[nodiscard]] static UE_FORCEINLINE_HINT int32 SwapWriteWithTempFlags(int32 Flags)
    {
        return ((Flags & EBufferFlag::TempMask) >> 2) | ((Flags & EBufferFlag::WriterMask) << 2) | (Flags & EBufferFlag::ReaderMask) | EBufferFlag::Dirty;
    }
 
private:
 
    TTripleBuffer(const TTripleBuffer&);
 
    TTripleBuffer& operator=(const TTripleBuffer&);
 
private:
 
    BufferType* Buffers;
 
    MS_ALIGN(16) int32 volatile Flags GCC_ALIGN(16);
 
    bool OwnsMemory;
};