MallocCallstackHandler.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "CoreTypes.h"
#include "HAL/CriticalSection.h"
#include "HAL/MemoryBase.h"
#include "HAL/PlatformTLS.h"
#include "Misc/Crc.h"
 
struct FGenericMemoryStats;
 
class FMallocCallstackHandler : public FMalloc
{
public:
    CORE_API FMallocCallstackHandler(FMalloc* InMalloc);
 
    CORE_API virtual void* Malloc(SIZE_T Count, uint32 Alignment = DEFAULT_ALIGNMENT) override;
 
    CORE_API virtual void* Realloc(void* Original, SIZE_T Count, uint32 Alignment = DEFAULT_ALIGNMENT)  override;
 
    CORE_API virtual void Free(void* Original) override;
 
    virtual SIZE_T QuantizeSize(SIZE_T Count, uint32 Alignment)  override
    {
        return UsedMalloc->QuantizeSize(Count, Alignment);
    }
 
    virtual bool GetAllocationSize(void *Original, SIZE_T &SizeOut)  override
    {
        return UsedMalloc->GetAllocationSize(Original, SizeOut);
    }
 
    virtual void Trim(bool bTrimThreadCaches) override
    {
        UsedMalloc->Trim(bTrimThreadCaches);
    }
 
    virtual void SetupTLSCachesOnCurrentThread() override
    {
        UsedMalloc->SetupTLSCachesOnCurrentThread();
    }
 
    virtual void MarkTLSCachesAsUsedOnCurrentThread() override
    {
        UsedMalloc->MarkTLSCachesAsUsedOnCurrentThread();
    }
 
    virtual void MarkTLSCachesAsUnusedOnCurrentThread()
    {
        UsedMalloc->MarkTLSCachesAsUnusedOnCurrentThread();
    }
 
    virtual void ClearAndDisableTLSCachesOnCurrentThread() override
    {
        UsedMalloc->ClearAndDisableTLSCachesOnCurrentThread();
    }
 
    virtual void InitializeStatsMetadata() override
    {
        UsedMalloc->InitializeStatsMetadata();
    }
 
    virtual void UpdateStats() override
    {
        UsedMalloc->UpdateStats();
    }
 
    virtual void GetAllocatorStats(FGenericMemoryStats& out_Stats) override
    {
        UsedMalloc->GetAllocatorStats(out_Stats);
    }
 
    virtual void DumpAllocatorStats(class FOutputDevice& Ar) override
    {
        UsedMalloc->DumpAllocatorStats(Ar);
    }
 
    virtual bool IsInternallyThreadSafe() const override
    {
        return true;
    }
 
    virtual bool ValidateHeap() override
    {
        return UsedMalloc->ValidateHeap();
    }
 
    virtual const TCHAR* GetDescriptiveName() override
    {
        return UsedMalloc->GetDescriptiveName();
    }
        
    virtual void OnMallocInitialized() override
    {
        UsedMalloc->OnMallocInitialized();
    }
 
    virtual void OnPreFork() override
    {
        UsedMalloc->OnPreFork();
    }
 
    virtual void OnPostFork() override
    {
        UsedMalloc->OnPostFork();
    }
 
    static constexpr inline SIZE_T MaxCallStackDepth = 64;
    static constexpr inline SIZE_T CallStackEntriesToSkipCount = 2;
 
    struct FCallStackInfo
    {
        uint32 Count;
        uint64 FramePointers[MaxCallStackDepth];
    };
 
    struct FCallStackMapKey
    {
        uint32 CRC;
        uint64* CallStack;
 
        FCallStackMapKey(uint64* InCallStack)
            : CallStack(InCallStack)
        {
            CRC = FCrc::MemCrc32(InCallStack, MaxCallStackDepth * sizeof(uint64));
        }
 
        friend bool operator==(const FCallStackMapKey& A, const FCallStackMapKey& B)
        {
            if (A.CRC != B.CRC)
            {
                return false;
            }
            for (int i = 0; i < MaxCallStackDepth; ++i)
            {
                uint64 APtr = A.CallStack[i];
                uint64 BPtr = B.CallStack[i];
                if (APtr != BPtr)
                {
                    return false;
                }
                if (APtr == 0)
                    break;
            }
            return true;
        }
 
        friend inline uint32 GetTypeHash(const FCallStackMapKey& InKey)
        {
            return InKey.CRC;
        }
    };
 
    virtual void Init();
    void DumpStackTraceToLog(int32 StackIndex);
 
    friend class FScopeDisableMallocCallstackHandler;
 
protected:
    FMalloc* UsedMalloc;
    bool Initialized;
    FCriticalSection CriticalSection;
    uint32 DisabledTLS;
 
    inline void IncDisabled()
    {
        uint64_t DisabledCount = (uint64_t)FPlatformTLS::GetTlsValue(DisabledTLS);
        ++DisabledCount;
        FPlatformTLS::SetTlsValue(DisabledTLS, (void*)DisabledCount);
    }
 
    inline void DecDisabled()
    {
        uint64_t DisabledCount = (uint64_t)FPlatformTLS::GetTlsValue(DisabledTLS);
        --DisabledCount;
        FPlatformTLS::SetTlsValue(DisabledTLS, (void*)DisabledCount);
    }
    virtual bool IsDisabled()
    {
        return FPlatformTLS::GetTlsValue(DisabledTLS) != 0;
    }
 
    CORE_API virtual void TrackRealloc(void* OldPtr, void* NewPtr, uint32 NewSize, uint32 OldSize, int32 CallStackIndex);
    virtual void TrackMalloc(void* Ptr, uint32 Size, int32 CallStackIndex) = 0;
    virtual void TrackFree(void* Ptr, uint32 OldSize, int32 CallStackIndex) = 0;
 
    FRWLock RWLock;
 
    TMap<FCallStackMapKey, int32> CallStackMapKeyToCallStackIndexMap;
    TArray<FCallStackInfo> CallStackInfoArray;
 
    virtual int32 GetCallStackIndex();
};
 
extern CORE_API FMallocCallstackHandler* GMallocCallstackHandler;
 
class FScopeDisableMallocCallstackHandler
{
public:
 
    FScopeDisableMallocCallstackHandler()
    {
        GMallocCallstackHandler->IncDisabled();
    }
 
    ~FScopeDisableMallocCallstackHandler()
    {
        GMallocCallstackHandler->DecDisabled();
    }
};