pkmem: pk_bucket_head indexing + more mem tests

1 files changed, 555 insertions, 1 deletions

diff --git a/test/pkmem.cpp b/test/pkmem.cpp
index 8dc429a..57ae2c4 100644
--- a/test/pkmem.cpp
+++ b/test/pkmem.cpp
@@ -3,7 +3,113 @@
 
 #include <csetjmp>
 #include <signal.h>
-#include <thread>
+
+class FreeTest {
+	public:
+	pk_membucket *bkt;
+	int cnt;
+	size_t sz[4];
+	size_t al[4];
+	void *ptrs[4];
+
+	FreeTest() :
+	bkt(pk_bucket_create("freetest", 1024 * 1024, false)) { }
+	virtual ~FreeTest() {
+		pk_bucket_destroy(this->bkt);
+	}
+
+	void setup() {
+		int i;
+		for (i = 0; i < this->cnt; ++i) {
+			ptrs[i] = pk_new(sz[i], al[i], bkt);
+		}
+	}
+
+	virtual void ensureState() {};
+};
+
+class FreeTest01 : public FreeTest {
+	public:
+
+	FreeTest01() : FreeTest()
+	{
+		cnt = 4;
+		sz[0] = 2;
+		sz[1] = 16;
+		sz[2] = 16;
+		sz[3] = 4;
+		al[0] = 1;
+		al[1] = 64;
+		al[2] = 16;
+		al[3] = 8;
+		this->setup();
+	}
+	virtual ~FreeTest01() {}
+
+	virtual void ensureState() override {
+		assert(3 == bkt->lastEmptyBlockIndex);
+		assert(80 == bkt->head);
+		assert(bkt->ptr + 00 == ptrs[0]);
+		assert(bkt->ptr + 64 == ptrs[1]);
+		assert(bkt->ptr + 16 == ptrs[2]);
+		assert(bkt->ptr +  8 == ptrs[3]);
+	}
+};
+
+/*
+	 [00-18] (19) ptr0
+	 [19-31] (13) memblock
+	 [ 32  ] ( 1) ptr2
+	 [33-63] (31) memblock
+	 [ 64  ] ( 1) ptr2
+	 [ 65  ] ( 0) HEAD
+*/
+class FreeTest02 : public FreeTest {
+	public:
+
+	FreeTest02() : FreeTest()
+	{
+		cnt = 3;
+		sz[0] = 19;
+		sz[1] = 1;
+		sz[2] = 1;
+		al[0] = 1;
+		al[1] = 64;
+		al[2] = 32;
+		this->setup();
+	}
+	virtual ~FreeTest02() {}
+
+	virtual void ensureState() override {
+		assert(2 == bkt->lastEmptyBlockIndex);
+		assert(65 == bkt->head);
+		assert(bkt->ptr + 00 == ptrs[0]);
+		assert(bkt->ptr + 64 == ptrs[1]);
+		assert(bkt->ptr + 32 == ptrs[2]);
+
+		assert(bkt->ptr + 19 == bkt->blocks[0].data);
+		assert(13 == bkt->blocks[0].size);
+
+		assert(bkt->ptr + 33 == bkt->blocks[1].data);
+		assert(31 == bkt->blocks[1].size);
+	}
+};
+
+const char *test_misalignment01 = "test_misalignment01";
+const char *test_misalignment02 = "test_misalignment02";
+const char *test_free_0000      = "test_free_0000";
+const char *test_free_1000      = "test_free_1000";
+const char *test_free_0100      = "test_free_0100";
+const char *test_free_0010      = "test_free_0010";
+const char *test_free_0001      = "test_free_0001";
+const char *test_free_after     = "test_free_after";
+const char *test_free_before    = "test_free_before";
+const char *test_free_between   = "test_free_between";
+const char *test_bucket_count01 = "test_bucket_count01";
+const char *test_bucket_count02 = "test_bucket_count02";
+const char *test_bucket_count03 = "test_bucket_count03";
+const char *test_bucket_count04 = "test_bucket_count04";
+const char *test_bucket_count05 = "test_bucket_count05";
 
 static bool expected_exit = false;
 static bool caught = false;
@@ -45,7 +151,379 @@ int main(int argc, char *argv[])
 	}
 	pk_memory_teardown_all();
 
+	// assert misalignment
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment01);
+	{
+		pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, false);
+		pk_new(1, 1, bkt);
+		pk_new(1, 64, bkt);
+		pk_new(9, 1, bkt);
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", bkt->lastEmptyBlockIndex);
+		assert(1 == bkt->lastEmptyBlockIndex);
+
+		fprintf(stdout, "head               : %li\n", bkt->head);
+		assert(65 == bkt->head);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", bkt->blocks[0].data);
+		assert(bkt->ptr + 10 == bkt->blocks[0].data);
+
+		fprintf(stdout, "blocks[0].size     : %li\n", bkt->blocks[0].size);
+		assert(54 == bkt->blocks[0].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment01);
+	pk_memory_teardown_all();
+
+	// assert misalignment + blank block test
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment02);
+	{
+		pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, false);
+		pk_new(1, 1, bkt);
+		pk_new(1, 64, bkt);
+		pk_new(9, 16, bkt);
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", bkt->lastEmptyBlockIndex);
+		assert(2 == bkt->lastEmptyBlockIndex);
+
+		fprintf(stdout, "head               : %li\n", bkt->head);
+		assert(65 == bkt->head);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", bkt->blocks[0].data);
+		assert(bkt->ptr + 1 == bkt->blocks[0].data);
+
+		fprintf(stdout, "blocks[0].size     : %li\n", bkt->blocks[0].size);
+		assert(15 == bkt->blocks[0].size);
+
+		fprintf(stdout, "blocks[1].data     : %p\n", bkt->blocks[1].data);
+		assert(bkt->ptr + 25 == bkt->blocks[1].data);
+
+		fprintf(stdout, "blocks[1].size     : %li\n", bkt->blocks[1].size);
+		assert(39 == bkt->blocks[1].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment02);
+	pk_memory_teardown_all();
+
+	// predictable free 0000
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0000);
+	{
+		FreeTest01 ft{};
+		ft.ensureState();
+
+		fprintf(stdout, "blocks[0].data     : %p\n", ft.bkt->blocks[0].data);
+		assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
+		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
+		assert(6 == ft.bkt->blocks[0].size);
+
+		fprintf(stdout, "blocks[1].data     : %p\n", ft.bkt->blocks[1].data);
+		assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
+		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
+		assert(4 == ft.bkt->blocks[1].size);
+
+		fprintf(stdout, "blocks[2].data     : %p\n", ft.bkt->blocks[2].data);
+		assert(ft.bkt->ptr + 32 == ft.bkt->blocks[2].data);
+		fprintf(stdout, "blocks[2].size     : %li\n", ft.bkt->blocks[2].size);
+		assert(32 == ft.bkt->blocks[2].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0000);
+	pk_memory_teardown_all();
+
+	// predictable free 1000
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_1000);
+	{
+		size_t expected_head = 80;
+		size_t free_index = 0;
+		FreeTest01 ft{};
+		ft.ensureState();
+
+		/* free events
+		 * 1st = ptr +00, size 02, memblock { +00, 08 }
+		 */
+		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
+		assert(3 == ft.bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		assert(expected_head == ft.bkt->head);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", ft.bkt->blocks[0].data);
+		assert(ft.bkt->ptr + 0 == ft.bkt->blocks[0].data);
+		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
+		assert(8 == ft.bkt->blocks[0].size);
+
+		fprintf(stdout, "blocks[1].data     : %p\n", ft.bkt->blocks[1].data);
+		assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
+		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
+		assert(4 == ft.bkt->blocks[1].size);
+
+		fprintf(stdout, "blocks[2].data     : %p\n", ft.bkt->blocks[2].data);
+		assert(ft.bkt->ptr + 32 == ft.bkt->blocks[2].data);
+		fprintf(stdout, "blocks[2].size     : %li\n", ft.bkt->blocks[2].size);
+		assert(32 == ft.bkt->blocks[2].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_1000);
+	pk_memory_teardown_all();
+
+	// predictable free 0100
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0100);
+	{
+		size_t expected_head = 32;
+		size_t free_index = 1;
+		FreeTest01 ft{};
+		ft.ensureState();
+
+		/* free events
+		 * 1st = ptr +64, size 16, move head ( =32 ), memblock { +02, 06 } memblock { +12, 4 }
+		 */
+		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
+		assert(2 == ft.bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		assert(expected_head == ft.bkt->head);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", ft.bkt->blocks[0].data);
+		assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
+		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
+		assert(6 == ft.bkt->blocks[0].size);
+
+		fprintf(stdout, "blocks[1].data     : %p\n", ft.bkt->blocks[1].data);
+		assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
+		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
+		assert(4 == ft.bkt->blocks[1].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0100);
+	pk_memory_teardown_all();
+
+	// predictable free 0010
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0010);
+	{
+		size_t expected_head = 80;
+		size_t free_index = 2;
+		FreeTest01 ft{};
+		ft.ensureState();
+
+		/* free events
+		 * 1st = ptr +16, size 16, memblock { +02, 06 } memblock { +12, 04 } memblock { +16, 48 }
+		 *                         memblock { +02, 06 } memblock { +12, 52 }
+		 */
+		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
+		assert(2 == ft.bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		assert(expected_head == ft.bkt->head);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", ft.bkt->blocks[0].data);
+		assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
+		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
+		assert(6 == ft.bkt->blocks[0].size);
+
+		fprintf(stdout, "blocks[1].data     : %p\n", ft.bkt->blocks[1].data);
+		assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
+		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
+		assert(52 == ft.bkt->blocks[1].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0010);
+	pk_memory_teardown_all();
+
+	// predictable free 0001
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0001);
+	{
+		size_t expected_head = 80;
+		size_t free_index = 3;
+		FreeTest01 ft{};
+		ft.ensureState();
+
+		/* free events
+		 * 1st = ptr +16, size 16, memblock { +02, 06 } memblock { +08, 08 } memblock { +32, 32 }
+		 *                         memblock { +02, 14 } memblock { +32, 32 }
+		 */
+		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
+		assert(2 == ft.bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		assert(expected_head == ft.bkt->head);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", ft.bkt->blocks[0].data);
+		assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
+		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
+		assert(14 == ft.bkt->blocks[0].size);
+
+		fprintf(stdout, "blocks[1].data     : %p\n", ft.bkt->blocks[1].data);
+		assert(ft.bkt->ptr + 32 == ft.bkt->blocks[1].data);
+		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
+		assert(32 == ft.bkt->blocks[1].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0001);
+	pk_memory_teardown_all();
+
+	// ensure free touching after only
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_after);
+	{
+		FreeTest02 ft{};
+		ft.ensureState();
+
+		// frees [00-18] which gets absorbed into [19-31]
+		// [00-31 memblock
+		pk_delete(ft.ptrs[0], ft.sz[0], ft.bkt);
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
+		assert(2 == ft.bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		assert(65 == ft.bkt->head);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", ft.bkt->blocks[0].data);
+		assert(ft.bkt->ptr + 0 == ft.bkt->blocks[0].data);
+		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
+		assert(32 == ft.bkt->blocks[0].size);
+
+		fprintf(stdout, "blocks[1].data     : %p\n", ft.bkt->blocks[1].data);
+		assert(ft.bkt->ptr + 33 == ft.bkt->blocks[1].data);
+		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
+		assert(31 == ft.bkt->blocks[1].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_after);
+	pk_memory_teardown_all();
+
+	// ensure free touching before only
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_before);
+	{
+		FreeTest02 ft{};
+		ft.ensureState();
+
+		/* fill everything, then allocate [65], moving HEAD
+			 [00-18] (19) ptr0
+			 [19-31] (13) ptr3
+			 [ 32  ] ( 1) ptr2
+			 [33-63] (31) ptr4
+			 [ 64  ] ( 1) ptr2
+			 [ 65  ] ( 1) ptr5
+			 [ 66  ] ( 0) HEAD
+		*/
+		void *ptr3 = pk_new(13, 1, ft.bkt);
+		void *ptr4 = pk_new(31, 1, ft.bkt);
+		void *ptr5 = pk_new( 1, 1, ft.bkt);
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
+		assert(0 == ft.bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		assert(66 == ft.bkt->head);
+
+		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
+		assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
+		fprintf(stdout, "ptr3               : %p\n", ptr3);
+		assert(ft.bkt->ptr + 19 == ptr3);
+		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
+		assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
+		fprintf(stdout, "ptr4               : %p\n", ptr4);
+		assert(ft.bkt->ptr + 33 == ptr4);
+		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
+		assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
+		fprintf(stdout, "ptr5               : %p\n", ptr5);
+		assert(ft.bkt->ptr + 65 == ptr5);
+
+		/* free [19-31]
+			 [00-18] (19) ptr0
+			 [19-31] (13) memblock
+			 [ 32  ] ( 1) ptr2
+			 [33-63] (31) ptr4
+			 [ 64  ] ( 1) ptr2
+			 [ 65  ] ( 0) ptr5
+			 [ 66  ] ( 0) HEAD
+		*/
+		pk_delete(ptr3, 13, ft.bkt);
+		ptr3 = nullptr;
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
+		assert(1 == ft.bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		assert(66 == ft.bkt->head);
+
+		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
+		assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
+		fprintf(stdout, "ptr3               : %p\n", ptr3);
+		assert(nullptr == ptr3);
+		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
+		assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
+		fprintf(stdout, "ptr4               : %p\n", ptr4);
+		assert(ft.bkt->ptr + 33 == ptr4);
+		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
+		assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
+		fprintf(stdout, "ptr5               : %p\n", ptr5);
+		assert(ft.bkt->ptr + 65 == ptr5);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", ft.bkt->blocks[0].data);
+		assert(ft.bkt->ptr + 19 == ft.bkt->blocks[0].data);
+		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
+		assert(13 == ft.bkt->blocks[0].size);
+
+		/* free [32] which gets absorbed into 19-32
+			 [19-32] (13) memblock
+			 [33-63] (31) ptr4
+		*/
+		pk_delete(ft.ptrs[2], ft.sz[2], ft.bkt);
+		ft.ptrs[2] = nullptr;
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
+		assert(1 == ft.bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		assert(66 == ft.bkt->head);
+
+		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
+		assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
+		fprintf(stdout, "ptr3               : %p\n", ptr3);
+		assert(nullptr == ptr3);
+		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
+		assert(nullptr == ft.ptrs[2]);
+		fprintf(stdout, "ptr4               : %p\n", ptr4);
+		assert(ft.bkt->ptr + 33 == ptr4);
+		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
+		assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
+		fprintf(stdout, "ptr5               : %p\n", ptr5);
+		assert(ft.bkt->ptr + 65 == ptr5);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", ft.bkt->blocks[0].data);
+		assert(ft.bkt->ptr + 19 == ft.bkt->blocks[0].data);
+		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
+		assert(14 == ft.bkt->blocks[0].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_before);
+	pk_memory_teardown_all();
+
+	// ensure free touching before and after
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_between);
+	{
+		FreeTest02 ft{};
+		ft.ensureState();
+
+		// frees [00-18] which gets absorbed into [19-31]
+		// [00-31 memblock
+		pk_delete(ft.ptrs[2], ft.sz[2], ft.bkt);
+		ft.ptrs[2] = nullptr;
+
+		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
+		assert(1 == ft.bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		assert(65 == ft.bkt->head);
+
+		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
+		assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
+		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
+		assert(nullptr == ft.ptrs[2]);
+		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
+		assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
+
+		fprintf(stdout, "blocks[0].data     : %p\n", ft.bkt->blocks[0].data);
+		assert(ft.bkt->ptr + 19 == ft.bkt->blocks[0].data);
+		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
+		assert(45 == ft.bkt->blocks[0].size);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_between);
+	pk_memory_teardown_all();
+
 	// assert bucket count
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count01);
 	do
 	{
 		int r;
@@ -72,9 +550,11 @@ int main(int argc, char *argv[])
 		goto uncaught_err;
 	}
 	while(false);
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count01);
 	pk_memory_teardown_all();
 
 	// assert no buckets available on pk_new with full memory
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count02);
 	do
 	{
 		int r;
@@ -106,9 +586,11 @@ int main(int argc, char *argv[])
 		goto uncaught_err;
 	}
 	while(false);
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count02);
 	pk_memory_teardown_all();
 
 	// assert no buckets available on pk_new with full memory
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count03);
 	do
 	{
 		int r;
@@ -141,6 +623,78 @@ int main(int argc, char *argv[])
 		goto uncaught_err;
 	}
 	while(false);
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count03);
+	pk_memory_teardown_all();
+
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count04);
+	{
+		pk_membucket *bkt1 = pk_bucket_create("bucket1", 1024, false);
+		pk_membucket *bkt2 = pk_bucket_create("bucket2", 1024, false);
+		pk_membucket *bkt3 = pk_bucket_create("bucket3", 1024, false);
+		pk_membucket *bkt4 = pk_bucket_create("bucket4", 1024, false);
+
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(4 == pk_bucket_head);
+
+		pk_bucket_destroy(bkt4);
+
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(3 == pk_bucket_head);
+
+		pk_bucket_destroy(bkt3);
+
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(2 == pk_bucket_head);
+
+		pk_bucket_destroy(bkt2);
+
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(1 == pk_bucket_head);
+
+		pk_bucket_destroy(bkt1);
+
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(0 == pk_bucket_head);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count04);
+	pk_memory_teardown_all();
+
+	/* 2025-01-06 JCB
+	 * buckets are stored in an array.
+	 * pk_bucket_head is only an *indicator* of how many buckets have been
+	 *  created total, and the index of the next available.
+	 */
+	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count05);
+	{
+		pk_membucket *bkt1 = pk_bucket_create("bucket1", 1024, false);
+		pk_membucket *bkt2 = pk_bucket_create("bucket2", 1024, false);
+		pk_membucket *bkt3 = pk_bucket_create("bucket3", 1024, false);
+		pk_membucket *bkt4 = pk_bucket_create("bucket4", 1024, false);
+
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(4 == pk_bucket_head);
+
+		pk_bucket_destroy(bkt1);
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(4 == pk_bucket_head);
+
+		pk_bucket_destroy(bkt2);
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(4 == pk_bucket_head);
+
+		pk_bucket_destroy(bkt3);
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(4 == pk_bucket_head);
+
+		pk_bucket_destroy(bkt4);
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(3 == pk_bucket_head);
+
+		pk_memory_flush();
+		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
+		assert(0 == pk_bucket_head);
+	}
+	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count05);
 	pk_memory_teardown_all();
 
 	return 0;