GenericPlatformMallocCrash.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "HAL/CriticalSection.h"
#include "HAL/MemoryBase.h"
 
struct FMallocCrashPool;
struct FPoolDesc;
 
struct FPtrInfo
{
    uint64 Size;
    uint8* Ptr;
 
#if PLATFORM_32BITS
    uint8 Padding[4];
#endif
 
    FPtrInfo():
        Size(0),
        Ptr(0)
    {}
 
    FPtrInfo( void* NewPtr ):
        Size(0),
        Ptr((uint8*)NewPtr)
    {}
};
 
struct FMallocCrashPool;
struct FPoolDesc;
 
struct FGenericPlatformMallocCrash final : public FMalloc
{
    friend struct FPoolDesc;
    friend struct FMallocCrashPool;
 
    enum
    {
        LARGE_MEMORYPOOL_SIZE = 2 * 1024 * 1024,
        REQUIRED_ALIGNMENT = 16,
 
        NUM_POOLS = 14,
        MAX_NUM_ALLOCS_IN_POOL = 2048,
 
        MEM_TAG     = 0xfe,
        MEM_WIPETAG = 0xcd,
    };
 
public:
    FGenericPlatformMallocCrash( FMalloc* MainMalloc );
    virtual ~FGenericPlatformMallocCrash();
 
    static CORE_API FGenericPlatformMallocCrash& Get( FMalloc* MainMalloc = nullptr );
 
    void SetAsGMalloc();
 
    static bool IsActive();
 
    // FMalloc interface.
    virtual void* Malloc( SIZE_T Size, uint32 Alignment ) override;
 
    virtual void* Realloc( void* Ptr, SIZE_T NewSize, uint32 Alignment ) override;
 
    virtual void Free( void* /*Ptr*/ ) override;
 
    virtual bool GetAllocationSize( void *Original, SIZE_T &SizeOut ) override;
 
    virtual bool IsInternallyThreadSafe() const override
    {
        return true;
    }
 
    virtual bool ValidateHeap() override
    {
        // Nothing to do here.
        return true;
    }
 
    virtual const TCHAR * GetDescriptiveName() override
    {
        return TEXT( "MallocCrash" );
    }
 
    CORE_API void PrintPoolsUsage();
 
protected:
    bool CheckThreadForAllocation() const;
    bool CheckThreadForFree() const;
 
    bool IsPtrInLargePool(void* Ptr) const;
    bool IsPtrInSmallPool(void* Ptr) const;
 
    const FPoolDesc& GetPoolDesc( uint32 Index ) const;
    uint32 CalculateSmallPoolTotalSize() const;
    uint32 CalculateBookkeepingPoolTotalSize() const;
 
    void InitializeSmallPools();
 
    // Choose a pool to make a new allocation from of the given size - may use a larger pool than necessary if small pools are exhausted.
    FMallocCrashPool* ChoosePoolForSize( uint32 AllocationSize ) const;
    // Find the pool that an allocation was made from if any.
    FMallocCrashPool* FindPoolForAlloc(void* Ptr) const;
    uint8* AllocateFromBookkeeping(uint32 AllocationSize);
    uint8* AllocateFromSmallPool( uint32 AllocationSize );
 
    uint64 GetAllocationSize(void *Original);
 
    static uint32 SafePageSize();
 
protected:
    FCriticalSection InternalLock;
 
    int32 CrashedThreadId = 0;
 
    uint8* LargeMemoryPool = nullptr;
 
    uint32 LargeMemoryPoolOffset = 0;
 
    uint8* SmallMemoryPool = nullptr;
 
    uint32 SmallMemoryPoolOffset = 0;
    uint32 SmallMemoryPoolSize = 0;
 
    uint8* BookkeepingPool = nullptr;
 
    uint32 BookkeepingPoolOffset = 0;
    uint32 BookkeepingPoolSize = 0;
 
    FMalloc* PreviousMalloc = nullptr;
};
 
 
 
 
 
struct FGenericStackBasedMallocCrash : public FMalloc
{
    FGenericStackBasedMallocCrash(FMalloc* MainMalloc);
    virtual ~FGenericStackBasedMallocCrash();
 
    static CORE_API FGenericStackBasedMallocCrash& Get(FMalloc* MainMalloc = nullptr);
 
    void SetAsGMalloc();
 
    static bool IsActive();
 
    virtual void* Malloc(SIZE_T Size, uint32 Alignment) override;
 
    virtual void* Realloc(void* Ptr, SIZE_T NewSize, uint32 Alignment) override;
 
    virtual void Free(void* /*Ptr*/) override;
 
    virtual const TCHAR * GetDescriptiveName() override
    {
        return TEXT("FGenericStackBasedMallocCrash");
    }
 
private:
    enum
    {
        MEMORYPOOL_SIZE = 256 * 1024
    };
 
    uint8* CurrentFreeMemPtr;
    uint8* FreeMemoryEndPtr;
};