mirror of
https://github.com/jemalloc/jemalloc.git
synced 2026-07-22 04:03:11 +00:00
Remove generic experimental hooks
This commit is contained in:
Slobodan Predolac
589
test/unit/hook.c
589
test/unit/hook.c
@@ -1,589 +0,0 @@
|
||||
#include "test/jemalloc_test.h"
|
||||
|
||||
#include "jemalloc/internal/hook.h"
|
||||
|
||||
static void *arg_extra;
|
||||
static int arg_type;
|
||||
static void *arg_result;
|
||||
static void *arg_address;
|
||||
static size_t arg_old_usize;
|
||||
static size_t arg_new_usize;
|
||||
static uintptr_t arg_result_raw;
|
||||
static uintptr_t arg_args_raw[4];
|
||||
|
||||
static int call_count = 0;
|
||||
|
||||
static void
|
||||
reset_args(void) {
|
||||
arg_extra = NULL;
|
||||
arg_type = 12345;
|
||||
arg_result = NULL;
|
||||
arg_address = NULL;
|
||||
arg_old_usize = 0;
|
||||
arg_new_usize = 0;
|
||||
arg_result_raw = 0;
|
||||
memset(arg_args_raw, 77, sizeof(arg_args_raw));
|
||||
}
|
||||
|
||||
static void
|
||||
alloc_free_size(size_t sz) {
|
||||
void *ptr = mallocx(1, 0);
|
||||
free(ptr);
|
||||
ptr = mallocx(1, 0);
|
||||
free(ptr);
|
||||
ptr = mallocx(1, MALLOCX_TCACHE_NONE);
|
||||
dallocx(ptr, MALLOCX_TCACHE_NONE);
|
||||
}
|
||||
|
||||
/*
|
||||
* We want to support a degree of user reentrancy. This tests a variety of
|
||||
* allocation scenarios.
|
||||
*/
|
||||
static void
|
||||
be_reentrant(void) {
|
||||
/* Let's make sure the tcache is non-empty if enabled. */
|
||||
alloc_free_size(1);
|
||||
alloc_free_size(1024);
|
||||
alloc_free_size(64 * 1024);
|
||||
alloc_free_size(256 * 1024);
|
||||
alloc_free_size(1024 * 1024);
|
||||
|
||||
/* Some reallocation. */
|
||||
void *ptr = mallocx(129, 0);
|
||||
ptr = rallocx(ptr, 130, 0);
|
||||
free(ptr);
|
||||
|
||||
ptr = mallocx(2 * 1024 * 1024, 0);
|
||||
free(ptr);
|
||||
ptr = mallocx(1 * 1024 * 1024, 0);
|
||||
ptr = rallocx(ptr, 2 * 1024 * 1024, 0);
|
||||
free(ptr);
|
||||
|
||||
ptr = mallocx(1, 0);
|
||||
ptr = rallocx(ptr, 1000, 0);
|
||||
free(ptr);
|
||||
}
|
||||
|
||||
static void
|
||||
set_args_raw(uintptr_t *args_raw, int nargs) {
|
||||
memcpy(arg_args_raw, args_raw, sizeof(uintptr_t) * nargs);
|
||||
}
|
||||
|
||||
static void
|
||||
expect_args_raw(uintptr_t *args_raw_expected, int nargs) {
|
||||
int cmp = memcmp(
|
||||
args_raw_expected, arg_args_raw, sizeof(uintptr_t) * nargs);
|
||||
expect_d_eq(cmp, 0, "Raw args mismatch");
|
||||
}
|
||||
|
||||
static void
|
||||
reset(void) {
|
||||
call_count = 0;
|
||||
reset_args();
|
||||
}
|
||||
|
||||
static void
|
||||
test_alloc_hook(void *extra, hook_alloc_t type, void *result,
|
||||
uintptr_t result_raw, uintptr_t args_raw[3]) {
|
||||
call_count++;
|
||||
arg_extra = extra;
|
||||
arg_type = (int)type;
|
||||
arg_result = result;
|
||||
arg_result_raw = result_raw;
|
||||
set_args_raw(args_raw, 3);
|
||||
be_reentrant();
|
||||
}
|
||||
|
||||
static void
|
||||
test_dalloc_hook(
|
||||
void *extra, hook_dalloc_t type, void *address, uintptr_t args_raw[3]) {
|
||||
call_count++;
|
||||
arg_extra = extra;
|
||||
arg_type = (int)type;
|
||||
arg_address = address;
|
||||
set_args_raw(args_raw, 3);
|
||||
be_reentrant();
|
||||
}
|
||||
|
||||
static void
|
||||
test_expand_hook(void *extra, hook_expand_t type, void *address,
|
||||
size_t old_usize, size_t new_usize, uintptr_t result_raw,
|
||||
uintptr_t args_raw[4]) {
|
||||
call_count++;
|
||||
arg_extra = extra;
|
||||
arg_type = (int)type;
|
||||
arg_address = address;
|
||||
arg_old_usize = old_usize;
|
||||
arg_new_usize = new_usize;
|
||||
arg_result_raw = result_raw;
|
||||
set_args_raw(args_raw, 4);
|
||||
be_reentrant();
|
||||
}
|
||||
|
||||
TEST_BEGIN(test_hooks_basic) {
|
||||
/* Just verify that the record their arguments correctly. */
|
||||
hooks_t hooks = {&test_alloc_hook, &test_dalloc_hook, &test_expand_hook,
|
||||
(void *)111};
|
||||
void *handle = hook_install(TSDN_NULL, &hooks);
|
||||
uintptr_t args_raw[4] = {10, 20, 30, 40};
|
||||
|
||||
/* Alloc */
|
||||
reset_args();
|
||||
hook_invoke_alloc(
|
||||
hook_alloc_posix_memalign, (void *)222, 333, args_raw);
|
||||
expect_ptr_eq(arg_extra, (void *)111, "Passed wrong user pointer");
|
||||
expect_d_eq((int)hook_alloc_posix_memalign, arg_type,
|
||||
"Passed wrong alloc type");
|
||||
expect_ptr_eq((void *)222, arg_result, "Passed wrong result address");
|
||||
expect_u64_eq(333, arg_result_raw, "Passed wrong result");
|
||||
expect_args_raw(args_raw, 3);
|
||||
|
||||
/* Dalloc */
|
||||
reset_args();
|
||||
hook_invoke_dalloc(hook_dalloc_sdallocx, (void *)222, args_raw);
|
||||
expect_d_eq(
|
||||
(int)hook_dalloc_sdallocx, arg_type, "Passed wrong dalloc type");
|
||||
expect_ptr_eq((void *)111, arg_extra, "Passed wrong user pointer");
|
||||
expect_ptr_eq((void *)222, arg_address, "Passed wrong address");
|
||||
expect_args_raw(args_raw, 3);
|
||||
|
||||
/* Expand */
|
||||
reset_args();
|
||||
hook_invoke_expand(
|
||||
hook_expand_xallocx, (void *)222, 333, 444, 555, args_raw);
|
||||
expect_d_eq(
|
||||
(int)hook_expand_xallocx, arg_type, "Passed wrong expand type");
|
||||
expect_ptr_eq((void *)111, arg_extra, "Passed wrong user pointer");
|
||||
expect_ptr_eq((void *)222, arg_address, "Passed wrong address");
|
||||
expect_zu_eq(333, arg_old_usize, "Passed wrong old usize");
|
||||
expect_zu_eq(444, arg_new_usize, "Passed wrong new usize");
|
||||
expect_zu_eq(555, arg_result_raw, "Passed wrong result");
|
||||
expect_args_raw(args_raw, 4);
|
||||
|
||||
hook_remove(TSDN_NULL, handle);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_hooks_null) {
|
||||
/* Null hooks should be ignored, not crash. */
|
||||
hooks_t hooks1 = {NULL, NULL, NULL, NULL};
|
||||
hooks_t hooks2 = {&test_alloc_hook, NULL, NULL, NULL};
|
||||
hooks_t hooks3 = {NULL, &test_dalloc_hook, NULL, NULL};
|
||||
hooks_t hooks4 = {NULL, NULL, &test_expand_hook, NULL};
|
||||
|
||||
void *handle1 = hook_install(TSDN_NULL, &hooks1);
|
||||
void *handle2 = hook_install(TSDN_NULL, &hooks2);
|
||||
void *handle3 = hook_install(TSDN_NULL, &hooks3);
|
||||
void *handle4 = hook_install(TSDN_NULL, &hooks4);
|
||||
|
||||
expect_ptr_ne(handle1, NULL, "Hook installation failed");
|
||||
expect_ptr_ne(handle2, NULL, "Hook installation failed");
|
||||
expect_ptr_ne(handle3, NULL, "Hook installation failed");
|
||||
expect_ptr_ne(handle4, NULL, "Hook installation failed");
|
||||
|
||||
uintptr_t args_raw[4] = {10, 20, 30, 40};
|
||||
|
||||
call_count = 0;
|
||||
hook_invoke_alloc(hook_alloc_malloc, NULL, 0, args_raw);
|
||||
expect_d_eq(call_count, 1, "Called wrong number of times");
|
||||
|
||||
call_count = 0;
|
||||
hook_invoke_dalloc(hook_dalloc_free, NULL, args_raw);
|
||||
expect_d_eq(call_count, 1, "Called wrong number of times");
|
||||
|
||||
call_count = 0;
|
||||
hook_invoke_expand(hook_expand_realloc, NULL, 0, 0, 0, args_raw);
|
||||
expect_d_eq(call_count, 1, "Called wrong number of times");
|
||||
|
||||
hook_remove(TSDN_NULL, handle1);
|
||||
hook_remove(TSDN_NULL, handle2);
|
||||
hook_remove(TSDN_NULL, handle3);
|
||||
hook_remove(TSDN_NULL, handle4);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_hooks_remove) {
|
||||
hooks_t hooks = {&test_alloc_hook, NULL, NULL, NULL};
|
||||
void *handle = hook_install(TSDN_NULL, &hooks);
|
||||
expect_ptr_ne(handle, NULL, "Hook installation failed");
|
||||
call_count = 0;
|
||||
uintptr_t args_raw[4] = {10, 20, 30, 40};
|
||||
hook_invoke_alloc(hook_alloc_malloc, NULL, 0, args_raw);
|
||||
expect_d_eq(call_count, 1, "Hook not invoked");
|
||||
|
||||
call_count = 0;
|
||||
hook_remove(TSDN_NULL, handle);
|
||||
hook_invoke_alloc(hook_alloc_malloc, NULL, 0, NULL);
|
||||
expect_d_eq(call_count, 0, "Hook invoked after removal");
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_hooks_alloc_simple) {
|
||||
/* "Simple" in the sense that we're not in a realloc variant. */
|
||||
hooks_t hooks = {&test_alloc_hook, NULL, NULL, (void *)123};
|
||||
void *handle = hook_install(TSDN_NULL, &hooks);
|
||||
expect_ptr_ne(handle, NULL, "Hook installation failed");
|
||||
|
||||
/* Stop malloc from being optimized away. */
|
||||
volatile int err;
|
||||
void *volatile ptr;
|
||||
|
||||
/* malloc */
|
||||
reset();
|
||||
ptr = malloc(1);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_alloc_malloc, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
|
||||
free(ptr);
|
||||
|
||||
/* posix_memalign */
|
||||
reset();
|
||||
err = posix_memalign((void **)&ptr, 1024, 1);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(
|
||||
arg_type, (int)hook_alloc_posix_memalign, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)err, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)&ptr, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq((uintptr_t)1024, arg_args_raw[1], "Wrong argument");
|
||||
expect_u64_eq((uintptr_t)1, arg_args_raw[2], "Wrong argument");
|
||||
free(ptr);
|
||||
|
||||
/* aligned_alloc */
|
||||
reset();
|
||||
ptr = aligned_alloc(1024, 1);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_alloc_aligned_alloc, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)1024, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong argument");
|
||||
free(ptr);
|
||||
|
||||
/* calloc */
|
||||
reset();
|
||||
ptr = calloc(11, 13);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_alloc_calloc, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)11, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq((uintptr_t)13, arg_args_raw[1], "Wrong argument");
|
||||
free(ptr);
|
||||
|
||||
/* memalign */
|
||||
#ifdef JEMALLOC_OVERRIDE_MEMALIGN
|
||||
reset();
|
||||
ptr = memalign(1024, 1);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_alloc_memalign, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)1024, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong argument");
|
||||
free(ptr);
|
||||
#endif /* JEMALLOC_OVERRIDE_MEMALIGN */
|
||||
|
||||
/* valloc */
|
||||
#ifdef JEMALLOC_OVERRIDE_VALLOC
|
||||
reset();
|
||||
ptr = valloc(1);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_alloc_valloc, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
|
||||
free(ptr);
|
||||
#endif /* JEMALLOC_OVERRIDE_VALLOC */
|
||||
|
||||
/* pvalloc */
|
||||
#ifdef JEMALLOC_OVERRIDE_PVALLOC
|
||||
reset();
|
||||
ptr = pvalloc(1);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_alloc_pvalloc, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
|
||||
free(ptr);
|
||||
#endif /* JEMALLOC_OVERRIDE_PVALLOC */
|
||||
|
||||
/* mallocx */
|
||||
reset();
|
||||
ptr = mallocx(1, MALLOCX_LG_ALIGN(10));
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_alloc_mallocx, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)1, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)MALLOCX_LG_ALIGN(10), arg_args_raw[1], "Wrong flags");
|
||||
free(ptr);
|
||||
|
||||
hook_remove(TSDN_NULL, handle);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_hooks_dalloc_simple) {
|
||||
/* "Simple" in the sense that we're not in a realloc variant. */
|
||||
hooks_t hooks = {NULL, &test_dalloc_hook, NULL, (void *)123};
|
||||
void *handle = hook_install(TSDN_NULL, &hooks);
|
||||
expect_ptr_ne(handle, NULL, "Hook installation failed");
|
||||
|
||||
void *volatile ptr;
|
||||
|
||||
/* free() */
|
||||
reset();
|
||||
ptr = malloc(1);
|
||||
free(ptr);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_dalloc_free, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_address, "Wrong pointer freed");
|
||||
expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
|
||||
|
||||
/* dallocx() */
|
||||
reset();
|
||||
ptr = malloc(1);
|
||||
dallocx(ptr, MALLOCX_TCACHE_NONE);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_dalloc_dallocx, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_address, "Wrong pointer freed");
|
||||
expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)MALLOCX_TCACHE_NONE, arg_args_raw[1], "Wrong raw arg");
|
||||
|
||||
/* sdallocx() */
|
||||
reset();
|
||||
ptr = malloc(1);
|
||||
sdallocx(ptr, 1, MALLOCX_TCACHE_NONE);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_dalloc_sdallocx, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_address, "Wrong pointer freed");
|
||||
expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
|
||||
expect_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong raw arg");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)MALLOCX_TCACHE_NONE, arg_args_raw[2], "Wrong raw arg");
|
||||
|
||||
hook_remove(TSDN_NULL, handle);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_hooks_expand_simple) {
|
||||
/* "Simple" in the sense that we're not in a realloc variant. */
|
||||
hooks_t hooks = {NULL, NULL, &test_expand_hook, (void *)123};
|
||||
void *handle = hook_install(TSDN_NULL, &hooks);
|
||||
expect_ptr_ne(handle, NULL, "Hook installation failed");
|
||||
|
||||
void *volatile ptr;
|
||||
|
||||
/* xallocx() */
|
||||
reset();
|
||||
ptr = malloc(1);
|
||||
size_t new_usize = xallocx(ptr, 100, 200, MALLOCX_TCACHE_NONE);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_expand_xallocx, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_address, "Wrong pointer expanded");
|
||||
expect_u64_eq(arg_old_usize, nallocx(1, 0), "Wrong old usize");
|
||||
expect_u64_eq(arg_new_usize, sallocx(ptr, 0), "Wrong new usize");
|
||||
expect_u64_eq(new_usize, arg_result_raw, "Wrong result");
|
||||
expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong arg");
|
||||
expect_u64_eq(100, arg_args_raw[1], "Wrong arg");
|
||||
expect_u64_eq(200, arg_args_raw[2], "Wrong arg");
|
||||
expect_u64_eq(MALLOCX_TCACHE_NONE, arg_args_raw[3], "Wrong arg");
|
||||
|
||||
hook_remove(TSDN_NULL, handle);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_hooks_realloc_as_malloc_or_free) {
|
||||
hooks_t hooks = {&test_alloc_hook, &test_dalloc_hook, &test_expand_hook,
|
||||
(void *)123};
|
||||
void *handle = hook_install(TSDN_NULL, &hooks);
|
||||
expect_ptr_ne(handle, NULL, "Hook installation failed");
|
||||
|
||||
void *volatile ptr;
|
||||
|
||||
/* realloc(NULL, size) as malloc */
|
||||
reset();
|
||||
ptr = realloc(NULL, 1);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_alloc_realloc, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)NULL, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq((uintptr_t)1, arg_args_raw[1], "Wrong argument");
|
||||
free(ptr);
|
||||
|
||||
/* realloc(ptr, 0) as free */
|
||||
if (opt_zero_realloc_action == zero_realloc_action_free) {
|
||||
ptr = malloc(1);
|
||||
reset();
|
||||
realloc(ptr, 0);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(
|
||||
arg_type, (int)hook_dalloc_realloc, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_address, "Wrong pointer freed");
|
||||
expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong raw arg");
|
||||
expect_u64_eq((uintptr_t)0, arg_args_raw[1], "Wrong raw arg");
|
||||
}
|
||||
|
||||
/* realloc(NULL, 0) as malloc(0) */
|
||||
reset();
|
||||
ptr = realloc(NULL, 0);
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, (int)hook_alloc_realloc, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong result");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)NULL, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq((uintptr_t)0, arg_args_raw[1], "Wrong argument");
|
||||
free(ptr);
|
||||
|
||||
hook_remove(TSDN_NULL, handle);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
static void
|
||||
do_realloc_test(void *(*ralloc)(void *, size_t, int), int flags,
|
||||
int expand_type, int dalloc_type) {
|
||||
hooks_t hooks = {&test_alloc_hook, &test_dalloc_hook, &test_expand_hook,
|
||||
(void *)123};
|
||||
void *handle = hook_install(TSDN_NULL, &hooks);
|
||||
expect_ptr_ne(handle, NULL, "Hook installation failed");
|
||||
|
||||
void *volatile ptr;
|
||||
void *volatile ptr2;
|
||||
|
||||
/* Realloc in-place, small. */
|
||||
ptr = malloc(129);
|
||||
reset();
|
||||
ptr2 = ralloc(ptr, 130, flags);
|
||||
expect_ptr_eq(ptr, ptr2, "Small realloc moved");
|
||||
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, expand_type, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_address, "Wrong address");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq((uintptr_t)130, arg_args_raw[1], "Wrong argument");
|
||||
free(ptr);
|
||||
|
||||
/*
|
||||
* Realloc in-place, large. Since we can't guarantee the large case
|
||||
* across all platforms, we stay resilient to moving results.
|
||||
*/
|
||||
ptr = malloc(2 * 1024 * 1024);
|
||||
free(ptr);
|
||||
ptr2 = malloc(1 * 1024 * 1024);
|
||||
reset();
|
||||
ptr = ralloc(ptr2, 2 * 1024 * 1024, flags);
|
||||
/* ptr is the new address, ptr2 is the old address. */
|
||||
if (ptr == ptr2) {
|
||||
expect_d_eq(call_count, 1, "Hook not called");
|
||||
expect_d_eq(arg_type, expand_type, "Wrong hook type");
|
||||
} else {
|
||||
expect_d_eq(call_count, 2, "Wrong hooks called");
|
||||
expect_ptr_eq(ptr, arg_result, "Wrong address");
|
||||
expect_d_eq(arg_type, dalloc_type, "Wrong hook type");
|
||||
}
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_ptr_eq(ptr2, arg_address, "Wrong address");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)ptr2, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)2 * 1024 * 1024, arg_args_raw[1], "Wrong argument");
|
||||
free(ptr);
|
||||
|
||||
/* Realloc with move, small. */
|
||||
ptr = malloc(8);
|
||||
reset();
|
||||
ptr2 = ralloc(ptr, 128, flags);
|
||||
expect_ptr_ne(ptr, ptr2, "Small realloc didn't move");
|
||||
|
||||
expect_d_eq(call_count, 2, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, dalloc_type, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_address, "Wrong address");
|
||||
expect_ptr_eq(ptr2, arg_result, "Wrong address");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr2, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq((uintptr_t)128, arg_args_raw[1], "Wrong argument");
|
||||
free(ptr2);
|
||||
|
||||
/* Realloc with move, large. */
|
||||
ptr = malloc(1);
|
||||
reset();
|
||||
ptr2 = ralloc(ptr, 2 * 1024 * 1024, flags);
|
||||
expect_ptr_ne(ptr, ptr2, "Large realloc didn't move");
|
||||
|
||||
expect_d_eq(call_count, 2, "Hook not called");
|
||||
expect_ptr_eq(arg_extra, (void *)123, "Wrong extra");
|
||||
expect_d_eq(arg_type, dalloc_type, "Wrong hook type");
|
||||
expect_ptr_eq(ptr, arg_address, "Wrong address");
|
||||
expect_ptr_eq(ptr2, arg_result, "Wrong address");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)ptr2, (uintptr_t)arg_result_raw, "Wrong raw result");
|
||||
expect_u64_eq((uintptr_t)ptr, arg_args_raw[0], "Wrong argument");
|
||||
expect_u64_eq(
|
||||
(uintptr_t)2 * 1024 * 1024, arg_args_raw[1], "Wrong argument");
|
||||
free(ptr2);
|
||||
|
||||
hook_remove(TSDN_NULL, handle);
|
||||
}
|
||||
|
||||
static void *
|
||||
realloc_wrapper(void *ptr, size_t size, UNUSED int flags) {
|
||||
return realloc(ptr, size);
|
||||
}
|
||||
|
||||
TEST_BEGIN(test_hooks_realloc) {
|
||||
do_realloc_test(
|
||||
&realloc_wrapper, 0, hook_expand_realloc, hook_dalloc_realloc);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_hooks_rallocx) {
|
||||
do_realloc_test(&rallocx, MALLOCX_TCACHE_NONE, hook_expand_rallocx,
|
||||
hook_dalloc_rallocx);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
int
|
||||
main(void) {
|
||||
/* We assert on call counts. */
|
||||
return test_no_reentrancy(test_hooks_basic, test_hooks_null,
|
||||
test_hooks_remove, test_hooks_alloc_simple,
|
||||
test_hooks_dalloc_simple, test_hooks_expand_simple,
|
||||
test_hooks_realloc_as_malloc_or_free, test_hooks_realloc,
|
||||
test_hooks_rallocx);
|
||||
}
|
||||
@@ -1,7 +1,6 @@
|
||||
#include "test/jemalloc_test.h"
|
||||
|
||||
#include "jemalloc/internal/ctl.h"
|
||||
#include "jemalloc/internal/hook.h"
|
||||
#include "jemalloc/internal/util.h"
|
||||
|
||||
TEST_BEGIN(test_mallctl_errors) {
|
||||
@@ -1216,79 +1215,6 @@ TEST_BEGIN(test_stats_arenas_hpa_shard_slabs) {
|
||||
}
|
||||
TEST_END
|
||||
|
||||
static void
|
||||
alloc_hook(void *extra, UNUSED hook_alloc_t type, UNUSED void *result,
|
||||
UNUSED uintptr_t result_raw, UNUSED uintptr_t args_raw[3]) {
|
||||
*(bool *)extra = true;
|
||||
}
|
||||
|
||||
static void
|
||||
dalloc_hook(void *extra, UNUSED hook_dalloc_t type, UNUSED void *address,
|
||||
UNUSED uintptr_t args_raw[3]) {
|
||||
*(bool *)extra = true;
|
||||
}
|
||||
|
||||
TEST_BEGIN(test_hooks) {
|
||||
bool hook_called = false;
|
||||
hooks_t hooks = {&alloc_hook, &dalloc_hook, NULL, &hook_called};
|
||||
void *handle = NULL;
|
||||
size_t sz = sizeof(handle);
|
||||
int err = mallctl(
|
||||
"experimental.hooks.install", &handle, &sz, &hooks, sizeof(hooks));
|
||||
expect_d_eq(err, 0, "Hook installation failed");
|
||||
expect_ptr_ne(handle, NULL, "Hook installation gave null handle");
|
||||
void *ptr = mallocx(1, 0);
|
||||
expect_true(hook_called, "Alloc hook not called");
|
||||
hook_called = false;
|
||||
free(ptr);
|
||||
expect_true(hook_called, "Free hook not called");
|
||||
|
||||
err = mallctl(
|
||||
"experimental.hooks.remove", NULL, NULL, &handle, sizeof(handle));
|
||||
expect_d_eq(err, 0, "Hook removal failed");
|
||||
hook_called = false;
|
||||
ptr = mallocx(1, 0);
|
||||
free(ptr);
|
||||
expect_false(hook_called, "Hook called after removal");
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_hooks_exhaustion) {
|
||||
bool hook_called = false;
|
||||
hooks_t hooks = {&alloc_hook, &dalloc_hook, NULL, &hook_called};
|
||||
|
||||
void *handle;
|
||||
void *handles[HOOK_MAX];
|
||||
size_t sz = sizeof(handle);
|
||||
int err;
|
||||
for (int i = 0; i < HOOK_MAX; i++) {
|
||||
handle = NULL;
|
||||
err = mallctl("experimental.hooks.install", &handle, &sz,
|
||||
&hooks, sizeof(hooks));
|
||||
expect_d_eq(err, 0, "Error installation hooks");
|
||||
expect_ptr_ne(handle, NULL, "Got NULL handle");
|
||||
handles[i] = handle;
|
||||
}
|
||||
err = mallctl(
|
||||
"experimental.hooks.install", &handle, &sz, &hooks, sizeof(hooks));
|
||||
expect_d_eq(err, EAGAIN, "Should have failed hook installation");
|
||||
for (int i = 0; i < HOOK_MAX; i++) {
|
||||
err = mallctl("experimental.hooks.remove", NULL, NULL,
|
||||
&handles[i], sizeof(handles[i]));
|
||||
expect_d_eq(err, 0, "Hook removal failed");
|
||||
}
|
||||
/* Insertion failed, but then we removed some; it should work now. */
|
||||
handle = NULL;
|
||||
err = mallctl(
|
||||
"experimental.hooks.install", &handle, &sz, &hooks, sizeof(hooks));
|
||||
expect_d_eq(err, 0, "Hook insertion failed");
|
||||
expect_ptr_ne(handle, NULL, "Got NULL handle");
|
||||
err = mallctl(
|
||||
"experimental.hooks.remove", NULL, NULL, &handle, sizeof(handle));
|
||||
expect_d_eq(err, 0, "Hook removal failed");
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_thread_idle) {
|
||||
/*
|
||||
* We're cheating a little bit in this test, and inferring things about
|
||||
@@ -1483,7 +1409,6 @@ main(void) {
|
||||
test_arenas_lextent_constants, test_arenas_create,
|
||||
test_arenas_lookup, test_prof_active, test_stats_arenas,
|
||||
test_stats_arenas_hpa_shard_counters,
|
||||
test_stats_arenas_hpa_shard_slabs, test_hooks,
|
||||
test_hooks_exhaustion, test_thread_idle, test_thread_peak,
|
||||
test_stats_arenas_hpa_shard_slabs, test_thread_idle, test_thread_peak,
|
||||
test_thread_event_hook);
|
||||
}
|
||||
|
||||
@@ -1,94 +0,0 @@
|
||||
#include "test/jemalloc_test.h"
|
||||
|
||||
#include "jemalloc/internal/seq.h"
|
||||
|
||||
typedef struct data_s data_t;
|
||||
struct data_s {
|
||||
int arr[10];
|
||||
};
|
||||
|
||||
static void
|
||||
set_data(data_t *data, int num) {
|
||||
for (int i = 0; i < 10; i++) {
|
||||
data->arr[i] = num;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
expect_data(data_t *data) {
|
||||
int num = data->arr[0];
|
||||
for (int i = 0; i < 10; i++) {
|
||||
expect_d_eq(num, data->arr[i], "Data consistency error");
|
||||
}
|
||||
}
|
||||
|
||||
seq_define(data_t, data)
|
||||
|
||||
typedef struct thd_data_s thd_data_t;
|
||||
struct thd_data_s {
|
||||
seq_data_t data;
|
||||
};
|
||||
|
||||
static void *
|
||||
seq_reader_thd(void *arg) {
|
||||
thd_data_t *thd_data = (thd_data_t *)arg;
|
||||
int iter = 0;
|
||||
data_t local_data;
|
||||
while (iter < 1000 * 1000 - 1) {
|
||||
bool success = seq_try_load_data(&local_data, &thd_data->data);
|
||||
if (success) {
|
||||
expect_data(&local_data);
|
||||
expect_d_le(iter, local_data.arr[0],
|
||||
"Seq read went back in time.");
|
||||
iter = local_data.arr[0];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void *
|
||||
seq_writer_thd(void *arg) {
|
||||
thd_data_t *thd_data = (thd_data_t *)arg;
|
||||
data_t local_data;
|
||||
memset(&local_data, 0, sizeof(local_data));
|
||||
for (int i = 0; i < 1000 * 1000; i++) {
|
||||
set_data(&local_data, i);
|
||||
seq_store_data(&thd_data->data, &local_data);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
TEST_BEGIN(test_seq_threaded) {
|
||||
thd_data_t thd_data;
|
||||
memset(&thd_data, 0, sizeof(thd_data));
|
||||
|
||||
thd_t reader;
|
||||
thd_t writer;
|
||||
|
||||
thd_create(&reader, seq_reader_thd, &thd_data);
|
||||
thd_create(&writer, seq_writer_thd, &thd_data);
|
||||
|
||||
thd_join(reader, NULL);
|
||||
thd_join(writer, NULL);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_seq_simple) {
|
||||
data_t data;
|
||||
seq_data_t seq;
|
||||
memset(&seq, 0, sizeof(seq));
|
||||
for (int i = 0; i < 1000 * 1000; i++) {
|
||||
set_data(&data, i);
|
||||
seq_store_data(&seq, &data);
|
||||
set_data(&data, 0);
|
||||
bool success = seq_try_load_data(&data, &seq);
|
||||
expect_b_eq(success, true, "Failed non-racing read");
|
||||
expect_data(&data);
|
||||
}
|
||||
}
|
||||
TEST_END
|
||||
|
||||
int
|
||||
main(void) {
|
||||
return test_no_reentrancy(test_seq_simple, test_seq_threaded);
|
||||
}
|
||||
130
test/unit/tsd.c
130
test/unit/tsd.c
@@ -1,10 +1,5 @@
|
||||
#include "test/jemalloc_test.h"
|
||||
|
||||
/*
|
||||
* If we're e.g. in debug mode, we *never* enter the fast path, and so shouldn't
|
||||
* be asserting that we're on one.
|
||||
*/
|
||||
static bool originally_fast;
|
||||
static int data_cleanup_count;
|
||||
|
||||
void
|
||||
@@ -190,128 +185,6 @@ TEST_BEGIN(test_tsd_sub_thread_dalloc_only) {
|
||||
}
|
||||
TEST_END
|
||||
|
||||
typedef struct {
|
||||
atomic_u32_t phase;
|
||||
atomic_b_t error;
|
||||
} global_slow_data_t;
|
||||
|
||||
static void *
|
||||
thd_start_global_slow(void *arg) {
|
||||
/* PHASE 0 */
|
||||
global_slow_data_t *data = (global_slow_data_t *)arg;
|
||||
free(mallocx(1, 0));
|
||||
|
||||
tsd_t *tsd = tsd_fetch();
|
||||
/*
|
||||
* No global slowness has happened yet; there was an error if we were
|
||||
* originally fast but aren't now.
|
||||
*/
|
||||
atomic_store_b(
|
||||
&data->error, originally_fast && !tsd_fast(tsd), ATOMIC_SEQ_CST);
|
||||
atomic_store_u32(&data->phase, 1, ATOMIC_SEQ_CST);
|
||||
|
||||
/* PHASE 2 */
|
||||
while (atomic_load_u32(&data->phase, ATOMIC_SEQ_CST) != 2) {
|
||||
}
|
||||
free(mallocx(1, 0));
|
||||
atomic_store_b(&data->error, tsd_fast(tsd), ATOMIC_SEQ_CST);
|
||||
atomic_store_u32(&data->phase, 3, ATOMIC_SEQ_CST);
|
||||
|
||||
/* PHASE 4 */
|
||||
while (atomic_load_u32(&data->phase, ATOMIC_SEQ_CST) != 4) {
|
||||
}
|
||||
free(mallocx(1, 0));
|
||||
atomic_store_b(&data->error, tsd_fast(tsd), ATOMIC_SEQ_CST);
|
||||
atomic_store_u32(&data->phase, 5, ATOMIC_SEQ_CST);
|
||||
|
||||
/* PHASE 6 */
|
||||
while (atomic_load_u32(&data->phase, ATOMIC_SEQ_CST) != 6) {
|
||||
}
|
||||
free(mallocx(1, 0));
|
||||
/* Only one decrement so far. */
|
||||
atomic_store_b(&data->error, tsd_fast(tsd), ATOMIC_SEQ_CST);
|
||||
atomic_store_u32(&data->phase, 7, ATOMIC_SEQ_CST);
|
||||
|
||||
/* PHASE 8 */
|
||||
while (atomic_load_u32(&data->phase, ATOMIC_SEQ_CST) != 8) {
|
||||
}
|
||||
free(mallocx(1, 0));
|
||||
/*
|
||||
* Both decrements happened; we should be fast again (if we ever
|
||||
* were)
|
||||
*/
|
||||
atomic_store_b(
|
||||
&data->error, originally_fast && !tsd_fast(tsd), ATOMIC_SEQ_CST);
|
||||
atomic_store_u32(&data->phase, 9, ATOMIC_SEQ_CST);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
TEST_BEGIN(test_tsd_global_slow) {
|
||||
global_slow_data_t data = {ATOMIC_INIT(0), ATOMIC_INIT(false)};
|
||||
/*
|
||||
* Note that the "mallocx" here (vs. malloc) is important, since the
|
||||
* compiler is allowed to optimize away free(malloc(1)) but not
|
||||
* free(mallocx(1)).
|
||||
*/
|
||||
free(mallocx(1, 0));
|
||||
tsd_t *tsd = tsd_fetch();
|
||||
originally_fast = tsd_fast(tsd);
|
||||
|
||||
thd_t thd;
|
||||
thd_create(&thd, thd_start_global_slow, (void *)&data.phase);
|
||||
/* PHASE 1 */
|
||||
while (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 1) {
|
||||
/*
|
||||
* We don't have a portable condvar/semaphore mechanism.
|
||||
* Spin-wait.
|
||||
*/
|
||||
}
|
||||
expect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), "");
|
||||
tsd_global_slow_inc(tsd_tsdn(tsd));
|
||||
free(mallocx(1, 0));
|
||||
expect_false(tsd_fast(tsd), "");
|
||||
atomic_store_u32(&data.phase, 2, ATOMIC_SEQ_CST);
|
||||
|
||||
/* PHASE 3 */
|
||||
while (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 3) {
|
||||
}
|
||||
expect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), "");
|
||||
/* Increase again, so that we can test multiple fast/slow changes. */
|
||||
tsd_global_slow_inc(tsd_tsdn(tsd));
|
||||
atomic_store_u32(&data.phase, 4, ATOMIC_SEQ_CST);
|
||||
free(mallocx(1, 0));
|
||||
expect_false(tsd_fast(tsd), "");
|
||||
|
||||
/* PHASE 5 */
|
||||
while (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 5) {
|
||||
}
|
||||
expect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), "");
|
||||
tsd_global_slow_dec(tsd_tsdn(tsd));
|
||||
atomic_store_u32(&data.phase, 6, ATOMIC_SEQ_CST);
|
||||
/* We only decreased once; things should still be slow. */
|
||||
free(mallocx(1, 0));
|
||||
expect_false(tsd_fast(tsd), "");
|
||||
|
||||
/* PHASE 7 */
|
||||
while (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 7) {
|
||||
}
|
||||
expect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), "");
|
||||
tsd_global_slow_dec(tsd_tsdn(tsd));
|
||||
atomic_store_u32(&data.phase, 8, ATOMIC_SEQ_CST);
|
||||
/* We incremented and then decremented twice; we should be fast now. */
|
||||
free(mallocx(1, 0));
|
||||
expect_true(!originally_fast || tsd_fast(tsd), "");
|
||||
|
||||
/* PHASE 9 */
|
||||
while (atomic_load_u32(&data.phase, ATOMIC_SEQ_CST) != 9) {
|
||||
}
|
||||
expect_false(atomic_load_b(&data.error, ATOMIC_SEQ_CST), "");
|
||||
|
||||
thd_join(thd, NULL);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
int
|
||||
main(void) {
|
||||
/* Ensure tsd bootstrapped. */
|
||||
@@ -321,6 +194,5 @@ main(void) {
|
||||
}
|
||||
|
||||
return test_no_reentrancy(test_tsd_main_thread, test_tsd_sub_thread,
|
||||
test_tsd_sub_thread_dalloc_only, test_tsd_reincarnation,
|
||||
test_tsd_global_slow);
|
||||
test_tsd_sub_thread_dalloc_only, test_tsd_reincarnation);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user