Insights-compatible memory tracking (#214)

This change introduces support for tracing of memory allocation activity. The code is ported from UE5, and Unreal Insights can be used to analyze the output. This is currently only fully supported on Windows, but will be extended to Mac/Linux in the near future.

To activate full memory tracking, pass `--trace=memory` on the commandline alongside `--tracehost=<ip>` or `-tracefile=<path>`. For more control over how much detail is traced you can instead pass some combination of `callstack`, `memtag`, `memalloc` instead. In practice, `--trace=memory` is an alias for `--trace=callstack,memtag,memalloc`). For convenience we also support `--trace=memory_light` which omits call stacks.

This change also introduces multiple memory allocators, which may be selected via command-line option `--malloc=<allocator>`:

* `mimalloc` - mimalloc (default, same as before)
* `rpmalloc` - rpmalloc is another high performance allocator for multithreaded applications which may be a better option than mimalloc (to be evaluated). Due to toolchain limitations this is currently only supported on Windows.
* `stomp` - an allocator intended to be used during development/debugging to help track down memory issues such as use-after-free or out-of-bounds access. Currently only supported on Windows.
* `ansi` - fallback to default system allocator

1 files changed, 251 insertions, 0 deletions

diff --git a/src/zencore/memory/mallocansi.cpp b/src/zencore/memory/mallocansi.cpp
new file mode 100644
index 000000000..9c3936172
--- /dev/null
+++ b/src/zencore/memory/mallocansi.cpp
@@ -0,0 +1,251 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include <zencore/memory/mallocansi.h>
+
+#include <zencore/intmath.h>
+#include <zencore/memory/align.h>
+#include <zencore/windows.h>
+
+#if ZEN_PLATFORM_LINUX
+#	define PLATFORM_USE_ANSI_POSIX_MALLOC 1
+#endif
+
+#if ZEN_PLATFORM_MAC
+#	define PLATFORM_USE_CUSTOM_MEMALIGN 1
+#endif
+
+#ifndef PLATFORM_USE_ANSI_MEMALIGN
+#	define PLATFORM_USE_ANSI_MEMALIGN 0
+#endif
+
+#ifndef PLATFORM_USE_ANSI_POSIX_MALLOC
+#	define PLATFORM_USE_ANSI_POSIX_MALLOC 0
+#endif
+
+#ifndef PLATFORM_USE_CUSTOM_MEMALIGN
+#	define PLATFORM_USE_CUSTOM_MEMALIGN 0
+#endif
+
+#if PLATFORM_USE_ANSI_POSIX_MALLOC
+#	include <malloc.h>
+#	include <string.h>
+#endif
+
+#define MALLOC_ANSI_USES__ALIGNED_MALLOC ZEN_PLATFORM_WINDOWS
+
+namespace zen {
+
+//////////////////////////////////////////////////////////////////////////
+
+void*
+AnsiMalloc(size_t Size, uint32_t Alignment)
+{
+#if MALLOC_ANSI_USES__ALIGNED_MALLOC
+	void* Result = _aligned_malloc(Size, Alignment);
+#elif PLATFORM_USE_ANSI_POSIX_MALLOC
+	void* Result;
+	if (posix_memalign(&Result, Alignment, Size) != 0)
+	{
+		Result = nullptr;
+	}
+#elif PLATFORM_USE_ANSI_MEMALIGN
+	Result = reallocalign(Ptr, NewSize, Alignment);
+#elif PLATFORM_USE_CUSTOM_MEMALIGN
+	void* Ptr	 = malloc(Size + Alignment + sizeof(void*) + sizeof(size_t));
+	void* Result = nullptr;
+	if (Ptr)
+	{
+		Result															= Align((uint8_t*)Ptr + sizeof(void*) + sizeof(size_t), Alignment);
+		*((void**)((uint8_t*)Result - sizeof(void*)))					= Ptr;
+		*((size_t*)((uint8_t*)Result - sizeof(void*) - sizeof(size_t))) = Size;
+	}
+#else
+#	error Unknown allocation path
+#endif
+
+	return Result;
+}
+
+size_t
+AnsiGetAllocationSize(void* Original)
+{
+#if MALLOC_ANSI_USES__ALIGNED_MALLOC
+	return _aligned_msize(Original, 16, 0);	 // TODO: incorrectly assumes alignment of 16
+#elif PLATFORM_USE_ANSI_POSIX_MALLOC || PLATFORM_USE_ANSI_MEMALIGN
+	return malloc_usable_size(Original);
+#elif PLATFORM_USE_CUSTOM_MEMALIGN
+	return *((size_t*)((uint8_t*)Original - sizeof(void*) - sizeof(size_t)));
+#else
+#	error Unknown allocation path
+#endif
+}
+
+void*
+AnsiRealloc(void* Ptr, size_t NewSize, uint32_t Alignment)
+{
+	void* Result = nullptr;
+
+#if MALLOC_ANSI_USES__ALIGNED_MALLOC
+	if (Ptr && NewSize)
+	{
+		Result = _aligned_realloc(Ptr, NewSize, Alignment);
+	}
+	else if (Ptr == nullptr)
+	{
+		Result = _aligned_malloc(NewSize, Alignment);
+	}
+	else
+	{
+		_aligned_free(Ptr);
+		Result = nullptr;
+	}
+#elif PLATFORM_USE_ANSI_POSIX_MALLOC
+	if (Ptr && NewSize)
+	{
+		size_t UsableSize = malloc_usable_size(Ptr);
+		if (posix_memalign(&Result, Alignment, NewSize) != 0)
+		{
+			Result = nullptr;
+		}
+		else if (UsableSize)
+		{
+			memcpy(Result, Ptr, Min(NewSize, UsableSize));
+		}
+		free(Ptr);
+	}
+	else if (Ptr == nullptr)
+	{
+		if (posix_memalign(&Result, Alignment, NewSize) != 0)
+		{
+			Result = nullptr;
+		}
+	}
+	else
+	{
+		free(Ptr);
+		Result = nullptr;
+	}
+#elif PLATFORM_USE_CUSTOM_MEMALIGN
+	if (Ptr && NewSize)
+	{
+		// Can't use realloc as it might screw with alignment.
+		Result		   = AnsiMalloc(NewSize, Alignment);
+		size_t PtrSize = AnsiGetAllocationSize(Ptr);
+		memcpy(Result, Ptr, Min(NewSize, PtrSize));
+		AnsiFree(Ptr);
+	}
+	else if (Ptr == nullptr)
+	{
+		Result = AnsiMalloc(NewSize, Alignment);
+	}
+	else
+	{
+		free(*((void**)((uint8_t*)Ptr - sizeof(void*))));
+		Result = nullptr;
+	}
+#else
+#	error Unknown allocation path
+#endif
+
+	return Result;
+}
+
+void
+AnsiFree(void* Ptr)
+{
+#if MALLOC_ANSI_USES__ALIGNED_MALLOC
+	_aligned_free(Ptr);
+#elif PLATFORM_USE_ANSI_POSIX_MALLOC || PLATFORM_USE_ANSI_MEMALIGN
+	free(Ptr);
+#elif PLATFORM_USE_CUSTOM_MEMALIGN
+	if (Ptr)
+	{
+		free(*((void**)((uint8_t*)Ptr - sizeof(void*))));
+	}
+#else
+#	error Unknown allocation path
+#endif
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+FMallocAnsi::FMallocAnsi()
+{
+#if ZEN_PLATFORM_WINDOWS
+	// Enable low fragmentation heap - http://msdn2.microsoft.com/en-US/library/aa366750.aspx
+	intptr_t CrtHeapHandle = _get_heap_handle();
+	ULONG	 EnableLFH	   = 2;
+	HeapSetInformation((void*)CrtHeapHandle, HeapCompatibilityInformation, &EnableLFH, sizeof(EnableLFH));
+#endif
+}
+
+void*
+FMallocAnsi::TryMalloc(size_t Size, uint32_t Alignment)
+{
+	Alignment = Max(Size >= 16 ? (uint32_t)16 : (uint32_t)8, Alignment);
+
+	void* Result = AnsiMalloc(Size, Alignment);
+
+	return Result;
+}
+
+void*
+FMallocAnsi::Malloc(size_t Size, uint32_t Alignment)
+{
+	void* Result = TryMalloc(Size, Alignment);
+
+	if (Result == nullptr && Size)
+	{
+		OutOfMemory(Size, Alignment);
+	}
+
+	return Result;
+}
+
+void*
+FMallocAnsi::TryRealloc(void* Ptr, size_t NewSize, uint32_t Alignment)
+{
+	Alignment = Max(NewSize >= 16 ? (uint32_t)16 : (uint32_t)8, Alignment);
+
+	void* Result = AnsiRealloc(Ptr, NewSize, Alignment);
+
+	return Result;
+}
+
+void*
+FMallocAnsi::Realloc(void* Ptr, size_t NewSize, uint32_t Alignment)
+{
+	void* Result = TryRealloc(Ptr, NewSize, Alignment);
+
+	if (Result == nullptr && NewSize != 0)
+	{
+		OutOfMemory(NewSize, Alignment);
+	}
+
+	return Result;
+}
+
+void
+FMallocAnsi::Free(void* Ptr)
+{
+	AnsiFree(Ptr);
+}
+
+bool
+FMallocAnsi::GetAllocationSize(void* Original, size_t& SizeOut)
+{
+	if (!Original)
+	{
+		return false;
+	}
+
+#if MALLOC_ANSI_USES__ALIGNED_MALLOC
+	ZEN_UNUSED(SizeOut);
+	return false;
+#else
+	SizeOut = AnsiGetAllocationSize(Original);
+	return true;
+#endif
+}
+
+}  // namespace zen