147 lines
4.2 KiB
C
147 lines
4.2 KiB
C
#include "test/jemalloc_test.h"
|
|
|
|
TEST_BEGIN(test_small_extent_size)
|
|
{
|
|
unsigned nbins, i;
|
|
size_t sz, extent_size;
|
|
size_t mib[4];
|
|
size_t miblen = sizeof(mib) / sizeof(size_t);
|
|
|
|
/*
|
|
* Iterate over all small size classes, get their extent sizes, and
|
|
* verify that the quantized size is the same as the extent size.
|
|
*/
|
|
|
|
sz = sizeof(unsigned);
|
|
assert_d_eq(mallctl("arenas.nbins", (void *)&nbins, &sz, NULL, 0), 0,
|
|
"Unexpected mallctl failure");
|
|
|
|
assert_d_eq(mallctlnametomib("arenas.bin.0.slab_size", mib, &miblen), 0,
|
|
"Unexpected mallctlnametomib failure");
|
|
for (i = 0; i < nbins; i++) {
|
|
mib[2] = i;
|
|
sz = sizeof(size_t);
|
|
assert_d_eq(mallctlbymib(mib, miblen, (void *)&extent_size, &sz,
|
|
NULL, 0), 0, "Unexpected mallctlbymib failure");
|
|
assert_zu_eq(extent_size,
|
|
extent_size_quantize_floor(extent_size),
|
|
"Small extent quantization should be a no-op "
|
|
"(extent_size=%zu)", extent_size);
|
|
assert_zu_eq(extent_size,
|
|
extent_size_quantize_ceil(extent_size),
|
|
"Small extent quantization should be a no-op "
|
|
"(extent_size=%zu)", extent_size);
|
|
}
|
|
}
|
|
TEST_END
|
|
|
|
TEST_BEGIN(test_large_extent_size)
|
|
{
|
|
bool cache_oblivious;
|
|
unsigned nlextents, i;
|
|
size_t sz, extent_size_prev, ceil_prev;
|
|
size_t mib[4];
|
|
size_t miblen = sizeof(mib) / sizeof(size_t);
|
|
|
|
/*
|
|
* Iterate over all large size classes, get their extent sizes, and
|
|
* verify that the quantized size is the same as the extent size.
|
|
*/
|
|
|
|
sz = sizeof(bool);
|
|
assert_d_eq(mallctl("config.cache_oblivious", (void *)&cache_oblivious,
|
|
&sz, NULL, 0), 0, "Unexpected mallctl failure");
|
|
|
|
sz = sizeof(unsigned);
|
|
assert_d_eq(mallctl("arenas.nlextents", (void *)&nlextents, &sz, NULL,
|
|
0), 0, "Unexpected mallctl failure");
|
|
|
|
assert_d_eq(mallctlnametomib("arenas.lextent.0.size", mib, &miblen), 0,
|
|
"Unexpected mallctlnametomib failure");
|
|
for (i = 0; i < nlextents; i++) {
|
|
size_t lextent_size, extent_size, floor, ceil;
|
|
|
|
mib[2] = i;
|
|
sz = sizeof(size_t);
|
|
assert_d_eq(mallctlbymib(mib, miblen, (void *)&lextent_size,
|
|
&sz, NULL, 0), 0, "Unexpected mallctlbymib failure");
|
|
extent_size = cache_oblivious ? lextent_size + PAGE :
|
|
lextent_size;
|
|
floor = extent_size_quantize_floor(extent_size);
|
|
ceil = extent_size_quantize_ceil(extent_size);
|
|
|
|
assert_zu_eq(extent_size, floor,
|
|
"Extent quantization should be a no-op for precise size "
|
|
"(lextent_size=%zu, extent_size=%zu)", lextent_size,
|
|
extent_size);
|
|
assert_zu_eq(extent_size, ceil,
|
|
"Extent quantization should be a no-op for precise size "
|
|
"(lextent_size=%zu, extent_size=%zu)", lextent_size,
|
|
extent_size);
|
|
|
|
if (i > 0) {
|
|
assert_zu_eq(extent_size_prev,
|
|
extent_size_quantize_floor(extent_size - PAGE),
|
|
"Floor should be a precise size");
|
|
if (extent_size_prev < ceil_prev) {
|
|
assert_zu_eq(ceil_prev, extent_size,
|
|
"Ceiling should be a precise size "
|
|
"(extent_size_prev=%zu, ceil_prev=%zu, "
|
|
"extent_size=%zu)", extent_size_prev,
|
|
ceil_prev, extent_size);
|
|
}
|
|
}
|
|
if (i + 1 < nlextents) {
|
|
extent_size_prev = floor;
|
|
ceil_prev = extent_size_quantize_ceil(extent_size +
|
|
PAGE);
|
|
}
|
|
}
|
|
}
|
|
TEST_END
|
|
|
|
TEST_BEGIN(test_monotonic)
|
|
{
|
|
#define SZ_MAX ZU(4 * 1024 * 1024)
|
|
unsigned i;
|
|
size_t floor_prev, ceil_prev;
|
|
|
|
floor_prev = 0;
|
|
ceil_prev = 0;
|
|
for (i = 1; i <= SZ_MAX >> LG_PAGE; i++) {
|
|
size_t extent_size, floor, ceil;
|
|
|
|
extent_size = i << LG_PAGE;
|
|
floor = extent_size_quantize_floor(extent_size);
|
|
ceil = extent_size_quantize_ceil(extent_size);
|
|
|
|
assert_zu_le(floor, extent_size,
|
|
"Floor should be <= (floor=%zu, extent_size=%zu, ceil=%zu)",
|
|
floor, extent_size, ceil);
|
|
assert_zu_ge(ceil, extent_size,
|
|
"Ceiling should be >= (floor=%zu, extent_size=%zu, "
|
|
"ceil=%zu)", floor, extent_size, ceil);
|
|
|
|
assert_zu_le(floor_prev, floor, "Floor should be monotonic "
|
|
"(floor_prev=%zu, floor=%zu, extent_size=%zu, ceil=%zu)",
|
|
floor_prev, floor, extent_size, ceil);
|
|
assert_zu_le(ceil_prev, ceil, "Ceiling should be monotonic "
|
|
"(floor=%zu, extent_size=%zu, ceil_prev=%zu, ceil=%zu)",
|
|
floor, extent_size, ceil_prev, ceil);
|
|
|
|
floor_prev = floor;
|
|
ceil_prev = ceil;
|
|
}
|
|
}
|
|
TEST_END
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
|
|
return (test(
|
|
test_small_extent_size,
|
|
test_large_extent_size,
|
|
test_monotonic));
|
|
}
|