GenericPlatformAtomics.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
 
 
struct MS_ALIGN(16) FInt128 
{
    int64 Low;
    int64 High;
} 
GCC_ALIGN(16);
 
 
struct FGenericPlatformAtomics
{
#if 0   // can never use these since the actual implementation would have to be in a derived class as we are not using virtuals
        // provided here for reference
    static FORCEINLINE int32 InterlockedIncrement(volatile int32* Value)
    {
        int32 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int32*)Value, RetVal + 1, RetVal) != RetVal);
        return RetVal + 1;
    }
 
#if PLATFORM_64BITS
    static FORCEINLINE int64 InterlockedIncrement(volatile int64* Value)
    {
        int64 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int64*)Value, RetVal + 1, RetVal) != RetVal);
        return RetVal + 1;
    }
#endif
 
    static FORCEINLINE int32 InterlockedDecrement(volatile int32* Value)
    {
        int32 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int32*)Value, RetVal - 1, RetVal) != RetVal);
        return RetVal - 1;
    }
 
#if PLATFORM_64BITS
    static FORCEINLINE int64 InterlockedDecrement(volatile int64* Value)
    {
        int64 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int64*)Value, RetVal - 1, RetVal) != RetVal);
        return RetVal - 1;
    }
#endif
 
    static FORCEINLINE int32 InterlockedAdd(volatile int32* Value,int32 Amount)
    {
        int32 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int32*)Value, RetVal + Amount, RetVal) != RetVal);
        return RetVal;
    }
 
#if PLATFORM_64BITS
    static FORCEINLINE int64 InterlockedAdd(volatile int64* Value, int64 Amount)
    {
        int64 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int64*)Value, RetVal + Amount, RetVal) != RetVal);
        return RetVal;
    }
#endif
 
    static FORCEINLINE int32 InterlockedExchange(volatile int32* Value,int32 Exchange)
    {
        int32 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int32*)Value, Exchange, RetVal) != RetVal);
        return RetVal;
    }
 
#if PLATFORM_64BITS
    static FORCEINLINE int64 InterlockedExchange (volatile int64* Value, int64 Exchange)
    {
        int64 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int64*)Value, Exchange, RetVal) != RetVal);
        return RetVal;
    }
#endif
 
    static FORCEINLINE void* InterlockedExchangePtr( void*volatile* Dest, void* Exchange )
    {
#if PLATFORM_64BITS
        #error must implement
#else
        InterlockedExchange((int32*)Dest, (int32)Exchange);
#endif
    }
 
    static FORCEINLINE int8 InterlockedCompareExchange(volatile int8* Dest,int8 Exchange,int8 Comparand)
    {
        #error must implement
    }
 
    static FORCEINLINE int16 InterlockedCompareExchange(volatile int16* Dest,int16 Exchange,int16 Comparand)
    {
        #error must implement
    }
 
    static FORCEINLINE int32 InterlockedCompareExchange(volatile int32* Dest,int32 Exchange,int32 Comparand)
    {
        #error must implement
    }
 
    static FORCEINLINE int64 InterlockedCompareExchange (volatile int64* Dest, int64 Exchange, int64 Comparand)
    {
        #error must implement
    }
 
    static FORCEINLINE int32 InterlockedAnd(volatile int32* Value, const int32 AndValue)
    {
        int32 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int32*)Value, RetVal & AndValue, RetVal) != RetVal);
        return RetVal;
    }
 
    static FORCEINLINE int32 InterlockedOr(volatile int32* Value, const int32 OrValue)
    {
        int32 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int32*)Value, RetVal | OrValue, RetVal) != RetVal);
        return RetVal;
    }
 
    static FORCEINLINE int32 InterlockedXor(volatile int32* Value, const int32 XorValue)
    {
        int32 RetVal;
        do
        {
            RetVal = *Value;
        } while (InterlockedCompareExchange((int32*)Value, RetVal ^ XorValue, RetVal) != RetVal);
        return RetVal;
    }
 
    static FORCEINLINE int8 AtomicRead(volatile const int8* Src)
    {
        return InterlockedCompareExchange((volatile int8*)Src, 0, 0);
    }
 
    static FORCEINLINE int16 AtomicRead(volatile const int16* Src)
    {
        return InterlockedCompareExchange((volatile int16*)Src, 0, 0);
    }
 
    static FORCEINLINE int32 AtomicRead(volatile const int32* Src)
    {
        return InterlockedCompareExchange((volatile int32*)Src, 0, 0);
    }
 
    static FORCEINLINE int64 AtomicRead(volatile const int64* Src)
    {
        return InterlockedCompareExchange((volatile int64*)Src, 0, 0);
    }
 
    static FORCEINLINE void* InterlockedCompareExchangePointer(void*volatile* Dest,void* Exchange,void* Comperand)
    {
#if PLATFORM_64BITS
        #error must implement
#else
        InterlockedCompareExchange((int32*)Dest, (int32)Exchange, (int32)Comperand);
#endif
    }
 
#if PLATFORM_HAS_128BIT_ATOMICS
    static FORCEINLINE bool InterlockedCompareExchange128( volatile FInt128* Dest, const FInt128& Exchange, FInt128* Comparand )
    {
        #error Must implement
    }
 
    static FORCEINLINE void AtomicRead128(const volatile FInt128* Src, FInt128* OutResult)
    {
        FInt128 Zero;
        Zero.High = 0;
        Zero.Low = 0;
        *OutResult = Zero;
        InterlockedCompareExchange128((volatile FInt128*)Src, Zero, OutResult);
    }
#endif // PLATFORM_HAS_128BIT_ATOMICS
 
#endif // 0
 
 
    static FORCEINLINE bool CanUseCompareExchange128()
    {
        return false;
    }
 
protected:
    static inline bool IsAligned( const volatile void* Ptr, const uint32 Alignment = sizeof(void*) )
    {
        return !(PTRINT(Ptr) & (Alignment - 1));
    }
};