checkpoint - memory overhual including tests

3 files changed, 242 insertions, 0 deletions

diff --git a/test/memory/CMakeLists.txt b/test/memory/CMakeLists.txt
new file mode 100644
index 0000000..ede5be4
--- /dev/null
+++ b/test/memory/CMakeLists.txt
@@ -0,0 +1,16 @@
+set(BINARY pke_test_memory)
+
+set(TEST_SOURCE_FILES 
+    main.cpp
+    general.cpp
+		../../src/memory.cpp
+)
+
+add_executable(${BINARY} ${TEST_SOURCE_FILES})
+
+add_test(NAME ${BINARY} COMMAND ${BINARY})
+
+target_include_directories(${BINARY} PUBLIC "../../src")
+
+target_link_libraries(${BINARY} PUBLIC gmock)
+
diff --git a/test/memory/general.cpp b/test/memory/general.cpp
new file mode 100644
index 0000000..825e2f6
--- /dev/null
+++ b/test/memory/general.cpp
@@ -0,0 +1,220 @@
+
+#include "memory.hpp"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+struct TMemBlock {
+	char *data;
+	size_t size;
+};
+
+struct TMemBucket {
+	int64_t size;
+	int64_t head;
+	int64_t lostBytes;
+	int64_t allocs;
+	int64_t lastEmptyBlockIndex;
+	int64_t maxBlockCount;
+	TMemBlock *blocks;
+	char *ptr;
+	bool transient;
+};
+
+class MemoryTest : public ::testing::Test {
+protected:
+	void SetUp() override {
+		MemBkt_Test = Pke_BeginTransientBucket(1024 * 1024);
+		bkt = reinterpret_cast<TMemBucket *>(MemBkt_Test);
+	};
+	void TearDown() override {
+		Pke_EndTransientBucket(MemBkt_Test);
+	};
+	MemBucket *MemBkt_Test = nullptr;
+	TMemBucket *bkt = nullptr;
+};
+
+/*
+ * Test that memory can be allocated predictably
+ */
+TEST_F(MemoryTest, EnsureAllocation001) {
+	// arrange
+	size_t sz = 2;
+	size_t alignment = 1;
+	
+	// act
+	Pke_New(sz, alignment, MemBkt_Test);
+	
+	// assert
+	EXPECT_EQ(-1, bkt->lastEmptyBlockIndex);
+	EXPECT_EQ(sz, bkt->head);
+};
+
+/*
+ * Test that memory can be freed predictably
+ */
+TEST_F(MemoryTest, EnsureFree001) {
+	// arrange
+	size_t sz = 2;
+	size_t alignment = 1;
+	
+	// act
+	void *ptr1 = Pke_New(sz, alignment, MemBkt_Test);
+	Pke_Delete(ptr1, sz, MemBkt_Test);
+	
+	// assert
+	EXPECT_EQ(-1, bkt->lastEmptyBlockIndex);
+	EXPECT_EQ(0, bkt->head);
+};
+
+
+/*
+ * Test that memory can be allocated and freed predictably
+ */
+class MemoryTestScenario100 : public MemoryTest {
+	void SetUp() override {
+		MemoryTest::SetUp();
+		for (long i = 0; i < cnt; ++i) {
+			ptrs[i] = Pke_New(sz[i], alignment[i], MemBkt_Test);
+		}
+	}
+protected:
+	void TestExpectedState() {
+		EXPECT_EQ(2, bkt->lastEmptyBlockIndex);
+		EXPECT_EQ(80, bkt->head);
+		EXPECT_EQ(bkt->ptr + 00, ptrs[0]);
+		EXPECT_EQ(bkt->ptr + 64, ptrs[1]);
+		EXPECT_EQ(bkt->ptr + 16, ptrs[2]);
+		EXPECT_EQ(bkt->ptr +  8, ptrs[3]);
+	}
+	const long cnt = 4;
+	const size_t sz[4] = {2, 16, 16, 4};
+	const size_t alignment[4] = {1, 64, 16, 8};
+	void * ptrs[4];
+};
+
+/* allocation events
+ * 1st = alignment 01, size 02, move head ( =02 )
+ * 2nd = alignment 64, size 16, move head ( =80 )   memBlock { +02, 62 }
+ * 3rd = alignment 16, size 16, memBlock { +2, 14 } memBlock { +32, 32 }
+ * 4th = alignment 08, size 04, memBlock { +2, 06 } memBlock { +12, 04 } memBlock { +32, 32 }
+ */
+
+TEST_F(MemoryTestScenario100, EnsureAllocFree0000) {
+	EXPECT_NO_FATAL_FAILURE(this->TestExpectedState());
+
+	// arrange
+	
+	// act
+	
+	// assert
+	EXPECT_EQ(bkt->ptr + 2, bkt->blocks[0].data);
+	EXPECT_EQ(6, bkt->blocks[0].size);
+
+	EXPECT_EQ(bkt->ptr + 12, bkt->blocks[1].data);
+	EXPECT_EQ(4, bkt->blocks[1].size);
+
+	EXPECT_EQ(bkt->ptr + 32, bkt->blocks[2].data);
+	EXPECT_EQ(32, bkt->blocks[2].size);
+}
+
+TEST_F(MemoryTestScenario100, EnsureAllocFree1000) {
+	EXPECT_NO_FATAL_FAILURE(this->TestExpectedState());
+
+	// arrange
+	size_t expectedHead = 80;
+	long freeIndex = 0;
+
+	// act
+	/* free events
+	 * 1st = ptr +00, size 02, memBlock { +00, 08 }
+	 */
+	Pke_Delete(ptrs[freeIndex], sz[freeIndex], MemBkt_Test);
+
+	// assert
+	EXPECT_EQ(2, bkt->lastEmptyBlockIndex);
+	EXPECT_EQ(expectedHead, bkt->head);
+
+	EXPECT_EQ(bkt->ptr + 0, bkt->blocks[0].data);
+	EXPECT_EQ(8, bkt->blocks[0].size);
+
+	EXPECT_EQ(bkt->ptr + 12, bkt->blocks[1].data);
+	EXPECT_EQ(4, bkt->blocks[1].size);
+
+	EXPECT_EQ(bkt->ptr + 32, bkt->blocks[2].data);
+	EXPECT_EQ(32, bkt->blocks[2].size);
+};
+
+TEST_F(MemoryTestScenario100, EnsureAllocFree0100) {
+	EXPECT_NO_FATAL_FAILURE(this->TestExpectedState());
+
+	// arrange
+	size_t expectedHead = 32;
+	long freeIndex = 1;
+
+	// act
+	/* free events
+	 * 1st = ptr +64, size 16, move head ( =32 ) memBlock { +02, 06 } memBlock { +12, 4 }
+	 */
+	Pke_Delete(ptrs[freeIndex], sz[freeIndex], MemBkt_Test);
+
+	// assert
+	EXPECT_EQ(1, bkt->lastEmptyBlockIndex);
+	EXPECT_EQ(expectedHead, bkt->head);
+
+	EXPECT_EQ(bkt->ptr + 2, bkt->blocks[0].data);
+	EXPECT_EQ(6, bkt->blocks[0].size);
+
+	EXPECT_EQ(bkt->ptr + 12, bkt->blocks[1].data);
+	EXPECT_EQ(4, bkt->blocks[1].size);
+};
+
+TEST_F(MemoryTestScenario100, EnsureAllocFree0010) {
+	EXPECT_NO_FATAL_FAILURE(this->TestExpectedState());
+
+	// arrange
+	size_t expectedHead = 80;
+	long freeIndex = 2;
+	
+	// act
+	/* free events
+	 * 1st = ptr +16, size 16, memBlock { +02, 06 } memBlock { +12, 04 } memBlock { +16, 48 }
+	 *                         memBlock { +02, 06 } memBlock { +12, 52 }
+	 */
+	Pke_Delete(ptrs[freeIndex], sz[freeIndex], MemBkt_Test);
+	
+	// assert
+	EXPECT_EQ(1, bkt->lastEmptyBlockIndex);
+	EXPECT_EQ(expectedHead, bkt->head);
+
+	EXPECT_EQ(bkt->ptr + 2, bkt->blocks[0].data);
+	EXPECT_EQ(6, bkt->blocks[0].size);
+
+	EXPECT_EQ(bkt->ptr + 12, bkt->blocks[1].data);
+	EXPECT_EQ(52, bkt->blocks[1].size);
+}
+
+TEST_F(MemoryTestScenario100, EnsureAllocFree0001) {
+	EXPECT_NO_FATAL_FAILURE(this->TestExpectedState());
+
+	// arrange
+	size_t expectedHead = 80;
+	long freeIndex = 3;
+	
+	// act
+	/* free events
+	 * 1st = ptr +08, size 4, memBlock { +02, 06 } memBlock { +08, 08 } memBlock { +32, 32 }
+	 *                        memBlock { +02, 14 } memBlock { +32, 32 }
+	 */
+	Pke_Delete(ptrs[freeIndex], sz[freeIndex], MemBkt_Test);
+	
+	// assert
+	EXPECT_EQ(1, bkt->lastEmptyBlockIndex);
+	EXPECT_EQ(expectedHead, bkt->head);
+
+	EXPECT_EQ(bkt->ptr + 2, bkt->blocks[0].data);
+	EXPECT_EQ(14, bkt->blocks[0].size);
+
+	EXPECT_EQ(bkt->ptr + 32, bkt->blocks[1].data);
+	EXPECT_EQ(32, bkt->blocks[1].size);
+}
diff --git a/test/memory/main.cpp b/test/memory/main.cpp
new file mode 100644
index 0000000..4483c91
--- /dev/null
+++ b/test/memory/main.cpp
@@ -0,0 +1,6 @@
+#include "gtest/gtest.h"
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}