Allocators Tools Initial
This commit is contained in:
IlushaShurupov
parent
4a2ab6f5d0
commit
6d0a4676ab
34 changed files with 3847 additions and 0 deletions
291
Allocators/outdated/tests/alloctests.cpp
Normal file
291
Allocators/outdated/tests/alloctests.cpp
Normal file
|
|
@ -0,0 +1,291 @@
|
|||
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "allocators.h"
|
||||
|
||||
struct test_struct {
|
||||
tp::alni val = 0;
|
||||
|
||||
test_struct() { val = 1; }
|
||||
~test_struct() { val = -1; }
|
||||
|
||||
bool operator==(const test_struct& in) { return in.val == val; }
|
||||
};
|
||||
|
||||
template <tp::alni size>
|
||||
struct allocator_test {
|
||||
test_struct data[size];
|
||||
bool is_allocated[size];
|
||||
tp::alni n_loaded = 0;
|
||||
|
||||
test_struct* allocations[size];
|
||||
|
||||
tp::AbstractAllocator* alloc;
|
||||
tp::AbstractAllocator* parent_alloc;
|
||||
const char* allocator_name = NULL;
|
||||
|
||||
tp::alni rand_idx(bool state) {
|
||||
RAND:
|
||||
|
||||
tp::alni idx = (tp::alni)(tp::randf() * (size + 1));
|
||||
CLAMP(idx, 0, size - 1);
|
||||
|
||||
if (state == is_allocated[idx]) {
|
||||
goto RAND;
|
||||
}
|
||||
return idx;
|
||||
}
|
||||
|
||||
allocator_test(tp::AbstractAllocator* palloc, const char* pallocator_name,
|
||||
tp::AbstractAllocator* p_parent_alloc) {
|
||||
allocator_name = pallocator_name;
|
||||
parent_alloc = p_parent_alloc;
|
||||
alloc = palloc;
|
||||
for (tp::alni i = 0; i < size; i++) {
|
||||
RAND:
|
||||
tp::alni val = tp::alni(tp::randf() * (size + 100.f));
|
||||
for (tp::alni check_idx = 0; check_idx < size; check_idx++) {
|
||||
if (data[check_idx].val == val) {
|
||||
goto RAND;
|
||||
}
|
||||
}
|
||||
|
||||
data[i].val = val;
|
||||
is_allocated[i] = false;
|
||||
allocations[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void verify_integrity() {
|
||||
// verify data integrity
|
||||
for (tp::alni i = 0; i < size; i++) {
|
||||
if (is_allocated[i]) {
|
||||
assert(*allocations[i] == data[i] && "data is currupted\n");
|
||||
}
|
||||
}
|
||||
|
||||
if (alloc->isWrapSupport()) assert(!alloc->isWrapCorrupted());
|
||||
if (parent_alloc && parent_alloc->isWrapSupport())
|
||||
assert(!parent_alloc->isWrapCorrupted());
|
||||
|
||||
verify_sizes();
|
||||
}
|
||||
|
||||
void verify_sizes() {
|
||||
return;
|
||||
#ifdef MEM_TRACE
|
||||
assert(alloc->sizeInuse() == n_loaded * sizeof(test_struct) &&
|
||||
"invalid inuse size\n");
|
||||
assert(alloc->sizeReserved() >= n_loaded * (tp::alni)sizeof(test_struct) &&
|
||||
"invalid reserved size\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
void load_item(tp::alni idx) {
|
||||
if (!is_allocated[idx]) {
|
||||
allocations[idx] = new (alloc) test_struct();
|
||||
|
||||
assert(allocations[idx] && "allocator returned NULL");
|
||||
|
||||
allocations[idx]->val = data[idx].val;
|
||||
is_allocated[idx] = true;
|
||||
n_loaded++;
|
||||
verify_integrity();
|
||||
}
|
||||
}
|
||||
|
||||
void unload_item(tp::alni idx) {
|
||||
if (is_allocated[idx]) {
|
||||
verify_integrity();
|
||||
delete allocations[idx];
|
||||
is_allocated[idx] = false;
|
||||
n_loaded--;
|
||||
verify_integrity();
|
||||
}
|
||||
}
|
||||
|
||||
void change_states(tp::Range<tp::alni> rg, bool state, bool reversed = false,
|
||||
bool random = false) {
|
||||
for (auto i : rg) {
|
||||
tp::alni idx = i;
|
||||
|
||||
if (random) {
|
||||
idx = rand_idx(state);
|
||||
}
|
||||
else if (reversed) {
|
||||
idx = size - i - 1;
|
||||
}
|
||||
|
||||
(state) ? load_item(idx) : unload_item(idx);
|
||||
}
|
||||
}
|
||||
|
||||
// full down-up load then up-down unload
|
||||
void test1() {
|
||||
change_states({ 0, size }, 1);
|
||||
change_states({ 0, size }, 0, true);
|
||||
}
|
||||
|
||||
// full down-up load then down-up unload
|
||||
void test2() {
|
||||
change_states({ 0, size }, 1);
|
||||
change_states({ 0, size }, 0);
|
||||
}
|
||||
|
||||
// full random load then random unload
|
||||
void test3() {
|
||||
change_states({ 0, size }, 1, 0, 1);
|
||||
change_states({ 0, size }, 0, 0, 1);
|
||||
}
|
||||
|
||||
// multipul tests 1-3
|
||||
void test4() {
|
||||
test1();
|
||||
test1();
|
||||
|
||||
test2();
|
||||
test2();
|
||||
|
||||
test3();
|
||||
test3();
|
||||
}
|
||||
|
||||
static tp::alnf sineupf(tp::alnf asize, tp::alnf x, bool reverse) {
|
||||
tp::alnf end = 4 * PI;
|
||||
tp::alnf a = (2 / 7.f) * asize;
|
||||
tp::alnf b = end / asize;
|
||||
|
||||
tp::alni c = ((-1 * reverse) + (1 * !reverse));
|
||||
tp::alnf c1 = (x - (end * reverse)) / b;
|
||||
tp::alnf c2 = (a * sin(x - (end * reverse)));
|
||||
tp::alnf out = c1 + c2;
|
||||
return c * out;
|
||||
}
|
||||
|
||||
// sin load & sin unload with ~1/2 drop factor
|
||||
void test5() {
|
||||
tp::alnf end = 4 * PI;
|
||||
tp::alnf step = end / 4.f;
|
||||
|
||||
for (char i = 0; i < 2; i++) {
|
||||
for (tp::alnf x = 0; x <= end; x += step) {
|
||||
tp::alni target_alloc_count = (tp::alni)ceil(sineupf(size, x, i));
|
||||
CLAMP(target_alloc_count, 0, size);
|
||||
|
||||
while (n_loaded > target_alloc_count) {
|
||||
unload_item(rand_idx(0));
|
||||
}
|
||||
while (n_loaded < target_alloc_count) {
|
||||
load_item(rand_idx(1));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef MEM_WRAP
|
||||
void check_wrap(tp::alni offset, bool after) {
|
||||
CLAMP(offset, 1, WRAP_LEN);
|
||||
|
||||
test_struct* ts = allocations[rand_idx(0)];
|
||||
tp::alni shift = (sizeof(test_struct) * after) + (offset - 1) * after -
|
||||
offset * (!after);
|
||||
tp::uint1* address = (((tp::uint1*)ts) + shift);
|
||||
|
||||
tp::uint1 val = *address;
|
||||
*address = 5;
|
||||
assert(alloc->isWrapCorrupted());
|
||||
*address = val;
|
||||
}
|
||||
#endif
|
||||
|
||||
// mem guards test
|
||||
void test6() {
|
||||
change_states({ 0, size }, 1);
|
||||
|
||||
#ifdef MEM_WRAP
|
||||
for (tp::alni after = 0; after < 2; after++) {
|
||||
for (tp::alni offset = 1; offset <= WRAP_LEN; offset++) {
|
||||
check_wrap(offset, after);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
change_states({ 0, size }, 0);
|
||||
}
|
||||
|
||||
void run_tests() {
|
||||
try {
|
||||
test1();
|
||||
test2();
|
||||
test3();
|
||||
test4();
|
||||
test5();
|
||||
if (alloc->isWrapSupport()) {
|
||||
test6();
|
||||
}
|
||||
|
||||
printf("%s - passed\n", allocator_name);
|
||||
if (!alloc->isWrapSupport()) {
|
||||
printf(" WARNING: %s has no wrap support!! \n", allocator_name);
|
||||
}
|
||||
}
|
||||
catch (...) {
|
||||
printf("%s - failed\n", allocator_name);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
void heap_alloc_test() {
|
||||
tp::alloc_init(); {
|
||||
try {
|
||||
allocator_test<150> hatest(tp::heapalloc, "heap allocator", NULL);
|
||||
hatest.run_tests();
|
||||
}
|
||||
catch (...) {
|
||||
printf("heap alloc failed\n");
|
||||
}
|
||||
} tp::alloc_uninit();
|
||||
}
|
||||
|
||||
void chunk_alloc_test() {
|
||||
tp::alloc_init(); {
|
||||
try {
|
||||
tp::ChunkAlloc calloc(sizeof(test_struct), 50);
|
||||
allocator_test<50> ca_test(&calloc, "chunk allocator", tp::heapalloc);
|
||||
ca_test.run_tests();
|
||||
}
|
||||
catch (...) {
|
||||
printf("chunk alloc failed\n");
|
||||
}
|
||||
} tp::alloc_uninit();
|
||||
}
|
||||
|
||||
void pool_alloc_test() {
|
||||
tp::alloc_init(); {
|
||||
try {
|
||||
tp::PoolAlloc palloc(sizeof(test_struct), 50);
|
||||
allocator_test<150> pa_test(&palloc, "pool allocator", tp::heapalloc);
|
||||
pa_test.run_tests();
|
||||
}
|
||||
catch (...) {
|
||||
printf("chunk alloc failed\n");
|
||||
}
|
||||
} tp::alloc_uninit();
|
||||
}
|
||||
|
||||
void allocators_test() {
|
||||
|
||||
printf("running tests on alocators:\n");
|
||||
|
||||
heap_alloc_test();
|
||||
chunk_alloc_test();
|
||||
pool_alloc_test();
|
||||
}
|
||||
|
||||
|
||||
CROSSPLATFORM_MAIN;
|
||||
int main(int argc, char* argv[]) {
|
||||
tp::print_env_info();
|
||||
allocators_test();
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue