Header refactoring: Pull size helpers out of jemalloc module.
This commit is contained in:
committed by
David Goldblatt
parent
041e041e1f
commit
8261e581be
@@ -81,7 +81,7 @@ vsalloc(tsdn_t *tsdn, const void *ptr) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return index2size(szind);
|
||||
return sz_index2size(szind);
|
||||
}
|
||||
|
||||
static unsigned
|
||||
|
@@ -1,5 +1,7 @@
|
||||
#include "test/jemalloc_test.h"
|
||||
|
||||
#include "jemalloc/internal/spin.h"
|
||||
|
||||
static unsigned arena_ind;
|
||||
static size_t sz;
|
||||
static size_t esz;
|
||||
@@ -100,7 +102,7 @@ TEST_BEGIN(test_retained) {
|
||||
|
||||
arena_ind = do_arena_create(NULL);
|
||||
sz = nallocx(HUGEPAGE, 0);
|
||||
esz = sz + large_pad;
|
||||
esz = sz + sz_large_pad;
|
||||
|
||||
atomic_store_u(&epoch, 0, ATOMIC_RELAXED);
|
||||
|
||||
@@ -136,9 +138,9 @@ TEST_BEGIN(test_retained) {
|
||||
arena_t *arena = arena_get(tsdn_fetch(), arena_ind, false);
|
||||
size_t usable = 0;
|
||||
size_t fragmented = 0;
|
||||
for (pszind_t pind = psz2ind(HUGEPAGE); pind <
|
||||
for (pszind_t pind = sz_psz2ind(HUGEPAGE); pind <
|
||||
arena->extent_grow_next; pind++) {
|
||||
size_t psz = pind2sz(pind);
|
||||
size_t psz = sz_pind2sz(pind);
|
||||
size_t psz_fragmented = psz % esz;
|
||||
size_t psz_usable = psz - psz_fragmented;
|
||||
/*
|
||||
|
@@ -86,7 +86,8 @@ TEST_END
|
||||
TEST_BEGIN(test_rtree_extrema) {
|
||||
extent_t extent_a, extent_b;
|
||||
extent_init(&extent_a, NULL, NULL, LARGE_MINCLASS, false,
|
||||
size2index(LARGE_MINCLASS), 0, extent_state_active, false, false);
|
||||
sz_size2index(LARGE_MINCLASS), 0, extent_state_active, false,
|
||||
false);
|
||||
extent_init(&extent_b, NULL, NULL, 0, false, NSIZES, 0,
|
||||
extent_state_active, false, false);
|
||||
|
||||
|
@@ -27,11 +27,11 @@ TEST_BEGIN(test_size_classes) {
|
||||
szind_t index, max_index;
|
||||
|
||||
max_size_class = get_max_size_class();
|
||||
max_index = size2index(max_size_class);
|
||||
max_index = sz_size2index(max_size_class);
|
||||
|
||||
for (index = 0, size_class = index2size(index); index < max_index ||
|
||||
for (index = 0, size_class = sz_index2size(index); index < max_index ||
|
||||
size_class < max_size_class; index++, size_class =
|
||||
index2size(index)) {
|
||||
sz_index2size(index)) {
|
||||
assert_true(index < max_index,
|
||||
"Loop conditionals should be equivalent; index=%u, "
|
||||
"size_class=%zu (%#zx)", index, size_class, size_class);
|
||||
@@ -39,42 +39,44 @@ TEST_BEGIN(test_size_classes) {
|
||||
"Loop conditionals should be equivalent; index=%u, "
|
||||
"size_class=%zu (%#zx)", index, size_class, size_class);
|
||||
|
||||
assert_u_eq(index, size2index(size_class),
|
||||
"size2index() does not reverse index2size(): index=%u -->"
|
||||
" size_class=%zu --> index=%u --> size_class=%zu", index,
|
||||
size_class, size2index(size_class),
|
||||
index2size(size2index(size_class)));
|
||||
assert_zu_eq(size_class, index2size(size2index(size_class)),
|
||||
"index2size() does not reverse size2index(): index=%u -->"
|
||||
" size_class=%zu --> index=%u --> size_class=%zu", index,
|
||||
size_class, size2index(size_class),
|
||||
index2size(size2index(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, size2index(size_class+1),
|
||||
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) ?
|
||||
s2u(index2size(index-1)+1) : s2u(1),
|
||||
"s2u() does not round up to size class");
|
||||
assert_zu_eq(size_class, s2u(size_class-1),
|
||||
"s2u() does not round up to size class");
|
||||
assert_zu_eq(size_class, s2u(size_class),
|
||||
"s2u() does not compute same size class");
|
||||
assert_zu_eq(s2u(size_class+1), index2size(index+1),
|
||||
"s2u() does not round up to next size class");
|
||||
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, size2index(index2size(index)),
|
||||
"size2index() does not reverse index2size()");
|
||||
assert_zu_eq(max_size_class, index2size(size2index(max_size_class)),
|
||||
"index2size() does not reverse size2index()");
|
||||
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, s2u(index2size(index-1)+1),
|
||||
"s2u() does not round up to size class");
|
||||
assert_zu_eq(size_class, s2u(size_class-1),
|
||||
"s2u() does not round up to size class");
|
||||
assert_zu_eq(size_class, s2u(size_class),
|
||||
"s2u() does not compute same size class");
|
||||
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
|
||||
|
||||
@@ -83,10 +85,11 @@ TEST_BEGIN(test_psize_classes) {
|
||||
pszind_t pind, max_pind;
|
||||
|
||||
max_psz = get_max_size_class() + PAGE;
|
||||
max_pind = psz2ind(max_psz);
|
||||
max_pind = sz_psz2ind(max_psz);
|
||||
|
||||
for (pind = 0, size_class = pind2sz(pind); pind < max_pind || size_class
|
||||
< max_psz; pind++, size_class = pind2sz(pind)) {
|
||||
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);
|
||||
@@ -94,42 +97,42 @@ TEST_BEGIN(test_psize_classes) {
|
||||
"Loop conditionals should be equivalent; pind=%u, "
|
||||
"size_class=%zu (%#zx)", pind, size_class, size_class);
|
||||
|
||||
assert_u_eq(pind, psz2ind(size_class),
|
||||
"psz2ind() does not reverse pind2sz(): pind=%u -->"
|
||||
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, psz2ind(size_class),
|
||||
pind2sz(psz2ind(size_class)));
|
||||
assert_zu_eq(size_class, pind2sz(psz2ind(size_class)),
|
||||
"pind2sz() does not reverse psz2ind(): pind=%u -->"
|
||||
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, psz2ind(size_class),
|
||||
pind2sz(psz2ind(size_class)));
|
||||
size_class, sz_psz2ind(size_class),
|
||||
sz_pind2sz(sz_psz2ind(size_class)));
|
||||
|
||||
assert_u_eq(pind+1, psz2ind(size_class+1),
|
||||
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) ?
|
||||
psz2u(pind2sz(pind-1)+1) : psz2u(1),
|
||||
"psz2u() does not round up to size class");
|
||||
assert_zu_eq(size_class, psz2u(size_class-1),
|
||||
"psz2u() does not round up to size class");
|
||||
assert_zu_eq(size_class, psz2u(size_class),
|
||||
"psz2u() does not compute same size class");
|
||||
assert_zu_eq(psz2u(size_class+1), pind2sz(pind+1),
|
||||
"psz2u() does not round up to next size class");
|
||||
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, psz2ind(pind2sz(pind)),
|
||||
"psz2ind() does not reverse pind2sz()");
|
||||
assert_zu_eq(max_psz, pind2sz(psz2ind(max_psz)),
|
||||
"pind2sz() does not reverse psz2ind()");
|
||||
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, psz2u(pind2sz(pind-1)+1),
|
||||
"psz2u() does not round up to size class");
|
||||
assert_zu_eq(size_class, psz2u(size_class-1),
|
||||
"psz2u() does not round up to size class");
|
||||
assert_zu_eq(size_class, psz2u(size_class),
|
||||
"psz2u() does not compute same size class");
|
||||
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
|
||||
|
||||
@@ -139,35 +142,35 @@ TEST_BEGIN(test_overflow) {
|
||||
max_size_class = get_max_size_class();
|
||||
max_psz = max_size_class + PAGE;
|
||||
|
||||
assert_u_eq(size2index(max_size_class+1), NSIZES,
|
||||
"size2index() should return NSIZES on overflow");
|
||||
assert_u_eq(size2index(ZU(PTRDIFF_MAX)+1), NSIZES,
|
||||
"size2index() should return NSIZES on overflow");
|
||||
assert_u_eq(size2index(SIZE_T_MAX), NSIZES,
|
||||
"size2index() should return NSIZES on overflow");
|
||||
assert_u_eq(sz_size2index(max_size_class+1), NSIZES,
|
||||
"sz_size2index() should return NSIZES on overflow");
|
||||
assert_u_eq(sz_size2index(ZU(PTRDIFF_MAX)+1), NSIZES,
|
||||
"sz_size2index() should return NSIZES on overflow");
|
||||
assert_u_eq(sz_size2index(SIZE_T_MAX), NSIZES,
|
||||
"sz_size2index() should return NSIZES on overflow");
|
||||
|
||||
assert_zu_eq(s2u(max_size_class+1), 0,
|
||||
"s2u() should return 0 for unsupported size");
|
||||
assert_zu_eq(s2u(ZU(PTRDIFF_MAX)+1), 0,
|
||||
"s2u() should return 0 for unsupported size");
|
||||
assert_zu_eq(s2u(SIZE_T_MAX), 0,
|
||||
"s2u() should return 0 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(psz2ind(max_size_class+1), NPSIZES,
|
||||
"psz2ind() should return NPSIZES on overflow");
|
||||
assert_u_eq(psz2ind(ZU(PTRDIFF_MAX)+1), NPSIZES,
|
||||
"psz2ind() should return NPSIZES on overflow");
|
||||
assert_u_eq(psz2ind(SIZE_T_MAX), NPSIZES,
|
||||
"psz2ind() should return NPSIZES on overflow");
|
||||
assert_u_eq(sz_psz2ind(max_size_class+1), NPSIZES,
|
||||
"sz_psz2ind() should return NPSIZES on overflow");
|
||||
assert_u_eq(sz_psz2ind(ZU(PTRDIFF_MAX)+1), NPSIZES,
|
||||
"sz_psz2ind() should return NPSIZES on overflow");
|
||||
assert_u_eq(sz_psz2ind(SIZE_T_MAX), NPSIZES,
|
||||
"sz_psz2ind() should return NPSIZES on overflow");
|
||||
|
||||
assert_zu_eq(psz2u(max_size_class+1), max_psz,
|
||||
"psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported"
|
||||
assert_zu_eq(sz_psz2u(max_size_class+1), max_psz,
|
||||
"sz_psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported"
|
||||
" size");
|
||||
assert_zu_eq(psz2u(ZU(PTRDIFF_MAX)+1), max_psz,
|
||||
"psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported "
|
||||
assert_zu_eq(sz_psz2u(ZU(PTRDIFF_MAX)+1), max_psz,
|
||||
"sz_psz2u() should return (LARGE_MAXCLASS + PAGE) for unsupported "
|
||||
"size");
|
||||
assert_zu_eq(psz2u(SIZE_T_MAX), max_psz,
|
||||
"psz2u() should return (LARGE_MAXCLASS + PAGE) on overflow");
|
||||
assert_zu_eq(sz_psz2u(SIZE_T_MAX), max_psz,
|
||||
"sz_psz2u() should return (LARGE_MAXCLASS + PAGE) on overflow");
|
||||
}
|
||||
TEST_END
|
||||
|
||||
|
Reference in New Issue
Block a user