Revert "Replace MallocAllocator with SystemAllocator"

This reverts commit de2f8b5.

# Conflicts:
#	Core/GameEngine/Include/Common/GameMemory.h
#	Core/GameEngine/Source/Common/System/GameMemoryCommon.cpp
#	Core/Libraries/Source/WWVegas/WWLib/DbgHelpLoader.cpp
#	Core/Libraries/Source/WWVegas/WWLib/MallocAllocator.h

Author: xezon

Core/GameEngine/CMakeLists.txt

@@ -651,7 +651,6 @@ set(GAMEENGINE_SRC
 #    Source/Common/System/FunctionLexicon.cpp
 #    Source/Common/System/GameCommon.cpp
     #Source/Common/System/GameMemory.cpp # is conditionally appended
-    Source/Common/System/GameMemoryCommon.cpp
     #Source/Common/System/GameMemoryInit.cpp # is conditionally appended
 #    Source/Common/System/GameType.cpp
 #    Source/Common/System/Geometry.cpp

Core/GameEngine/Include/Common/GameMemory.h

@@ -177,24 +177,8 @@
 
 	};
 
-#define USE_FILLER_VALUE
-
 #endif // MEMORYPOOL_DEBUG
 
-extern Int theTotalSystemAllocationInBytes;
-extern Int thePeakSystemAllocationInBytes;
-
-// TheSuperHackers @tweak The system allocator functions are now global.
-// Use this to bypass Game Memory Pools in exceptional circumstances.
-extern void* sysAllocateDoNotZero(size_t numBytes);
-extern void sysFree(void* p);
-extern void memset32(void* ptr, Int value, size_t bytesToFill);
-
-#ifdef USE_FILLER_VALUE
-extern UnsignedInt s_initFillerValue;
-extern void calcFillerValue(Int index);
-#endif
-
 // TheSuperHackers @build xezon 30/03/2025 Define DISABLE_GAMEMEMORY to use a null implementations for Game Memory.
 // Useful for address sanitizer checks and other investigations.
 // Is included below the macros so that memory pool debug code can still be used.

Core/GameEngine/Source/Common/System/GameMemory.cpp

@@ -114,7 +114,21 @@ DECLARE_PERF_TIMER(MemoryPoolInitFilling)
 		#define MEMORYPOOL_SINGLEBLOCK_GETS_STACKTRACE
 	#endif
 
+	#define USE_FILLER_VALUE
+
 	const Int MAX_INIT_FILLER_COUNT = 8;
+	#ifdef USE_FILLER_VALUE
+		static UnsignedInt s_initFillerValue = 0xf00dcafe; // will be replaced, should never be this value at runtime
+		static void calcFillerValue(Int index)
+		{
+			s_initFillerValue = (index & 3) << 1;
+			s_initFillerValue |= 0x01;
+			s_initFillerValue |= (~(s_initFillerValue << 4)) & 0xf0;
+			s_initFillerValue |= (s_initFillerValue << 8);
+			s_initFillerValue |= (s_initFillerValue << 16);
+			//DEBUG_LOG(("Setting MemoryPool initFillerValue to %08x (index %d)",s_initFillerValue,index));
+		}
+	#endif
 
 #endif
 
@@ -155,6 +169,8 @@ DECLARE_PERF_TIMER(MemoryPoolInitFilling)
 
 #ifdef MEMORYPOOL_DEBUG
 
+	static Int theTotalSystemAllocationInBytes = 0;
+	static Int thePeakSystemAllocationInBytes = 0;
 	static Int theTotalLargeBlocks = 0;
 	static Int thePeakLargeBlocks = 0;
 	Int theTotalDMA = 0;
@@ -187,7 +203,9 @@ static Bool theMainInitFlag = false;
 #define MEM_BOUND_ALIGNMENT 4
 
 static Int roundUpMemBound(Int i);
-
+static void *sysAllocateDoNotZero(Int numBytes);
+static void sysFree(void* p);
+static void memset32(void* ptr, Int value, Int bytesToFill);
 #ifdef MEMORYPOOL_STACKTRACE
 static void doStackDumpOutput(const char* m);
 static void doStackDump(void **stacktrace, int size);
@@ -205,6 +223,73 @@ static Int roundUpMemBound(Int i)
 	return (i + (MEM_BOUND_ALIGNMENT-1)) & ~(MEM_BOUND_ALIGNMENT-1);
 }
 
+//-----------------------------------------------------------------------------
+/**
+	this is the low-level allocator that we use to request memory from the OS.
+	all (repeat, all) memory allocations in this module should ultimately
+	go thru this routine (or sysAllocate).
+
+	note: throws ERROR_OUT_OF_MEMORY on failure; never returns null
+*/
+static void* sysAllocateDoNotZero(Int numBytes)
+{
+	void* p = ::GlobalAlloc(GMEM_FIXED, numBytes);
+	if (!p)
+		throw ERROR_OUT_OF_MEMORY;
+#ifdef MEMORYPOOL_DEBUG
+	{
+		USE_PERF_TIMER(MemoryPoolDebugging)
+		#ifdef USE_FILLER_VALUE
+		{
+			USE_PERF_TIMER(MemoryPoolInitFilling)
+			::memset32(p, s_initFillerValue, ::GlobalSize(p));
+		}
+		#endif
+		theTotalSystemAllocationInBytes += ::GlobalSize(p);
+		if (thePeakSystemAllocationInBytes < theTotalSystemAllocationInBytes)
+			thePeakSystemAllocationInBytes = theTotalSystemAllocationInBytes;
+	}
+#endif
+	return p;
+}
+
+//-----------------------------------------------------------------------------
+/**
+	the counterpart to sysAllocate / sysAllocateDoNotZero; used to free blocks
+	allocated by them. it is OK to pass null here (it will just be ignored).
+*/
+static void sysFree(void* p)
+{
+	if (p)
+	{
+#ifdef MEMORYPOOL_DEBUG
+		{
+			USE_PERF_TIMER(MemoryPoolDebugging)
+			::memset32(p, GARBAGE_FILL_VALUE, ::GlobalSize(p));
+			theTotalSystemAllocationInBytes -= ::GlobalSize(p);
+		}
+#endif
+		::GlobalFree(p);
+	}
+}
+
+// ----------------------------------------------------------------------------
+/**
+	fills memory with a 32-bit value (note: assumes the ptr is 4-byte-aligned)
+*/
+static void memset32(void* ptr, Int value, Int bytesToFill)
+{
+	Int wordsToFill = bytesToFill>>2;
+	bytesToFill -= (wordsToFill<<2);
+
+	Int *p = (Int*)ptr;
+	for (++wordsToFill; --wordsToFill; )
+		*p++ = value;
+
+	Byte *b = (Byte *)p;
+	for (++bytesToFill; --bytesToFill; )
+		*b++ = (Byte)value;
+}
 
 #ifdef MEMORYPOOL_STACKTRACE
 // ----------------------------------------------------------------------------
@@ -1548,20 +1633,20 @@ void* MemoryPool::allocateBlockDoNotZeroImplementation(DECLARE_LITERALSTRING_ARG
 	if (m_firstBlobWithFreeBlocks != NULL && !m_firstBlobWithFreeBlocks->hasAnyFreeBlocks())
 	{
 		// hmm... the current 'free' blob has nothing available. look and see if there
-		// are any other existing blobs with free space.
+		// are any other existing blobs with freespace.
 		MemoryPoolBlob *blob = m_firstBlob;
 		for (; blob != NULL; blob = blob->getNextInList())
 		{
 			if (blob->hasAnyFreeBlocks())
 			 	break;
 		}
 
-		// note that if we walk through the list without finding anything, this will
-		// reset m_firstBlobWithFreeBlocks to null and fall through.
+		// note that if we walk thru the list without finding anything, this will
+		// reset m_firstBlobWithFreeBlocks to null and fall thru.
 	 	m_firstBlobWithFreeBlocks = blob;
 	}
 
-	// OK, if we are here then we have no blobs with free space... darn.
+	// OK, if we are here then we have no blobs with freespace... darn.
 	// allocate an overflow block.
 	if (m_firstBlobWithFreeBlocks == NULL)
 	{