Kinda have this memory alloation strat sorted...

code/base/arena.h

@@ -20,10 +20,10 @@ typedef U32 ArenaFlags;
 enum
 {
 	// Don't chain this arena
-	ArenaFlag_NoChain      = (1 << 0), 
-	// Only works if backing is virtual memory, will allocate a new backing VArena when the current block exhausts
-	// Otherwise will assume backing can chain multiple block_size arenas until failure.
-	ArenaFlag_ChainVirtual = (1 << 1),
+	ArenaFlag_NoChain        = (1 << 0), 
+	// Only relevant if backing is virtual memory, will prevent allocating a new backing VArena when the current block exhausts
+	// Will assume backing can chain multiple block_size arenas however. If there is an allocation failure it will assert.
+	ArenaFlag_NoChainVirtual = (1 << 1),
 };
 
 typedef struct ArenaParams ArenaParams;
@@ -34,13 +34,16 @@ struct ArenaParams
 	U64           block_size; // If chaining VArenas set this to the reserve size
 };
 
-/* NOTE(Ed): This is a combination of several concepts into a single interface:
-	* A arena 'block' of memory with segmented chaining of the blocks
+/* NOTE(Ed): The original metadesk arena is a combination of several concepts into a single interface:
 	* An OS virtual memory allocation scheme
+	* A arena 'block' of memory with segmented chaining of the blocks
 	* A push/pop stack allocation interface for the arena
 
-	TODO(Ed): We need to lift the virtual memory tracking to its own data structure 
-	and virtual memory interface utilizing memory_substrate.h
+	The virtual memory has been abstracted into a backing allocator,
+	and chaining still supports reserving new virtual address regions .
+	(can be disabled with ArenaFlag_NoChainVirtual)
+
+	If large pages are desired, see VArena.
 */
 
 typedef struct Arena Arena;
@@ -49,8 +52,8 @@ struct Arena
 	Arena*        prev;    // previous arena in chain
 	Arena*        current; // current arena in chain
 	AllocatorInfo backing;
-	U64           pos;
-	U64           block_size;
+	SSIZE         pos;
+	SSIZE         block_size;
 	ArenaFlags    flags;
 };
 static_assert(size_of(Arena) <= ARENA_HEADER_SIZE, "sizeof(Arena) <= ARENA_HEADER_SIZE");
@@ -59,7 +62,7 @@ typedef struct TempArena TempArena;
 struct TempArena
 {
 	Arena* arena;
-	U64    pos;
+	SSIZE  pos;
 };
 
 ////////////////////////////////
@@ -67,23 +70,29 @@ struct TempArena
 
 MD_API void* arena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags);
 
+inline
+AllocatorInfo arena_allocator(Arena* arena) {
+	AllocatorInfo info = { arena_allocator_proc, arena};
+	return info;
+}
+
 //- rjf: arena creation/destruction
 
-MD_API Arena* arena_alloc_(ArenaParams *params);
-#define       arena_alloc(...) arena_alloc_( & ( ArenaParams) { .backing = {}, .reserve_size = MB(64), .commit_size = KB(64), __VA_ARGS__ } )
+MD_API Arena* arena_alloc_(ArenaParams* params);
+#define       arena_alloc(...) arena_alloc_( &(ArenaParams){ __VA_ARGS__ } )
 
 void arena_release(Arena *arena);
 
 //- rjf: arena push/pop/pos core functions
 
-internal void *arena_push  (Arena *arena, U64 size, U64 align);
+internal void *arena_push  (Arena *arena, SSIZE size, SSIZE align);
 internal U64   arena_pos   (Arena *arena);
-internal void  arena_pop_to(Arena *arena, U64 pos);
+internal void  arena_pop_to(Arena *arena, SSIZE pos);
 
 //- rjf: arena push/pop helpers
 
 internal void arena_clear(Arena *arena);
-internal void arena_pop  (Arena *arena, U64 amt);
+internal void arena_pop  (Arena *arena, SSIZE amt);
 
 //- rjf: temporary arena scopes
 
@@ -110,3 +119,20 @@ arena_release(Arena* arena)
 		alloc_free(arena->backing, n);
 	}
 }
+
+// DEFAULT_ALLOCATOR
+#ifndef MD_OVERRIDE_DEFAULT_ALLOCATOR
+// The default allocator for this base module is the Arena allocator with a VArena backing
+inline
+AllocatorInfo default_allocator()
+{
+	local_persist thread_local VArena* backing_vmem = nullptr;
+	local_persist thread_local Arena*  arena        = nullptr;
+	if (arena == nullptr) {
+		backing_vmem = varena_alloc(.flags = 0, .base_addr = 0x0, .reserve_size = VARENA_DEFAULT_RESERVE, .commit_size = VARENA_DEFAULT_COMMIT);
+		arena        = arena_alloc(.backing = varena_allocator(backing_vmem), .block_size = VARENA_DEFAULT_RESERVE);
+	}
+	AllocatorInfo info = { arena_allocator_proc, arena };
+	return info;
+}
+#endif