3aba072cef
The global data is mostly only used at initialization, or for easy access to values we could compute statically. Instead of consuming that space (and risking TLB misses), we can just pass around a pointer to stack data during bootstrapping.
189 lines
6.9 KiB
C
189 lines
6.9 KiB
C
#include "test/jemalloc_test.h"
|
|
|
|
static size_t
|
|
get_max_size_class(void) {
|
|
unsigned nlextents;
|
|
size_t mib[4];
|
|
size_t sz, miblen, max_size_class;
|
|
|
|
sz = sizeof(unsigned);
|
|
assert_d_eq(mallctl("arenas.nlextents", (void *)&nlextents, &sz, NULL,
|
|
0), 0, "Unexpected mallctl() error");
|
|
|
|
miblen = sizeof(mib) / sizeof(size_t);
|
|
assert_d_eq(mallctlnametomib("arenas.lextent.0.size", mib, &miblen), 0,
|
|
"Unexpected mallctlnametomib() error");
|
|
mib[2] = nlextents - 1;
|
|
|
|
sz = sizeof(size_t);
|
|
assert_d_eq(mallctlbymib(mib, miblen, (void *)&max_size_class, &sz,
|
|
NULL, 0), 0, "Unexpected mallctlbymib() error");
|
|
|
|
return max_size_class;
|
|
}
|
|
|
|
TEST_BEGIN(test_size_classes) {
|
|
size_t size_class, max_size_class;
|
|
szind_t index, max_index;
|
|
|
|
max_size_class = get_max_size_class();
|
|
max_index = sz_size2index(max_size_class);
|
|
|
|
for (index = 0, size_class = sz_index2size(index); index < max_index ||
|
|
size_class < max_size_class; index++, size_class =
|
|
sz_index2size(index)) {
|
|
assert_true(index < max_index,
|
|
"Loop conditionals should be equivalent; index=%u, "
|
|
"size_class=%zu (%#zx)", index, size_class, size_class);
|
|
assert_true(size_class < max_size_class,
|
|
"Loop conditionals should be equivalent; index=%u, "
|
|
"size_class=%zu (%#zx)", index, size_class, size_class);
|
|
|
|
assert_u_eq(index, sz_size2index(size_class),
|
|
"sz_size2index() does not reverse sz_index2size(): index=%u"
|
|
" --> size_class=%zu --> index=%u --> size_class=%zu",
|
|
index, size_class, sz_size2index(size_class),
|
|
sz_index2size(sz_size2index(size_class)));
|
|
assert_zu_eq(size_class,
|
|
sz_index2size(sz_size2index(size_class)),
|
|
"sz_index2size() does not reverse sz_size2index(): index=%u"
|
|
" --> size_class=%zu --> index=%u --> size_class=%zu",
|
|
index, size_class, sz_size2index(size_class),
|
|
sz_index2size(sz_size2index(size_class)));
|
|
|
|
assert_u_eq(index+1, sz_size2index(size_class+1),
|
|
"Next size_class does not round up properly");
|
|
|
|
assert_zu_eq(size_class, (index > 0) ?
|
|
sz_s2u(sz_index2size(index-1)+1) : sz_s2u(1),
|
|
"sz_s2u() does not round up to size class");
|
|
assert_zu_eq(size_class, sz_s2u(size_class-1),
|
|
"sz_s2u() does not round up to size class");
|
|
assert_zu_eq(size_class, sz_s2u(size_class),
|
|
"sz_s2u() does not compute same size class");
|
|
assert_zu_eq(sz_s2u(size_class+1), sz_index2size(index+1),
|
|
"sz_s2u() does not round up to next size class");
|
|
}
|
|
|
|
assert_u_eq(index, sz_size2index(sz_index2size(index)),
|
|
"sz_size2index() does not reverse sz_index2size()");
|
|
assert_zu_eq(max_size_class, sz_index2size(
|
|
sz_size2index(max_size_class)),
|
|
"sz_index2size() does not reverse sz_size2index()");
|
|
|
|
assert_zu_eq(size_class, sz_s2u(sz_index2size(index-1)+1),
|
|
"sz_s2u() does not round up to size class");
|
|
assert_zu_eq(size_class, sz_s2u(size_class-1),
|
|
"sz_s2u() does not round up to size class");
|
|
assert_zu_eq(size_class, sz_s2u(size_class),
|
|
"sz_s2u() does not compute same size class");
|
|
}
|
|
TEST_END
|
|
|
|
TEST_BEGIN(test_psize_classes) {
|
|
size_t size_class, max_psz;
|
|
pszind_t pind, max_pind;
|
|
|
|
max_psz = get_max_size_class() + PAGE;
|
|
max_pind = sz_psz2ind(max_psz);
|
|
|
|
for (pind = 0, size_class = sz_pind2sz(pind);
|
|
pind < max_pind || size_class < max_psz;
|
|
pind++, size_class = sz_pind2sz(pind)) {
|
|
assert_true(pind < max_pind,
|
|
"Loop conditionals should be equivalent; pind=%u, "
|
|
"size_class=%zu (%#zx)", pind, size_class, size_class);
|
|
assert_true(size_class < max_psz,
|
|
"Loop conditionals should be equivalent; pind=%u, "
|
|
"size_class=%zu (%#zx)", pind, size_class, size_class);
|
|
|
|
assert_u_eq(pind, sz_psz2ind(size_class),
|
|
"sz_psz2ind() does not reverse sz_pind2sz(): pind=%u -->"
|
|
" size_class=%zu --> pind=%u --> size_class=%zu", pind,
|
|
size_class, sz_psz2ind(size_class),
|
|
sz_pind2sz(sz_psz2ind(size_class)));
|
|
assert_zu_eq(size_class, sz_pind2sz(sz_psz2ind(size_class)),
|
|
"sz_pind2sz() does not reverse sz_psz2ind(): pind=%u -->"
|
|
" size_class=%zu --> pind=%u --> size_class=%zu", pind,
|
|
size_class, sz_psz2ind(size_class),
|
|
sz_pind2sz(sz_psz2ind(size_class)));
|
|
|
|
if (size_class == SC_LARGE_MAXCLASS) {
|
|
assert_u_eq(SC_NPSIZES, sz_psz2ind(size_class + 1),
|
|
"Next size_class does not round up properly");
|
|
} else {
|
|
assert_u_eq(pind + 1, sz_psz2ind(size_class + 1),
|
|
"Next size_class does not round up properly");
|
|
}
|
|
|
|
assert_zu_eq(size_class, (pind > 0) ?
|
|
sz_psz2u(sz_pind2sz(pind-1)+1) : sz_psz2u(1),
|
|
"sz_psz2u() does not round up to size class");
|
|
assert_zu_eq(size_class, sz_psz2u(size_class-1),
|
|
"sz_psz2u() does not round up to size class");
|
|
assert_zu_eq(size_class, sz_psz2u(size_class),
|
|
"sz_psz2u() does not compute same size class");
|
|
assert_zu_eq(sz_psz2u(size_class+1), sz_pind2sz(pind+1),
|
|
"sz_psz2u() does not round up to next size class");
|
|
}
|
|
|
|
assert_u_eq(pind, sz_psz2ind(sz_pind2sz(pind)),
|
|
"sz_psz2ind() does not reverse sz_pind2sz()");
|
|
assert_zu_eq(max_psz, sz_pind2sz(sz_psz2ind(max_psz)),
|
|
"sz_pind2sz() does not reverse sz_psz2ind()");
|
|
|
|
assert_zu_eq(size_class, sz_psz2u(sz_pind2sz(pind-1)+1),
|
|
"sz_psz2u() does not round up to size class");
|
|
assert_zu_eq(size_class, sz_psz2u(size_class-1),
|
|
"sz_psz2u() does not round up to size class");
|
|
assert_zu_eq(size_class, sz_psz2u(size_class),
|
|
"sz_psz2u() does not compute same size class");
|
|
}
|
|
TEST_END
|
|
|
|
TEST_BEGIN(test_overflow) {
|
|
size_t max_size_class, max_psz;
|
|
|
|
max_size_class = get_max_size_class();
|
|
max_psz = max_size_class + PAGE;
|
|
|
|
assert_u_eq(sz_size2index(max_size_class+1), SC_NSIZES,
|
|
"sz_size2index() should return NSIZES on overflow");
|
|
assert_u_eq(sz_size2index(ZU(PTRDIFF_MAX)+1), SC_NSIZES,
|
|
"sz_size2index() should return NSIZES on overflow");
|
|
assert_u_eq(sz_size2index(SIZE_T_MAX), SC_NSIZES,
|
|
"sz_size2index() should return NSIZES on overflow");
|
|
|
|
assert_zu_eq(sz_s2u(max_size_class+1), 0,
|
|
"sz_s2u() should return 0 for unsupported size");
|
|
assert_zu_eq(sz_s2u(ZU(PTRDIFF_MAX)+1), 0,
|
|
"sz_s2u() should return 0 for unsupported size");
|
|
assert_zu_eq(sz_s2u(SIZE_T_MAX), 0,
|
|
"sz_s2u() should return 0 on overflow");
|
|
|
|
assert_u_eq(sz_psz2ind(max_size_class+1), SC_NPSIZES,
|
|
"sz_psz2ind() should return NPSIZES on overflow");
|
|
assert_u_eq(sz_psz2ind(ZU(PTRDIFF_MAX)+1), SC_NPSIZES,
|
|
"sz_psz2ind() should return NPSIZES on overflow");
|
|
assert_u_eq(sz_psz2ind(SIZE_T_MAX), SC_NPSIZES,
|
|
"sz_psz2ind() should return NPSIZES on overflow");
|
|
|
|
assert_zu_eq(sz_psz2u(max_size_class+1), max_psz,
|
|
"sz_psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported"
|
|
" size");
|
|
assert_zu_eq(sz_psz2u(ZU(PTRDIFF_MAX)+1), max_psz,
|
|
"sz_psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported "
|
|
"size");
|
|
assert_zu_eq(sz_psz2u(SIZE_T_MAX), max_psz,
|
|
"sz_psz2u() should return (LARGE_MAXCLASS + PAGE) on overflow");
|
|
}
|
|
TEST_END
|
|
|
|
int
|
|
main(void) {
|
|
return test(
|
|
test_size_classes,
|
|
test_psize_classes,
|
|
test_overflow);
|
|
}
|