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

15 files changed, 990 insertions, 10 deletions

diff --git a/src/zencore/include/zencore/guardvalue.h b/src/zencore/include/zencore/guardvalue.h
new file mode 100644
index 000000000..5419e882a
--- /dev/null
+++ b/src/zencore/include/zencore/guardvalue.h
@@ -0,0 +1,40 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+namespace zen {
+
+/**
+ * exception-safe guard around saving/restoring a value.
+ * Commonly used to make sure a value is restored
+ * even if the code early outs in the future.
+ * Usage:
+ *  	TGuardValue<bool> GuardSomeBool(bSomeBool, false); // Sets bSomeBool to false, and restores it in dtor.
+ */
+template<typename RefType, typename AssignedType = RefType>
+struct TGuardValue
+{
+	[[nodiscard]] TGuardValue(RefType& ReferenceValue, const AssignedType& NewValue)
+	: RefValue(ReferenceValue)
+	, OriginalValue(ReferenceValue)
+	{
+		RefValue = NewValue;
+	}
+	~TGuardValue() { RefValue = OriginalValue; }
+
+	/**
+	 * Provides read-only access to the original value of the data being tracked by this struct
+	 *
+	 * @return	a const reference to the original data value
+	 */
+	const AssignedType& GetOriginalValue() const { return OriginalValue; }
+
+	TGuardValue& operator=(const TGuardValue&) = delete;
+	TGuardValue(const TGuardValue&)			   = delete;
+
+private:
+	RefType&	 RefValue;
+	AssignedType OriginalValue;
+};
+
+}  // namespace zen
diff --git a/src/zencore/include/zencore/iobuffer.h b/src/zencore/include/zencore/iobuffer.h
index 493b7375e..93a27ea58 100644
--- a/src/zencore/include/zencore/iobuffer.h
+++ b/src/zencore/include/zencore/iobuffer.h
@@ -99,6 +99,11 @@ public:
 	ZENCORE_API IoBufferCore(size_t SizeBytes, size_t Alignment);
 	ZENCORE_API ~IoBufferCore();
 
+	void* operator new(size_t Size);
+	void  operator delete(void* Ptr);
+	void* operator new[](size_t Size)  = delete;
+	void  operator delete[](void* Ptr) = delete;
+
 	// Reference counting
 
 	inline uint32_t AddRef() const { return AtomicIncrement(const_cast<IoBufferCore*>(this)->m_RefCount); }
@@ -244,7 +249,6 @@ protected:
 		kIsExtended		= 1 << 2,  // Is actually a SharedBufferExtendedCore
 		kIsMaterialized = 1 << 3,  // Data pointers are valid
 		kIsWholeFile	= 1 << 5,  // References an entire file
-		kIoBufferAlloc	= 1 << 6,  // Using IoBuffer allocator
 		kIsOwnedByThis	= 1 << 7,
 
 		// Note that we have some extended flags defined below
diff --git a/src/zencore/include/zencore/memory.h b/src/zencore/include/zencore/memory.h
index fdea1a5f1..8361ab9d8 100644
--- a/src/zencore/include/zencore/memory.h
+++ b/src/zencore/include/zencore/memory.h
@@ -22,17 +22,10 @@ template<typename T>
 concept ContiguousRange = true;
 #endif
 
-struct MemoryView;
-
-class Memory
-{
-public:
-	ZENCORE_API static void* Alloc(size_t Size, size_t Alignment = sizeof(void*));
-	ZENCORE_API static void	 Free(void* Ptr);
-};
-
 //////////////////////////////////////////////////////////////////////////
 
+struct MemoryView;
+
 struct MutableMemoryView
 {
 	MutableMemoryView() = default;
diff --git a/src/zencore/include/zencore/memory/fmalloc.h b/src/zencore/include/zencore/memory/fmalloc.h
new file mode 100644
index 000000000..aeb05b651
--- /dev/null
+++ b/src/zencore/include/zencore/memory/fmalloc.h
@@ -0,0 +1,103 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zenbase/zenbase.h>
+
+namespace zen {
+
+enum
+{
+	DEFAULT_ALIGNMENT = 0
+};
+
+/**
+ * Inherit from FUseSystemMallocForNew if you want your objects to be placed in memory
+ * alloced by the system malloc routines, bypassing GMalloc. This is e.g. used by FMalloc
+ * itself.
+ */
+class FUseSystemMallocForNew
+{
+public:
+	void* operator new(size_t Size);
+	void  operator delete(void* Ptr);
+	void* operator new[](size_t Size);
+	void  operator delete[](void* Ptr);
+};
+
+/** Memory allocator abstraction
+ */
+
+class FMalloc : public FUseSystemMallocForNew
+{
+public:
+	/**
+	 * Malloc
+	 */
+	virtual void* Malloc(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT) = 0;
+
+	/**
+	 * TryMalloc - like Malloc(), but may return a nullptr result if the allocation
+	 *             request cannot be satisfied.
+	 */
+	virtual void* TryMalloc(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT);
+
+	/**
+	 * Realloc
+	 */
+	virtual void* Realloc(void* Original, size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT) = 0;
+
+	/**
+	 * TryRealloc - like Realloc(), but may return a nullptr if the allocation
+	 *              request cannot be satisfied. Note that in this case the memory
+	 *              pointed to by Original will still be valid
+	 */
+	virtual void* TryRealloc(void* Original, size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT);
+
+	/**
+	 * Free
+	 */
+	virtual void Free(void* Original) = 0;
+
+	/**
+	 * Malloc zeroed memory
+	 */
+	virtual void* MallocZeroed(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT);
+
+	/**
+	 * TryMallocZeroed - like MallocZeroed(), but may return a nullptr result if the allocation
+	 *                   request cannot be satisfied.
+	 */
+	virtual void* TryMallocZeroed(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT);
+
+	/**
+	 * For some allocators this will return the actual size that should be requested to eliminate
+	 * internal fragmentation. The return value will always be >= Count. This can be used to grow
+	 * and shrink containers to optimal sizes.
+	 * This call is always fast and threadsafe with no locking.
+	 */
+	virtual size_t QuantizeSize(size_t Count, uint32_t Alignment);
+
+	/**
+	 * If possible determine the size of the memory allocated at the given address
+	 *
+	 * @param Original - Pointer to memory we are checking the size of
+	 * @param SizeOut - If possible, this value is set to the size of the passed in pointer
+	 * @return true if succeeded
+	 */
+	virtual bool GetAllocationSize(void* Original, size_t& SizeOut);
+
+	/**
+	 * Notifies the malloc implementation that initialization of all allocators in GMalloc is complete, so it's safe to initialize any extra
+	 * features that require "regular" allocations
+	 */
+	virtual void OnMallocInitialized();
+
+	virtual void Trim(bool bTrimThreadCaches);
+
+	virtual void OutOfMemory(size_t Size, uint32_t Alignment);
+};
+
+extern FMalloc* GMalloc; /* Memory allocator */
+
+}  // namespace zen
diff --git a/src/zencore/include/zencore/memory/llm.h b/src/zencore/include/zencore/memory/llm.h
new file mode 100644
index 000000000..4f1c9de77
--- /dev/null
+++ b/src/zencore/include/zencore/memory/llm.h
@@ -0,0 +1,31 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zenbase/zenbase.h>
+#include <zencore/memory/tagtrace.h>
+
+namespace zen {
+
+// clang-format off
+#define LLM_ENUM_GENERIC_TAGS(macro) \
+	macro(Untagged,			"Untagged", -1) \
+	macro(ProgramSize,		"ProgramSize", -1) \
+	macro(Metrics,			"Metrics", -1) \
+	macro(Logging,			"Logging", -1) \
+	macro(IoBuffer,			"IoBuffer", -1) \
+	macro(IoBufferMemory,	"IoMemory", ELLMTag::IoBuffer) \
+	macro(IoBufferCore,		"IoCore", ELLMTag::IoBuffer)
+
+// clang-format on
+
+enum class ELLMTag : uint8_t
+{
+#define LLM_ENUM(Enum, Str, Parent) Enum,
+	LLM_ENUM_GENERIC_TAGS(LLM_ENUM)
+#undef LLM_ENUM
+
+	GenericTagCount
+};
+
+}  // namespace zen
diff --git a/src/zencore/include/zencore/memory/mallocansi.h b/src/zencore/include/zencore/memory/mallocansi.h
new file mode 100644
index 000000000..510695c8c
--- /dev/null
+++ b/src/zencore/include/zencore/memory/mallocansi.h
@@ -0,0 +1,31 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "fmalloc.h"
+#include "memory.h"
+
+namespace zen {
+
+void* AnsiMalloc(size_t Size, uint32_t Alignment);
+void* AnsiRealloc(void* Ptr, size_t NewSize, uint32_t Alignment);
+void  AnsiFree(void* Ptr);
+
+//
+// ANSI C memory allocator.
+//
+
+class FMallocAnsi final : public FMalloc
+{
+public:
+	FMallocAnsi();
+
+	virtual void* Malloc(size_t Size, uint32_t Alignment) override;
+	virtual void* TryMalloc(size_t Size, uint32_t Alignment) override;
+	virtual void* Realloc(void* Ptr, size_t NewSize, uint32_t Alignment) override;
+	virtual void* TryRealloc(void* Ptr, size_t NewSize, uint32_t Alignment) override;
+	virtual void  Free(void* Ptr) override;
+	virtual bool  GetAllocationSize(void* Original, size_t& SizeOut) override;
+};
+
+}  // namespace zen
diff --git a/src/zencore/include/zencore/memory/mallocmimalloc.h b/src/zencore/include/zencore/memory/mallocmimalloc.h
new file mode 100644
index 000000000..759eeb4a6
--- /dev/null
+++ b/src/zencore/include/zencore/memory/mallocmimalloc.h
@@ -0,0 +1,36 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zencore/memory/fmalloc.h>
+
+#if ZEN_USE_MIMALLOC
+#	define ZEN_MIMALLOC_ENABLED 1
+#endif
+
+#if !defined(ZEN_MIMALLOC_ENABLED)
+#	define ZEN_MIMALLOC_ENABLED 0
+#endif
+
+#if ZEN_MIMALLOC_ENABLED
+
+namespace zen {
+
+class FMallocMimalloc final : public FMalloc
+{
+public:
+	FMallocMimalloc();
+	virtual void* Malloc(size_t Size, uint32_t Alignment) override;
+	virtual void* TryMalloc(size_t Size, uint32_t Alignment) override;
+	virtual void* Realloc(void* Ptr, size_t NewSize, uint32_t Alignment) override;
+	virtual void* TryRealloc(void* Ptr, size_t NewSize, uint32_t Alignment) override;
+	virtual void  Free(void* Ptr) override;
+	virtual void* MallocZeroed(size_t Count, uint32_t Alignment) override;
+	virtual void* TryMallocZeroed(size_t Count, uint32_t Alignment) override;
+	virtual bool  GetAllocationSize(void* Original, size_t& SizeOut) override;
+	virtual void  Trim(bool bTrimThreadCaches) override;
+};
+
+}  // namespace zen
+
+#endif
diff --git a/src/zencore/include/zencore/memory/mallocrpmalloc.h b/src/zencore/include/zencore/memory/mallocrpmalloc.h
new file mode 100644
index 000000000..be2627b2d
--- /dev/null
+++ b/src/zencore/include/zencore/memory/mallocrpmalloc.h
@@ -0,0 +1,37 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zencore/memory/fmalloc.h>
+
+#if ZEN_USE_RPMALLOC
+#	define ZEN_RPMALLOC_ENABLED 1
+#endif
+
+#if !defined(ZEN_RPMALLOC_ENABLED)
+#	define ZEN_RPMALLOC_ENABLED 0
+#endif
+
+#if ZEN_RPMALLOC_ENABLED
+
+namespace zen {
+
+class FMallocRpmalloc final : public FMalloc
+{
+public:
+	FMallocRpmalloc();
+	~FMallocRpmalloc();
+	virtual void* Malloc(size_t Size, uint32_t Alignment) override;
+	virtual void* TryMalloc(size_t Size, uint32_t Alignment) override;
+	virtual void* Realloc(void* Ptr, size_t NewSize, uint32_t Alignment) override;
+	virtual void* TryRealloc(void* Ptr, size_t NewSize, uint32_t Alignment) override;
+	virtual void  Free(void* Ptr) override;
+	virtual void* MallocZeroed(size_t Count, uint32_t Alignment) override;
+	virtual void* TryMallocZeroed(size_t Count, uint32_t Alignment) override;
+	virtual bool  GetAllocationSize(void* Original, size_t& SizeOut) override;
+	virtual void  Trim(bool bTrimThreadCaches) override;
+};
+
+}  // namespace zen
+
+#endif
diff --git a/src/zencore/include/zencore/memory/mallocstomp.h b/src/zencore/include/zencore/memory/mallocstomp.h
new file mode 100644
index 000000000..5d83868bb
--- /dev/null
+++ b/src/zencore/include/zencore/memory/mallocstomp.h
@@ -0,0 +1,100 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zenbase/zenbase.h>
+
+#if ZEN_PLATFORM_WINDOWS
+#	define ZEN_WITH_MALLOC_STOMP 1
+#endif
+
+#ifndef ZEN_WITH_MALLOC_STOMP
+#	define ZEN_WITH_MALLOC_STOMP 0
+#endif
+
+/**
+ * Stomp memory allocator support should be enabled in Core.Build.cs.
+ * Run-time validation should be enabled using '-stompmalloc' command line argument.
+ */
+
+#if ZEN_WITH_MALLOC_STOMP
+
+#	include <zencore/memory/fmalloc.h>
+#	include <zencore/thread.h>
+
+namespace zen {
+
+/**
+ * Stomp memory allocator. It helps find the following errors:
+ * - Read or writes off the end of an allocation.
+ * - Read or writes off the beginning of an allocation.
+ * - Read or writes after freeing an allocation.
+ */
+class FMallocStomp final : public FMalloc
+{
+	struct FAllocationData;
+
+	const size_t PageSize;
+
+	/** If it is set to true, instead of focusing on overruns the allocator will focus on underruns. */
+	const bool bUseUnderrunMode;
+	RwLock	   Lock;
+
+	uintptr_t				VirtualAddressCursor	= 0;
+	size_t					VirtualAddressMax		= 0;
+	static constexpr size_t VirtualAddressBlockSize = 1 * 1024 * 1024 * 1024;  // 1 GB blocks
+
+public:
+	// FMalloc interface.
+	explicit FMallocStomp(const bool InUseUnderrunMode = false);
+
+	/**
+	 * Allocates a block of a given number of bytes of memory with the required alignment.
+	 * In the process it allocates as many pages as necessary plus one that will be protected
+	 * making it unaccessible and causing an exception. The actual allocation will be pushed
+	 * to the end of the last valid unprotected page. To deal with underrun errors a sentinel
+	 * is added right before the allocation in page which is checked on free.
+	 *
+	 * @param Size Size in bytes of the memory block to allocate.
+	 * @param Alignment Alignment in bytes of the memory block to allocate.
+	 * @return A pointer to the beginning of the memory block.
+	 */
+	virtual void* Malloc(size_t Size, uint32_t Alignment) override;
+
+	virtual void* TryMalloc(size_t Size, uint32_t Alignment) override;
+
+	/**
+	 * Changes the size of the memory block pointed to by OldPtr.
+	 * The function may move the memory block to a new location.
+	 *
+	 * @param OldPtr Pointer to a memory block previously allocated with Malloc.
+	 * @param NewSize New size in bytes for the memory block.
+	 * @param Alignment Alignment in bytes for the reallocation.
+	 * @return A pointer to the reallocated memory block, which may be either the same as ptr or a new location.
+	 */
+	virtual void* Realloc(void* InPtr, size_t NewSize, uint32_t Alignment) override;
+
+	virtual void* TryRealloc(void* InPtr, size_t NewSize, uint32_t Alignment) override;
+
+	/**
+	 * Frees a memory allocation and verifies the sentinel in the process.
+	 *
+	 * @param InPtr Pointer of the data to free.
+	 */
+	virtual void Free(void* InPtr) override;
+
+	/**
+	 * If possible determine the size of the memory allocated at the given address.
+	 * This will included all the pages that were allocated so it will be far more
+	 * than what's set on the FAllocationData.
+	 *
+	 * @param Original - Pointer to memory we are checking the size of
+	 * @param SizeOut - If possible, this value is set to the size of the passed in pointer
+	 * @return true if succeeded
+	 */
+	virtual bool GetAllocationSize(void* Original, size_t& SizeOut) override;
+};
+
+}  // namespace zen
+
+#endif	// WITH_MALLOC_STOMP
diff --git a/src/zencore/include/zencore/memory/memory.h b/src/zencore/include/zencore/memory/memory.h
new file mode 100644
index 000000000..2fc20def6
--- /dev/null
+++ b/src/zencore/include/zencore/memory/memory.h
@@ -0,0 +1,78 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <stdlib.h>
+#include <zencore/memory/fmalloc.h>
+
+#define UE_ALLOCATION_FUNCTION(...)
+
+namespace zen {
+
+/**
+ * Corresponds to UE-side FMemory implementation
+ */
+
+class Memory
+{
+public:
+	static void Initialize();
+
+	//
+	// C style memory allocation stubs that fall back to C runtime
+	//
+	UE_ALLOCATION_FUNCTION(1) static void* SystemMalloc(size_t Size);
+	static void SystemFree(void* Ptr);
+
+	//
+	// C style memory allocation stubs.
+	//
+
+	static inline void* Alloc(size_t Size, size_t Alignment = sizeof(void*)) { return Malloc(Size, uint32_t(Alignment)); }
+
+	UE_ALLOCATION_FUNCTION(1, 2) static inline void* Malloc(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT);
+	UE_ALLOCATION_FUNCTION(2, 3) static inline void* Realloc(void* Original, size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT);
+	static inline void	 Free(void* Original);
+	static inline size_t GetAllocSize(void* Original);
+
+	UE_ALLOCATION_FUNCTION(1, 2) static inline void* MallocZeroed(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT);
+
+private:
+	static void GCreateMalloc();
+};
+
+inline void*
+Memory::Malloc(size_t Count, uint32_t Alignment)
+{
+	return GMalloc->TryMalloc(Count, Alignment);
+}
+
+inline void*
+Memory::Realloc(void* Original, size_t Count, uint32_t Alignment)
+{
+	return GMalloc->TryRealloc(Original, Count, Alignment);
+}
+
+inline void
+Memory::Free(void* Original)
+{
+	if (Original)
+	{
+		GMalloc->Free(Original);
+	}
+}
+
+inline size_t
+Memory::GetAllocSize(void* Original)
+{
+	size_t Size = 0;
+	return GMalloc->GetAllocationSize(Original, Size) ? Size : 0;
+}
+
+inline void*
+Memory::MallocZeroed(size_t Count, uint32_t Alignment)
+{
+	return GMalloc->TryMallocZeroed(Count, Alignment);
+}
+
+}  // namespace zen
diff --git a/src/zencore/include/zencore/memory/memorytrace.h b/src/zencore/include/zencore/memory/memorytrace.h
new file mode 100644
index 000000000..d1ab1f914
--- /dev/null
+++ b/src/zencore/include/zencore/memory/memorytrace.h
@@ -0,0 +1,251 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include <zencore/enumflags.h>
+#include <zencore/trace.h>
+
+#if !defined(UE_MEMORY_TRACE_AVAILABLE)
+#	define UE_MEMORY_TRACE_AVAILABLE 0
+#endif
+
+#if !defined(UE_MEMORY_TRACE_LATE_INIT)
+#	define UE_MEMORY_TRACE_LATE_INIT 0
+#endif
+
+#if !defined(PLATFORM_USES_FIXED_GMalloc_CLASS)
+#	define PLATFORM_USES_FIXED_GMalloc_CLASS 0
+#endif
+
+#if !defined(UE_MEMORY_TRACE_ENABLED) && UE_TRACE_ENABLED
+#	if UE_MEMORY_TRACE_AVAILABLE
+#		define UE_MEMORY_TRACE_ENABLED ZEN_WITH_MEMTRACK
+#	endif
+#endif
+
+#if !defined(UE_MEMORY_TRACE_ENABLED)
+#	define UE_MEMORY_TRACE_ENABLED 0
+#endif
+
+namespace zen {
+
+////////////////////////////////////////////////////////////////////////////////
+typedef uint32_t HeapId;
+
+////////////////////////////////////////////////////////////////////////////////
+enum EMemoryTraceRootHeap : uint8_t
+{
+	SystemMemory,  // RAM
+	VideoMemory,   // VRAM
+	EndHardcoded = VideoMemory,
+	EndReserved	 = 15
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// These values are traced. Do not modify existing values in order to maintain
+// compatibility.
+enum class EMemoryTraceHeapFlags : uint16_t
+{
+	None	   = 0,
+	Root	   = 1 << 0,
+	NeverFrees = 1 << 1,  // The heap doesn't free (e.g. linear allocator)
+};
+ENUM_CLASS_FLAGS(EMemoryTraceHeapFlags);
+
+////////////////////////////////////////////////////////////////////////////////
+// These values are traced. Do not modify existing values in order to maintain
+// compatibility.
+enum class EMemoryTraceHeapAllocationFlags : uint8_t
+{
+	None = 0,
+	Heap = 1 << 0,	// Is a heap, can be used to unmark alloc as heap.
+	Swap = 2 << 0,	// Is a swap page
+};
+ENUM_CLASS_FLAGS(EMemoryTraceHeapAllocationFlags);
+
+////////////////////////////////////////////////////////////////////////////////
+enum class EMemoryTraceSwapOperation : uint8
+{
+	PageOut	   = 0,	 // Paged out to swap
+	PageIn	   = 1,	 // Read from swap via page fault
+	FreeInSwap = 2,	 // Freed while being paged out in swap
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Internal options for early initialization of memory tracing systems. Exposed
+// here due to visibility in platform implementations.
+enum class EMemoryTraceInit : uint8
+{
+	Disabled	= 0,
+	AllocEvents = 1 << 0,
+	Callstacks	= 1 << 1,
+	Tags		= 1 << 2,
+	Full		= AllocEvents | Callstacks | Tags,
+	Light		= AllocEvents | Tags,
+};
+
+ENUM_CLASS_FLAGS(EMemoryTraceInit);
+
+////////////////////////////////////////////////////////////////////////////////
+#if UE_MEMORY_TRACE_ENABLED
+
+#	define UE_MEMORY_TRACE(x) x
+
+UE_TRACE_CHANNEL_EXTERN(MemAllocChannel);
+
+////////////////////////////////////////////////////////////////////////////////
+class FMalloc* MemoryTrace_Create(class FMalloc* InMalloc);
+void		   MemoryTrace_Initialize();
+void		   MemoryTrace_Shutdown();
+
+/**
+ * Register a new heap specification (name). Use the returned value when marking heaps.
+ * @param ParentId Heap id of parent heap.
+ * @param Name Descriptive name of the heap.
+ * @param Flags Properties of this heap. See \ref EMemoryTraceHeapFlags
+ * @return Heap id to use when allocating memory
+ */
+HeapId MemoryTrace_HeapSpec(HeapId ParentId, const char16_t* Name, EMemoryTraceHeapFlags Flags = EMemoryTraceHeapFlags::None);
+
+/**
+ * Register a new root heap specification (name). Use the returned value as parent to other heaps.
+ * @param Name Descriptive name of the root heap.
+ * @param Flags Properties of the this root heap. See \ref EMemoryTraceHeapFlags
+ * @return Heap id to use when allocating memory
+ */
+HeapId MemoryTrace_RootHeapSpec(const char16_t* Name, EMemoryTraceHeapFlags Flags = EMemoryTraceHeapFlags::None);
+
+/**
+ * Mark a traced allocation as being a heap.
+ * @param Address Address of the allocation
+ * @param Heap Heap id, see /ref MemoryTrace_HeapSpec. If no specific heap spec has been created the correct root heap needs to be given.
+ * @param Flags Additional properties of the heap allocation. Note that \ref EMemoryTraceHeapAllocationFlags::Heap is implicit.
+ * @param ExternalCallstackId CallstackId to use, if 0 will use current callstack id.
+ */
+void MemoryTrace_MarkAllocAsHeap(uint64							 Address,
+								 HeapId							 Heap,
+								 EMemoryTraceHeapAllocationFlags Flags				 = EMemoryTraceHeapAllocationFlags::None,
+								 uint32							 ExternalCallstackId = 0);
+
+/**
+ * Unmark an allocation as a heap. When an allocation that has previously been used as a heap is reused as a regular
+ * allocation.
+ * @param Address Address of the allocation
+ * @param Heap Heap id
+ * @param ExternalCallstackId CallstackId to use, if 0 will use current callstack id.
+ */
+void MemoryTrace_UnmarkAllocAsHeap(uint64 Address, HeapId Heap, uint32 ExternalCallstackId = 0);
+
+/**
+ * Trace an allocation event.
+ * @param Address Address of allocation
+ * @param Size Size of allocation
+ * @param Alignment Alignment of the allocation
+ * @param RootHeap Which root heap this belongs to (system memory, video memory etc)
+ * @param ExternalCallstackId CallstackId to use, if 0 will use current callstack id.
+ */
+void MemoryTrace_Alloc(uint64 Address,
+					   uint64 Size,
+					   uint32 Alignment,
+					   HeapId RootHeap			  = EMemoryTraceRootHeap::SystemMemory,
+					   uint32 ExternalCallstackId = 0);
+
+/**
+ * Trace a free event.
+ * @param Address Address of the allocation being freed
+ * @param RootHeap Which root heap this belongs to (system memory, video memory etc)
+ * @param ExternalCallstackId CallstackId to use, if 0 will use current callstack id.
+ */
+void MemoryTrace_Free(uint64 Address, HeapId RootHeap = EMemoryTraceRootHeap::SystemMemory, uint32 ExternalCallstackId = 0);
+
+/**
+ * Trace a free related to a reallocation event.
+ * @param Address Address of the allocation being freed
+ * @param RootHeap Which root heap this belongs to (system memory, video memory etc)
+ * @param ExternalCallstackId CallstackId to use, if 0 will use current callstack id.
+ */
+void MemoryTrace_ReallocFree(uint64 Address, HeapId RootHeap = EMemoryTraceRootHeap::SystemMemory, uint32 ExternalCallstackId = 0);
+
+/** Trace an allocation related to a reallocation event.
+ * @param Address Address of allocation
+ * @param NewSize Size of allocation
+ * @param Alignment Alignment of the allocation
+ * @param RootHeap Which root heap this belongs to (system memory, video memory etc)
+ * @param ExternalCallstackId CallstackId to use, if 0 will use current callstack id.
+ */
+void MemoryTrace_ReallocAlloc(uint64 Address,
+							  uint64 NewSize,
+							  uint32 Alignment,
+							  HeapId RootHeap			 = EMemoryTraceRootHeap::SystemMemory,
+							  uint32 ExternalCallstackId = 0);
+
+/** Trace a swap operation. Only available for system memory root heap (EMemoryTraceRootHeap::SystemMemory).
+ * @param PageAddress Page address for operation, in case of PageIn can be address of the page fault (not aligned to page boundary).
+ * @param SwapOperation Which swap operation is happening to the address.
+ * @param CompressedSize Compressed size of the page for page out operation.
+ * @param CallstackId CallstackId to use, if 0 to ignore (will not use current callstack id).
+ */
+void MemoryTrace_SwapOp(uint64 PageAddress, EMemoryTraceSwapOperation SwapOperation, uint32 CompressedSize = 0, uint32 CallstackId = 0);
+
+////////////////////////////////////////////////////////////////////////////////
+#else  // UE_MEMORY_TRACE_ENABLED
+
+#	define UE_MEMORY_TRACE(x)
+inline HeapId
+MemoryTrace_RootHeapSpec(const char16_t* /*Name*/, EMemoryTraceHeapFlags /* Flags = EMemoryTraceHeapFlags::None */)
+{
+	return ~0u;
+};
+inline HeapId
+MemoryTrace_HeapSpec(HeapId /*ParentId*/, const char16_t* /*Name*/, EMemoryTraceHeapFlags /* Flags = EMemoryTraceHeapFlags::None */)
+{
+	return ~0u;
+}
+inline void
+MemoryTrace_MarkAllocAsHeap(uint64_t /*Address*/, HeapId /*Heap*/)
+{
+}
+inline void
+MemoryTrace_UnmarkAllocAsHeap(uint64_t /*Address*/, HeapId /*Heap*/)
+{
+}
+inline void
+MemoryTrace_Alloc(uint64_t /*Address*/,
+				  uint64_t /*Size*/,
+				  uint32_t /*Alignment*/,
+				  HeapId   RootHeap			   = EMemoryTraceRootHeap::SystemMemory,
+				  uint32_t ExternalCallstackId = 0)
+{
+	ZEN_UNUSED(RootHeap, ExternalCallstackId);
+}
+inline void
+MemoryTrace_Free(uint64_t /*Address*/, HeapId RootHeap = EMemoryTraceRootHeap::SystemMemory, uint32_t ExternalCallstackId = 0)
+{
+	ZEN_UNUSED(RootHeap, ExternalCallstackId);
+}
+inline void
+MemoryTrace_ReallocFree(uint64_t /*Address*/, HeapId RootHeap = EMemoryTraceRootHeap::SystemMemory, uint32_t ExternalCallstackId = 0)
+{
+	ZEN_UNUSED(RootHeap, ExternalCallstackId);
+}
+inline void
+MemoryTrace_ReallocAlloc(uint64_t /*Address*/,
+						 uint64_t /*NewSize*/,
+						 uint32_t /*Alignment*/,
+						 HeapId	  RootHeap			  = EMemoryTraceRootHeap::SystemMemory,
+						 uint32_t ExternalCallstackId = 0)
+{
+	ZEN_UNUSED(RootHeap, ExternalCallstackId);
+}
+inline void
+MemoryTrace_SwapOp(uint64_t /*PageAddress*/,
+				   EMemoryTraceSwapOperation /*SwapOperation*/,
+				   uint32_t CompressedSize = 0,
+				   uint32_t CallstackId	   = 0)
+{
+	ZEN_UNUSED(CompressedSize, CallstackId);
+}
+
+#endif	// UE_MEMORY_TRACE_ENABLED
+
+}  // namespace zen
diff --git a/src/zencore/include/zencore/memory/newdelete.h b/src/zencore/include/zencore/memory/newdelete.h
new file mode 100644
index 000000000..d22c8604f
--- /dev/null
+++ b/src/zencore/include/zencore/memory/newdelete.h
@@ -0,0 +1,155 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zenbase/zenbase.h>
+#include <new>
+
+#if defined(_MSC_VER)
+#	if (_MSC_VER >= 1900) && !defined(__EDG__)
+#		define ZEN_RESTRICT __declspec(allocator) __declspec(restrict)
+#	else
+#		define ZEN_RESTRICT __declspec(restrict)
+#	endif
+#else
+#	define ZEN_RESTRICT
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+
+[[nodiscard]] ZEN_RESTRICT void* zen_new(size_t size);
+[[nodiscard]] ZEN_RESTRICT void* zen_new_aligned(size_t size, size_t alignment);
+[[nodiscard]] ZEN_RESTRICT void* zen_new_nothrow(size_t size) noexcept;
+[[nodiscard]] ZEN_RESTRICT void* zen_new_aligned_nothrow(size_t size, size_t alignment) noexcept;
+
+void zen_free(void* p) noexcept;
+void zen_free_size(void* p, size_t size) noexcept;
+void zen_free_size_aligned(void* p, size_t size, size_t alignment) noexcept;
+void zen_free_aligned(void* p, size_t alignment) noexcept;
+
+//////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && defined(_Ret_notnull_) && defined(_Post_writable_byte_size_)
+#	define zen_decl_new(n)			[[nodiscard]] _VCRT_ALLOCATOR _Ret_notnull_ _Post_writable_byte_size_(n)
+#	define zen_decl_new_nothrow(n) [[nodiscard]] _VCRT_ALLOCATOR _Ret_maybenull_ _Success_(return != NULL) _Post_writable_byte_size_(n)
+#else
+#	define zen_decl_new(n)			[[nodiscard]]
+#	define zen_decl_new_nothrow(n) [[nodiscard]]
+#endif
+
+void
+operator delete(void* p) noexcept
+{
+	zen_free(p);
+}
+
+void
+operator delete[](void* p) noexcept
+{
+	zen_free(p);
+}
+
+void
+operator delete(void* p, const std::nothrow_t&) noexcept
+{
+	zen_free(p);
+}
+
+void
+operator delete[](void* p, const std::nothrow_t&) noexcept
+{
+	zen_free(p);
+}
+
+zen_decl_new(n) void*
+operator new(std::size_t n) noexcept(false)
+{
+	return zen_new(n);
+}
+
+zen_decl_new(n) void*
+operator new[](std::size_t n) noexcept(false)
+{
+	return zen_new(n);
+}
+
+zen_decl_new_nothrow(n) void*
+operator new(std::size_t n, const std::nothrow_t& tag) noexcept
+{
+	(void)(tag);
+	return zen_new_nothrow(n);
+}
+
+zen_decl_new_nothrow(n) void*
+operator new[](std::size_t n, const std::nothrow_t& tag) noexcept
+{
+	(void)(tag);
+	return zen_new_nothrow(n);
+}
+
+#if (__cplusplus >= 201402L || _MSC_VER >= 1916)
+void
+operator delete(void* p, std::size_t n) noexcept
+{
+	zen_free_size(p, n);
+};
+void
+operator delete[](void* p, std::size_t n) noexcept
+{
+	zen_free_size(p, n);
+};
+#endif
+
+#if (__cplusplus > 201402L || defined(__cpp_aligned_new))
+void
+operator delete(void* p, std::align_val_t al) noexcept
+{
+	zen_free_aligned(p, static_cast<size_t>(al));
+}
+void
+operator delete[](void* p, std::align_val_t al) noexcept
+{
+	zen_free_aligned(p, static_cast<size_t>(al));
+}
+void
+operator delete(void* p, std::size_t n, std::align_val_t al) noexcept
+{
+	zen_free_size_aligned(p, n, static_cast<size_t>(al));
+};
+void
+operator delete[](void* p, std::size_t n, std::align_val_t al) noexcept
+{
+	zen_free_size_aligned(p, n, static_cast<size_t>(al));
+};
+void
+operator delete(void* p, std::align_val_t al, const std::nothrow_t&) noexcept
+{
+	zen_free_aligned(p, static_cast<size_t>(al));
+}
+void
+operator delete[](void* p, std::align_val_t al, const std::nothrow_t&) noexcept
+{
+	zen_free_aligned(p, static_cast<size_t>(al));
+}
+
+void*
+operator new(std::size_t n, std::align_val_t al) noexcept(false)
+{
+	return zen_new_aligned(n, static_cast<size_t>(al));
+}
+void*
+operator new[](std::size_t n, std::align_val_t al) noexcept(false)
+{
+	return zen_new_aligned(n, static_cast<size_t>(al));
+}
+void*
+operator new(std::size_t n, std::align_val_t al, const std::nothrow_t&) noexcept
+{
+	return zen_new_aligned_nothrow(n, static_cast<size_t>(al));
+}
+void*
+operator new[](std::size_t n, std::align_val_t al, const std::nothrow_t&) noexcept
+{
+	return zen_new_aligned_nothrow(n, static_cast<size_t>(al));
+}
+#endif
diff --git a/src/zencore/include/zencore/memory/tagtrace.h b/src/zencore/include/zencore/memory/tagtrace.h
new file mode 100644
index 000000000..f51b21466
--- /dev/null
+++ b/src/zencore/include/zencore/memory/tagtrace.h
@@ -0,0 +1,93 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include <zenbase/zenbase.h>
+#include <zencore/trace.h>
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace zen {
+
+enum class ELLMTag : uint8_t;
+
+int32_t MemoryTrace_AnnounceCustomTag(int32_t Tag, int32_t ParentTag, const char* Display);
+int32_t MemoryTrace_GetActiveTag();
+
+inline constexpr int32_t TRACE_TAG = 257;
+
+}  // namespace zen
+
+////////////////////////////////////////////////////////////////////////////////
+#if !defined(UE_MEMORY_TAGS_TRACE_ENABLED)
+#	define UE_MEMORY_TAGS_TRACE_ENABLED 1
+#endif
+
+#if UE_MEMORY_TAGS_TRACE_ENABLED && UE_TRACE_ENABLED
+
+namespace zen {
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+  * Used to associate any allocation within this scope to a given tag.
+  *
+  * We need to be able to convert the three types of inputs to LLM scopes:
+  * - ELLMTag, an uint8 with fixed categories. There are three sub ranges
+	  Generic tags, platform and project tags.
+  * - FName, free form string, for example a specific asset.
+  * - TagData, an opaque pointer from LLM.
+  *
+  */
+class FMemScope
+{
+public:
+	FMemScope();  // Used with SetTagAndActivate
+	FMemScope(int32_t InTag, bool bShouldActivate = true);
+	FMemScope(ELLMTag InTag, bool bShouldActivate = true);
+	~FMemScope();
+
+private:
+	void								ActivateScope(int32_t InTag);
+	UE::Trace::Private::FScopedLogScope Inner;
+	int32_t								PrevTag;
+};
+
+/**
+ * A scope that activates in case no existing scope is active.
+ */
+template<typename TagType>
+class FDefaultMemScope : public FMemScope
+{
+public:
+	FDefaultMemScope(TagType InTag) : FMemScope(InTag, MemoryTrace_GetActiveTag() == 0) {}
+};
+
+/**
+ * Used order to keep the tag for memory that is being reallocated.
+ */
+class FMemScopePtr
+{
+public:
+	FMemScopePtr(uint64_t InPtr);
+	~FMemScopePtr();
+
+private:
+	UE::Trace::Private::FScopedLogScope Inner;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+#	define UE_MEMSCOPE(InTag)				FMemScope PREPROCESSOR_JOIN(MemScope, __LINE__)(InTag);
+#	define UE_MEMSCOPE_PTR(InPtr)			FMemScopePtr PREPROCESSOR_JOIN(MemPtrScope, __LINE__)((uint64)InPtr);
+#	define UE_MEMSCOPE_DEFAULT(InTag)		FDefaultMemScope PREPROCESSOR_JOIN(MemScope, __LINE__)(InTag);
+#	define UE_MEMSCOPE_UNINITIALIZED(Line) FMemScope PREPROCESSOR_JOIN(MemScope, Line);
+
+#else  // UE_MEMORY_TAGS_TRACE_ENABLED
+
+////////////////////////////////////////////////////////////////////////////////
+#	define UE_MEMSCOPE(...)
+#	define UE_MEMSCOPE_PTR(...)
+#	define UE_MEMSCOPE_DEFAULT(...)
+#	define UE_MEMSCOPE_UNINITIALIZED(...)
+#	define UE_MEMSCOPE_ACTIVATE(...)
+
+#endif	// UE_MEMORY_TAGS_TRACE_ENABLED
+}
diff --git a/src/zencore/include/zencore/string.h b/src/zencore/include/zencore/string.h
index b10b6a2ba..e2ef1c1a0 100644
--- a/src/zencore/include/zencore/string.h
+++ b/src/zencore/include/zencore/string.h
@@ -51,6 +51,30 @@ StringLength(const wchar_t* str)
 	return wcslen(str);
 }
 
+inline bool
+StringCompare(const char16_t* s1, const char16_t* s2)
+{
+	char16_t c1, c2;
+
+	while ((c1 = *s1) == (c2 = *s2))
+	{
+		if (c1 == 0)
+		{
+			return 0;
+		}
+
+		++s1;
+		++s2;
+	}
+	return uint16_t(c1) - uint16_t(c2);
+}
+
+inline bool
+StringEquals(const char16_t* s1, const char16_t* s2)
+{
+	return StringCompare(s1, s2) == 0;
+}
+
 inline size_t
 StringLength(const char16_t* str)
 {
diff --git a/src/zencore/include/zencore/trace.h b/src/zencore/include/zencore/trace.h
index 89e4b76bf..2ca2b7c81 100644
--- a/src/zencore/include/zencore/trace.h
+++ b/src/zencore/include/zencore/trace.h
@@ -19,6 +19,8 @@ ZEN_THIRD_PARTY_INCLUDES_END
 #define ZEN_TRACE_CPU(x) TRACE_CPU_SCOPE(x)
 #define ZEN_TRACE_CPU_FLUSH(x) TRACE_CPU_SCOPE(x, trace::CpuScopeFlags::CpuFlush)
 
+namespace zen {
+
 enum class TraceType
 {
 	File,
@@ -32,6 +34,8 @@ bool IsTracing();
 void TraceStart(std::string_view ProgramName, const char* HostOrPath, TraceType Type);
 bool TraceStop();
 
+}
+
 #else
 
 #define ZEN_TRACE_CPU(x)