summaryrefslogtreecommitdiff
path: root/test/pkmem.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'test/pkmem.cpp')
-rw-r--r--test/pkmem.cpp313
1 files changed, 174 insertions, 139 deletions
diff --git a/test/pkmem.cpp b/test/pkmem.cpp
index 1a6dd8f..98d2dd2 100644
--- a/test/pkmem.cpp
+++ b/test/pkmem.cpp
@@ -3,7 +3,14 @@
#include "../pkmem.h"
-#include <new>
+#define PK_IMPL_FUNCINSTR
+#include "../pkfuncinstr.h"
+
+#ifndef PK_MEMORY_FORCE_MALLOC
+ #define pk_mem_assert(expr) assert(expr)
+#else
+ #define pk_mem_assert(expr) (void)0;
+#endif
class FreeTest {
public:
@@ -48,12 +55,12 @@ class FreeTest01 : public FreeTest {
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]);
+ pk_mem_assert(3 == bkt->lastEmptyBlockIndex);
+ 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]);
}
};
@@ -82,20 +89,21 @@ class FreeTest02 : public FreeTest {
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]);
+ pk_mem_assert(2 == bkt->lastEmptyBlockIndex);
+ 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]);
- assert(bkt->ptr + 19 == bkt->blocks[0].data);
- assert(13 == bkt->blocks[0].size);
+ pk_mem_assert(bkt->ptr + 19 == bkt->blocks[0].data);
+ pk_mem_assert(13 == bkt->blocks[0].size);
- assert(bkt->ptr + 33 == bkt->blocks[1].data);
- assert(31 == bkt->blocks[1].size);
+ pk_mem_assert(bkt->ptr + 33 == bkt->blocks[1].data);
+ pk_mem_assert(31 == bkt->blocks[1].size);
}
};
+const char *test_basic_alloc = "test_basic_alloc";
const char *test_misalignment01 = "test_misalignment01";
const char *test_misalignment02 = "test_misalignment02";
const char *test_free_0000 = "test_free_0000";
@@ -113,6 +121,14 @@ const char *test_bucket_count03 = "test_bucket_count03";
const char *test_bucket_count04 = "test_bucket_count04";
const char *test_bucket_count05 = "test_bucket_count05";
+void pk_test_pkmem_spinup(bool init_funcinstr = false) {
+ if (init_funcinstr) pk_funcinstr_init();
+}
+void pk_test_pkmem_teardown() {
+ pk_funcinstr_teardown();
+ pk_memory_teardown_all();
+}
+
/*
static bool expected_exit = false;
static bool caught = false;
@@ -127,7 +143,7 @@ exit(int code)
_exit(code);
}
}
-// assert() calls abort(), handle
+// pk_mem_assert() calls abort(), handle
void
handle_assert_abort(int sig)
{
@@ -149,14 +165,18 @@ int main(int argc, char *argv[])
int i;
// pk_new<T>
+ pk_test_pkmem_spinup(true);
+ fprintf(stdout, "[pkmem.cpp] start: %s\n", test_basic_alloc);
{
char *some_dang_string = pk_new<char>(64);
fprintf(stdout, "some_dang_string: %s: %p\n", some_dang_string, (void *)some_dang_string);
pk_delete<char>(some_dang_string, 64);
}
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
+ fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_basic_alloc);
// assert misalignment
+ pk_test_pkmem_spinup(true);
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment01);
{
pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, false);
@@ -165,21 +185,22 @@ int main(int argc, char *argv[])
pk_new(9, 1, bkt);
fprintf(stdout, "lastEmptyBlockIndex: %li\n", bkt->lastEmptyBlockIndex);
- assert(1 == bkt->lastEmptyBlockIndex);
+ pk_mem_assert(1 == bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", bkt->head);
- assert(65 == bkt->head);
+ pk_mem_assert(65 == bkt->head);
fprintf(stdout, "blocks[0].data : %p\n", (void *)bkt->blocks[0].data);
- assert(bkt->ptr + 10 == bkt->blocks[0].data);
+ pk_mem_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);
+ pk_mem_assert(54 == bkt->blocks[0].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment01);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
// assert misalignment + blank block test
+ pk_test_pkmem_spinup();
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_misalignment02);
{
pk_membucket *bkt = pk_bucket_create("misalignment", 1024 * 1024, false);
@@ -188,51 +209,53 @@ int main(int argc, char *argv[])
pk_new(9, 16, bkt);
fprintf(stdout, "lastEmptyBlockIndex: %li\n", bkt->lastEmptyBlockIndex);
- assert(2 == bkt->lastEmptyBlockIndex);
+ pk_mem_assert(2 == bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", bkt->head);
- assert(65 == bkt->head);
+ pk_mem_assert(65 == bkt->head);
fprintf(stdout, "blocks[0].data : %p\n", (void *)bkt->blocks[0].data);
- assert(bkt->ptr + 1 == bkt->blocks[0].data);
+ pk_mem_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);
+ pk_mem_assert(15 == bkt->blocks[0].size);
fprintf(stdout, "blocks[1].data : %p\n", (void *)bkt->blocks[1].data);
- assert(bkt->ptr + 25 == bkt->blocks[1].data);
+ pk_mem_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);
+ pk_mem_assert(39 == bkt->blocks[1].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_misalignment02);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
// predictable free 0000
+ pk_test_pkmem_spinup(true);
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0000);
{
FreeTest01 ft{};
ft.ensureState();
fprintf(stdout, "blocks[0].data : %p\n", (void *)ft.bkt->blocks[0].data);
- assert(ft.bkt->ptr + 2 == 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);
- assert(6 == ft.bkt->blocks[0].size);
+ pk_mem_assert(6 == ft.bkt->blocks[0].size);
fprintf(stdout, "blocks[1].data : %p\n", (void *)ft.bkt->blocks[1].data);
- assert(ft.bkt->ptr + 12 == 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);
- assert(4 == ft.bkt->blocks[1].size);
+ pk_mem_assert(4 == ft.bkt->blocks[1].size);
fprintf(stdout, "blocks[2].data : %p\n", (void *)ft.bkt->blocks[2].data);
- assert(ft.bkt->ptr + 32 == 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);
- assert(32 == ft.bkt->blocks[2].size);
+ pk_mem_assert(32 == ft.bkt->blocks[2].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0000);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
// predictable free 1000
+ pk_test_pkmem_spinup();
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_1000);
{
size_t expected_head = 80;
@@ -246,29 +269,30 @@ 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);
- assert(3 == ft.bkt->lastEmptyBlockIndex);
+ pk_mem_assert(3 == ft.bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", ft.bkt->head);
- assert(expected_head == ft.bkt->head);
+ pk_mem_assert(expected_head == ft.bkt->head);
fprintf(stdout, "blocks[0].data : %p\n", (void *)ft.bkt->blocks[0].data);
- assert(ft.bkt->ptr + 0 == 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);
- assert(8 == ft.bkt->blocks[0].size);
+ pk_mem_assert(8 == ft.bkt->blocks[0].size);
fprintf(stdout, "blocks[1].data : %p\n", (void *)ft.bkt->blocks[1].data);
- assert(ft.bkt->ptr + 12 == 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);
- assert(4 == ft.bkt->blocks[1].size);
+ pk_mem_assert(4 == ft.bkt->blocks[1].size);
fprintf(stdout, "blocks[2].data : %p\n", (void *)ft.bkt->blocks[2].data);
- assert(ft.bkt->ptr + 32 == 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);
- assert(32 == ft.bkt->blocks[2].size);
+ pk_mem_assert(32 == ft.bkt->blocks[2].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_1000);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
// predictable free 0100
+ pk_test_pkmem_spinup();
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0100);
{
size_t expected_head = 32;
@@ -282,24 +306,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);
- assert(2 == ft.bkt->lastEmptyBlockIndex);
+ pk_mem_assert(2 == ft.bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", ft.bkt->head);
- assert(expected_head == ft.bkt->head);
+ pk_mem_assert(expected_head == ft.bkt->head);
fprintf(stdout, "blocks[0].data : %p\n", (void *)ft.bkt->blocks[0].data);
- assert(ft.bkt->ptr + 2 == 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);
- assert(6 == ft.bkt->blocks[0].size);
+ pk_mem_assert(6 == ft.bkt->blocks[0].size);
fprintf(stdout, "blocks[1].data : %p\n", (void *)ft.bkt->blocks[1].data);
- assert(ft.bkt->ptr + 12 == 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);
- assert(4 == ft.bkt->blocks[1].size);
+ pk_mem_assert(4 == ft.bkt->blocks[1].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0100);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
// predictable free 0010
+ pk_test_pkmem_spinup();
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0010);
{
size_t expected_head = 80;
@@ -314,24 +339,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);
- assert(2 == ft.bkt->lastEmptyBlockIndex);
+ pk_mem_assert(2 == ft.bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", ft.bkt->head);
- assert(expected_head == ft.bkt->head);
+ pk_mem_assert(expected_head == ft.bkt->head);
fprintf(stdout, "blocks[0].data : %p\n", (void *)ft.bkt->blocks[0].data);
- assert(ft.bkt->ptr + 2 == 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);
- assert(6 == ft.bkt->blocks[0].size);
+ pk_mem_assert(6 == ft.bkt->blocks[0].size);
fprintf(stdout, "blocks[1].data : %p\n", (void *)ft.bkt->blocks[1].data);
- assert(ft.bkt->ptr + 12 == 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);
- assert(52 == ft.bkt->blocks[1].size);
+ pk_mem_assert(52 == ft.bkt->blocks[1].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0010);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
// predictable free 0001
+ pk_test_pkmem_spinup();
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_0001);
{
size_t expected_head = 80;
@@ -346,24 +372,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);
- assert(2 == ft.bkt->lastEmptyBlockIndex);
+ pk_mem_assert(2 == ft.bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", ft.bkt->head);
- assert(expected_head == ft.bkt->head);
+ pk_mem_assert(expected_head == ft.bkt->head);
fprintf(stdout, "blocks[0].data : %p\n", (void *)ft.bkt->blocks[0].data);
- assert(ft.bkt->ptr + 2 == 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);
- assert(14 == ft.bkt->blocks[0].size);
+ pk_mem_assert(14 == ft.bkt->blocks[0].size);
fprintf(stdout, "blocks[1].data : %p\n", (void *)ft.bkt->blocks[1].data);
- assert(ft.bkt->ptr + 32 == 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);
- assert(32 == ft.bkt->blocks[1].size);
+ pk_mem_assert(32 == ft.bkt->blocks[1].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_0001);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
// ensure free touching after only
+ pk_test_pkmem_spinup();
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_after);
{
FreeTest02 ft{};
@@ -374,24 +401,25 @@ int main(int argc, char *argv[])
pk_delete(ft.ptrs[0], ft.sz[0], ft.bkt);
fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
- assert(2 == ft.bkt->lastEmptyBlockIndex);
+ pk_mem_assert(2 == ft.bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", ft.bkt->head);
- assert(65 == ft.bkt->head);
+ pk_mem_assert(65 == ft.bkt->head);
fprintf(stdout, "blocks[0].data : %p\n", (void *)ft.bkt->blocks[0].data);
- assert(ft.bkt->ptr + 0 == 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);
- assert(32 == ft.bkt->blocks[0].size);
+ pk_mem_assert(32 == ft.bkt->blocks[0].size);
fprintf(stdout, "blocks[1].data : %p\n", (void *)ft.bkt->blocks[1].data);
- assert(ft.bkt->ptr + 33 == 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);
- assert(31 == ft.bkt->blocks[1].size);
+ pk_mem_assert(31 == ft.bkt->blocks[1].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_after);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
// ensure free touching before only
+ pk_test_pkmem_spinup();
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_before);
{
FreeTest02 ft{};
@@ -411,22 +439,22 @@ int main(int argc, char *argv[])
void *ptr5 = pk_new( 1, 1, ft.bkt);
fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
- assert(0 == ft.bkt->lastEmptyBlockIndex);
+ pk_mem_assert(0 == ft.bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", ft.bkt->head);
- assert(66 == ft.bkt->head);
+ pk_mem_assert(66 == ft.bkt->head);
fprintf(stdout, "ptr0 : %p\n", ft.ptrs[0]);
- assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
+ pk_mem_assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
fprintf(stdout, "ptr3 : %p\n", ptr3);
- assert(ft.bkt->ptr + 19 == ptr3);
+ pk_mem_assert(ft.bkt->ptr + 19 == ptr3);
fprintf(stdout, "ptr2 : %p\n", ft.ptrs[2]);
- assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
+ pk_mem_assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
fprintf(stdout, "ptr4 : %p\n", ptr4);
- assert(ft.bkt->ptr + 33 == ptr4);
+ pk_mem_assert(ft.bkt->ptr + 33 == ptr4);
fprintf(stdout, "ptr1 : %p\n", ft.ptrs[1]);
- assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
+ pk_mem_assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
fprintf(stdout, "ptr5 : %p\n", ptr5);
- assert(ft.bkt->ptr + 65 == ptr5);
+ pk_mem_assert(ft.bkt->ptr + 65 == ptr5);
/* free [19-31]
[00-18] (19) ptr0
@@ -441,27 +469,27 @@ int main(int argc, char *argv[])
ptr3 = nullptr;
fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
- assert(1 == ft.bkt->lastEmptyBlockIndex);
+ pk_mem_assert(1 == ft.bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", ft.bkt->head);
- assert(66 == ft.bkt->head);
+ pk_mem_assert(66 == ft.bkt->head);
fprintf(stdout, "ptr0 : %p\n", ft.ptrs[0]);
- assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
+ pk_mem_assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
fprintf(stdout, "ptr3 : %p\n", ptr3);
- assert(nullptr == ptr3);
+ pk_mem_assert(nullptr == ptr3);
fprintf(stdout, "ptr2 : %p\n", ft.ptrs[2]);
- assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
+ pk_mem_assert(ft.bkt->ptr + 32 == ft.ptrs[2]);
fprintf(stdout, "ptr4 : %p\n", ptr4);
- assert(ft.bkt->ptr + 33 == ptr4);
+ pk_mem_assert(ft.bkt->ptr + 33 == ptr4);
fprintf(stdout, "ptr1 : %p\n", ft.ptrs[1]);
- assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
+ pk_mem_assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
fprintf(stdout, "ptr5 : %p\n", ptr5);
- assert(ft.bkt->ptr + 65 == ptr5);
+ pk_mem_assert(ft.bkt->ptr + 65 == ptr5);
fprintf(stdout, "blocks[0].data : %p\n", (void *)ft.bkt->blocks[0].data);
- assert(ft.bkt->ptr + 19 == 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);
- assert(13 == ft.bkt->blocks[0].size);
+ pk_mem_assert(13 == ft.bkt->blocks[0].size);
/* free [32] which gets absorbed into 19-32
[19-32] (13) memblock
@@ -471,32 +499,33 @@ int main(int argc, char *argv[])
ft.ptrs[2] = nullptr;
fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
- assert(1 == ft.bkt->lastEmptyBlockIndex);
+ pk_mem_assert(1 == ft.bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", ft.bkt->head);
- assert(66 == ft.bkt->head);
+ pk_mem_assert(66 == ft.bkt->head);
fprintf(stdout, "ptr0 : %p\n", ft.ptrs[0]);
- assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
+ pk_mem_assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
fprintf(stdout, "ptr3 : %p\n", ptr3);
- assert(nullptr == ptr3);
+ pk_mem_assert(nullptr == ptr3);
fprintf(stdout, "ptr2 : %p\n", ft.ptrs[2]);
- assert(nullptr == ft.ptrs[2]);
+ pk_mem_assert(nullptr == ft.ptrs[2]);
fprintf(stdout, "ptr4 : %p\n", ptr4);
- assert(ft.bkt->ptr + 33 == ptr4);
+ pk_mem_assert(ft.bkt->ptr + 33 == ptr4);
fprintf(stdout, "ptr1 : %p\n", ft.ptrs[1]);
- assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
+ pk_mem_assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
fprintf(stdout, "ptr5 : %p\n", ptr5);
- assert(ft.bkt->ptr + 65 == ptr5);
+ pk_mem_assert(ft.bkt->ptr + 65 == ptr5);
fprintf(stdout, "blocks[0].data : %p\n", (void *)ft.bkt->blocks[0].data);
- assert(ft.bkt->ptr + 19 == 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);
- assert(14 == ft.bkt->blocks[0].size);
+ pk_mem_assert(14 == ft.bkt->blocks[0].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_before);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
// ensure free touching before and after
+ pk_test_pkmem_spinup();
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_free_between);
{
FreeTest02 ft{};
@@ -508,25 +537,26 @@ int main(int argc, char *argv[])
ft.ptrs[2] = nullptr;
fprintf(stdout, "lastEmptyBlockIndex: %li\n", ft.bkt->lastEmptyBlockIndex);
- assert(1 == ft.bkt->lastEmptyBlockIndex);
+ pk_mem_assert(1 == ft.bkt->lastEmptyBlockIndex);
fprintf(stdout, "head : %li\n", ft.bkt->head);
- assert(65 == ft.bkt->head);
+ pk_mem_assert(65 == ft.bkt->head);
fprintf(stdout, "ptr0 : %p\n", ft.ptrs[0]);
- assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
+ pk_mem_assert(ft.bkt->ptr + 0 == ft.ptrs[0]);
fprintf(stdout, "ptr2 : %p\n", ft.ptrs[2]);
- assert(nullptr == ft.ptrs[2]);
+ pk_mem_assert(nullptr == ft.ptrs[2]);
fprintf(stdout, "ptr1 : %p\n", ft.ptrs[1]);
- assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
+ pk_mem_assert(ft.bkt->ptr + 64 == ft.ptrs[1]);
fprintf(stdout, "blocks[0].data : %p\n", (void *)ft.bkt->blocks[0].data);
- assert(ft.bkt->ptr + 19 == 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);
- assert(45 == ft.bkt->blocks[0].size);
+ pk_mem_assert(45 == ft.bkt->blocks[0].size);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_free_between);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
+ pk_test_pkmem_spinup();
fprintf(stdout, "[pkmem.cpp] start: %s\n", test_alloc_strings);
{
size_t diff;
@@ -545,62 +575,65 @@ int main(int argc, char *argv[])
diff = str1 - bkt->ptr;
fprintf(stdout, "str1 - ptr : %zu\n", diff);
- assert(diff == 0);
+ pk_mem_assert(diff == 0);
diff = str2 - str1;
fprintf(stdout, "str2 - str1 : %zu\n", diff);
- assert(diff == 16);
+ pk_mem_assert(diff == 16);
diff = str2 - bkt->ptr;
fprintf(stdout, "str2 - ptr : %zu\n", diff);
- assert(diff == 16);
+ pk_mem_assert(diff == 16);
diff = (char *)handle1 - str1;
fprintf(stdout, "handle1 - str1 : %zu\n", diff);
- assert(diff == 32);
+ pk_mem_assert(diff == 32);
diff = (char *)handle2 - (char *)handle1;
fprintf(stdout, "handle2 - handle1 : %zu\n", diff);
- assert(diff == 8);
+ pk_mem_assert(diff == 8);
pk_bucket_destroy(bkt);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_alloc_strings);
- pk_memory_teardown_all();
+ 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);
- assert(bkt != nullptr);
+ pk_mem_assert(bkt != nullptr);
(void)bkt;
}
pk_membucket *bkt = pk_bucket_create("lol", 1024, false);
- assert(bkt == nullptr);
+ pk_mem_assert(bkt == nullptr);
}
while(false);
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count01);
- pk_memory_teardown_all();
+ 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);
char *asdf = pk_new<char>(768, bkt);
- assert(asdf != nullptr);
+ pk_mem_assert(asdf != nullptr);
}
char *asdf = pk_new<char>(768);
- assert(asdf == nullptr);
+ pk_mem_assert(asdf == nullptr);
}
while(false);
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count02);
- pk_memory_teardown_all();
+ 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
{
@@ -608,15 +641,16 @@ int main(int argc, char *argv[])
for (i = 0; i < PK_MAX_BUCKET_COUNT; ++i) {
bkt = pk_bucket_create("lol3", 1024, false);
char *asdf = pk_new<char>(768, bkt);
- assert(asdf != nullptr);
+ pk_mem_assert(asdf != nullptr);
}
char *asdf = pk_new<char>(768, bkt);
- assert(asdf == nullptr);
+ pk_mem_assert(asdf == nullptr);
}
while(false);
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count03);
- pk_memory_teardown_all();
+ 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);
@@ -625,36 +659,37 @@ int main(int argc, char *argv[])
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_mem_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_mem_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_mem_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_mem_assert(1 == pk_bucket_head);
pk_bucket_destroy(bkt1);
fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
- assert(0 == pk_bucket_head);
+ pk_mem_assert(0 == pk_bucket_head);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count04);
- pk_memory_teardown_all();
+ 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
* 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);
@@ -663,30 +698,30 @@ int main(int argc, char *argv[])
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_mem_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_mem_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_mem_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_mem_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_mem_assert(3 == pk_bucket_head);
pk_memory_flush();
fprintf(stdout, "pk_bucket_head: %li\n", pk_bucket_head);
- assert(0 == pk_bucket_head);
+ pk_mem_assert(0 == pk_bucket_head);
}
fprintf(stdout, "[pkmem.cpp] end: %s\n\n", test_bucket_count05);
- pk_memory_teardown_all();
+ pk_test_pkmem_teardown();
return 0;
}
generated by cgit v1.2.3 (git 2.39.1) at 2026-01-04 10:05:33 +0000