MemoryBase.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/PlatformCrt.h"
#include "Misc/Exec.h"
#include "Misc/OutputDevice.h"
#include "Templates/Atomic.h"
 
class UWorld;
template <typename T> class TAtomic;
 
#ifndef UPDATE_MALLOC_STATS
    #define UPDATE_MALLOC_STATS 1
#endif
 
enum
{
    // Default allocator alignment. If the default is specified, the allocator applies to engine rules.
    // Blocks >= 16 bytes will be 16-byte-aligned, Blocks < 16 will be 8-byte aligned. If the allocator does
    // not support allocation alignment, the alignment will be ignored.
    DEFAULT_ALIGNMENT = 0,
 
    // Minimum allocator alignment
    MIN_ALIGNMENT = 8,
};
 
    
namespace UE::Private
{
    CORE_API extern TSAN_ATOMIC(class FMalloc*) GMalloc;
}
 
UE_DEPRECATED(5.6, "Consider using FMemory::Malloc instead of accessing GMalloc directly.")
CORE_API extern class FMalloc* const& GMalloc;
 
CORE_API extern class FMalloc** GFixedMallocLocationPtr;
 
struct FGenericMemoryStats;
 
 
class FUseSystemMallocForNew
{
public:
    CORE_API void* operator new(size_t Size);
 
    CORE_API void operator delete(void* Ptr);
 
    void* operator new[](size_t Size);
 
    void operator delete[](void* Ptr);
};
 
class FMalloc  : 
    public FUseSystemMallocForNew,
    public FExec
{
public:
    virtual void* Malloc( SIZE_T Count, uint32 Alignment=DEFAULT_ALIGNMENT ) = 0;
 
    CORE_API virtual void* TryMalloc( SIZE_T Count, uint32 Alignment=DEFAULT_ALIGNMENT );
 
    virtual void* Realloc( void* Original, SIZE_T Count, uint32 Alignment=DEFAULT_ALIGNMENT ) = 0;
 
    CORE_API virtual void* TryRealloc(void* Original, SIZE_T Count, uint32 Alignment=DEFAULT_ALIGNMENT);
 
    virtual void Free( void* Original ) = 0;
 
    CORE_API virtual void* MallocZeroed(SIZE_T Count, uint32 Alignment = DEFAULT_ALIGNMENT);
 
    CORE_API virtual void* TryMallocZeroed(SIZE_T Count, uint32 Alignment = DEFAULT_ALIGNMENT);
        
    virtual SIZE_T QuantizeSize(SIZE_T Count, uint32 Alignment)
    {
        return Count; // Default implementation has no way of determining this
    }
 
    virtual bool GetAllocationSize(void *Original, SIZE_T &SizeOut)
    {
        return false; // Default implementation has no way of determining this
    }
 
    virtual void Trim(bool bTrimThreadCaches)
    {
    }
 
    virtual void SetupTLSCachesOnCurrentThread()
    {
    }
 
    virtual void MarkTLSCachesAsUsedOnCurrentThread()
    {
    }
 
    virtual void MarkTLSCachesAsUnusedOnCurrentThread()
    {
    }
 
    virtual void ClearAndDisableTLSCachesOnCurrentThread()
    {
    }
 
    CORE_API virtual void InitializeStatsMetadata();
 
#if UE_ALLOW_EXEC_COMMANDS
    virtual bool Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar ) override
    { 
        return false; 
    }
#endif // UE_ALLOW_EXEC_COMMANDS
 
    CORE_API virtual void UpdateStats();
 
    CORE_API virtual void GetAllocatorStats( FGenericMemoryStats& out_Stats );
 
    virtual void DumpAllocatorStats( class FOutputDevice& Ar )
    {
        Ar.Logf( TEXT("Allocator Stats for %s: (not implemented)" ), GetDescriptiveName() );
    }
 
    virtual bool IsInternallyThreadSafe() const 
    { 
        return false; 
    }
 
    virtual bool ValidateHeap()
    {
        return( true );
    }
 
    virtual const TCHAR* GetDescriptiveName()
    {
        return TEXT("Unspecified allocator");
    }
 
    virtual void OnMallocInitialized() {}
 
    virtual void OnPreFork() {}
 
    virtual void OnPostFork() {}
 
    virtual uint64 GetImmediatelyFreeableCachedMemorySize() const
    {
        return 0;
    }
 
    virtual uint64 GetTotalFreeCachedMemorySize() const
    {
        return 0;
    }
 
protected:
    friend struct FCurrentFrameCalls;
 
#if !UE_BUILD_SHIPPING
public:
    static CORE_API TAtomic<uint64> MaxSingleAlloc;
#endif
};