mirror of
https://github.com/jemalloc/jemalloc.git
synced 2026-07-23 21:23:06 +00:00
Extents: Split out introspection functionality.
This isn't really part of the core extent allocation facilities. Especially as this module grows, having it in its own place may come in handy.
This commit is contained in:
David Goldblatt
committed by
David Goldblatt
David Goldblatt
parent
92a511d385
commit
403f2d1664
267
test/unit/inspect.c
Normal file
267
test/unit/inspect.c
Normal file
@@ -0,0 +1,267 @@
|
||||
#include "test/jemalloc_test.h"
|
||||
|
||||
#define TEST_UTIL_EINVAL(node, a, b, c, d, why_inval) do { \
|
||||
assert_d_eq(mallctl("experimental.utilization." node, \
|
||||
a, b, c, d), EINVAL, "Should fail when " why_inval); \
|
||||
assert_zu_eq(out_sz, out_sz_ref, \
|
||||
"Output size touched when given invalid arguments"); \
|
||||
assert_d_eq(memcmp(out, out_ref, out_sz_ref), 0, \
|
||||
"Output content touched when given invalid arguments"); \
|
||||
} while (0)
|
||||
|
||||
#define TEST_UTIL_QUERY_EINVAL(a, b, c, d, why_inval) \
|
||||
TEST_UTIL_EINVAL("query", a, b, c, d, why_inval)
|
||||
#define TEST_UTIL_BATCH_EINVAL(a, b, c, d, why_inval) \
|
||||
TEST_UTIL_EINVAL("batch_query", a, b, c, d, why_inval)
|
||||
|
||||
#define TEST_UTIL_VALID(node) do { \
|
||||
assert_d_eq(mallctl("experimental.utilization." node, \
|
||||
out, &out_sz, in, in_sz), 0, \
|
||||
"Should return 0 on correct arguments"); \
|
||||
assert_zu_eq(out_sz, out_sz_ref, "incorrect output size"); \
|
||||
assert_d_ne(memcmp(out, out_ref, out_sz_ref), 0, \
|
||||
"Output content should be changed"); \
|
||||
} while (0)
|
||||
|
||||
#define TEST_UTIL_BATCH_VALID TEST_UTIL_VALID("batch_query")
|
||||
|
||||
#define TEST_MAX_SIZE (1 << 20)
|
||||
|
||||
TEST_BEGIN(test_query) {
|
||||
size_t sz;
|
||||
/*
|
||||
* Select some sizes that can span both small and large sizes, and are
|
||||
* numerically unrelated to any size boundaries.
|
||||
*/
|
||||
for (sz = 7; sz <= TEST_MAX_SIZE && sz <= SC_LARGE_MAXCLASS;
|
||||
sz += (sz <= SC_SMALL_MAXCLASS ? 1009 : 99989)) {
|
||||
void *p = mallocx(sz, 0);
|
||||
void **in = &p;
|
||||
size_t in_sz = sizeof(const void *);
|
||||
size_t out_sz = sizeof(void *) + sizeof(size_t) * 5;
|
||||
void *out = mallocx(out_sz, 0);
|
||||
void *out_ref = mallocx(out_sz, 0);
|
||||
size_t out_sz_ref = out_sz;
|
||||
|
||||
assert_ptr_not_null(p,
|
||||
"test pointer allocation failed");
|
||||
assert_ptr_not_null(out,
|
||||
"test output allocation failed");
|
||||
assert_ptr_not_null(out_ref,
|
||||
"test reference output allocation failed");
|
||||
|
||||
#define SLABCUR_READ(out) (*(void **)out)
|
||||
#define COUNTS(out) ((size_t *)((void **)out + 1))
|
||||
#define NFREE_READ(out) COUNTS(out)[0]
|
||||
#define NREGS_READ(out) COUNTS(out)[1]
|
||||
#define SIZE_READ(out) COUNTS(out)[2]
|
||||
#define BIN_NFREE_READ(out) COUNTS(out)[3]
|
||||
#define BIN_NREGS_READ(out) COUNTS(out)[4]
|
||||
|
||||
SLABCUR_READ(out) = NULL;
|
||||
NFREE_READ(out) = NREGS_READ(out) = SIZE_READ(out) = -1;
|
||||
BIN_NFREE_READ(out) = BIN_NREGS_READ(out) = -1;
|
||||
memcpy(out_ref, out, out_sz);
|
||||
|
||||
/* Test invalid argument(s) errors */
|
||||
TEST_UTIL_QUERY_EINVAL(NULL, &out_sz, in, in_sz,
|
||||
"old is NULL");
|
||||
TEST_UTIL_QUERY_EINVAL(out, NULL, in, in_sz,
|
||||
"oldlenp is NULL");
|
||||
TEST_UTIL_QUERY_EINVAL(out, &out_sz, NULL, in_sz,
|
||||
"newp is NULL");
|
||||
TEST_UTIL_QUERY_EINVAL(out, &out_sz, in, 0,
|
||||
"newlen is zero");
|
||||
in_sz -= 1;
|
||||
TEST_UTIL_QUERY_EINVAL(out, &out_sz, in, in_sz,
|
||||
"invalid newlen");
|
||||
in_sz += 1;
|
||||
out_sz_ref = out_sz -= 2 * sizeof(size_t);
|
||||
TEST_UTIL_QUERY_EINVAL(out, &out_sz, in, in_sz,
|
||||
"invalid *oldlenp");
|
||||
out_sz_ref = out_sz += 2 * sizeof(size_t);
|
||||
|
||||
/* Examine output for valid call */
|
||||
TEST_UTIL_VALID("query");
|
||||
assert_zu_le(sz, SIZE_READ(out),
|
||||
"Extent size should be at least allocation size");
|
||||
assert_zu_eq(SIZE_READ(out) & (PAGE - 1), 0,
|
||||
"Extent size should be a multiple of page size");
|
||||
if (sz <= SC_SMALL_MAXCLASS) {
|
||||
assert_zu_le(NFREE_READ(out), NREGS_READ(out),
|
||||
"Extent free count exceeded region count");
|
||||
assert_zu_le(NREGS_READ(out), SIZE_READ(out),
|
||||
"Extent region count exceeded size");
|
||||
assert_zu_ne(NREGS_READ(out), 0,
|
||||
"Extent region count must be positive");
|
||||
assert_true(NFREE_READ(out) == 0 || (SLABCUR_READ(out)
|
||||
!= NULL && SLABCUR_READ(out) <= p),
|
||||
"Allocation should follow first fit principle");
|
||||
if (config_stats) {
|
||||
assert_zu_le(BIN_NFREE_READ(out),
|
||||
BIN_NREGS_READ(out),
|
||||
"Bin free count exceeded region count");
|
||||
assert_zu_ne(BIN_NREGS_READ(out), 0,
|
||||
"Bin region count must be positive");
|
||||
assert_zu_le(NFREE_READ(out),
|
||||
BIN_NFREE_READ(out),
|
||||
"Extent free count exceeded bin free count");
|
||||
assert_zu_le(NREGS_READ(out),
|
||||
BIN_NREGS_READ(out),
|
||||
"Extent region count exceeded "
|
||||
"bin region count");
|
||||
assert_zu_eq(BIN_NREGS_READ(out)
|
||||
% NREGS_READ(out), 0,
|
||||
"Bin region count isn't a multiple of "
|
||||
"extent region count");
|
||||
assert_zu_le(
|
||||
BIN_NFREE_READ(out) - NFREE_READ(out),
|
||||
BIN_NREGS_READ(out) - NREGS_READ(out),
|
||||
"Free count in other extents in the bin "
|
||||
"exceeded region count in other extents "
|
||||
"in the bin");
|
||||
assert_zu_le(NREGS_READ(out) - NFREE_READ(out),
|
||||
BIN_NREGS_READ(out) - BIN_NFREE_READ(out),
|
||||
"Extent utilized count exceeded "
|
||||
"bin utilized count");
|
||||
}
|
||||
} else {
|
||||
assert_zu_eq(NFREE_READ(out), 0,
|
||||
"Extent free count should be zero");
|
||||
assert_zu_eq(NREGS_READ(out), 1,
|
||||
"Extent region count should be one");
|
||||
assert_ptr_null(SLABCUR_READ(out),
|
||||
"Current slab must be null for large size classes");
|
||||
if (config_stats) {
|
||||
assert_zu_eq(BIN_NFREE_READ(out), 0,
|
||||
"Bin free count must be zero for "
|
||||
"large sizes");
|
||||
assert_zu_eq(BIN_NREGS_READ(out), 0,
|
||||
"Bin region count must be zero for "
|
||||
"large sizes");
|
||||
}
|
||||
}
|
||||
|
||||
#undef BIN_NREGS_READ
|
||||
#undef BIN_NFREE_READ
|
||||
#undef SIZE_READ
|
||||
#undef NREGS_READ
|
||||
#undef NFREE_READ
|
||||
#undef COUNTS
|
||||
#undef SLABCUR_READ
|
||||
|
||||
free(out_ref);
|
||||
free(out);
|
||||
free(p);
|
||||
}
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_batch) {
|
||||
size_t sz;
|
||||
/*
|
||||
* Select some sizes that can span both small and large sizes, and are
|
||||
* numerically unrelated to any size boundaries.
|
||||
*/
|
||||
for (sz = 17; sz <= TEST_MAX_SIZE && sz <= SC_LARGE_MAXCLASS;
|
||||
sz += (sz <= SC_SMALL_MAXCLASS ? 1019 : 99991)) {
|
||||
void *p = mallocx(sz, 0);
|
||||
void *q = mallocx(sz, 0);
|
||||
void *in[] = {p, q};
|
||||
size_t in_sz = sizeof(const void *) * 2;
|
||||
size_t out[] = {-1, -1, -1, -1, -1, -1};
|
||||
size_t out_sz = sizeof(size_t) * 6;
|
||||
size_t out_ref[] = {-1, -1, -1, -1, -1, -1};
|
||||
size_t out_sz_ref = out_sz;
|
||||
|
||||
assert_ptr_not_null(p, "test pointer allocation failed");
|
||||
assert_ptr_not_null(q, "test pointer allocation failed");
|
||||
|
||||
/* Test invalid argument(s) errors */
|
||||
TEST_UTIL_BATCH_EINVAL(NULL, &out_sz, in, in_sz,
|
||||
"old is NULL");
|
||||
TEST_UTIL_BATCH_EINVAL(out, NULL, in, in_sz,
|
||||
"oldlenp is NULL");
|
||||
TEST_UTIL_BATCH_EINVAL(out, &out_sz, NULL, in_sz,
|
||||
"newp is NULL");
|
||||
TEST_UTIL_BATCH_EINVAL(out, &out_sz, in, 0,
|
||||
"newlen is zero");
|
||||
in_sz -= 1;
|
||||
TEST_UTIL_BATCH_EINVAL(out, &out_sz, in, in_sz,
|
||||
"newlen is not an exact multiple");
|
||||
in_sz += 1;
|
||||
out_sz_ref = out_sz -= 2 * sizeof(size_t);
|
||||
TEST_UTIL_BATCH_EINVAL(out, &out_sz, in, in_sz,
|
||||
"*oldlenp is not an exact multiple");
|
||||
out_sz_ref = out_sz += 2 * sizeof(size_t);
|
||||
in_sz -= sizeof(const void *);
|
||||
TEST_UTIL_BATCH_EINVAL(out, &out_sz, in, in_sz,
|
||||
"*oldlenp and newlen do not match");
|
||||
in_sz += sizeof(const void *);
|
||||
|
||||
/* Examine output for valid calls */
|
||||
#define TEST_EQUAL_REF(i, message) \
|
||||
assert_d_eq(memcmp(out + (i) * 3, out_ref + (i) * 3, 3), 0, message)
|
||||
|
||||
#define NFREE_READ(out, i) out[(i) * 3]
|
||||
#define NREGS_READ(out, i) out[(i) * 3 + 1]
|
||||
#define SIZE_READ(out, i) out[(i) * 3 + 2]
|
||||
|
||||
out_sz_ref = out_sz /= 2;
|
||||
in_sz /= 2;
|
||||
TEST_UTIL_BATCH_VALID;
|
||||
assert_zu_le(sz, SIZE_READ(out, 0),
|
||||
"Extent size should be at least allocation size");
|
||||
assert_zu_eq(SIZE_READ(out, 0) & (PAGE - 1), 0,
|
||||
"Extent size should be a multiple of page size");
|
||||
if (sz <= SC_SMALL_MAXCLASS) {
|
||||
assert_zu_le(NFREE_READ(out, 0), NREGS_READ(out, 0),
|
||||
"Extent free count exceeded region count");
|
||||
assert_zu_le(NREGS_READ(out, 0), SIZE_READ(out, 0),
|
||||
"Extent region count exceeded size");
|
||||
assert_zu_ne(NREGS_READ(out, 0), 0,
|
||||
"Extent region count must be positive");
|
||||
} else {
|
||||
assert_zu_eq(NFREE_READ(out, 0), 0,
|
||||
"Extent free count should be zero");
|
||||
assert_zu_eq(NREGS_READ(out, 0), 1,
|
||||
"Extent region count should be one");
|
||||
}
|
||||
TEST_EQUAL_REF(1,
|
||||
"Should not overwrite content beyond what's needed");
|
||||
in_sz *= 2;
|
||||
out_sz_ref = out_sz *= 2;
|
||||
|
||||
memcpy(out_ref, out, 3 * sizeof(size_t));
|
||||
TEST_UTIL_BATCH_VALID;
|
||||
TEST_EQUAL_REF(0, "Statistics should be stable across calls");
|
||||
if (sz <= SC_SMALL_MAXCLASS) {
|
||||
assert_zu_le(NFREE_READ(out, 1), NREGS_READ(out, 1),
|
||||
"Extent free count exceeded region count");
|
||||
} else {
|
||||
assert_zu_eq(NFREE_READ(out, 0), 0,
|
||||
"Extent free count should be zero");
|
||||
}
|
||||
assert_zu_eq(NREGS_READ(out, 0), NREGS_READ(out, 1),
|
||||
"Extent region count should be same for same region size");
|
||||
assert_zu_eq(SIZE_READ(out, 0), SIZE_READ(out, 1),
|
||||
"Extent size should be same for same region size");
|
||||
|
||||
#undef SIZE_READ
|
||||
#undef NREGS_READ
|
||||
#undef NFREE_READ
|
||||
|
||||
#undef TEST_EQUAL_REF
|
||||
|
||||
free(q);
|
||||
free(p);
|
||||
}
|
||||
}
|
||||
TEST_END
|
||||
|
||||
int
|
||||
main(void) {
|
||||
assert_zu_lt(SC_SMALL_MAXCLASS, TEST_MAX_SIZE,
|
||||
"Test case cannot cover large classes");
|
||||
return test(test_query, test_batch);
|
||||
}
|
||||
Reference in New Issue
Block a user