ObjectMemoryAnalyzer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/PlatformCrt.h"
#include "HAL/PlatformMath.h"
#include "Misc/AssertionMacros.h"
#include "UObject/UObjectAnnotation.h"
 
class FOutputDevice;
class UClass;
class UObject;
 
struct FObjectMemoryUsage
{
    struct EObjFlags
    {
        enum Type
        {
            IsRoot                  = 1<<0,
            IsReferencedByRoot      = 1<<1,
            IsProcessed             = 1<<2,
            IsReferencedByNonRoot   = 1<<3,
        };
    };
 
    FObjectMemoryUsage()
        : InclusiveMemoryUsage(0)
        , ExclusiveMemoryUsage(0)
        , Flags(0)
        , Object(NULL)
    {
    }
    FObjectMemoryUsage(SIZE_T InclusiveMemUsage, SIZE_T ExclusiveMemUsage, uint32 InFlags = 0)
        : InclusiveMemoryUsage(InclusiveMemUsage)
        , ExclusiveMemoryUsage(ExclusiveMemUsage)
        , Flags(InFlags)
        , Object(NULL)
    {
    }
    UE_FORCEINLINE_HINT bool IsDefault()
    {
        return false;
    }
 
    UE_FORCEINLINE_HINT bool IsRoot() const { return !!(Flags&EObjFlags::IsRoot); }
    UE_FORCEINLINE_HINT bool IsReferencedByRoot() const { return !!(Flags&EObjFlags::IsReferencedByRoot); }
    UE_FORCEINLINE_HINT bool IsProcessed() const { return !!(Flags&EObjFlags::IsProcessed); }
    UE_FORCEINLINE_HINT bool IsReferencedByNonRoot() const { return !!(Flags&EObjFlags::IsReferencedByNonRoot); }
    
    SIZE_T InclusiveMemoryUsage;
    SIZE_T ExclusiveMemoryUsage;
    SIZE_T InclusiveResourceSize;
    SIZE_T ExclusiveResourceSize;
    uint32 Flags;
 
    UObject*         Object;
    TArray<UObject*> RootReferencer;
    TArray<UObject*> NonRootReferencer;
};
 
 
struct FObjectMemoryAnalyzer
{
    struct EAnalyzeFlags
    {
        enum Type
        {
            IncludeDefaultObjects   = 1<<0,
        };
    };
 
    struct ESortKey
    {
        enum Type
        {
            InclusiveSize,
            ExclusiveSize,
            InclusiveResSize,
            ExclusiveResSize,
            InclusiveTotal,
            ExclusiveTotal,
        };
    };
 
    struct FCompareFSortBySize
    {       
        FCompareFSortBySize( ESortKey::Type InSortKey )
            : SortKey( InSortKey )
        {}
 
        inline bool operator()( const FObjectMemoryUsage& A, const FObjectMemoryUsage& B ) const
        {
            switch (SortKey)
            {
                case ESortKey::InclusiveSize:       return A.InclusiveMemoryUsage > B.InclusiveMemoryUsage;
                case ESortKey::ExclusiveSize:       return A.ExclusiveMemoryUsage > B.ExclusiveMemoryUsage;
                case ESortKey::InclusiveResSize:    return A.InclusiveResourceSize > B.InclusiveResourceSize;
                case ESortKey::ExclusiveResSize:    return A.ExclusiveResourceSize > B.ExclusiveResourceSize;
                case ESortKey::InclusiveTotal:      return (A.InclusiveMemoryUsage + A.InclusiveResourceSize*1024) > (B.InclusiveMemoryUsage + B.InclusiveResourceSize*1024);
                case ESortKey::ExclusiveTotal:      return (A.ExclusiveMemoryUsage + A.ExclusiveResourceSize*1024) > (B.ExclusiveMemoryUsage + B.ExclusiveResourceSize*1024);
            }
 
            check(false);
            return false;
        }
 
        ESortKey::Type SortKey;
    };
 
    COREUOBJECT_API FObjectMemoryAnalyzer(uint32 Flags = 0);
    COREUOBJECT_API FObjectMemoryAnalyzer(class UClass* BaseClass, uint32 Flags = 0);
    COREUOBJECT_API FObjectMemoryAnalyzer(class UObject* Object, uint32 Flags = 0);
    COREUOBJECT_API FObjectMemoryAnalyzer(const TArray<class UObject*>& ObjectList, uint32 Flags = 0);
 
    COREUOBJECT_API void AnalyzeObject(class UObject* Object);
    COREUOBJECT_API void AnalyzeObjects(const TArray<class UObject*>& ObjectList);
    COREUOBJECT_API void AnalyzeObjects(class UClass* BaseClass);
 
    COREUOBJECT_API int32 GetResults(TArray<FObjectMemoryUsage>& Results);
    COREUOBJECT_API const FObjectMemoryUsage& GetObjectMemoryUsage(class UObject* Obj);
 
    struct EPrintFlags
    {
        enum Type
        {
            PrintReferences = 1<<0,
            PrintReferencer = 1<<1,
 
            PrintAll        = PrintReferences | PrintReferencer,
        };
    };
 
    COREUOBJECT_API void PrintResults(FOutputDevice& Ar, uint32 PrintFlags = 0);
 
private:
    int32 GetReferencedObjects(UObject* Obj, TArray<UObject*>& ReferencedObjects);
    void ProcessSubObjRecursive(UObject* Root, UObject* Object);
    SIZE_T CalculateSizeRecursive(UObject* Object);
    FString GetFlagsString(const FObjectMemoryUsage& Annotation);
    void PrintSubObjects(FOutputDevice& Ar, const FString& Indent, UObject* Parent, uint32 PrintFlags);
 
 
    UClass* BaseClass;
    TArray<UObject*> ObjectList;
    FUObjectAnnotationDense<FObjectMemoryUsage, true> MemUsageAnnotations;
    uint32 AnalyzeFlags;
};