#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic ignored "-Walloc-size-larger-than="
#endif
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <errno.h>
#include <string.h>
#ifdef __cplusplus
#include <new>
#include <vector>
#endif
#include "mimalloc.h"
#include "mimalloc-stats.h"
#include "mimalloc/types.h"
#include "testhelper.h"
bool test_theap1(void);
bool test_theap2(void);
bool test_theap_arena_destroy(void);
bool test_theap_arena_delete(void);
bool test_stl_allocator1(void);
bool test_stl_allocator2(void);
bool test_stl_theap_allocator1(void);
bool test_stl_theap_allocator2(void);
bool test_stl_theap_allocator3(void);
bool test_stl_theap_allocator4(void);
static bool test_zero_aligned_first(void);
static bool test_aligned_all(void);
static bool test_heap_destroy_xthread_free(void);
static bool test_heap_destroy_stale_theap(void);
static bool test_thread_done_no_reinit(void);
static bool test_thread_heap_release(void);
static bool test_heap_delete_concurrent_free(void);
#ifdef __cplusplus
static bool test_new_first(void);
#endif
#if !MI_QSBR
static void mi_cdecl qsbr_record_error(int err, void* arg) {
*(int*)arg = err;
}
#endif
static bool mem_has_vals(const uint8_t* p, size_t size, uint8_t val) {
if (p==NULL) return false;
if (size==0) return true;
return (p[0] == val && memcmp(p, p + 1, size - 1) == 0); }
static bool mem_is_zero(const void* p, size_t size) {
return mem_has_vals((const uint8_t*)p,size,0);
}
#if MI_TEST_LIGHT >= 2
#define MI_TEST_SIZE_STEP(size,step) ((size) < 64 ? (step) : 15*(step))
#define MI_TEST_LARGE_STEP (6*1024)
#define MI_TEST_ITERS(n) ((n)/8)
#elif MI_TEST_LIGHT
#define MI_TEST_SIZE_STEP(size,step) ((size) < 128 ? (step) : 7*(step))
#define MI_TEST_LARGE_STEP (3*1024)
#define MI_TEST_ITERS(n) ((n)/4)
#else
#define MI_TEST_SIZE_STEP(size,step) ((size) < 256 ? (step) : 3*(step))
#define MI_TEST_LARGE_STEP (1024)
#define MI_TEST_ITERS(n) (n)
#endif
#define MI_TEST_SMALL_SIZE_STEP(size) ((size) + 8 >= MI_SMALL_SIZE_MAX && (size) <= MI_SMALL_SIZE_MAX + 8 ? 1 : MI_TEST_SIZE_STEP(size,1))
int main(void) {
mi_options_print();
mi_option_disable(mi_option_verbose);
CHECK_BODY("pointer-address-and-memtag") {
uint8_t area[128];
for (size_t tag = 0; tag < 16; tag++) {
void* p = mi_ptr_with_memtag(area, tag);
void* q = mi_ptr_with_addr(p, mi_addr(area) + 32);
result = result && mi_addr(p) == mi_addr(area) && mi_addr(q) == mi_addr(area + 32);
#if MI_MTE
result = result && mi_ptr_memtag(p) == tag;
#else
result = result && mi_ptr_memtag(p) == 0;
#endif
result = result && mi_ptr_memtag(q) == mi_ptr_memtag(p);
result = result && mi_ptr_memtag_meta(q) == area + 32;
}
#if MI_MTE
void* p = (void*)((uintptr_t)mi_ptr_with_memtag(area, 5) | (~MI_PTR_ADDR_MASK & ~MI_PTR_MEMTAG_MASK));
result = result && mi_addr(p) == mi_addr(area) && mi_ptr_memtag(p) == 5;
result = result && mi_ptr_with_memtag(p, 0xF5) == mi_ptr_with_memtag(area, 5);
#endif
};
CHECK_BODY("pointer-pack-rederive") {
uint8_t area[128];
for (size_t tag = 0; tag < 16; tag++) {
void* p = mi_ptr_with_memtag(mi_ptr_bounded(area + 32, 16), tag);
void* auth = mi_ptr_with_memtag(area, tag ^ 1);
void* unpacked = mi_ptr_unpack(auth, mi_ptr_pack(p));
void* derived = mi_ptr_rederive(auth, p);
result = result && mi_addr(unpacked) == mi_addr(p) && mi_addr(derived) == mi_addr(p);
result = result && mi_ptr_memtag(unpacked) == mi_ptr_memtag(p) && mi_ptr_memtag(derived) == mi_ptr_memtag(p);
void* base = mi_ptr_with_addr(derived, mi_addr(area));
result = result && mi_addr(base) == mi_addr(area) && mi_ptr_memtag(base) == mi_ptr_memtag(p);
#if MI_CHERI
result = result && __builtin_cheri_tag_get(unpacked) && __builtin_cheri_tag_get(base);
result = result && __builtin_cheri_base_get(unpacked) == __builtin_cheri_base_get(auth);
result = result && __builtin_cheri_length_get(unpacked) == __builtin_cheri_length_get(auth);
result = result && __builtin_cheri_base_get(base) == __builtin_cheri_base_get(auth);
result = result && __builtin_cheri_length_get(base) == __builtin_cheri_length_get(auth);
#endif
}
};
CHECK_BODY("malloc-zero") {
void* p = mi_malloc(0);
result = (p != NULL);
mi_free(p);
};
CHECK_BODY("malloc-nomem1") {
result = (mi_malloc((size_t)PTRDIFF_MAX + (size_t)1) == NULL);
};
CHECK_BODY("malloc-free-null") {
mi_free(NULL);
};
#if MI_INTPTR_BITS > 32
CHECK_BODY("malloc-free-invalid-low") {
mi_cfree((void*)(MI_ZU(0x0000000003990080))); };
#endif
CHECK_BODY("calloc-overflow") {
result = (mi_calloc((size_t)&mi_calloc | 1024,SIZE_MAX/1000) == NULL); };
CHECK_BODY("malloc-large") { void* p = mi_malloc(67108872);
mi_free(p);
};
CHECK_BODY("malloc-size") {
void* p = mi_malloc(42);
result = (mi_malloc_size(p) >= 42 && mi_malloc_usable_size(p) >= 42);
mi_free(p);
};
CHECK_BODY("calloc0") {
void* p = mi_calloc(0,1000);
const size_t usable = mi_usable_size(p);
result = (usable <= 16);
mi_free(p);
};
CHECK_BODY("mi_urealloc_invalid") {
void* p = mi_malloc(64);
size_t pre, post;
void* q = mi_urealloc((char*)p + 3, 58, &pre, &post); mi_free(p);
result = (q==NULL || q==(uint8_t*)p+3);
}
CHECK_BODY("posix_memalign1") {
void* p = &p;
int err = mi_posix_memalign(&p, sizeof(void*), 32);
result = ((err==0 && (uintptr_t)p % sizeof(void*) == 0) || p==&p);
mi_free(p);
};
CHECK_BODY("posix_memalign_no_align") {
void* p = &p;
int err = mi_posix_memalign(&p, 3, 32);
result = (err==EINVAL && p==&p);
};
CHECK_BODY("posix_memalign_zero") {
void* p = &p;
int err = mi_posix_memalign(&p, sizeof(void*), 0);
mi_free(p);
result = (err==0);
};
CHECK_BODY("posix_memalign_nopow2") {
void* p = &p;
int err = mi_posix_memalign(&p, 3*sizeof(void*), 32);
result = (err==EINVAL && p==&p);
};
CHECK_BODY("posix_memalign_nomem") {
void* p = &p;
int err = mi_posix_memalign(&p, sizeof(void*), SIZE_MAX);
result = (err==ENOMEM && p==&p);
};
CHECK_BODY("malloc-aligned1") {
void* p = mi_malloc_aligned(32,32); result = (p != NULL && (uintptr_t)(p) % 32 == 0); mi_free(p);
};
CHECK_BODY("malloc-aligned2") {
void* p = mi_malloc_aligned(48,32); result = (p != NULL && (uintptr_t)(p) % 32 == 0); mi_free(p);
};
CHECK_BODY("malloc-aligned3") {
void* p1 = mi_malloc_aligned(48,32); bool result1 = (p1 != NULL && (uintptr_t)(p1) % 32 == 0);
void* p2 = mi_malloc_aligned(48,32); bool result2 = (p2 != NULL && (uintptr_t)(p2) % 32 == 0);
mi_free(p2);
mi_free(p1);
result = (result1&&result2);
};
CHECK_BODY("malloc-aligned4") {
void* p;
bool ok = true;
for (int i = 0; i < 8 && ok; i++) {
p = mi_malloc_aligned(8, 16);
ok = (p != NULL && (uintptr_t)(p) % 16 == 0); mi_free(p);
}
result = ok;
};
CHECK_BODY("free-size-aligned-overaligned") { const size_t size = 8;
const size_t alignment = 16 * 1024;
void* p[200];
bool ok = true;
for (size_t i = 0; i < 200; i++) {
p[i] = mi_malloc_aligned(size, alignment);
ok = ok && (p[i] != NULL) && ((uintptr_t)p[i] % alignment == 0);
}
for (size_t i = 0; i < 200; i++) {
mi_free_size_aligned(p[i], size, alignment);
}
result = ok;
};
CHECK_BODY("malloc-aligned5") {
void* p = mi_malloc_aligned(4097,4096);
size_t usable = mi_usable_size(p);
result = (usable >= 4097 && usable < 16000);
fprintf(stderr, "malloc_aligned5: usable size: %zi. ", usable);
mi_free(p);
};
CHECK_BODY("malloc-aligned7") {
void* p = mi_malloc_aligned(1024,MI_PAGE_MAX_OVERALLOC_ALIGN);
mi_free(p);
result = ((uintptr_t)p % MI_PAGE_MAX_OVERALLOC_ALIGN) == 0;
};
CHECK_BODY("malloc-aligned8") {
bool ok = true;
for (int i = 0; i < 5 && ok; i++) {
int n = (1 << i);
void* p = mi_malloc_aligned(1024, n * MI_PAGE_MAX_OVERALLOC_ALIGN);
ok = ((uintptr_t)p % (n*MI_PAGE_MAX_OVERALLOC_ALIGN)) == 0;
mi_free(p);
}
result = ok;
};
CHECK_BODY("malloc-aligned9") { bool ok = true;
void* p[8];
const int max_align_shift =
#if SIZE_MAX > UINT32_MAX
28
#else
20
#endif
;
size_t sizes[8] = { 8, 512, 1024 * 1024, MI_PAGE_MAX_OVERALLOC_ALIGN, MI_PAGE_MAX_OVERALLOC_ALIGN + 1, 2 * MI_PAGE_MAX_OVERALLOC_ALIGN, 8 * MI_PAGE_MAX_OVERALLOC_ALIGN, 0 };
for (int i = 0; i < max_align_shift && ok; i++) {
int align = (1 << i);
for (int j = 0; j < 8 && ok; j++) {
p[j] = mi_zalloc_aligned(sizes[j], align);
ok = ((uintptr_t)p[j] % align) == 0;
}
for (int j = 0; j < 8; j++) {
mi_free(p[j]);
}
}
result = ok;
};
CHECK_BODY("malloc-aligned9a") { void* p = mi_zalloc_aligned(1024 * 1024, 2);
mi_free(p);
p = mi_zalloc_aligned(1024 * 1024, 2);
mi_free(p);
result = true;
};
CHECK_BODY("malloc-aligned10") {
bool ok = true;
void* p[10+1];
int align;
int j;
for(j = 0, align = 1; j <= 10 && ok; align *= 2, j++ ) {
p[j] = mi_malloc_aligned(43 + align, align);
ok = ((uintptr_t)p[j] % align) == 0;
}
for ( ; j > 0; j--) {
mi_free(p[j-1]);
}
result = ok;
}
CHECK_BODY("mimalloc-aligned12") {
void* p = mi_malloc_aligned(0x100, 0x100);
result = (((uintptr_t)p % 0x100) == 0); mi_free(p);
}
CHECK_BODY("mimalloc-aligned13") {
bool ok = true;
for( size_t size = 1; size <= (MI_SMALL_SIZE_MAX * 2) && ok; size += MI_TEST_SMALL_SIZE_STEP(size) ) {
for(size_t align = 1; align <= size && ok; align *= 2 ) {
void* p[10];
for(int i = 0; i < 10 && ok; i++) {
p[i] = mi_malloc_aligned(size,align);;
ok = (p[i] != NULL && ((uintptr_t)(p[i]) % align) == 0);
}
for(int i = 0; i < 10 && ok; i++) {
mi_free(p[i]);
}
}
}
result = ok;
}
CHECK_BODY("mimalloc-size-aligned14") {
bool ok = true;
for( size_t size = 1; size <= (MI_SMALL_SIZE_MAX * 2) && ok; size += MI_TEST_SMALL_SIZE_STEP(size) ) {
for(size_t align = 1; align <= 16*size && ok; align *= 2) {
void* p[10];
for(int i = 0; i < 10 && ok; i++) {
p[i] = mi_malloc_aligned(size,align);;
ok = (p[i] != NULL && ((uintptr_t)(p[i]) % align) == 0);
}
for(int i = 0; i < 10 && ok; i++) {
mi_free_size_aligned(p[i],size,align);
}
}
}
result = ok;
}
CHECK_BODY("mimalloc-aligned15") {
result = test_aligned_all();
}
CHECK_BODY("malloc-aligned-at1") {
void* p = mi_malloc_aligned_at(48,32,0); result = (p != NULL && ((uintptr_t)(p) + 0) % 32 == 0); mi_free(p);
};
CHECK_BODY("malloc-aligned-at2") {
void* p = mi_malloc_aligned_at(50,32,8); result = (p != NULL && ((uintptr_t)(p) + 8) % 32 == 0); mi_free(p);
};
CHECK_BODY("realloc-aligned-from-offset") { void* p = mi_malloc_aligned_at(16,16,4);
void* q = mi_realloc_aligned(p,16,sizeof(void*));
result = (p != NULL && q != NULL && (uintptr_t)q % sizeof(void*) == 0); mi_free(q);
};
CHECK_BODY("memalign1") {
void* p;
bool ok = true;
for (int i = 0; i < 8 && ok; i++) {
p = mi_memalign(16,8);
ok = (p != NULL && (uintptr_t)(p) % 16 == 0); mi_free(p);
}
result = ok;
};
CHECK_BODY("zalloc-csize-large") {
mi_theap_t* theap = mi_theap_get_default();
size_t size = MI_SMALL_SIZE_MAX + 64;
bool ok = true;
for (int round = 0; round < 16 && ok; round++) {
uint8_t* junk = (uint8_t*)mi_theap_malloc(theap, size);
memset(junk, 0xAB, size);
mi_free(junk);
uint8_t* z = (uint8_t*)mi_theap_zalloc_csize(theap, size);
ok = mem_is_zero(z, size);
mi_free(z);
}
result = ok;
};
CHECK_BODY("zalloc-aligned-small1") {
size_t zalloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2);
result = mem_is_zero(p, zalloc_size);
mi_free(p);
};
CHECK_BODY("rezalloc_aligned-small1") {
size_t zalloc_size = MI_SMALL_SIZE_MAX / 2;
uint8_t* p = (uint8_t*)mi_zalloc_aligned(zalloc_size, MI_MAX_ALIGN_SIZE * 2);
result = mem_is_zero(p, zalloc_size);
zalloc_size *= 3;
p = (uint8_t*)mi_rezalloc_aligned(p, zalloc_size, MI_MAX_ALIGN_SIZE * 2);
result = result && mem_is_zero(p, zalloc_size);
mi_free(p);
};
CHECK_BODY("rezalloc_aligned_zeros") { size_t alignment = 1024;
size_t n = 1024 * 6;
void* ptr = mi_zalloc_aligned(n, alignment);
assert(mem_is_zero(ptr,n));
memset(ptr,123,n/2);
ptr = mi_rezalloc_aligned(ptr, n/2, alignment);
assert(mem_has_vals((uint8_t*)ptr,n/2,123));
ptr = mi_rezalloc_aligned(ptr, n, alignment);
assert(mem_has_vals((uint8_t*)ptr,n/2,123));
result = mem_is_zero((uint8_t*)ptr + n/2, n/2);
mi_free(ptr);
}
#if !MI_QSBR
CHECK_BODY("heap-qsbr-unavailable") {
int err = 0;
mi_register_error(&qsbr_record_error, &err);
mi_heap_t* heap = mi_heap_new_qsbr();
mi_register_error(NULL, NULL);
result = (heap == NULL && err == ENOSYS);
if (heap != NULL) { mi_heap_destroy(heap); }
}
#endif
CHECK_BODY("heap_aligned1") {
mi_heap_t* heap = mi_heap_new();
const size_t alignment = 128 * 1024; const size_t buffer_size = 1 * 1024 * 1024; void* buffer = mi_heap_malloc_aligned(heap, buffer_size, alignment);
bool nonnull = (buffer != NULL);
assert(nonnull);
const bool is_aligned = ((uintptr_t)buffer % alignment) == 0;
assert(is_aligned);
mi_free(buffer);
mi_heap_destroy(heap);
result = (nonnull && is_aligned);
}
CHECK_BODY("realloc-null") {
void* p = mi_realloc(NULL,4);
result = (p != NULL);
mi_free(p);
};
CHECK_BODY("realloc-null-sizezero") {
void* p = mi_realloc(NULL,0); result = (p != NULL);
mi_free(p);
};
CHECK_BODY("realloc-sizezero") {
void* p = mi_malloc(4);
void* q = mi_realloc(p, 0);
result = (q != NULL);
mi_free(q);
};
CHECK_BODY("realloc-shrink") { void* p = mi_malloc(4096);
const size_t size = mi_usable_size(p);
void* q = mi_realloc(p, size - size/16); result = (q == p);
void* r = mi_realloc(q, size/2 + 16); result = result && (r != NULL && mi_usable_size(r) < size - size/8);
void* s = mi_realloc_aligned(r, 4096, 64);
const size_t asize = mi_usable_size(s);
void* t = mi_realloc_aligned(s, asize/2 + 16, 64);
result = result && (t != NULL && mi_usable_size(t) < asize - asize/8 && ((uintptr_t)t % 64) == 0);
mi_free(t);
};
CHECK_BODY("realloc-shrink-huge") {
const size_t size = 8*MI_MiB;
uint8_t* p = (uint8_t*)mi_malloc(size);
memset(p, 1, size);
const size_t half = mi_usable_size(p)/2 + 1; uint8_t* q = (uint8_t*)mi_realloc(p, half); #if defined(__wasi__) || defined(__EMSCRIPTEN__)
const bool in_place = false; #else
const bool in_place = true;
#endif
result = ((q == p) == in_place && q[0] == 1 && q[half - 1] == 1);
uint8_t* volatile qv = q; memset(qv, 2, mi_usable_size(q)); uint8_t* r = (uint8_t*)mi_realloc(q, size/8); result = result && (r != NULL && r != q && r[0] == 2 && r[size/8 - 1] == 2);
mi_free(r);
};
CHECK_BODY("reallocarray-null-sizezero") {
void* p = mi_reallocarray(NULL,0,16); result = (p != NULL && errno == 0);
mi_free(p);
};
CHECK_BODY("reallocarray-overflow") {
uint8_t* p = (uint8_t*)mi_malloc(32);
if (p == NULL) { result = false; }
else {
memset(p, 0x5A, 32);
errno = 0;
void* q = mi_reallocarray(p, SIZE_MAX / 2 + 1, 2);
result = (q == NULL && errno == ENOMEM && mem_has_vals(p, 32, 0x5A));
mi_free(q == NULL ? p : q);
}
};
CHECK_BODY("reallocarr-grow") {
void* p = mi_malloc(32);
if (p == NULL) { result = false; }
else {
memset(p, 0x5A, 32);
int err = mi_reallocarr(&p, 64, 2);
result = (err == 0 && mi_usable_size(p) >= 128 && mem_has_vals((uint8_t*)p, 32, 0x5A));
mi_free(p);
}
};
CHECK_BODY("reallocarr-zero-count") {
void* p = mi_malloc(32);
if (p == NULL) { result = false; }
else {
int err = mi_reallocarr(&p, 0, 2);
result = (err == 0 && p == NULL);
mi_free(p);
}
};
CHECK_BODY("reallocarr-zero-size") {
void* p = mi_malloc(32);
if (p == NULL) { result = false; }
else {
int err = mi_reallocarr(&p, 2, 0);
result = (err == 0 && p == NULL);
mi_free(p);
}
};
CHECK_BODY("realloc-aligned-other-heap") {
mi_heap_t* heap = mi_heap_new();
void* p = mi_heap_malloc_aligned(heap, 100, 64);
void* q = mi_realloc_aligned(p, 100, 64); result = (q != NULL && mi_heap_of(q) != heap);
mi_free(q);
mi_heap_delete(heap);
};
CHECK_BODY("reallocarr-overflow") {
void* p = mi_malloc(32);
if (p == NULL) { result = false; }
else {
memset(p, 0x5A, 32);
void* original = p;
int err = mi_reallocarr(&p, SIZE_MAX / 2 + 1, 2);
result = (err == EOVERFLOW && p == original && mem_has_vals((uint8_t*)p, 32, 0x5A));
mi_free(original);
}
};
CHECK_BODY("realloc-guarded") { void* shared_ptr = NULL;
for (int iterations = 0; iterations < MI_TEST_ITERS(64); ++iterations) {
for (int i = 0; i < 1024; ++i) {
shared_ptr = mi_realloc(shared_ptr, i * 64);
}
}
mi_free(shared_ptr);
}
CHECK_BODY("guarded-api-small-free") {
mi_heap_t* heap = mi_heap_new();
mi_theap_t* theap = (heap == NULL ? NULL : mi_heap_theap(heap));
if (theap == NULL) { result = false; }
else {
void* blocks[128];
mi_theap_guarded_set_size_bound(theap, 0, MI_SMALL_SIZE_MAX);
mi_theap_guarded_set_sample_rate(theap, 1, 1);
for (size_t i = 0; i < 128; i++) {
blocks[i] = mi_theap_malloc(theap, MI_SMALL_SIZE_MAX);
if (blocks[i] == NULL) { result = false; }
else { memset(blocks[i], 0x5A, MI_SMALL_SIZE_MAX); }
}
mi_theap_guarded_set_sample_rate(theap, 0, 0);
for (size_t i = 0; i < 128; i++) {
if (i % 2 == 0) { mi_free_small(blocks[i]); }
else { mi_free_size(blocks[i], MI_SMALL_SIZE_MAX); }
}
}
if (heap != NULL) { mi_heap_delete(heap); }
}
CHECK_BODY("free_small1") {
for(size_t n = 1; n < MI_SMALL_SIZE_MAX; n *=2) {
const size_t size = n*sizeof(int);
int* p = (int*)mi_zalloc(size);
p[n-1] = 42;
mi_free_size(p,size);
}
}
CHECK_BODY("free_small2") {
for(size_t n = 1; n < MI_SMALL_SIZE_MAX; n *=2) {
const size_t size = n*sizeof(int);
int* p = (int*)mi_zalloc(size);
p[n-1] = 42;
p = (int*)mi_rezalloc(p, size + MI_SMALL_SIZE_MAX);
mi_free_size(p,size + MI_SMALL_SIZE_MAX);
}
}
CHECK_BODY("free_small3") {
for(size_t n = 1; n < MI_SMALL_SIZE_MAX/sizeof(int); n *=2) {
const size_t size = n*sizeof(int);
int* p = (int*)mi_zalloc_small(size);
p[n-1] = 42;
mi_free_small(p);
}
}
CHECK_BODY("free_small_null") { mi_free_small(NULL);
mi_free_small_local(NULL);
result = (errno == 0);
}
CHECK_BODY("free_small4") {
for(size_t n = 1; n < MI_SMALL_SIZE_MAX/sizeof(int); n *=2) {
const size_t size = n*sizeof(int);
int* p = (int*)mi_zalloc_small(size);
p[n-1] = 42;
mi_free(p);
}
}
CHECK_BODY("umalloc1") {
for(size_t size = 1; size <= 32*MI_MiB; size *= 2 ) {
size_t bsize;
void* p = mi_umalloc(size,&bsize);
assert(bsize >= size);
size_t pre_size;
size_t post_size;
p = mi_urealloc(p, size + 1024, &pre_size, &post_size);
assert(pre_size == bsize);
assert(post_size >= size + 1024);
size_t fsize;
mi_ufree(p,&fsize);
assert(fsize == post_size);
}
}
CHECK_BODY("ucalloc-nomem") {
size_t bsize = 42;
void* p = mi_ucalloc(SIZE_MAX/4, 4, &bsize);
result = (p == NULL && bsize == 42);
}
#if (MI_SIZE_SIZE > 4)
CHECK_BODY("arena_reserve") {
result = (0==mi_reserve_os_memory(16*MI_GiB,false,true));
}
#if TEST_ARENAS
CHECK_BODY("arena_reserve_child") {
const size_t arena_size = 24 * MI_GiB;
const size_t allocation_size = 63 * MI_MiB;
const size_t allocation_count = 272;
const size_t alignment = mi_arena_min_alignment();
mi_arena_id_t arena_id = NULL;
bool ok = (0==mi_reserve_os_memory_ex(arena_size,false ,false ,
true , &arena_id));
if (!ok) {
fprintf(stderr, "failed to register the 24 GiB arena\n");
ok = true; }
else {
mi_heap_t* heap = mi_heap_new_in_arena(arena_id);
for (size_t i = 0; i < allocation_count && ok; i++) {
void* p = mi_heap_malloc(heap, allocation_size);
if (p == NULL) {
fprintf(stderr, "allocation %zu failed after %zu MiB; child arena was not used\n", i, i * allocation_size / MI_MiB);
ok = false;
}
if (!mi_arena_contains(arena_id, p)) {
fprintf(stderr, "allocation %zu came from outside the requested arena\n", i);
ok = false;
}
}
fprintf(stderr, "allocated %zu MiB from the parent arena and its children\n", allocation_count * allocation_size / MI_MiB);
mi_heap_destroy(heap);
}
result = ok;
}
#endif
#endif
#if defined(__cplusplus) && !defined(_MSC_VER)
CHECK_BODY("c++ new-handler") {
std::set_new_handler([]{ throw std::bad_alloc(); });
void* p = mi_new_nothrow(SIZE_MAX/2);
result = (p==NULL);
}
CHECK_BODY("c++ new handler2") {
try {
void* p = mi_new_n(SIZE_MAX/2, 4);
(void)(p);
result = false;
}
catch(const std::bad_alloc&) {
result = true;
}
}
#endif
CHECK_BODY("stats-json-exact-buffer") { bool exact = false;
for (int i = 0; i < 100 && !exact; i++) {
char* json = mi_stats_get_json(0, NULL);
if (json == NULL) break;
const size_t len = strlen(json);
char* buf = (char*)mi_malloc(len + 1);
exact = (buf != NULL && mi_stats_get_json(len + 1, buf) == buf && strlen(buf) == len);
mi_free(buf);
mi_free(json);
}
result = exact;
}
CHECK_BODY("heap-os1") {
mi_heap_t* h = mi_heap_new();
void* p = mi_heap_malloc_aligned(h, 1<<20, 2<<20); mi_heap_delete(h);
mi_free(p); }
CHECK_BODY("heap-os2") {
mi_collect(true);
mi_stats_t_decl(stats0);
mi_stats_get(&stats0);
mi_heap_t* h = mi_heap_new();
long failed = 0;
for(int i = 0; i < 10; i++) {
int* p = (int*)mi_heap_malloc_aligned(h, 1<<20, 2<<20); if (p==NULL) {
failed++;
}
else {
p[0] = 42;
}
}
mi_heap_destroy(h);
mi_collect(true);
mi_stats_t_decl(stats1);
mi_stats_get(&stats1);
result = (stats0.pages.current == stats1.pages.current);
if (!result) {
fprintf(stderr, "heap-os2: pages: %ld != %ld (failed: %ld)\n", (long)stats0.pages.current, (long)stats1.pages.current, failed);
}
}
CHECK_BODY("heap-destroy-os-pages") { mi_collect(true);
mi_stats_t_decl(stats0);
mi_stats_get(&stats0);
mi_option_set(mi_option_disallow_arena_alloc, 1); mi_heap_t* h = mi_heap_new();
bool allocated = true;
for (int i = 0; i < 1000; i++) { if (mi_heap_malloc(h, 48) == NULL) { allocated = false; }
}
mi_heap_destroy(h);
mi_option_set(mi_option_disallow_arena_alloc, 0);
mi_collect(true);
mi_stats_t_decl(stats1);
mi_stats_get(&stats1);
result = allocated && (stats0.pages.current == stats1.pages.current); }
#define NHEAPS (1000)
CHECK_BODY("heap-many") { mi_heap_t* heaps[NHEAPS];
for (size_t i = 0; i < NHEAPS; i++) {
heaps[i] = mi_heap_new();
if (heaps[i] == NULL) { result = false; break; };
if (mi_heap_malloc(heaps[i], 32) == NULL) { result = false; break; }
}
for (size_t i = 0; i < NHEAPS; i++) {
mi_heap_destroy(heaps[i]);
}
}
CHECK_BODY("subproc-destroy-keeps-thread-locals") { mi_heap_t* const h2 = mi_heap_new();
mi_theap_t* const t2 = mi_heap_theap(h2);
mi_theap_t* const tmain = mi_heap_theap(mi_heap_main());
mi_subproc_destroy(mi_subproc_new());
mi_heap_t* const h3 = mi_heap_new();
mi_theap_t* const t3 = mi_heap_theap(h3);
mi_subproc_destroy(mi_subproc_new());
mi_heap_t* const h4 = mi_heap_new();
mi_theap_t* const t4 = mi_heap_theap(h4);
result = (t2!=NULL && t3!=NULL && t4!=NULL && t2!=t3 && t3!=t4);
for (int i = 0; i < 100 && result; i++) {
result = (mi_heap_theap(h2)==t2 && mi_heap_theap(h3)==t3 && mi_heap_theap(h4)==t4 && mi_heap_theap(mi_heap_main())==tmain);
}
mi_heap_delete(h4);
mi_heap_delete(h3);
mi_heap_delete(h2);
}
CHECK_THREADS_BODY("heap-destroy-xthread-free") { result = test_heap_destroy_xthread_free();
}
CHECK_THREADS_BODY("heap-destroy-stale-theap") { result = test_heap_destroy_stale_theap();
}
CHECK_THREADS_BODY("thread-done-no-reinit") { result = test_thread_done_no_reinit();
}
CHECK_THREADS_BODY("thread-heap-release") { result = test_thread_heap_release();
}
CHECK_THREADS_BODY("heap-delete-concurrent-free") { result = test_heap_delete_concurrent_free();
}
CHECK_THREADS_BODY("thread_zero_aligned_first") {
result = mi_run_on_thread(&test_zero_aligned_first);
}
#ifdef __cplusplus
CHECK_THREADS_BODY("thread_new_first") {
result = mi_run_on_thread(&test_new_first);
}
#endif
#if !defined(MI_TRACK_ASAN)
CHECK_BODY("realpath") {
char* s = mi_realpath( ".", NULL );
mi_free(s);
};
#endif
CHECK("stl_allocator1", test_stl_allocator1());
CHECK("stl_allocator2", test_stl_allocator2());
return print_test_summary();
}
bool test_stl_allocator1(void) {
#ifdef __cplusplus
std::vector<int, mi_stl_allocator<int> > vec;
vec.push_back(1);
vec.pop_back();
return vec.size() == 0;
#else
return true;
#endif
}
struct some_struct { int i; int j; double z; };
bool test_stl_allocator2(void) {
#ifdef __cplusplus
std::vector<some_struct, mi_stl_allocator<some_struct> > vec;
vec.push_back(some_struct());
vec.pop_back();
return vec.size() == 0;
#else
return true;
#endif
}
static bool test_zero_aligned_first(void) {
void* p = mi_malloc_aligned(0, 16); bool res = (p != NULL && (uintptr_t)(p) % 16 == 0);
mi_free(p);
p = mi_zalloc_aligned(0, 32);
res = res && (p != NULL && (uintptr_t)(p) % 32 == 0);
mi_free(p);
return res;
}
static bool test_aligned_check(size_t size, size_t align, bool zero) {
void* p[8];
bool ok = true;
for (int i = 0; i < 8; i++) {
p[i] = (zero ? mi_zalloc_aligned(size, align) : mi_malloc_aligned(size, align));
if (p[i] == NULL || ((uintptr_t)p[i] % align) != 0 || mi_usable_size(p[i]) < size || (zero && !mem_is_zero(p[i], size))) {
ok = false;
}
if (p[i] != NULL) { memset(p[i], 0xAB, size); }
}
for (int i = 0; i < 8; i++) {
mi_free(p[i]);
}
return ok;
}
static bool test_aligned_all(void) {
bool ok = true;
for (size_t size = 0; size <= 300*1024 && ok; size += MI_TEST_SIZE_STEP(size, (size < 16*1024 ? 8 : 512))) {
for (size_t align = 8; align <= 4096 && ok; align *= 2) {
ok = test_aligned_check(size, align, ((size/8) & 1) != 0);
}
}
for (size_t size = 4*1024*1024 - 4096; size <= 4*1024*1024 + 3*4096 && ok; size += MI_TEST_LARGE_STEP) {
for (size_t align = 8; align <= 4096 && ok; align *= 2) {
ok = test_aligned_check(size, align, false);
}
}
return ok;
}
#ifdef __cplusplus
static bool test_new_first(void) {
char* p = (char*)mi_new(20);
bool res = (p != NULL && (uintptr_t)(p) % 16 == 0);
mi_free_csize(p,20);
return res;
}
#endif
static void* xthread_free_block;
static long xthread_efault_count;
static bool xthread_free_fun(void) {
mi_free(xthread_free_block); return true;
}
static void xthread_count_efault(int err, void* arg) {
(void)arg;
if (err == EFAULT) { xthread_efault_count++; }
}
static bool test_heap_destroy_xthread_free(void) {
mi_heap_t* heap = mi_heap_new();
if (heap == NULL) return false;
void* live = mi_heap_malloc(heap, 32); xthread_free_block = mi_heap_malloc(heap, 32);
if (live == NULL || xthread_free_block == NULL) return false;
if (!mi_run_on_thread(&xthread_free_fun)) return false;
xthread_efault_count = 0;
mi_register_error(&xthread_count_efault, NULL); mi_heap_destroy(heap);
mi_register_error(NULL, NULL);
return (xthread_efault_count == 0);
}
typedef struct test_worker_s {
void (*fun)(size_t id);
size_t id;
} test_worker_t;
typedef struct test_gate_s {
int step;
#ifdef _WIN32
CRITICAL_SECTION lock;
CONDITION_VARIABLE cond;
#else
pthread_mutex_t lock;
pthread_cond_t cond;
#endif
} test_gate_t;
#ifdef _WIN32
static void test_gate_init(test_gate_t* g) { g->step = 0; InitializeCriticalSection(&g->lock); InitializeConditionVariable(&g->cond); }
static void test_gate_done(test_gate_t* g) { DeleteCriticalSection(&g->lock); }
static void test_gate_set(test_gate_t* g, int step) {
EnterCriticalSection(&g->lock); g->step = step; LeaveCriticalSection(&g->lock);
WakeAllConditionVariable(&g->cond);
}
static void test_gate_wait(test_gate_t* g, int step) {
EnterCriticalSection(&g->lock);
while (g->step < step) { SleepConditionVariableCS(&g->cond, &g->lock, INFINITE); }
LeaveCriticalSection(&g->lock);
}
typedef HANDLE test_thread_t;
static DWORD WINAPI test_thread_entry(LPVOID arg) { const test_worker_t* w = (const test_worker_t*)arg; w->fun(w->id); return 0; }
static bool test_thread_start(test_thread_t* t, const test_worker_t* w) {
*t = CreateThread(NULL, 0, &test_thread_entry, (LPVOID)w, 0, NULL);
return (*t != NULL);
}
static void test_thread_join(test_thread_t t) { WaitForSingleObject(t, INFINITE); CloseHandle(t); }
#else
static void test_gate_init(test_gate_t* g) { g->step = 0; pthread_mutex_init(&g->lock, NULL); pthread_cond_init(&g->cond, NULL); }
static void test_gate_done(test_gate_t* g) { pthread_cond_destroy(&g->cond); pthread_mutex_destroy(&g->lock); }
static void test_gate_set(test_gate_t* g, int step) {
pthread_mutex_lock(&g->lock); g->step = step; pthread_mutex_unlock(&g->lock);
pthread_cond_broadcast(&g->cond);
}
static void test_gate_wait(test_gate_t* g, int step) {
pthread_mutex_lock(&g->lock);
while (g->step < step) { pthread_cond_wait(&g->cond, &g->lock); }
pthread_mutex_unlock(&g->lock);
}
typedef pthread_t test_thread_t;
static void* test_thread_entry(void* arg) { const test_worker_t* w = (const test_worker_t*)arg; w->fun(w->id); return NULL; }
static bool test_thread_start(test_thread_t* t, const test_worker_t* w) {
return (pthread_create(t, NULL, &test_thread_entry, (void*)w) == 0);
}
static void test_thread_join(test_thread_t t) { pthread_join(t, NULL); }
#endif
static test_gate_t stale_gate;
static mi_heap_t* stale_heap; static bool stale_result;
static void stale_theap_worker(size_t id) {
(void)id;
void* p = mi_heap_malloc(stale_heap, 16); mi_free(p);
p = mi_heap_malloc(stale_heap, 16); test_gate_set(&stale_gate, 1);
test_gate_wait(&stale_gate, 2); void* q = mi_heap_malloc(stale_heap, 16); stale_result = (p != NULL && q != NULL && mi_heap_contains(stale_heap, q));
mi_free(q);
}
#define STALE_MAX_HEAPS (1000)
static bool test_heap_destroy_stale_theap(void) {
test_gate_init(&stale_gate);
mi_heap_t* const destroyed = mi_heap_new();
if (destroyed == NULL) return false;
stale_heap = destroyed;
stale_result = false;
test_thread_t thread;
const test_worker_t worker = { &stale_theap_worker, 0 };
if (!test_thread_start(&thread, &worker)) return false;
test_gate_wait(&stale_gate, 1);
mi_heap_destroy(destroyed);
mi_heap_t* heaps[STALE_MAX_HEAPS];
size_t count = 0;
bool reused = false;
while (count < STALE_MAX_HEAPS) {
mi_heap_t* const heap = mi_heap_new();
if (heap == NULL) break;
heaps[count++] = heap;
if (heap == destroyed) { reused = true; break; }
}
if (count == 0) return false;
stale_heap = heaps[count-1];
test_gate_set(&stale_gate, 2);
test_thread_join(thread);
for (size_t i = 0; i < count; i++) { mi_heap_destroy(heaps[i]); }
test_gate_done(&stale_gate);
if (!reused) { fprintf(stderr, "(heap address not reused, inconclusive) "); }
return stale_result;
}
static int64_t current_threads(void) {
mi_stats_t_decl(stats);
mi_stats_get(&stats);
return stats.threads.current;
}
static bool thread_done_no_reinit_fun(void) {
mi_free(mi_malloc(32)); mi_heap_t* const other = mi_heap_new();
if (other == NULL) return false;
const int64_t threads = current_threads();
mi_thread_done();
bool ok = (current_threads() == threads - 1);
void* p = mi_malloc(64);
void* q = mi_zalloc_aligned(100, 256);
void* r = mi_malloc(1000000);
ok = ok && p != NULL && q != NULL && r != NULL && mem_is_zero(q, 100) && ((uintptr_t)q % 256) == 0;
mi_heap_t* heap = mi_heap_main();
void* s = mi_heap_malloc(heap, 32);
ok = ok && s != NULL;
ok = ok && mi_heap_malloc(other, 32) == NULL; mi_free(p); mi_free(q); mi_free(r); mi_free(s);
ok = ok && (current_threads() == threads - 1);
mi_thread_init(); ok = ok && (current_threads() == threads);
void* t = mi_malloc(32);
ok = ok && t != NULL;
mi_free(t);
mi_heap_delete(other);
return ok;
}
static bool test_thread_done_no_reinit(void) {
return mi_run_on_thread(&thread_done_no_reinit_fun);
}
static mi_heap_t* release_heap;
static void* release_blocks[64];
static bool thread_heap_release_fun(void) {
for (int i = 0; i < 64; i++) {
release_blocks[i] = mi_heap_malloc(release_heap, 16 + i);
if (release_blocks[i] == NULL) return false;
}
mi_free(release_blocks[0]); release_blocks[0] = NULL;
mi_thread_heap_release(release_heap);
bool ok = (mi_heap_malloc(release_heap, 16) == NULL && mi_heap_malloc(release_heap, 100000) == NULL);
mi_free(release_blocks[1]); release_blocks[1] = NULL;
mi_thread_heap_release(release_heap); ok = ok && (mi_heap_malloc(release_heap, 16) == NULL);
return ok;
}
static bool test_thread_heap_release(void) {
release_heap = mi_heap_new();
if (release_heap == NULL) return false;
mi_thread_heap_release(release_heap); bool ok = (mi_heap_malloc(release_heap, 16) == NULL);
ok = ok && mi_run_on_thread(&thread_heap_release_fun);
mi_heap_delete(release_heap);
for (int i = 0; i < 64; i++) { mi_free(release_blocks[i]); }
return ok;
}
#define DELETE_FREE_THREADS (4)
#define DELETE_FREE_BLOCKS (4096)
static mi_heap_t* delete_free_heap;
static void* delete_free_blocks[DELETE_FREE_THREADS][DELETE_FREE_BLOCKS];
static void delete_free_alloc_worker(size_t id) {
for (size_t i = 0; i < DELETE_FREE_BLOCKS; i++) {
const size_t size = (i % 100 == 0 ? 100000 + i : (i % 10 == 0 ? 2000 + i : 8 + i % 256));
delete_free_blocks[id][i] = mi_heap_malloc(delete_free_heap, size);
}
for (size_t i = 0; i < DELETE_FREE_BLOCKS; i += 3) {
mi_free(delete_free_blocks[id][i]);
delete_free_blocks[id][i] = NULL;
}
mi_thread_heap_release(delete_free_heap);
}
static void delete_free_worker(size_t id) {
for (size_t i = 0; i < DELETE_FREE_BLOCKS; i++) {
mi_free(delete_free_blocks[id][i]);
}
}
static bool test_heap_delete_concurrent_free(void) {
const long disallow_arena_alloc = mi_option_get(mi_option_disallow_arena_alloc);
for (int iter = 0; iter < MI_TEST_ITERS(20); iter++) {
mi_option_set(mi_option_disallow_arena_alloc, iter % 2); delete_free_heap = mi_heap_new();
if (delete_free_heap == NULL) return false;
test_thread_t threads[DELETE_FREE_THREADS];
test_worker_t workers[DELETE_FREE_THREADS];
for (size_t i = 0; i < DELETE_FREE_THREADS; i++) {
workers[i].fun = &delete_free_alloc_worker; workers[i].id = i;
if (!test_thread_start(&threads[i], &workers[i])) return false;
}
for (size_t i = 0; i < DELETE_FREE_THREADS; i++) { test_thread_join(threads[i]); }
for (size_t i = 0; i < DELETE_FREE_THREADS; i++) {
workers[i].fun = &delete_free_worker;
if (!test_thread_start(&threads[i], &workers[i])) return false;
}
mi_heap_delete(delete_free_heap);
for (size_t i = 0; i < DELETE_FREE_THREADS; i++) { test_thread_join(threads[i]); }
}
mi_option_set(mi_option_disallow_arena_alloc, disallow_arena_alloc);
return true;
}