pkmem.h: debug on bucket + change signatures

6 files changed, 36 insertions, 169 deletions

diff --git a/test/pkarr.c b/test/pkarr.c
index 58a0c7f..74ff27d 100644
--- a/test/pkarr.c
+++ b/test/pkarr.c
@@ -31,17 +31,16 @@ void
 test_spinup(struct pk_arr *arr, struct pk_membucket **bkt)
 {
 	memset(arr, 0, sizeof(struct pk_arr));
-	*bkt = pk_bucket_create("test", 1024 * 1024, false);
+	*bkt = pk_mem_bucket_create("test", 1024 * 1024, false);
 	arr->bkt = *bkt;
 }
 
 void
 test_teardown(struct pk_arr *arr, struct pk_membucket **bkt)
 {
-	pk_bucket_destroy(*bkt);
+	pk_mem_bucket_destroy(*bkt);
 	*bkt = NULL;
 	arr->data = NULL;
-	pk_memory_teardown_all();
 }
 
 bool
diff --git a/test/pkarr.cpp b/test/pkarr.cpp
index 600b38f..4b03922 100644
--- a/test/pkarr.cpp
+++ b/test/pkarr.cpp
@@ -14,13 +14,13 @@
 void
 test_spinup(struct pk_membucket **bkt)
 {
-	*bkt = pk_bucket_create("test", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE);
+	*bkt = pk_mem_bucket_create("test", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE);
 }
 
 void
 test_teardown(struct pk_membucket **bkt)
 {
-	pk_bucket_destroy(*bkt);
+	pk_mem_bucket_destroy(*bkt);
 	*bkt = NULL;
 }
 
diff --git a/test/pkbktarr.c b/test/pkbktarr.c
index ef8a78f..6767cbc 100644
--- a/test/pkbktarr.c
+++ b/test/pkbktarr.c
@@ -39,15 +39,15 @@ void iter(void *user_data, void *arr_item) {
 
 void test_spinup(struct pk_membucket **bkt_buckets, struct pk_membucket **bkt_data)
 {
-	*bkt_buckets = pk_bucket_create("buckets", 1 << 16, false);
-	*bkt_data = pk_bucket_create("data", 1 << 16, false);
+	*bkt_buckets = pk_mem_bucket_create("buckets", 1 << 16, false);
+	*bkt_data = pk_mem_bucket_create("data", 1 << 16, false);
 	global_counter = 0;
 }
 
 void test_teardown(struct pk_membucket **bkt_buckets, struct pk_membucket **bkt_data)
 {
-	pk_bucket_destroy(*bkt_buckets);
-	pk_bucket_destroy(*bkt_data);
+	pk_mem_bucket_destroy(*bkt_buckets);
+	pk_mem_bucket_destroy(*bkt_data);
 	*bkt_buckets = nullptr;
 	*bkt_data = nullptr;
 }
diff --git a/test/pkbktarr.cpp b/test/pkbktarr.cpp
index 45d2ba2..c4ce85c 100644
--- a/test/pkbktarr.cpp
+++ b/test/pkbktarr.cpp
@@ -7,15 +7,15 @@
 
 void test_spinup(struct pk_membucket **bkt_buckets, struct pk_membucket **bkt_data)
 {
-	*bkt_buckets = pk_bucket_create("buckets", 1 << 16, PK_MEMBUCKET_FLAG_NONE);
-	*bkt_data = pk_bucket_create("data", 1 << 16, PK_MEMBUCKET_FLAG_NONE);
+	*bkt_buckets = pk_mem_bucket_create("buckets", 1 << 16, PK_MEMBUCKET_FLAG_NONE);
+	*bkt_data = pk_mem_bucket_create("data", 1 << 16, PK_MEMBUCKET_FLAG_NONE);
 }
 
 void test_teardown(struct pk_membucket **bkt_buckets, struct pk_membucket **bkt_data)
 {
 	// reverse order
-	pk_bucket_destroy(*bkt_data);
-	pk_bucket_destroy(*bkt_buckets);
+	pk_mem_bucket_destroy(*bkt_data);
+	pk_mem_bucket_destroy(*bkt_buckets);
 	*bkt_buckets = nullptr;
 	*bkt_data = nullptr;
 }
diff --git a/test/pkmem.c b/test/pkmem.c
index 7614379..5ec2643 100644
--- a/test/pkmem.c
+++ b/test/pkmem.c
@@ -15,8 +15,8 @@ struct mem_test {
 } mt;
 
 void spinup() {
-	mt.bkt1 = pk_bucket_create("bkt1", 1024, false);
-	mt.bkt2 = pk_bucket_create("bkt2", 1024, false);
+	mt.bkt1 = pk_mem_bucket_create("bkt1", 1024, false);
+	mt.bkt2 = pk_mem_bucket_create("bkt2", 1024, false);
 }
 
 void spinup_w_instr() {
@@ -25,8 +25,8 @@ void spinup_w_instr() {
 }
 
 void teardown() {
-	pk_bucket_destroy(mt.bkt1);
-	pk_bucket_destroy(mt.bkt2);
+	pk_mem_bucket_destroy(mt.bkt1);
+	pk_mem_bucket_destroy(mt.bkt2);
 	pk_funcinstr_teardown();
 }
 
@@ -38,7 +38,7 @@ int main(int argc, char *argv[])
 	// pk_new_base
 	{
 		spinup_w_instr();
-		pk_bucket_set_client_bucket(mt.bkt1);
+		pk_mem_bucket_set_client_mem_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);
diff --git a/test/pkmem.cpp b/test/pkmem.cpp
index 6a52f25..3a2b425 100644
--- a/test/pkmem.cpp
+++ b/test/pkmem.cpp
@@ -21,11 +21,11 @@ class FreeTest {
 	void *ptrs[4];
 
 	FreeTest() :
-	bkt(pk_bucket_create("freetest", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE)) {
-		pk_bucket_set_client_bucket(this->bkt);
+	bkt(pk_mem_bucket_create("freetest", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE)) {
+		pk_mem_bucket_set_client_mem_bucket(this->bkt);
 	}
 	virtual ~FreeTest() {
-		pk_bucket_destroy(this->bkt);
+		pk_mem_bucket_destroy(this->bkt);
 	}
 
 	void setup() {
@@ -128,7 +128,6 @@ void pk_test_pkmem_spinup(bool init_funcinstr = false) {
 }
 void pk_test_pkmem_teardown() {
 	pk_funcinstr_teardown();
-	pk_memory_teardown_all();
 }
 
 /*
@@ -170,16 +169,18 @@ int main(int argc, char *argv[])
 	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);
+		pk_membucket *bkt = pk_mem_bucket_create("test-some-dang-string", 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_mem_bucket_set_client_mem_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);
+#ifdef PK_MEMORY_DEBUGGER
+		fprintf(stdout, "debug block         : size: %zu, data: %p\n", bkt->debug_blocks[0].size, bkt->debug_blocks[0].ptr);
+		pk_mem_assert(64 == bkt->debug_blocks[0].size);
+		pk_mem_assert((char*)bkt + EXPECTED_PK_MEMBLOCK_SIZE == bkt->debug_blocks[0].data);
+#endif
 
 		fprintf(stdout, "bkt->head           : %lu\n", bkt->head);
 		pk_mem_assert(64 == bkt->head);
@@ -193,7 +194,7 @@ int main(int argc, char *argv[])
 
 		pk_delete<char>(some_dang_string, 64);
 
-		pk_bucket_destroy(bkt);
+		pk_mem_bucket_destroy(bkt);
 	}
 	pk_test_pkmem_teardown();
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_basic_alloc);
@@ -202,8 +203,8 @@ 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, PK_MEMBUCKET_FLAG_NONE);
-		pk_bucket_set_client_bucket(bkt);
+		pk_membucket *bkt = pk_mem_bucket_create("misalignment", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_mem_bucket_set_client_mem_bucket(bkt);
 		pk_new(1, 1, bkt);
 		pk_new(1, 64, bkt);
 		pk_new(9, 1, bkt);
@@ -220,7 +221,7 @@ int main(int argc, char *argv[])
 		fprintf(stdout, "blocks[15].size     : %li\n", bkt->blocks[15].size);
 		pk_mem_assert(54 == bkt->blocks[15].size);
 
-		pk_bucket_destroy(bkt);
+		pk_mem_bucket_destroy(bkt);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment01);
 	pk_test_pkmem_teardown();
@@ -229,8 +230,8 @@ 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, PK_MEMBUCKET_FLAG_NONE);
-		pk_bucket_set_client_bucket(bkt);
+		pk_membucket *bkt = pk_mem_bucket_create("misalignment", 1024 * 1024, PK_MEMBUCKET_FLAG_NONE);
+		pk_mem_bucket_set_client_mem_bucket(bkt);
 		pk_new(1, 1, bkt);
 		pk_new(1, 64, bkt);
 		pk_new(9, 16, bkt);
@@ -253,7 +254,7 @@ int main(int argc, char *argv[])
 		fprintf(stdout, "blocks[14].size     : %li\n", bkt->blocks[14].size);
 		pk_mem_assert(39 == bkt->blocks[14].size);
 
-		pk_bucket_destroy(bkt);
+		pk_mem_bucket_destroy(bkt);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment02);
 	pk_test_pkmem_teardown();
@@ -589,7 +590,7 @@ 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, PK_MEMBUCKET_FLAG_NONE);
+		pk_membucket *bkt = pk_mem_bucket_create(test_free_between, PK_MEM_DEFAULT_BUCKET_SIZE, PK_MEMBUCKET_FLAG_NONE);
 
 		char *str1 = pk_new<char>(16, bkt);
 		char *str2 = pk_new<char>(16, bkt);
@@ -622,143 +623,10 @@ int main(int argc, char *argv[])
 		fprintf(stdout, "handle2 - handle1   : %zu\n", diff);
 		pk_mem_assert(diff == 8);
 
-		pk_bucket_destroy(bkt);
+		pk_mem_bucket_destroy(bkt);
 	}
 	fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_alloc_strings);
 	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, PK_MEMBUCKET_FLAG_NONE);
-			pk_mem_assert(bkt != nullptr);
-			(void)bkt;
-		}
-		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, PK_MEMBUCKET_FLAG_NONE);
-			char *asdf = pk_new<char>(768, bkt);
-			pk_mem_assert(asdf != nullptr);
-		}
-		char *asdf = pk_new<char>(768);
-		pk_mem_assert(asdf == nullptr);
-	}
-	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, PK_MEMBUCKET_FLAG_NONE);
-			char *asdf = pk_new<char>(768, bkt);
-			pk_mem_assert(asdf != nullptr);
-		}
-		char *asdf = pk_new<char>(768, bkt);
-		pk_mem_assert(asdf == nullptr);
-	}
-	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, 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, "debug_alloc_head: %li\n", debug_alloc_head);
-		pk_mem_assert(4 == debug_alloc_head);
-
-		pk_bucket_destroy(bkt4);
-
-		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
-		pk_mem_assert(3 == debug_alloc_head);
-
-		pk_bucket_destroy(bkt3);
-
-		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
-		pk_mem_assert(2 == debug_alloc_head);
-
-		pk_bucket_destroy(bkt2);
-
-		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
-		pk_mem_assert(1 == debug_alloc_head);
-
-		pk_bucket_destroy(bkt1);
-
-		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.
-	 * 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, 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, "debug_alloc_head: %li\n", debug_alloc_head);
-		pk_mem_assert(4 == debug_alloc_head);
-
-		pk_bucket_destroy(bkt1);
-		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
-		pk_mem_assert(4 == debug_alloc_head);
-
-		pk_bucket_destroy(bkt2);
-		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
-		pk_mem_assert(4 == debug_alloc_head);
-
-		pk_bucket_destroy(bkt3);
-		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
-		pk_mem_assert(4 == debug_alloc_head);
-
-		pk_bucket_destroy(bkt4);
-		fprintf(stdout, "debug_alloc_head: %li\n", debug_alloc_head);
-		pk_mem_assert(0 == debug_alloc_head);
-
-		/*
-		pk_memory_flush();
-		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();
-
 	return 0;
 }