Add basic allocators

engine/native/CMakeLists.txt

@@ -4,4 +4,4 @@ include(Modules)
 add_subdirectory(thirdparty SYSTEM)
 
 add_modules_library(core SHARED)
-target_link_libraries(core PUBLIC definitions math)
+target_link_libraries(core PUBLIC definitions math memory)

engine/native/core/CMakeLists.txt

@@ -1,3 +1,4 @@
 add_modules_library(definitions PIC)
 add_modules_library(math)
+add_modules_library(memory)
 target_link_libraries(math PUBLIC definitions)

engine/native/core/core.cppm

@@ -1,3 +1,4 @@
 export module core;
 export import core.defs;
 export import core.math;
+export import core.memory;

engine/native/core/memory/allocator.cpp

@@ -0,0 +1,34 @@
+module;
+
+#include <cstddef>
+
+module core.memory.allocator;
+
+namespace draco::memory
+{
+	Error nilAlloc(
+		Allocator alloc,
+		Slice *dst,
+		size_t size,
+		size_t align
+	)
+	{
+		return Error::NotImplemented;
+	}
+
+	Error nilFree(Allocator alloc, Slice block)
+	{
+		return Error::NotImplemented;
+	}
+
+	Error nilFreeAll(Allocator alloc)
+	{
+		return Error::NotImplemented;
+	}
+
+	void asAllocatorVoid(Allocator *dst, void *alloc, AllocatorVTbl *vtbl)
+	{
+		dst->allocatorData = (void*)alloc;
+		dst->vtbl = vtbl;
+	}
+}

engine/native/core/memory/allocator.cppm

@@ -0,0 +1,55 @@
+module;
+
+#include <cstddef>
+
+export module core.memory.allocator;
+export import core.memory.slice;
+
+export namespace draco::memory
+{
+	enum class Error
+	{
+		Okay,
+		OutOfMemory,
+		NotImplemented,
+		IllegalAddressRange,
+		Other, // This one shouldn't be needed. If you see it returned, make a
+			   // new error.
+	};
+
+	struct AllocatorVTbl;
+
+	struct Allocator
+	{
+		AllocatorVTbl *vtbl;
+		void *allocatorData;
+	};
+
+	struct AllocatorVTbl
+	{
+		using AllocFn = Error (*)(
+			Allocator alloc,
+			Slice *dst,
+			size_t size,
+			size_t align
+		);
+		using FreeFn = Error (*)(Allocator alloc, Slice block);
+		using FreeAllFn = Error (*)(Allocator alloc);
+		AllocFn alloc;
+		FreeFn free;
+		FreeAllFn freeAll;
+	};
+
+	Error nilAlloc(
+		Allocator alloc,
+		Slice *dst,
+		size_t size,
+		size_t align
+	);
+
+	Error nilFree(Allocator alloc, Slice block);
+
+	Error nilFreeAll(Allocator alloc);
+
+	void asAllocatorVoid(Allocator *dst, void *alloc, AllocatorVTbl *vtbl);
+}

engine/native/core/memory/bumpAllocator.cpp

@@ -0,0 +1,117 @@
+module;
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+module core.memory.bumpAllocator;
+
+namespace draco::memory::bump
+{
+	void init(
+		BumpAllocator *alloc,
+		Allocator baseAlloc,
+		// one page by default on unix-like systems
+		size_t minAllocRequest
+	)
+	{
+		memset(alloc, 0, sizeof(BumpAllocator));
+		alloc->base = baseAlloc;
+		alloc->minAllocRequest = minAllocRequest;
+	}
+
+	void deinit(BumpAllocator *alloc)
+	{
+		Node *lastNode;
+		Node *node = alloc->first;
+		while (node != nullptr)
+		{
+			lastNode = node;
+			node = node->next;
+			alloc->base.vtbl->free(
+				alloc->base,
+				{
+					.data = (void*)lastNode,
+					.size = lastNode->size + sizeof(Node),
+			   	}
+			);
+		}
+	}
+
+	Error alloc(Allocator alloc, Slice *dst, size_t size, size_t align)
+	{
+		Error err;
+		BumpAllocator *allocData = (BumpAllocator *)alloc.allocatorData;
+		uintptr_t alignMask = align - 1;
+		Node **lastNode;
+		Node **node = &(allocData->first);
+		size_t pos = allocData->allocated;
+		size_t oldPos = pos;
+		size_t reqSize = size;
+		size_t spillover = 0;
+		Slice newBlock;
+		uintptr_t currentPtr;
+		assert(std::popcount(align) == 1);
+		lastNode = node;
+		while (((*node) != nullptr) & (pos > 0))
+		{
+			oldPos = pos;
+			pos -= std::min((*node)->size, pos);
+			lastNode = node;
+			node = &((*node)->next);
+		}
+		assert(pos == 0); // fraudulent mark provided
+		currentPtr = ((uintptr_t)(*lastNode)) + sizeof(Node) + oldPos;
+		reqSize = size + ((align - (currentPtr & alignMask)) & alignMask);
+		if (!(*lastNode) || (reqSize > ((*lastNode)->size - oldPos)))
+		{
+			if (*lastNode)
+			{
+				spillover = ((*lastNode)->size - oldPos);
+			}
+			reqSize = (sizeof(Node) + size + alignMask) & ~alignMask;
+			err = allocData->base.vtbl->alloc(
+				allocData->base,
+				&newBlock,
+				std::max(allocData->minAllocRequest, reqSize),
+				std::max(alignof(Node), align)
+			);
+			if (err != Error::Okay)
+			{
+				return Error::OutOfMemory;
+			}
+			(*node) = (Node *)newBlock.data;
+			(*node)->next = nullptr;
+			(*node)->size = newBlock.size - sizeof(Node);
+			pos = 0;
+			lastNode = node;
+			oldPos = 0;
+		}
+		currentPtr = ((uintptr_t)&((*lastNode)->data[oldPos]));
+		reqSize = size + ((align - (currentPtr & alignMask)) & alignMask);
+		currentPtr = (currentPtr + alignMask) & ~alignMask;
+		allocData->allocated += reqSize + spillover;
+		dst->data = (void*)currentPtr;
+		dst->size = size;
+		return Error::Okay;
+	}
+
+	Error freeAll(Allocator alloc)
+	{
+		BumpAllocator *allocData = (BumpAllocator *)alloc.allocatorData;
+		allocData->allocated = 0;
+		return Error::Okay;
+	}
+
+	size_t saveMark(BumpAllocator *self)
+	{
+		return self->allocated;
+	}
+
+	void resumeMark(BumpAllocator *self, size_t mark)
+	{
+		self->allocated = mark;
+	}
+}

engine/native/core/memory/bumpAllocator.cppm

@@ -0,0 +1,59 @@
+module;
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+export module core.memory.bumpAllocator;
+export import core.memory.allocator;
+export import core.memory.slice;
+
+export namespace draco::memory
+{
+	namespace bump
+	{
+		struct Node
+		{
+			Node *next;
+			size_t size;
+			uint8_t data[];
+		};
+
+		struct BumpAllocator
+		{
+			Allocator base;
+			Node *first;
+			size_t minAllocRequest;
+			size_t allocated;
+		};
+
+		void init(
+			BumpAllocator *alloc,
+			Allocator baseAlloc,
+			// one page by default on unix-like systems
+			size_t minAllocRequest = (1 << 12)
+		);
+
+		void deinit(BumpAllocator *alloc);
+
+		Error alloc(Allocator alloc, Slice *dst, size_t size, size_t align);
+
+		Error freeAll(Allocator alloc);
+
+		AllocatorVTbl bumpAllocatorVtbl = {
+			.alloc = alloc,
+			.free = nilFree,
+			.freeAll = freeAll,
+		};
+
+		size_t saveMark(BumpAllocator *self);
+
+		void resumeMark(BumpAllocator *self, size_t mark);
+
+		inline void asAllocator(Allocator *dst, BumpAllocator *alloc)
+		{
+			asAllocatorVoid(dst, (void*)alloc, &bumpAllocatorVtbl);
+		}
+	}
+}