MallocThreadSafeProxy.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "HAL/MemoryBase.h"
#include "Misc/ScopeLock.h"
 
class FMallocThreadSafeProxy : public FMalloc
{
private:
    FMalloc*            UsedMalloc;
    FCriticalSection    SynchronizationObject;
 
public:
    FMallocThreadSafeProxy( FMalloc* InMalloc)
    :   UsedMalloc( InMalloc )
    {}
 
    virtual void InitializeStatsMetadata() override
    {
        UsedMalloc->InitializeStatsMetadata();
    }
 
    virtual void* Malloc( SIZE_T Size, uint32 Alignment ) override
    {
        FScopeLock ScopeLock( &SynchronizationObject );
        return UsedMalloc->Malloc( Size, Alignment );
    }
 
    virtual void* Realloc( void* Ptr, SIZE_T NewSize, uint32 Alignment ) override
    {
        FScopeLock ScopeLock( &SynchronizationObject );
        return UsedMalloc->Realloc( Ptr, NewSize, Alignment );
    }
 
    virtual void Free( void* Ptr ) override
    {
        if( Ptr )
        {
            FScopeLock ScopeLock( &SynchronizationObject );
            UsedMalloc->Free( Ptr );
        }
    }
 
    virtual void GetAllocatorStats( FGenericMemoryStats& out_Stats ) override
    {
        FScopeLock ScopeLock( &SynchronizationObject );
        UsedMalloc->GetAllocatorStats( out_Stats );
    }
 
    virtual void DumpAllocatorStats( class FOutputDevice& Ar ) override
    {
        FScopeLock ScopeLock( &SynchronizationObject );
        UsedMalloc->DumpAllocatorStats( Ar );
    }
 
    virtual bool ValidateHeap() override
    {
        FScopeLock Lock( &SynchronizationObject );
        return( UsedMalloc->ValidateHeap() );
    }
 
#if UE_ALLOW_EXEC_COMMANDS
    virtual bool Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar ) override
    {
        FScopeLock ScopeLock( &SynchronizationObject );
        return UsedMalloc->Exec( InWorld, Cmd, Ar);
    }
#endif // UE_ALLOW_EXEC_COMMANDS
 
    virtual bool GetAllocationSize(void *Original, SIZE_T &SizeOut) override
    {
        FScopeLock ScopeLock( &SynchronizationObject );
        return UsedMalloc->GetAllocationSize(Original,SizeOut);
    }
 
    virtual const TCHAR* GetDescriptiveName() override
    { 
        FScopeLock ScopeLock( &SynchronizationObject );
        check(UsedMalloc);
        return UsedMalloc->GetDescriptiveName(); 
    }
 
    virtual void Trim(bool bTrimThreadCaches) override
    {
        FScopeLock ScopeLock(&SynchronizationObject);
        check(UsedMalloc);
        UsedMalloc->Trim(bTrimThreadCaches);
    }
 
    virtual bool IsInternallyThreadSafe() const override
    { 
        return true; 
    }
 
    virtual void OnMallocInitialized() override
    {
        UsedMalloc->OnMallocInitialized();
    }
 
    virtual void OnPreFork() override
    {
        UsedMalloc->OnPreFork();
    }
 
    virtual void OnPostFork() override
    {
        UsedMalloc->OnPostFork();
    }
};