first pass memory buckets

5 files changed, 139 insertions, 7 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c367dcc..0a3f4f7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,6 +13,8 @@ set(CMAKE_CXX_FLAGS_RELEASE "-O3 -s DNDEBUG")
 
 set(PKE_SOURCE_FILES
 	src/main.cpp
+	src/memory.hpp
+	src/memory.cpp
 	src/window.hpp
 	src/window.cpp
 )
diff --git a/src/memory.cpp b/src/memory.cpp
new file mode 100644
index 0000000..83f8483
--- /dev/null
+++ b/src/memory.cpp
@@ -0,0 +1,92 @@
+
+#include "memory.hpp"
+
+struct pke::MemBucket {
+	int64_t size;
+	int64_t head;
+	int64_t free;
+	int64_t allocs;
+	char * ptr;
+};
+
+pke::MemBucket buckets[128]; // 32 gigs
+int64_t bucketHead = 0;
+
+int64_t InitNewBucket(int64_t sz) {
+	buckets[bucketHead].size = sz;
+	buckets[bucketHead].ptr = reinterpret_cast<char *>(std::malloc(sz));
+	buckets[bucketHead].free = 0;
+	buckets[bucketHead].head = 0;
+	buckets[bucketHead].allocs = 0;
+	return bucketHead++;
+}
+
+void *pke::PkeNew(std::size_t sz) {
+	MemBucket *bkt = nullptr;
+	for (long i = 0; i < bucketHead; ++i) {
+		if (buckets[i].size - buckets[i].head > sz) {
+			bkt = &buckets[i];
+		}
+	}
+	if (bkt == nullptr) {
+		bkt = &buckets[InitNewBucket(DEFAULT_BUCKET_SIZE)];
+	}
+	void *ptr = bkt->ptr + bkt->head;
+	bkt->head += sz;
+	bkt->allocs++;
+	return ptr;
+}
+
+void *pke::PkeNew(std::size_t sz, pke::MemBucket *bkt) {
+	void *ptr = bkt->ptr + bkt->head;
+	bkt->head += sz;
+	bkt->allocs++;
+	return ptr;
+}
+
+void pke::PkeDelete(void *ptr) {
+	pke::MemBucket *bkt = nullptr;
+	for (long i = 0; i < bucketHead; ++i) {
+		bkt = &buckets[i];
+		if (ptr > bkt->ptr && ptr < bkt->ptr + bkt->size) break;
+	}
+	if (bkt == nullptr) {
+		std::printf("bad pointer %llu", reinterpret_cast<unsigned long long>(ptr));
+		throw "bad pointer";
+	}
+	bkt->allocs--;
+	if (bkt->allocs == 0) {
+		bkt->head = 0;
+		bkt->free = 0;
+	}
+}
+
+void pke::PkeDelete(void *ptr, pke::MemBucket *bkt) {
+	bkt->allocs--;
+	if (bkt->allocs == 0) {
+		bkt->head = 0;
+		bkt->free = 0;
+	}
+}
+
+pke::MemBucket *pke::BeginTransientBucket(int64_t sz) {
+	return &buckets[InitNewBucket(sz)];
+}
+
+void pke::EndTransientBucket(pke::MemBucket *bkt) {
+	int64_t foundIndex = -1;
+	for (int64_t i = 0; i < bucketHead; ++i) {
+		if (&buckets[i] == bkt) {
+			foundIndex = i;
+			std::free(bkt->ptr);
+			bkt->size = 0;
+			bkt->head = 0;
+			bkt->free = 0;
+			bkt->ptr = reinterpret_cast<char *>(0xCAFEBABE);
+			break;
+		}
+	}
+	if (foundIndex == bucketHead) {
+		bucketHead--;
+	}
+}
diff --git a/src/memory.hpp b/src/memory.hpp
new file mode 100644
index 0000000..43ada0f
--- /dev/null
+++ b/src/memory.hpp
@@ -0,0 +1,34 @@
+#ifndef PKE_MEMORY_HPP
+#define PKE_MEMORY_HPP
+
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+
+#define DEFAULT_BUCKET_SIZE 1UL << 27
+
+namespace pke
+{
+
+struct MemBucket;
+
+void *PkeNew(std::size_t sz);
+void *PkeNew(std::size_t sz, MemBucket *bkt);
+void PkeDelete(void *ptr);
+void PkeDelete(void *ptr, MemBucket *bkt);
+
+MemBucket *BeginTransientBucket(int64_t sz = DEFAULT_BUCKET_SIZE); // 256MB
+void EndTransientBucket(MemBucket *bkt);
+
+template <typename T>
+T *PkeNew() {
+	return reinterpret_cast<T *>(PkeNew(sizeof(T)));
+}
+template <typename T>
+T *PkeNew(std::size_t sz) {
+	return reinterpret_cast<T *>(PkeNew(sz));
+}
+
+} /* pke */ 
+
+#endif /* PKE_MEMORY_HPP */
diff --git a/src/window.cpp b/src/window.cpp
index 2ab34c6..ef65c5d 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -334,7 +334,7 @@ void CreateSwapchain() {
 	if (selectedSurfaceIndex == -1u) {
 		unsigned int surfaceFormatCounts;
 		vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, vkSurfaceKHR, &surfaceFormatCounts, nullptr);
-		VkSurfaceFormatKHR *surfaceFormats = new VkSurfaceFormatKHR[surfaceFormatCounts];
+		VkSurfaceFormatKHR *surfaceFormats = pke::PkeNew<VkSurfaceFormatKHR>(sizeof(VkSurfaceFormatKHR) * surfaceFormatCounts);
 		vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, vkSurfaceKHR, &surfaceFormatCounts, surfaceFormats);
 		selectedSurfaceIndex = 0;
 		for (long i = 0; i < surfaceFormatCounts; ++i) {
@@ -346,7 +346,7 @@ void CreateSwapchain() {
 			break;
 		}
 
-		delete[] surfaceFormats;
+		pke::PkeDelete(surfaceFormats);
 	}
 
 	int width, height;
@@ -362,8 +362,8 @@ void CreateSwapchain() {
 	if (selectedPresentIndex == -1u) {
 		unsigned int presentModeCount = 0;
 		vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, vkSurfaceKHR, &presentModeCount, nullptr);
-		VkPresentModeKHR *presentModes = new VkPresentModeKHR[presentModeCount];
-		vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, vkSurfaceKHR, &presentModeCount, nullptr);
+		VkPresentModeKHR *presentModes = pke::PkeNew<VkPresentModeKHR>(sizeof(VkPresentModeKHR) * presentModeCount);
+		vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, vkSurfaceKHR, &presentModeCount, presentModes);
 		unsigned long mailboxIndex = -1;
 		unsigned long fifoRelaxedIndex = -1;
 		for (long i = 0; i < presentModeCount; ++i) {
@@ -375,7 +375,7 @@ void CreateSwapchain() {
 		}
 		selectedPresentIndex = mailboxIndex != -1ul ? mailboxIndex : fifoRelaxedIndex;
 		vkPresentModeKHR = presentModes[selectedPresentIndex];
-		delete[] presentModes;
+		pke::PkeDelete(presentModes);
 	}
 
 	VkSwapchainCreateInfoKHR vkSwapchainCreateInfo{};
@@ -427,9 +427,9 @@ void CreateSwapchain() {
 	vkImageViewCreateInfo.subresourceRange = vkImageSubresourceRange;
 
 	vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, nullptr);
-	swapchainImages = new VkImage[swapchainLength];
+	swapchainImages = pke::PkeNew<VkImage>(sizeof(VkImage) * swapchainLength);
 	vkGetSwapchainImagesKHR(vkDevice, vkSwapchainKHR, &swapchainLength, swapchainImages);
-	swapchainImageViews = new VkImageView[swapchainLength];
+	swapchainImageViews = pke::PkeNew<VkImageView>(sizeof(VkImageView) * swapchainLength);
 	for (long i = 0; i < swapchainLength; ++i) {
 		vkImageViewCreateInfo.image = swapchainImages[i];
 		vkCreateImageView(vkDevice, &vkImageViewCreateInfo, vkAllocator, &swapchainImageViews[i]);
@@ -441,6 +441,8 @@ void DestroySwapchain() {
 		for (long i = 0; i < swapchainLength; ++i) {
 			vkDestroyImageView(vkDevice, swapchainImageViews[i], vkAllocator);
 		}
+		pke::PkeDelete(swapchainImageViews);
+		pke::PkeDelete(swapchainImages);
 	}
 	vkDestroySwapchainKHR(vkDevice, vkSwapchainKHR, vkAllocator);
 	swapchainImages = reinterpret_cast<VkImage *>(0xCAFEBABE);
diff --git a/src/window.hpp b/src/window.hpp
index 38f3151..5c29008 100644
--- a/src/window.hpp
+++ b/src/window.hpp
@@ -1,6 +1,8 @@
 #ifndef PKE_WINDOW_HPP
 #define PKE_WINDOW_HPP
 
+#include "memory.hpp"
+
 #include <GLFW/glfw3.h>
 #include <vulkan/vulkan.h>