Initial

public/Allocators.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "HeapAllocator.hpp"
+#include "ChunkAllocator.hpp"
+#include "PoolAllocator.hpp"
+
+namespace tp {
+	extern ModuleManifest gModuleAllocator;
+};
+
+inline void* operator new(size_t aSize, void* aWhere) noexcept { return aWhere; }
+
+void* operator new(size_t aSize);
+void* operator new[](size_t _Size);
+void  operator delete(void* aPtr);
+void  operator delete[](void* aPtr);
+
+void* operator new(size_t aSize, tp::HeapAlloc& aAlloc);
+void* operator new[](size_t _Size, tp::HeapAlloc& aAlloc);
+void  operator delete(void* aPtr, tp::HeapAlloc& aAlloc);
+void  operator delete[](void* aPtr, tp::HeapAlloc& aAlloc);
+
+void* operator new(size_t aSize, tp::HeapAllocGlobal& aAlloc);
+void* operator new[](size_t _Size, tp::HeapAllocGlobal& aAlloc);
+void  operator delete(void* aPtr, tp::HeapAllocGlobal& aAlloc);
+void  operator delete[](void* aPtr, tp::HeapAllocGlobal& aAlloc);

public/ChunkAllocator.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "common.h"
+#include "PublicConfig.hpp"
+
+namespace tp {
+
+	// Chunk Allocator
+	// Constant time allocations and deallocations in any order.
+	// Memory blocks are fixed in size and number of blocks can not exceed given parameter.
+	struct ChunkAlloc {
+
+		ChunkAlloc(ualni aBlockSize, void* aMemory, ualni aMemSize);
+		ChunkAlloc(ualni aBlockSize, ualni aNBlocks);
+
+		void* allocate();
+		void deallocate(void* aPtr);
+		bool isFull();
+		bool isEmpty();
+
+		~ChunkAlloc();
+
+	private:
+		ualni mBSize; // Size of data in aligned units
+		ualni mNBlocks;
+
+		ualni* mBuff;
+		ualni* mNextBlock = 0;
+		ualni mNFreeBlocks;
+		ualni mNInitBlocks = 0;
+		bool mOwnBuff = false;
+	};
+};

public/HeapAllocator.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "HeapAllocatorGlobal.hpp"
+
+namespace tp {
+
+	struct HeapAlloc {
+
+#ifdef MEM_DEBUG
+		HeapAllocGlobal mAlloc;
+
+		ualni mNumAllocations = 0;
+		struct MemHeadLocal* mEntry = NULL;
+#endif
+
+		void* allocate(ualni aBlockSize);
+		void deallocate(void* aPtr);
+		~HeapAlloc();
+	};
+};

public/HeapAllocatorGlobal.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "common.h"
+#include "PublicConfig.hpp"
+
+namespace tp {
+
+	struct HeapAllocGlobal {
+
+#ifdef MEM_DEBUG
+		static ualni mNumAllocations;
+		static struct MemHead* mEntry;
+#endif
+		
+		static void* allocate(ualni aBlockSize);
+		static void deallocate(void* aPtr);
+		~HeapAllocGlobal();
+	};
+};

public/PickAllocator.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "HeapAllocatorGlobal.hpp"
+
+namespace tp {
+
+	struct PickAlloc {
+		PickAlloc();
+		void* allocate(ualni aBlockSize);
+		void deallocate(void* aPtr);
+		~PickAlloc();
+	};
+};

public/PoolAllocator.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "ChunkAllocator.hpp"
+
+namespace tp {
+
+	// Pool Allocator
+	// Overcomes chunk allocator fixed number of max allocations
+	struct PoolAlloc {
+
+		PoolAlloc(ualni aBlockSize, ualni aChunkSize);
+		void* allocate();
+		void deallocate(void* aPtr);
+		~PoolAlloc();
+
+	private:
+
+		struct Chunk : public ChunkAlloc {
+			Chunk(ualni aBlockSize, ualni aChunlSize) : ChunkAlloc(aBlockSize, aChunlSize) {}
+			Chunk* mNext = NULL;
+			Chunk* mPrev = NULL;
+		};
+
+		struct Chunks {
+			void add(Chunk*);
+			void remove(Chunk*);
+			Chunk* find(void* aPtr);
+			Chunk* findNotFull();
+			Chunk** mBuff = NULL;
+			ualni mUsedLen = 0;
+			ualni mLen = 0;
+
+		private:
+			Chunk** findUtil(Chunk** aLeft, Chunk** aRight, void* aPtr);
+		};
+
+		Chunks mChunks;
+		Chunk* mFreeChunk = NULL;
+		ualni mBlockSize;
+		ualni mChunkSize;
+	};
+};