pkmem.h: chkpt: major refactor for ad-hoc buckets

2 files changed, 258 insertions, 220 deletions

diff --git a/test/pkmem.c b/test/pkmem.c
index 252428d..7614379 100644
--- a/test/pkmem.c
+++ b/test/pkmem.c
@@ -38,6 +38,7 @@ int main(int argc, char *argv[])
 	// pk_new_base
 	{
 		spinup_w_instr();
+		pk_bucket_set_client_bucket(mt.bkt1);
 		char *some_dang_string = (char*)pk_new_base(64, alignof(char*));
 		fprintf(stdout, "some_dang_string: %s: %p\n", some_dang_string, (void *)some_dang_string);
 		pk_delete_base(some_dang_string, 64);
@@ -64,9 +65,9 @@ int main(int argc, char *argv[])
 
 		if (zero_length_string != NULL) exit(1);
 		if (strlen(three_length_string) != 2) exit(1);
-		if (mt.bkt1->allocs != 1) exit(1);
+		if (mt.bkt1->alloc_count != 1) exit(1);
 		if (mt.bkt1->head != 3) exit(1);
-		if (mt.bkt1->lastEmptyBlockIndex != 0) exit(1);
+		if (mt.bkt1->block_head_r != 0) exit(1);
 
 		PK_LOGV_INF("%s: %s\n", __FILE__, "handles zero-length alloc");
 		teardown();
diff --git a/test/pkmem.cpp b/test/pkmem.cpp
index 98d2dd2..6a52f25 100644
--- a/test/pkmem.cpp
+++ b/test/pkmem.cpp
@@ -21,7 +21,9 @@ class FreeTest {
 	void *ptrs[4];
 
 	FreeTest() :
-	bkt(pk_bucket_create("freetest", 1024 * 1024, false)) { }
+	bkt(pk_bucket_create("freetest", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE)) {
+		pk_bucket_set_client_bucket(this->bkt);
+	}
 	virtual ~FreeTest() {
 		pk_bucket_destroy(this->bkt);
 	}
@@ -55,12 +57,12 @@ class FreeTest01 : public FreeTest {
 	virtual ~FreeTest01() {}
 
 	virtual void ensureState() override {
-		pk_mem_assert(3 == bkt->lastEmptyBlockIndex);
+		pk_mem_assert(3 == bkt->block_head_r);
 		pk_mem_assert(80 == bkt->head);
-		pk_mem_assert(bkt->ptr + 00 == ptrs[0]);
-		pk_mem_assert(bkt->ptr + 64 == ptrs[1]);
-		pk_mem_assert(bkt->ptr + 16 == ptrs[2]);
-		pk_mem_assert(bkt->ptr +  8 == ptrs[3]);
+		pk_mem_assert(&bkt->data[0] + 00 == ptrs[0]);
+		pk_mem_assert(&bkt->data[0] + 64 == ptrs[1]);
+		pk_mem_assert(&bkt->data[0] + 16 == ptrs[2]);
+		pk_mem_assert(&bkt->data[0] +  8 == ptrs[3]);
 	}
 };
 
@@ -89,17 +91,17 @@ class FreeTest02 : public FreeTest {
 	virtual ~FreeTest02() {}
 
 	virtual void ensureState() override {
-		pk_mem_assert(2 == bkt->lastEmptyBlockIndex);
+		pk_mem_assert(2 == bkt->block_head_r);
 		pk_mem_assert(65 == bkt->head);
-		pk_mem_assert(bkt->ptr + 00 == ptrs[0]);
-		pk_mem_assert(bkt->ptr + 64 == ptrs[1]);
-		pk_mem_assert(bkt->ptr + 32 == ptrs[2]);
+		pk_mem_assert(&bkt->data[0] + 00 == ptrs[0]);
+		pk_mem_assert(&bkt->data[0] + 64 == ptrs[1]);
+		pk_mem_assert(&bkt->data[0] + 32 == ptrs[2]);
 
-		pk_mem_assert(bkt->ptr + 19 == bkt->blocks[0].data);
-		pk_mem_assert(13 == bkt->blocks[0].size);
+		pk_mem_assert(&bkt->data[0] + 19 == bkt->blocks[15].data);
+		pk_mem_assert(13 == bkt->blocks[15].size);
 
-		pk_mem_assert(bkt->ptr + 33 == bkt->blocks[1].data);
-		pk_mem_assert(31 == bkt->blocks[1].size);
+		pk_mem_assert(&bkt->data[0] + 33 == bkt->blocks[14].data);
+		pk_mem_assert(31 == bkt->blocks[14].size);
 	}
 };
 
@@ -162,15 +164,36 @@ int main(int argc, char *argv[])
 	// signal(SIGABRT, handle_assert_abort);
 	(void)argc;
 	(void)argv;
-	int i;
+	// int i;
 
 	// pk_new<T>
 	pk_test_pkmem_spinup(true);
 	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_basic_alloc);
 	{
+		pk_membucket *bkt = pk_bucket_create("test-some-dang-string", 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_bucket_set_client_bucket(bkt);
+
 		char *some_dang_string = pk_new<char>(64);
+
 		fprintf(stdout, "some_dang_string: %s: %p\n", some_dang_string, (void *)some_dang_string);
+
+		fprintf(stdout, "debug block         : size: %zu, data: %p\n", debug_allocs[0][0].size, debug_allocs[0][0].ptr);
+		pk_mem_assert(64 == debug_allocs[0][0].size);
+		pk_mem_assert((char*)bkt + EXPECTED_PK_MEMBLOCK_SIZE == debug_allocs[0][0].data);
+
+		fprintf(stdout, "bkt->head           : %lu\n", bkt->head);
+		pk_mem_assert(64 == bkt->head);
+
+		fprintf(stdout, "blocks[15].data     : %p\n", bkt->blocks[15].ptr);
+		pk_mem_assert(&bkt->data[0] + 64 == bkt->blocks[15].data);
+
+		fprintf(stdout, "blocks[15].size     : %li\n", bkt->blocks[15].size);
+		// 576 == 1024 - EXPECTED_PK_MEMBLOCK_SIZE - (sizeof(pk_memblock) * bkt->block_capacity) - 64
+		pk_mem_assert(576 == bkt->blocks[15].size);
+
 		pk_delete<char>(some_dang_string, 64);
+
+		pk_bucket_destroy(bkt);
 	}
 	pk_test_pkmem_teardown();
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_basic_alloc);
@@ -179,22 +202,25 @@ int main(int argc, char *argv[])
 	pk_test_pkmem_spinup(true);
 	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment01);
 	{
-		pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, false);
+		pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_bucket_set_client_bucket(bkt);
 		pk_new(1, 1, bkt);
 		pk_new(1, 64, bkt);
 		pk_new(9, 1, bkt);
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", bkt->lastEmptyBlockIndex);
-		pk_mem_assert(1 == bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "block_head_r: %u\n", bkt->block_head_r);
+		pk_mem_assert(1 == bkt->block_head_r);
 
-		fprintf(stdout, "head               : %li\n", bkt->head);
+		fprintf(stdout, "head                : %li\n", bkt->head);
 		pk_mem_assert(65 == bkt->head);
 
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)bkt->blocks[0].data);
-		pk_mem_assert(bkt->ptr + 10 == bkt->blocks[0].data);
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)bkt->blocks[15].data);
+		pk_mem_assert(&bkt->data[0] + 10 == bkt->blocks[15].data);
 
-		fprintf(stdout, "blocks[0].size     : %li\n", bkt->blocks[0].size);
-		pk_mem_assert(54 == bkt->blocks[0].size);
+		fprintf(stdout, "blocks[15].size     : %li\n", bkt->blocks[15].size);
+		pk_mem_assert(54 == bkt->blocks[15].size);
+
+		pk_bucket_destroy(bkt);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment01);
 	pk_test_pkmem_teardown();
@@ -203,28 +229,31 @@ int main(int argc, char *argv[])
 	pk_test_pkmem_spinup();
 	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment02);
 	{
-		pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, false);
+		pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_bucket_set_client_bucket(bkt);
 		pk_new(1, 1, bkt);
 		pk_new(1, 64, bkt);
 		pk_new(9, 16, bkt);
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", bkt->lastEmptyBlockIndex);
-		pk_mem_assert(2 == bkt->lastEmptyBlockIndex);
+		fprintf(stdout, "block_head_r: %u\n", bkt->block_head_r);
+		pk_mem_assert(2 == bkt->block_head_r);
 
-		fprintf(stdout, "head               : %li\n", bkt->head);
+		fprintf(stdout, "head                : %li\n", bkt->head);
 		pk_mem_assert(65 == bkt->head);
 
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)bkt->blocks[0].data);
-		pk_mem_assert(bkt->ptr + 1 == bkt->blocks[0].data);
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)bkt->blocks[15].data);
+		pk_mem_assert(&bkt->data[0] + 1 == bkt->blocks[15].data);
 
-		fprintf(stdout, "blocks[0].size     : %li\n", bkt->blocks[0].size);
-		pk_mem_assert(15 == bkt->blocks[0].size);
+		fprintf(stdout, "blocks[15].size     : %li\n", bkt->blocks[15].size);
+		pk_mem_assert(15 == bkt->blocks[15].size);
 
-		fprintf(stdout, "blocks[1].data     : %p\n", (void *)bkt->blocks[1].data);
-		pk_mem_assert(bkt->ptr + 25 == bkt->blocks[1].data);
+		fprintf(stdout, "blocks[14].data     : %p\n", (void *)bkt->blocks[14].data);
+		pk_mem_assert(&bkt->data[0] + 25 == bkt->blocks[14].data);
 
-		fprintf(stdout, "blocks[1].size     : %li\n", bkt->blocks[1].size);
-		pk_mem_assert(39 == bkt->blocks[1].size);
+		fprintf(stdout, "blocks[14].size     : %li\n", bkt->blocks[14].size);
+		pk_mem_assert(39 == bkt->blocks[14].size);
+
+		pk_bucket_destroy(bkt);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment02);
 	pk_test_pkmem_teardown();
@@ -236,20 +265,20 @@ int main(int argc, char *argv[])
 		FreeTest01 ft{};
 		ft.ensureState();
 
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
-		pk_mem_assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
-		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
-		pk_mem_assert(6 == ft.bkt->blocks[0].size);
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
+		pk_mem_assert(&ft.bkt->data[0] + 2 == ft.bkt->blocks[15].data);
+		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
+		pk_mem_assert(6 == ft.bkt->blocks[15].size);
 
-		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
-		pk_mem_assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
-		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
-		pk_mem_assert(4 == ft.bkt->blocks[1].size);
+		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
+		pk_mem_assert(&ft.bkt->data[0] + 12 == ft.bkt->blocks[14].data);
+		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
+		pk_mem_assert(4 == ft.bkt->blocks[14].size);
 
-		fprintf(stdout, "blocks[2].data     : %p\n", (void *)ft.bkt->blocks[2].data);
-		pk_mem_assert(ft.bkt->ptr + 32 == ft.bkt->blocks[2].data);
-		fprintf(stdout, "blocks[2].size     : %li\n", ft.bkt->blocks[2].size);
-		pk_mem_assert(32 == ft.bkt->blocks[2].size);
+		fprintf(stdout, "blocks[13].data     : %p\n", (void *)ft.bkt->blocks[13].data);
+		pk_mem_assert(&ft.bkt->data[0] + 32 == ft.bkt->blocks[13].data);
+		fprintf(stdout, "blocks[13].size     : %li\n", ft.bkt->blocks[13].size);
+		pk_mem_assert(32 == ft.bkt->blocks[13].size);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0000);
 	pk_test_pkmem_teardown();
@@ -268,25 +297,25 @@ int main(int argc, char *argv[])
 		 */
 		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
-		pk_mem_assert(3 == ft.bkt->lastEmptyBlockIndex);
-		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
+		pk_mem_assert(3 == ft.bkt->block_head_r);
+		fprintf(stdout, "head                : %li\n", ft.bkt->head);
 		pk_mem_assert(expected_head == ft.bkt->head);
 
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
-		pk_mem_assert(ft.bkt->ptr + 0 == ft.bkt->blocks[0].data);
-		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
-		pk_mem_assert(8 == ft.bkt->blocks[0].size);
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
+		pk_mem_assert(&ft.bkt->data[0] + 0 == ft.bkt->blocks[15].data);
+		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
+		pk_mem_assert(8 == ft.bkt->blocks[15].size);
 
-		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
-		pk_mem_assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
-		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
-		pk_mem_assert(4 == ft.bkt->blocks[1].size);
+		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
+		pk_mem_assert(&ft.bkt->data[0] + 12 == ft.bkt->blocks[14].data);
+		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
+		pk_mem_assert(4 == ft.bkt->blocks[14].size);
 
-		fprintf(stdout, "blocks[2].data     : %p\n", (void *)ft.bkt->blocks[2].data);
-		pk_mem_assert(ft.bkt->ptr + 32 == ft.bkt->blocks[2].data);
-		fprintf(stdout, "blocks[2].size     : %li\n", ft.bkt->blocks[2].size);
-		pk_mem_assert(32 == ft.bkt->blocks[2].size);
+		fprintf(stdout, "blocks[13].data     : %p\n", (void *)ft.bkt->blocks[13].data);
+		pk_mem_assert(&ft.bkt->data[0] + 32 == ft.bkt->blocks[13].data);
+		fprintf(stdout, "blocks[13].size     : %li\n", ft.bkt->blocks[13].size);
+		pk_mem_assert(32 == ft.bkt->blocks[13].size);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_1000);
 	pk_test_pkmem_teardown();
@@ -305,20 +334,20 @@ int main(int argc, char *argv[])
 		 */
 		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
-		pk_mem_assert(2 == ft.bkt->lastEmptyBlockIndex);
-		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
+		pk_mem_assert(2 == ft.bkt->block_head_r);
+		fprintf(stdout, "head                : %li\n", ft.bkt->head);
 		pk_mem_assert(expected_head == ft.bkt->head);
 
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
-		pk_mem_assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
-		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
-		pk_mem_assert(6 == ft.bkt->blocks[0].size);
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
+		pk_mem_assert(&ft.bkt->data[0] + 2 == ft.bkt->blocks[15].data);
+		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
+		pk_mem_assert(6 == ft.bkt->blocks[15].size);
 
-		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
-		pk_mem_assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
-		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
-		pk_mem_assert(4 == ft.bkt->blocks[1].size);
+		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
+		pk_mem_assert(&ft.bkt->data[0] + 12 == ft.bkt->blocks[14].data);
+		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
+		pk_mem_assert(4 == ft.bkt->blocks[14].size);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0100);
 	pk_test_pkmem_teardown();
@@ -338,20 +367,20 @@ int main(int argc, char *argv[])
 		 */
 		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
-		pk_mem_assert(2 == ft.bkt->lastEmptyBlockIndex);
-		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
+		pk_mem_assert(2 == ft.bkt->block_head_r);
+		fprintf(stdout, "head                : %li\n", ft.bkt->head);
 		pk_mem_assert(expected_head == ft.bkt->head);
 
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
-		pk_mem_assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
-		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
-		pk_mem_assert(6 == ft.bkt->blocks[0].size);
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
+		pk_mem_assert(&ft.bkt->data[0] + 2 == ft.bkt->blocks[15].data);
+		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
+		pk_mem_assert(6 == ft.bkt->blocks[15].size);
 
-		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
-		pk_mem_assert(ft.bkt->ptr + 12 == ft.bkt->blocks[1].data);
-		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
-		pk_mem_assert(52 == ft.bkt->blocks[1].size);
+		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
+		pk_mem_assert(&ft.bkt->data[0] + 12 == ft.bkt->blocks[14].data);
+		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
+		pk_mem_assert(52 == ft.bkt->blocks[14].size);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0010);
 	pk_test_pkmem_teardown();
@@ -371,20 +400,20 @@ int main(int argc, char *argv[])
 		 */
 		pk_delete(ft.ptrs[free_index], ft.sz[free_index], ft.bkt);
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
-		pk_mem_assert(2 == ft.bkt->lastEmptyBlockIndex);
-		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
+		pk_mem_assert(2 == ft.bkt->block_head_r);
+		fprintf(stdout, "head                : %li\n", ft.bkt->head);
 		pk_mem_assert(expected_head == ft.bkt->head);
 
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
-		pk_mem_assert(ft.bkt->ptr + 2 == ft.bkt->blocks[0].data);
-		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
-		pk_mem_assert(14 == ft.bkt->blocks[0].size);
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
+		pk_mem_assert(&ft.bkt->data[0] + 2 == ft.bkt->blocks[15].data);
+		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
+		pk_mem_assert(14 == ft.bkt->blocks[15].size);
 
-		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
-		pk_mem_assert(ft.bkt->ptr + 32 == ft.bkt->blocks[1].data);
-		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
-		pk_mem_assert(32 == ft.bkt->blocks[1].size);
+		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
+		pk_mem_assert(&ft.bkt->data[0] + 32 == ft.bkt->blocks[14].data);
+		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
+		pk_mem_assert(32 == ft.bkt->blocks[14].size);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0001);
 	pk_test_pkmem_teardown();
@@ -400,20 +429,20 @@ int main(int argc, char *argv[])
 		// [00-31 memblock
 		pk_delete(ft.ptrs[0], ft.sz[0], ft.bkt);
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
-		pk_mem_assert(2 == ft.bkt->lastEmptyBlockIndex);
-		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
+		pk_mem_assert(2 == ft.bkt->block_head_r);
+		fprintf(stdout, "head                : %li\n", ft.bkt->head);
 		pk_mem_assert(65 == ft.bkt->head);
 
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
-		pk_mem_assert(ft.bkt->ptr + 0 == ft.bkt->blocks[0].data);
-		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
-		pk_mem_assert(32 == ft.bkt->blocks[0].size);
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
+		pk_mem_assert(&ft.bkt->data[0] + 0 == ft.bkt->blocks[15].data);
+		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
+		pk_mem_assert(32 == ft.bkt->blocks[15].size);
 
-		fprintf(stdout, "blocks[1].data     : %p\n", (void *)ft.bkt->blocks[1].data);
-		pk_mem_assert(ft.bkt->ptr + 33 == ft.bkt->blocks[1].data);
-		fprintf(stdout, "blocks[1].size     : %li\n", ft.bkt->blocks[1].size);
-		pk_mem_assert(31 == ft.bkt->blocks[1].size);
+		fprintf(stdout, "blocks[14].data     : %p\n", (void *)ft.bkt->blocks[14].data);
+		pk_mem_assert(&ft.bkt->data[0] + 33 == ft.bkt->blocks[14].data);
+		fprintf(stdout, "blocks[14].size     : %li\n", ft.bkt->blocks[14].size);
+		pk_mem_assert(31 == ft.bkt->blocks[14].size);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_after);
 	pk_test_pkmem_teardown();
@@ -438,23 +467,23 @@ int main(int argc, char *argv[])
 		void *ptr4 = pk_new(31, 1, ft.bkt);
 		void *ptr5 = pk_new( 1, 1, ft.bkt);
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
-		pk_mem_assert(0 == ft.bkt->lastEmptyBlockIndex);
-		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
+		pk_mem_assert(0 == ft.bkt->block_head_r);
+		fprintf(stdout, "head                : %li\n", ft.bkt->head);
 		pk_mem_assert(66 == ft.bkt->head);
 
-		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
-		pk_mem_assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
-		fprintf(stdout, "ptr3               : %p\n", ptr3);
-		pk_mem_assert(ft.bkt->ptr + 19 == ptr3);
-		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
-		pk_mem_assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
-		fprintf(stdout, "ptr4               : %p\n", ptr4);
-		pk_mem_assert(ft.bkt->ptr + 33 == ptr4);
-		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
-		pk_mem_assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
-		fprintf(stdout, "ptr5               : %p\n", ptr5);
-		pk_mem_assert(ft.bkt->ptr + 65 == ptr5);
+		fprintf(stdout, "ptr0                : %p\n", ft.ptrs[0]);
+		pk_mem_assert(&ft.bkt->data[0] + 0 == ft.ptrs[0]);
+		fprintf(stdout, "ptr3                : %p\n", ptr3);
+		pk_mem_assert(&ft.bkt->data[0] + 19 == ptr3);
+		fprintf(stdout, "ptr2                : %p\n", ft.ptrs[2]);
+		pk_mem_assert(&ft.bkt->data[0] + 32 == ft.ptrs[2]);
+		fprintf(stdout, "ptr4                : %p\n", ptr4);
+		pk_mem_assert(&ft.bkt->data[0] + 33 == ptr4);
+		fprintf(stdout, "ptr1                : %p\n", ft.ptrs[1]);
+		pk_mem_assert(&ft.bkt->data[0] + 64 == ft.ptrs[1]);
+		fprintf(stdout, "ptr5                : %p\n", ptr5);
+		pk_mem_assert(&ft.bkt->data[0] + 65 == ptr5);
 
 		/* free [19-31]
 			 [00-18] (19) ptr0
@@ -468,28 +497,28 @@ int main(int argc, char *argv[])
 		pk_delete(ptr3, 13, ft.bkt);
 		ptr3 = nullptr;
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
-		pk_mem_assert(1 == ft.bkt->lastEmptyBlockIndex);
-		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
+		pk_mem_assert(1 == ft.bkt->block_head_r);
+		fprintf(stdout, "head                : %li\n", ft.bkt->head);
 		pk_mem_assert(66 == ft.bkt->head);
 
-		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
-		pk_mem_assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
-		fprintf(stdout, "ptr3               : %p\n", ptr3);
+		fprintf(stdout, "ptr0                : %p\n", ft.ptrs[0]);
+		pk_mem_assert(&ft.bkt->data[0] + 0 == ft.ptrs[0]);
+		fprintf(stdout, "ptr3                : %p\n", ptr3);
 		pk_mem_assert(nullptr == ptr3);
-		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
-		pk_mem_assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
-		fprintf(stdout, "ptr4               : %p\n", ptr4);
-		pk_mem_assert(ft.bkt->ptr + 33 == ptr4);
-		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
-		pk_mem_assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
-		fprintf(stdout, "ptr5               : %p\n", ptr5);
-		pk_mem_assert(ft.bkt->ptr + 65 == ptr5);
-
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
-		pk_mem_assert(ft.bkt->ptr + 19 == ft.bkt->blocks[0].data);
-		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
-		pk_mem_assert(13 == ft.bkt->blocks[0].size);
+		fprintf(stdout, "ptr2                : %p\n", ft.ptrs[2]);
+		pk_mem_assert(&ft.bkt->data[0] + 32 == ft.ptrs[2]);
+		fprintf(stdout, "ptr4                : %p\n", ptr4);
+		pk_mem_assert(&ft.bkt->data[0] + 33 == ptr4);
+		fprintf(stdout, "ptr1                : %p\n", ft.ptrs[1]);
+		pk_mem_assert(&ft.bkt->data[0] + 64 == ft.ptrs[1]);
+		fprintf(stdout, "ptr5                : %p\n", ptr5);
+		pk_mem_assert(&ft.bkt->data[0] + 65 == ptr5);
+
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
+		pk_mem_assert(&ft.bkt->data[0] + 19 == ft.bkt->blocks[15].data);
+		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
+		pk_mem_assert(13 == ft.bkt->blocks[15].size);
 
 		/* free [32] which gets absorbed into 19-32
 			 [19-32] (13) memblock
@@ -498,28 +527,28 @@ int main(int argc, char *argv[])
 		pk_delete(ft.ptrs[2], ft.sz[2], ft.bkt);
 		ft.ptrs[2] = nullptr;
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
-		pk_mem_assert(1 == ft.bkt->lastEmptyBlockIndex);
-		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
+		pk_mem_assert(1 == ft.bkt->block_head_r);
+		fprintf(stdout, "head                : %li\n", ft.bkt->head);
 		pk_mem_assert(66 == ft.bkt->head);
 
-		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
-		pk_mem_assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
-		fprintf(stdout, "ptr3               : %p\n", ptr3);
+		fprintf(stdout, "ptr0                : %p\n", ft.ptrs[0]);
+		pk_mem_assert(&ft.bkt->data[0] + 0 == ft.ptrs[0]);
+		fprintf(stdout, "ptr3                : %p\n", ptr3);
 		pk_mem_assert(nullptr == ptr3);
-		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
+		fprintf(stdout, "ptr2                : %p\n", ft.ptrs[2]);
 		pk_mem_assert(nullptr == ft.ptrs[2]);
-		fprintf(stdout, "ptr4               : %p\n", ptr4);
-		pk_mem_assert(ft.bkt->ptr + 33 == ptr4);
-		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
-		pk_mem_assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
-		fprintf(stdout, "ptr5               : %p\n", ptr5);
-		pk_mem_assert(ft.bkt->ptr + 65 == ptr5);
-
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
-		pk_mem_assert(ft.bkt->ptr + 19 == ft.bkt->blocks[0].data);
-		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
-		pk_mem_assert(14 == ft.bkt->blocks[0].size);
+		fprintf(stdout, "ptr4                : %p\n", ptr4);
+		pk_mem_assert(&ft.bkt->data[0] + 33 == ptr4);
+		fprintf(stdout, "ptr1                : %p\n", ft.ptrs[1]);
+		pk_mem_assert(&ft.bkt->data[0] + 64 == ft.ptrs[1]);
+		fprintf(stdout, "ptr5                : %p\n", ptr5);
+		pk_mem_assert(&ft.bkt->data[0] + 65 == ptr5);
+
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
+		pk_mem_assert(&ft.bkt->data[0] + 19 == ft.bkt->blocks[15].data);
+		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
+		pk_mem_assert(14 == ft.bkt->blocks[15].size);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_before);
 	pk_test_pkmem_teardown();
@@ -536,22 +565,22 @@ int main(int argc, char *argv[])
 		pk_delete(ft.ptrs[2], ft.sz[2], ft.bkt);
 		ft.ptrs[2] = nullptr;
 
-		fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
-		pk_mem_assert(1 == ft.bkt->lastEmptyBlockIndex);
-		fprintf(stdout, "head               : %li\n", ft.bkt->head);
+		fprintf(stdout, "block_head_r: %u\n", ft.bkt->block_head_r);
+		pk_mem_assert(1 == ft.bkt->block_head_r);
+		fprintf(stdout, "head                : %li\n", ft.bkt->head);
 		pk_mem_assert(65 == ft.bkt->head);
 
-		fprintf(stdout, "ptr0               : %p\n", ft.ptrs[0]);
-		pk_mem_assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
-		fprintf(stdout, "ptr2               : %p\n", ft.ptrs[2]);
+		fprintf(stdout, "ptr0                : %p\n", ft.ptrs[0]);
+		pk_mem_assert(&ft.bkt->data[0] + 0 == ft.ptrs[0]);
+		fprintf(stdout, "ptr2                : %p\n", ft.ptrs[2]);
 		pk_mem_assert(nullptr == ft.ptrs[2]);
-		fprintf(stdout, "ptr1               : %p\n", ft.ptrs[1]);
-		pk_mem_assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
+		fprintf(stdout, "ptr1                : %p\n", ft.ptrs[1]);
+		pk_mem_assert(&ft.bkt->data[0] + 64 == ft.ptrs[1]);
 
-		fprintf(stdout, "blocks[0].data     : %p\n", (void *)ft.bkt->blocks[0].data);
-		pk_mem_assert(ft.bkt->ptr + 19 == ft.bkt->blocks[0].data);
-		fprintf(stdout, "blocks[0].size     : %li\n", ft.bkt->blocks[0].size);
-		pk_mem_assert(45 == ft.bkt->blocks[0].size);
+		fprintf(stdout, "blocks[15].data     : %p\n", (void *)ft.bkt->blocks[15].data);
+		pk_mem_assert(&ft.bkt->data[0] + 19 == ft.bkt->blocks[15].data);
+		fprintf(stdout, "blocks[15].size     : %li\n", ft.bkt->blocks[15].size);
+		pk_mem_assert(45 == ft.bkt->blocks[15].size);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_between);
 	pk_test_pkmem_teardown();
@@ -560,37 +589,37 @@ int main(int argc, char *argv[])
 	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_alloc_strings);
 	{
 		size_t diff;
-		pk_membucket *bkt = pk_bucket_create(test_free_between, PK_DEFAULT_BUCKET_SIZE, false);
+		pk_membucket *bkt = pk_bucket_create(test_free_between, PK_DEFAULT_BUCKET_SIZE, PK_MEMBUCKET_FLAG_NONE);
 
 		char *str1 = pk_new<char>(16, bkt);
 		char *str2 = pk_new<char>(16, bkt);
 		pk_handle *handle1 = pk_new<pk_handle>(bkt);
 		pk_handle *handle2 = pk_new<pk_handle>(bkt);
 
-		fprintf(stdout, "ptr                : %p\n", (void *)bkt->ptr);
-		fprintf(stdout, "str1               : %p\n", (void *)str1);
-		fprintf(stdout, "str2               : %p\n", (void *)str2);
-		fprintf(stdout, "handle1            : %p\n", (void *)handle1);
-		fprintf(stdout, "handle2            : %p\n", (void *)handle2);
+		fprintf(stdout, "ptr                 : %p\n", (void *)&bkt->data[0]);
+		fprintf(stdout, "str1                : %p\n", (void *)str1);
+		fprintf(stdout, "str2                : %p\n", (void *)str2);
+		fprintf(stdout, "handle1             : %p\n", (void *)handle1);
+		fprintf(stdout, "handle2             : %p\n", (void *)handle2);
 
-		diff = str1 - bkt->ptr;
-		fprintf(stdout, "str1 - ptr         : %zu\n", diff);
+		diff = str1 - &bkt->data[0];
+		fprintf(stdout, "str1 - ptr          : %zu\n", diff);
 		pk_mem_assert(diff == 0);
 
 		diff = str2 - str1;
-		fprintf(stdout, "str2 - str1        : %zu\n", diff);
+		fprintf(stdout, "str2 - str1         : %zu\n", diff);
 		pk_mem_assert(diff == 16);
 
-		diff = str2 - bkt->ptr;
-		fprintf(stdout, "str2 - ptr         : %zu\n", diff);
+		diff = str2 - &bkt->data[0];
+		fprintf(stdout, "str2 - ptr          : %zu\n", diff);
 		pk_mem_assert(diff == 16);
 
 		diff = (char *)handle1 - str1;
-		fprintf(stdout, "handle1 - str1     : %zu\n", diff);
+		fprintf(stdout, "handle1 - str1      : %zu\n", diff);
 		pk_mem_assert(diff == 32);
 
 		diff = (char *)handle2 - (char *)handle1;
-		fprintf(stdout, "handle2 - handle1  : %zu\n", diff);
+		fprintf(stdout, "handle2 - handle1   : %zu\n", diff);
 		pk_mem_assert(diff == 8);
 
 		pk_bucket_destroy(bkt);
@@ -599,29 +628,32 @@ int main(int argc, char *argv[])
 	pk_test_pkmem_teardown();
 
 	// assert bucket count
+	/*
 	pk_test_pkmem_spinup(false);
 	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count01);
 	do
 	{
 		for (i = 0; i < PK_MAX_BUCKET_COUNT; ++i) {
-			pk_membucket *bkt = pk_bucket_create("lol", 1024, false);
+			pk_membucket *bkt = pk_bucket_create("lol", 1024, PK_MEMBUCKET_FLAG_NONE);
 			pk_mem_assert(bkt != nullptr);
 			(void)bkt;
 		}
-		pk_membucket *bkt = pk_bucket_create("lol", 1024, false);
+		pk_membucket *bkt = pk_bucket_create("lol", 1024, PK_MEMBUCKET_FLAG_NONE);
 		pk_mem_assert(bkt == nullptr);
 	}
 	while(false);
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count01);
 	pk_test_pkmem_teardown();
+	*/
 
 	// assert no buckets available on pk_new with full memory
+	/*
 	pk_test_pkmem_spinup(false);
 	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count02);
 	do
 	{
 		for (i = 0; i < PK_MAX_BUCKET_COUNT; ++i) {
-			pk_membucket *bkt = pk_bucket_create("lol2", 1024, false);
+			pk_membucket *bkt = pk_bucket_create("lol2", 1024, PK_MEMBUCKET_FLAG_NONE);
 			char *asdf = pk_new<char>(768, bkt);
 			pk_mem_assert(asdf != nullptr);
 		}
@@ -631,15 +663,17 @@ int main(int argc, char *argv[])
 	while(false);
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count02);
 	pk_test_pkmem_teardown();
+	*/
 
 	// assert no buckets available on pk_new with full memory
+	/*
 	pk_test_pkmem_spinup(false);
 	fprintf(stdout, "[pkmem.cpp] start: %s\n", test_bucket_count03);
 	do
 	{
 		pk_membucket *bkt = nullptr;
 		for (i = 0; i < PK_MAX_BUCKET_COUNT; ++i) {
-			bkt = pk_bucket_create("lol3", 1024, false);
+			bkt = pk_bucket_create("lol3", 1024, PK_MEMBUCKET_FLAG_NONE);
 			char *asdf = pk_new<char>(768, bkt);
 			pk_mem_assert(asdf != nullptr);
 		}
@@ -649,76 +683,79 @@ int main(int argc, char *argv[])
 	while(false);
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count03);
 	pk_test_pkmem_teardown();
+	*/
 
 	pk_test_pkmem_spinup(false);
 	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);
+		pk_membucket *bkt1 = pk_bucket_create("bucket1", 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_membucket *bkt2 = pk_bucket_create("bucket2", 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_membucket *bkt3 = pk_bucket_create("bucket3", 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_membucket *bkt4 = pk_bucket_create("bucket4", 1024, PK_MEMBUCKET_FLAG_NONE);
 
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(4 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(4 == debug_alloc_head);
 
 		pk_bucket_destroy(bkt4);
 
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(3 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(3 == debug_alloc_head);
 
 		pk_bucket_destroy(bkt3);
 
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(2 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(2 == debug_alloc_head);
 
 		pk_bucket_destroy(bkt2);
 
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(1 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(1 == debug_alloc_head);
 
 		pk_bucket_destroy(bkt1);
 
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(0 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(0 == debug_alloc_head);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count04);
 	pk_test_pkmem_teardown();
 
 	/* 2025-01-06 JCB
 	 * buckets are stored in an array.
-	 * pk_bucket_head is only an *indicator* of how many buckets have been
+	 * debug_alloc_head is only an *indicator* of how many buckets have been
 	 *  created total, and the index of the next available.
 	 */
 	pk_test_pkmem_spinup(false);
 	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);
+		pk_membucket *bkt1 = pk_bucket_create("bucket1", 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_membucket *bkt2 = pk_bucket_create("bucket2", 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_membucket *bkt3 = pk_bucket_create("bucket3", 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_membucket *bkt4 = pk_bucket_create("bucket4", 1024, PK_MEMBUCKET_FLAG_NONE);
 
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(4 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(4 == debug_alloc_head);
 
 		pk_bucket_destroy(bkt1);
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(4 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(4 == debug_alloc_head);
 
 		pk_bucket_destroy(bkt2);
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(4 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(4 == debug_alloc_head);
 
 		pk_bucket_destroy(bkt3);
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(4 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(4 == debug_alloc_head);
 
 		pk_bucket_destroy(bkt4);
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(3 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(0 == debug_alloc_head);
 
+		/*
 		pk_memory_flush();
-		fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
-		pk_mem_assert(0 == pk_bucket_head);
+		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
+		pk_mem_assert(0 == debug_alloc_head);
+		*/
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count05);
 	pk_test_pkmem_teardown();