MallocLeakDetection.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    MallocLeakDetection.h: Helper class to track memory allocations
=============================================================================*/
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "HAL/MemoryBase.h"
#include "HAL/ThreadSafeBool.h"
#include "HAL/UnrealMemory.h"
#include "Hash/CityHash.h"
#include "Misc/Crc.h"
#include "Misc/ScopeLock.h"
 
#ifndef MALLOC_LEAKDETECTION
    #define MALLOC_LEAKDETECTION 0
#endif
 
struct FMallocLeakReportOptions
{
    enum class ESortOption
    {
        SortSize,
        SortRate,
        SortHash
    };
 
    FMallocLeakReportOptions()
    {
        FMemory::Memzero(this, sizeof(FMallocLeakReportOptions));
    }
 
    uint32          SizeFilter;
 
    float           RateFilter;
 
    bool            OnlyNonDeleters;
 
    uint32          FrameStart;
 
    uint32          FrameEnd;
 
    ESortOption     SortBy;
 
    FOutputDevice*  OutputDevice;
};
 
#if MALLOC_LEAKDETECTION
 
class FMallocLeakDetection
{
    using CallstackHashType = uint64;
 
    struct FCallstackTrack
    {
        FCallstackTrack()
        {
            FMemory::Memzero(this, sizeof(FCallstackTrack));
        }
        static constexpr int32 Depth = 32;
        uint64 Callstack[Depth];
        uint32 FirstFrame;
        uint32 LastFrame;
        uint64 Size;
        CallstackHashType CachedHash;
        uint32 Count;
 
        // least square line fit stuff
        uint32 NumCheckPoints;
        float SumOfFramesNumbers;
        float SumOfFramesNumbersSquared;
        float SumOfMemory;
        float SumOfMemoryTimesFrameNumber;
 
        // least square line results
        float Baseline;
        float BytesPerFrame;
 
        bool operator==(const FCallstackTrack& Other) const
        {
            bool bEqual = true;
            for (int32 i = 0; i < Depth; ++i)
            {
                if (Callstack[i] != Other.Callstack[i])
                {
                    bEqual = false;
                    break;
                }
            }
            return bEqual;
        }
 
        bool operator!=(const FCallstackTrack& Other) const
        {
            return !(*this == Other);
        }
 
        void GetLinearFit();
        
        CallstackHashType GetHash() 
        {
            const char* Data = reinterpret_cast<const char*>(Callstack);
            CachedHash = CityHash64(Data, sizeof(Callstack));
            return CachedHash;
        }
    };
 
private:
 
    CORE_API FMallocLeakDetection();
    CORE_API ~FMallocLeakDetection();
 
    CORE_API void AddCallstack(FCallstackTrack& Callstack);
    CORE_API void RemoveCallstack(FCallstackTrack& Callstack);
 
    TMap<void*, FCallstackTrack> OpenPointers;
 
    TMap<CallstackHashType, FCallstackTrack> UniqueCallstacks;
 
    TSet<CallstackHashType> KnownDeleters;
 
    TSet<CallstackHashType> KnownTrimmers;
 
    TMap<void*, FString>        PointerContexts;
 
    struct FContextString { TCHAR Buffer[64]; };
    TArray<FContextString>  Contexts;
        
    FCriticalSection AllocatedPointersCritical; 
 
    bool    bRecursive;
 
    bool    bCaptureAllocs;
 
    int32   MinAllocationSize;
 
    SIZE_T  TotalTracked;
 
    int32   AllocsWithoutCompact;
 
public: 
 
    static CORE_API FMallocLeakDetection& Get();
    static CORE_API void HandleMallocLeakCommand(const TArray< FString >& Args);
 
    CORE_API void SetAllocationCollection(bool bEnabled, int32 Size = 0);
 
    bool IsAllocationCollectionEnabled(void) const { return bCaptureAllocs; }
 
    CORE_API void ClearData();
 
    CORE_API int32 DumpOpenCallstacks(const TCHAR* FileName, const FMallocLeakReportOptions& Options = FMallocLeakReportOptions());
 
    CORE_API void CheckpointLinearFit();
 
    CORE_API void Malloc(void* Ptr, SIZE_T Size);
 
    CORE_API void Realloc(void* OldPtr, SIZE_T OldSize, void* NewPtr, SIZE_T NewSize);
 
    CORE_API void Free(void* Ptr);  
 
    CORE_API void SetDisabledForThisThread(const bool Disabled);
 
    CORE_API bool IsDisabledForThisThread() const;
 
    void PushContext(const FString& Context)
    {
        this->PushContext(*Context);
    }
    CORE_API void PushContext(const TCHAR* Context);
 
    CORE_API void PopContext();
 
    CORE_API void GetOpenCallstacks(TArray<CallstackHashType>& OutCallstacks, SIZE_T& OutTotalSize, const FMallocLeakReportOptions& Options = FMallocLeakReportOptions());
};
 
class FMallocLeakDetectionIgnoreScope
{
public:
    FMallocLeakDetectionIgnoreScope()
    {
        FMallocLeakDetection::Get().SetDisabledForThisThread(true);
    }
 
    ~FMallocLeakDetectionIgnoreScope()
    {
        FMallocLeakDetection::Get().SetDisabledForThisThread(false);
    }
 
    // Non-copyable
    FMallocLeakDetectionIgnoreScope(const FMallocLeakDetectionIgnoreScope&) = delete;
    FMallocLeakDetectionIgnoreScope& operator=(const FMallocLeakDetectionIgnoreScope&) = delete;
};
 
class FMallocLeakScopedContext
{
public:
    template <typename ArgType>
    explicit FMallocLeakScopedContext(ArgType&& Context)
    {
        FMallocLeakDetection::Get().PushContext(Forward<ArgType>(Context));
    }
 
    ~FMallocLeakScopedContext()
    {
        FMallocLeakDetection::Get().PopContext();
    }
 
    // Non-copyable
    FMallocLeakScopedContext(const FMallocLeakScopedContext&) = delete;
    FMallocLeakScopedContext& operator=(const FMallocLeakScopedContext&) = delete;
};
 
#define MALLOCLEAK_IGNORE_SCOPE() \
    FMallocLeakDetectionIgnoreScope ANONYMOUS_VARIABLE(DetectionShouldIgnoreScope)
 
#define MALLOCLEAK_SCOPED_CONTEXT(Context) \
    FMallocLeakScopedContext ANONYMOUS_VARIABLE(ScopedContext)(Context)
 
#else // MALLOC_LEAKDETECTION 0
 
#define MALLOCLEAK_IGNORE_SCOPE()
#define MALLOCLEAK_SCOPED_CONTEXT(Context)
 
#endif // MALLOC_LEAKDETECTION