summaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/unit/decay.c192
-rw-r--r--test/unit/decay.sh2
-rw-r--r--test/unit/mallctl.c154
-rw-r--r--test/unit/pack.sh2
-rw-r--r--test/unit/stats.c36
5 files changed, 270 insertions, 116 deletions
diff --git a/test/unit/decay.c b/test/unit/decay.c
index eb4df9d..471a558 100644
--- a/test/unit/decay.c
+++ b/test/unit/decay.c
@@ -22,18 +22,28 @@ nstime_update_mock(nstime_t *time) {
}
static unsigned
-do_arena_create(ssize_t decay_time) {
+do_arena_create(ssize_t dirty_decay_time, ssize_t muzzy_decay_time) {
unsigned arena_ind;
size_t sz = sizeof(unsigned);
assert_d_eq(mallctl("arenas.create", (void *)&arena_ind, &sz, NULL, 0),
0, "Unexpected mallctl() failure");
size_t mib[3];
size_t miblen = sizeof(mib)/sizeof(size_t);
- assert_d_eq(mallctlnametomib("arena.0.decay_time", mib, &miblen), 0,
- "Unexpected mallctlnametomib() failure");
+
+ assert_d_eq(mallctlnametomib("arena.0.dirty_decay_time", mib, &miblen),
+ 0, "Unexpected mallctlnametomib() failure");
+ mib[1] = (size_t)arena_ind;
+ assert_d_eq(mallctlbymib(mib, miblen, NULL, NULL,
+ (void *)&dirty_decay_time,
+ sizeof(dirty_decay_time)), 0, "Unexpected mallctlbymib() failure");
+
+ assert_d_eq(mallctlnametomib("arena.0.muzzy_decay_time", mib, &miblen),
+ 0, "Unexpected mallctlnametomib() failure");
mib[1] = (size_t)arena_ind;
- assert_d_eq(mallctlbymib(mib, miblen, NULL, NULL, (void *)&decay_time,
- sizeof(decay_time)), 0, "Unexpected mallctlbymib() failure");
+ assert_d_eq(mallctlbymib(mib, miblen, NULL, NULL,
+ (void *)&muzzy_decay_time,
+ sizeof(muzzy_decay_time)), 0, "Unexpected mallctlbymib() failure");
+
return arena_ind;
}
@@ -78,11 +88,10 @@ do_decay(unsigned arena_ind) {
}
static uint64_t
-get_arena_npurge(unsigned arena_ind) {
- do_epoch();
+get_arena_npurge_impl(const char *mibname, unsigned arena_ind) {
size_t mib[4];
size_t miblen = sizeof(mib)/sizeof(size_t);
- assert_d_eq(mallctlnametomib("stats.arenas.0.npurge", mib, &miblen), 0,
+ assert_d_eq(mallctlnametomib(mibname, mib, &miblen), 0,
"Unexpected mallctlnametomib() failure");
mib[2] = (size_t)arena_ind;
uint64_t npurge = 0;
@@ -92,6 +101,25 @@ get_arena_npurge(unsigned arena_ind) {
return npurge;
}
+static uint64_t
+get_arena_dirty_npurge(unsigned arena_ind) {
+ do_epoch();
+ return get_arena_npurge_impl("stats.arenas.0.dirty_npurge", arena_ind);
+}
+
+static uint64_t
+get_arena_muzzy_npurge(unsigned arena_ind) {
+ do_epoch();
+ return get_arena_npurge_impl("stats.arenas.0.muzzy_npurge", arena_ind);
+}
+
+static uint64_t
+get_arena_npurge(unsigned arena_ind) {
+ do_epoch();
+ return get_arena_npurge_impl("stats.arenas.0.dirty_npurge", arena_ind) +
+ get_arena_npurge_impl("stats.arenas.0.muzzy_npurge", arena_ind);
+}
+
static size_t
get_arena_pdirty(unsigned arena_ind) {
do_epoch();
@@ -107,6 +135,21 @@ get_arena_pdirty(unsigned arena_ind) {
return pdirty;
}
+static size_t
+get_arena_pmuzzy(unsigned arena_ind) {
+ do_epoch();
+ size_t mib[4];
+ size_t miblen = sizeof(mib)/sizeof(size_t);
+ assert_d_eq(mallctlnametomib("stats.arenas.0.pmuzzy", mib, &miblen), 0,
+ "Unexpected mallctlnametomib() failure");
+ mib[2] = (size_t)arena_ind;
+ size_t pmuzzy;
+ size_t sz = sizeof(pmuzzy);
+ assert_d_eq(mallctlbymib(mib, miblen, (void *)&pmuzzy, &sz, NULL, 0), 0,
+ "Unexpected mallctlbymib() failure");
+ return pmuzzy;
+}
+
static void *
do_mallocx(size_t size, int flags) {
void *p = mallocx(size, flags);
@@ -133,7 +176,7 @@ TEST_BEGIN(test_decay_ticks) {
int err;
/* Set up a manually managed arena for test. */
- arena_ind = do_arena_create(0);
+ arena_ind = do_arena_create(0, 0);
/* Migrate to the new arena, and get the ticker. */
unsigned old_arena_ind;
@@ -317,19 +360,66 @@ TEST_BEGIN(test_decay_ticks) {
}
TEST_END
-TEST_BEGIN(test_decay_ticker) {
-#define NPS 1024
+static void
+decay_ticker_helper(unsigned arena_ind, int flags, bool dirty, ssize_t dt,
+ uint64_t dirty_npurge0, uint64_t muzzy_npurge0, bool terminate_asap) {
#define NINTERVALS 101
- ssize_t dt = opt_decay_time;
- unsigned arena_ind = do_arena_create(dt);
+ nstime_t time, update_interval, decay_time, deadline;
+
+ nstime_init(&time, 0);
+ nstime_update(&time);
+
+ nstime_init2(&decay_time, dt, 0);
+ nstime_copy(&deadline, &time);
+ nstime_add(&deadline, &decay_time);
+
+ nstime_init2(&update_interval, dt, 0);
+ nstime_idivide(&update_interval, NINTERVALS);
+
+ /*
+ * Keep q's slab from being deallocated during the looping below. If a
+ * cached slab were to repeatedly come and go during looping, it could
+ * prevent the decay backlog ever becoming empty.
+ */
+ void *p = do_mallocx(1, flags);
+ uint64_t dirty_npurge1, muzzy_npurge1;
+ do {
+ for (unsigned i = 0; i < DECAY_NTICKS_PER_UPDATE / 2;
+ i++) {
+ void *q = do_mallocx(1, flags);
+ dallocx(q, flags);
+ }
+ dirty_npurge1 = get_arena_dirty_npurge(arena_ind);
+ muzzy_npurge1 = get_arena_muzzy_npurge(arena_ind);
+
+ nstime_add(&time_mock, &update_interval);
+ nstime_update(&time);
+ } while (nstime_compare(&time, &deadline) <= 0 && ((dirty_npurge1 ==
+ dirty_npurge0 && muzzy_npurge1 == muzzy_npurge0) ||
+ !terminate_asap));
+ dallocx(p, flags);
+
+ if (config_stats) {
+ assert_u64_gt(dirty_npurge1 + muzzy_npurge1, dirty_npurge0 +
+ muzzy_npurge0, "Expected purging to occur");
+ }
+#undef NINTERVALS
+}
+
+TEST_BEGIN(test_decay_ticker) {
+#define NPS 2048
+ ssize_t ddt = opt_dirty_decay_time;
+ ssize_t mdt = opt_muzzy_decay_time;
+ unsigned arena_ind = do_arena_create(ddt, mdt);
int flags = (MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE);
void *ps[NPS];
size_t large;
/*
- * Allocate a bunch of large objects, pause the clock, deallocate the
- * objects, restore the clock, then [md]allocx() in a tight loop while
- * advancing time rapidly to verify the ticker triggers purging.
+ * Allocate a bunch of large objects, pause the clock, deallocate every
+ * other object (to fragment virtual memory), restore the clock, then
+ * [md]allocx() in a tight loop while advancing time rapidly to verify
+ * the ticker triggers purging.
*/
if (config_tcache) {
@@ -346,7 +436,8 @@ TEST_BEGIN(test_decay_ticker) {
}
do_purge(arena_ind);
- uint64_t npurge0 = get_arena_npurge(arena_ind);
+ uint64_t dirty_npurge0 = get_arena_dirty_npurge(arena_ind);
+ uint64_t muzzy_npurge0 = get_arena_muzzy_npurge(arena_ind);
for (unsigned i = 0; i < NPS; i++) {
ps[i] = do_mallocx(large, flags);
@@ -362,7 +453,7 @@ TEST_BEGIN(test_decay_ticker) {
nstime_monotonic = nstime_monotonic_mock;
nstime_update = nstime_update_mock;
- for (unsigned i = 0; i < NPS; i++) {
+ for (unsigned i = 0; i < NPS; i += 2) {
dallocx(ps[i], flags);
unsigned nupdates0 = nupdates_mock;
do_decay(arena_ind);
@@ -370,51 +461,16 @@ TEST_BEGIN(test_decay_ticker) {
"Expected nstime_update() to be called");
}
- nstime_t time, update_interval, decay_time, deadline;
-
- nstime_init(&time, 0);
- nstime_update(&time);
-
- nstime_init2(&decay_time, dt, 0);
- nstime_copy(&deadline, &time);
- nstime_add(&deadline, &decay_time);
-
- nstime_init2(&update_interval, dt, 0);
- nstime_idivide(&update_interval, NINTERVALS);
-
- nstime_init2(&decay_time, dt, 0);
- nstime_copy(&deadline, &time);
- nstime_add(&deadline, &decay_time);
-
- /*
- * Keep q's slab from being deallocated during the looping below. If
- * a cached slab were to repeatedly come and go during looping, it could
- * prevent the decay backlog ever becoming empty.
- */
- void *p = do_mallocx(1, flags);
- uint64_t npurge1;
- do {
- for (unsigned i = 0; i < DECAY_NTICKS_PER_UPDATE / 2; i++) {
- void *q = do_mallocx(1, flags);
- dallocx(q, flags);
- }
- npurge1 = get_arena_npurge(arena_ind);
+ decay_ticker_helper(arena_ind, flags, true, ddt, dirty_npurge0,
+ muzzy_npurge0, true);
+ decay_ticker_helper(arena_ind, flags, false, ddt+mdt, dirty_npurge0,
+ muzzy_npurge0, false);
- nstime_add(&time_mock, &update_interval);
- nstime_update(&time);
- } while (nstime_compare(&time, &deadline) <= 0 && npurge1 == npurge0);
- dallocx(p, flags);
+ do_arena_destroy(arena_ind);
nstime_monotonic = nstime_monotonic_orig;
nstime_update = nstime_update_orig;
-
- if (config_stats) {
- assert_u64_gt(npurge1, npurge0, "Expected purging to occur");
- }
-
- do_arena_destroy(arena_ind);
#undef NPS
-#undef NINTERVALS
}
TEST_END
@@ -435,8 +491,7 @@ TEST_BEGIN(test_decay_nonmonotonic) {
"Unexpected mallctl failure");
do_epoch();
sz = sizeof(uint64_t);
- assert_d_eq(mallctl("stats.arenas.0.npurge", (void *)&npurge0, &sz,
- NULL, 0), config_stats ? 0 : ENOENT, "Unexpected mallctl result");
+ npurge0 = get_arena_npurge(0);
nupdates_mock = 0;
nstime_init(&time_mock, 0);
@@ -464,8 +519,7 @@ TEST_BEGIN(test_decay_nonmonotonic) {
do_epoch();
sz = sizeof(uint64_t);
- assert_d_eq(mallctl("stats.arenas.0.npurge", (void *)&npurge1, &sz,
- NULL, 0), config_stats ? 0 : ENOENT, "Unexpected mallctl result");
+ npurge1 = get_arena_npurge(0);
if (config_stats) {
assert_u64_eq(npurge0, npurge1, "Unexpected purging occurred");
@@ -478,24 +532,28 @@ TEST_BEGIN(test_decay_nonmonotonic) {
TEST_END
TEST_BEGIN(test_decay_now) {
- unsigned arena_ind = do_arena_create(0);
+ unsigned arena_ind = do_arena_create(0, 0);
assert_zu_eq(get_arena_pdirty(arena_ind), 0, "Unexpected dirty pages");
+ assert_zu_eq(get_arena_pmuzzy(arena_ind), 0, "Unexpected muzzy pages");
size_t sizes[] = {16, PAGE<<2, HUGEPAGE<<2};
- /* Verify that dirty pages never linger after deallocation. */
+ /* Verify that dirty/muzzy pages never linger after deallocation. */
for (unsigned i = 0; i < sizeof(sizes)/sizeof(size_t); i++) {
size_t size = sizes[i];
generate_dirty(arena_ind, size);
assert_zu_eq(get_arena_pdirty(arena_ind), 0,
"Unexpected dirty pages");
+ assert_zu_eq(get_arena_pmuzzy(arena_ind), 0,
+ "Unexpected muzzy pages");
}
do_arena_destroy(arena_ind);
}
TEST_END
TEST_BEGIN(test_decay_never) {
- unsigned arena_ind = do_arena_create(-1);
+ unsigned arena_ind = do_arena_create(-1, -1);
int flags = MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE;
assert_zu_eq(get_arena_pdirty(arena_ind), 0, "Unexpected dirty pages");
+ assert_zu_eq(get_arena_pmuzzy(arena_ind), 0, "Unexpected muzzy pages");
size_t sizes[] = {16, PAGE<<2, HUGEPAGE<<2};
void *ptrs[sizeof(sizes)/sizeof(size_t)];
for (unsigned i = 0; i < sizeof(sizes)/sizeof(size_t); i++) {
@@ -503,12 +561,16 @@ TEST_BEGIN(test_decay_never) {
}
/* Verify that each deallocation generates additional dirty pages. */
size_t pdirty_prev = get_arena_pdirty(arena_ind);
+ size_t pmuzzy_prev = get_arena_pmuzzy(arena_ind);
assert_zu_eq(pdirty_prev, 0, "Unexpected dirty pages");
+ assert_zu_eq(pmuzzy_prev, 0, "Unexpected muzzy pages");
for (unsigned i = 0; i < sizeof(sizes)/sizeof(size_t); i++) {
dallocx(ptrs[i], flags);
size_t pdirty = get_arena_pdirty(arena_ind);
+ size_t pmuzzy = get_arena_pmuzzy(arena_ind);
assert_zu_gt(pdirty, pdirty_prev,
"Expected dirty pages to increase.");
+ assert_zu_eq(pmuzzy, 0, "Unexpected muzzy pages");
pdirty_prev = pdirty;
}
do_arena_destroy(arena_ind);
diff --git a/test/unit/decay.sh b/test/unit/decay.sh
index 284af81..0df1788 100644
--- a/test/unit/decay.sh
+++ b/test/unit/decay.sh
@@ -1,6 +1,6 @@
#!/bin/sh
-export MALLOC_CONF="decay_time:1"
+export MALLOC_CONF="dirty_decay_time:1,muzzy_decay_time:1"
if [ "x${enable_tcache}" = "x1" ] ; then
export MALLOC_CONF="${MALLOC_CONF},lg_tcache_max:0"
fi
diff --git a/test/unit/mallctl.c b/test/unit/mallctl.c
index 1aedbe8..4241063 100644
--- a/test/unit/mallctl.c
+++ b/test/unit/mallctl.c
@@ -161,7 +161,8 @@ TEST_BEGIN(test_mallctl_opt) {
TEST_MALLCTL_OPT(const char *, dss, always);
TEST_MALLCTL_OPT(unsigned, narenas, always);
TEST_MALLCTL_OPT(const char *, percpu_arena, always);
- TEST_MALLCTL_OPT(ssize_t, decay_time, always);
+ TEST_MALLCTL_OPT(ssize_t, dirty_decay_time, always);
+ TEST_MALLCTL_OPT(ssize_t, muzzy_decay_time, always);
TEST_MALLCTL_OPT(bool, stats_print, always);
TEST_MALLCTL_OPT(const char *, junk, fill);
TEST_MALLCTL_OPT(bool, zero, fill);
@@ -401,32 +402,68 @@ TEST_BEGIN(test_arena_i_initialized) {
}
TEST_END
-TEST_BEGIN(test_arena_i_decay_time) {
- ssize_t decay_time, orig_decay_time, prev_decay_time;
+TEST_BEGIN(test_arena_i_dirty_decay_time) {
+ ssize_t dirty_decay_time, orig_dirty_decay_time, prev_dirty_decay_time;
size_t sz = sizeof(ssize_t);
- assert_d_eq(mallctl("arena.0.decay_time", (void *)&orig_decay_time, &sz,
- NULL, 0), 0, "Unexpected mallctl() failure");
+ assert_d_eq(mallctl("arena.0.dirty_decay_time",
+ (void *)&orig_dirty_decay_time, &sz, NULL, 0), 0,
+ "Unexpected mallctl() failure");
- decay_time = -2;
- assert_d_eq(mallctl("arena.0.decay_time", NULL, NULL,
- (void *)&decay_time, sizeof(ssize_t)), EFAULT,
+ dirty_decay_time = -2;
+ assert_d_eq(mallctl("arena.0.dirty_decay_time", NULL, NULL,
+ (void *)&dirty_decay_time, sizeof(ssize_t)), EFAULT,
"Unexpected mallctl() success");
- decay_time = 0x7fffffff;
- assert_d_eq(mallctl("arena.0.decay_time", NULL, NULL,
- (void *)&decay_time, sizeof(ssize_t)), 0,
+ dirty_decay_time = 0x7fffffff;
+ assert_d_eq(mallctl("arena.0.dirty_decay_time", NULL, NULL,
+ (void *)&dirty_decay_time, sizeof(ssize_t)), 0,
"Unexpected mallctl() failure");
- for (prev_decay_time = decay_time, decay_time = -1;
- decay_time < 20; prev_decay_time = decay_time, decay_time++) {
- ssize_t old_decay_time;
+ for (prev_dirty_decay_time = dirty_decay_time, dirty_decay_time = -1;
+ dirty_decay_time < 20; prev_dirty_decay_time = dirty_decay_time,
+ dirty_decay_time++) {
+ ssize_t old_dirty_decay_time;
- assert_d_eq(mallctl("arena.0.decay_time", (void *)&old_decay_time,
- &sz, (void *)&decay_time, sizeof(ssize_t)), 0,
+ assert_d_eq(mallctl("arena.0.dirty_decay_time",
+ (void *)&old_dirty_decay_time, &sz,
+ (void *)&dirty_decay_time, sizeof(ssize_t)), 0,
"Unexpected mallctl() failure");
- assert_zd_eq(old_decay_time, prev_decay_time,
- "Unexpected old arena.0.decay_time");
+ assert_zd_eq(old_dirty_decay_time, prev_dirty_decay_time,
+ "Unexpected old arena.0.dirty_decay_time");
+ }
+}
+TEST_END
+
+TEST_BEGIN(test_arena_i_muzzy_decay_time) {
+ ssize_t muzzy_decay_time, orig_muzzy_decay_time, prev_muzzy_decay_time;
+ size_t sz = sizeof(ssize_t);
+
+ assert_d_eq(mallctl("arena.0.muzzy_decay_time",
+ (void *)&orig_muzzy_decay_time, &sz, NULL, 0), 0,
+ "Unexpected mallctl() failure");
+
+ muzzy_decay_time = -2;
+ assert_d_eq(mallctl("arena.0.muzzy_decay_time", NULL, NULL,
+ (void *)&muzzy_decay_time, sizeof(ssize_t)), EFAULT,
+ "Unexpected mallctl() success");
+
+ muzzy_decay_time = 0x7fffffff;
+ assert_d_eq(mallctl("arena.0.muzzy_decay_time", NULL, NULL,
+ (void *)&muzzy_decay_time, sizeof(ssize_t)), 0,
+ "Unexpected mallctl() failure");
+
+ for (prev_muzzy_decay_time = muzzy_decay_time, muzzy_decay_time = -1;
+ muzzy_decay_time < 20; prev_muzzy_decay_time = muzzy_decay_time,
+ muzzy_decay_time++) {
+ ssize_t old_muzzy_decay_time;
+
+ assert_d_eq(mallctl("arena.0.muzzy_decay_time",
+ (void *)&old_muzzy_decay_time, &sz,
+ (void *)&muzzy_decay_time, sizeof(ssize_t)), 0,
+ "Unexpected mallctl() failure");
+ assert_zd_eq(old_muzzy_decay_time, prev_muzzy_decay_time,
+ "Unexpected old arena.0.muzzy_decay_time");
}
}
TEST_END
@@ -522,32 +559,68 @@ TEST_BEGIN(test_arena_i_dss) {
}
TEST_END
-TEST_BEGIN(test_arenas_decay_time) {
- ssize_t decay_time, orig_decay_time, prev_decay_time;
+TEST_BEGIN(test_arenas_dirty_decay_time) {
+ ssize_t dirty_decay_time, orig_dirty_decay_time, prev_dirty_decay_time;
size_t sz = sizeof(ssize_t);
- assert_d_eq(mallctl("arenas.decay_time", (void *)&orig_decay_time, &sz,
- NULL, 0), 0, "Unexpected mallctl() failure");
+ assert_d_eq(mallctl("arenas.dirty_decay_time",
+ (void *)&orig_dirty_decay_time, &sz, NULL, 0), 0,
+ "Unexpected mallctl() failure");
+
+ dirty_decay_time = -2;
+ assert_d_eq(mallctl("arenas.dirty_decay_time", NULL, NULL,
+ (void *)&dirty_decay_time, sizeof(ssize_t)), EFAULT,
+ "Unexpected mallctl() success");
+
+ dirty_decay_time = 0x7fffffff;
+ assert_d_eq(mallctl("arenas.dirty_decay_time", NULL, NULL,
+ (void *)&dirty_decay_time, sizeof(ssize_t)), 0,
+ "Expected mallctl() failure");
+
+ for (prev_dirty_decay_time = dirty_decay_time, dirty_decay_time = -1;
+ dirty_decay_time < 20; prev_dirty_decay_time = dirty_decay_time,
+ dirty_decay_time++) {
+ ssize_t old_dirty_decay_time;
+
+ assert_d_eq(mallctl("arenas.dirty_decay_time",
+ (void *)&old_dirty_decay_time, &sz,
+ (void *)&dirty_decay_time, sizeof(ssize_t)), 0,
+ "Unexpected mallctl() failure");
+ assert_zd_eq(old_dirty_decay_time, prev_dirty_decay_time,
+ "Unexpected old arenas.dirty_decay_time");
+ }
+}
+TEST_END
+
+TEST_BEGIN(test_arenas_muzzy_decay_time) {
+ ssize_t muzzy_decay_time, orig_muzzy_decay_time, prev_muzzy_decay_time;
+ size_t sz = sizeof(ssize_t);
+
+ assert_d_eq(mallctl("arenas.muzzy_decay_time",
+ (void *)&orig_muzzy_decay_time, &sz, NULL, 0), 0,
+ "Unexpected mallctl() failure");
- decay_time = -2;
- assert_d_eq(mallctl("arenas.decay_time", NULL, NULL,
- (void *)&decay_time, sizeof(ssize_t)), EFAULT,
+ muzzy_decay_time = -2;
+ assert_d_eq(mallctl("arenas.muzzy_decay_time", NULL, NULL,
+ (void *)&muzzy_decay_time, sizeof(ssize_t)), EFAULT,
"Unexpected mallctl() success");
- decay_time = 0x7fffffff;
- assert_d_eq(mallctl("arenas.decay_time", NULL, NULL,
- (void *)&decay_time, sizeof(ssize_t)), 0,
+ muzzy_decay_time = 0x7fffffff;
+ assert_d_eq(mallctl("arenas.muzzy_decay_time", NULL, NULL,
+ (void *)&muzzy_decay_time, sizeof(ssize_t)), 0,
"Expected mallctl() failure");
- for (prev_decay_time = decay_time, decay_time = -1;
- decay_time < 20; prev_decay_time = decay_time, decay_time++) {
- ssize_t old_decay_time;
+ for (prev_muzzy_decay_time = muzzy_decay_time, muzzy_decay_time = -1;
+ muzzy_decay_time < 20; prev_muzzy_decay_time = muzzy_decay_time,
+ muzzy_decay_time++) {
+ ssize_t old_muzzy_decay_time;
- assert_d_eq(mallctl("arenas.decay_time",
- (void *)&old_decay_time, &sz, (void *)&decay_time,
- sizeof(ssize_t)), 0, "Unexpected mallctl() failure");
- assert_zd_eq(old_decay_time, prev_decay_time,
- "Unexpected old arenas.decay_time");
+ assert_d_eq(mallctl("arenas.muzzy_decay_time",
+ (void *)&old_muzzy_decay_time, &sz,
+ (void *)&muzzy_decay_time, sizeof(ssize_t)), 0,
+ "Unexpected mallctl() failure");
+ assert_zd_eq(old_muzzy_decay_time, prev_muzzy_decay_time,
+ "Unexpected old arenas.muzzy_decay_time");
}
}
TEST_END
@@ -630,7 +703,8 @@ TEST_BEGIN(test_stats_arenas) {
TEST_STATS_ARENAS(unsigned, nthreads);
TEST_STATS_ARENAS(const char *, dss);
- TEST_STATS_ARENAS(ssize_t, decay_time);
+ TEST_STATS_ARENAS(ssize_t, dirty_decay_time);
+ TEST_STATS_ARENAS(ssize_t, muzzy_decay_time);
TEST_STATS_ARENAS(size_t, pactive);
TEST_STATS_ARENAS(size_t, pdirty);
@@ -653,11 +727,13 @@ main(void) {
test_tcache,
test_thread_arena,
test_arena_i_initialized,
- test_arena_i_decay_time,
+ test_arena_i_dirty_decay_time,
+ test_arena_i_muzzy_decay_time,
test_arena_i_purge,
test_arena_i_decay,
test_arena_i_dss,
- test_arenas_decay_time,
+ test_arenas_dirty_decay_time,
+ test_arenas_muzzy_decay_time,
test_arenas_constants,
test_arenas_bin_constants,
test_arenas_lextent_constants,
diff --git a/test/unit/pack.sh b/test/unit/pack.sh
index de12e55..76757ac 100644
--- a/test/unit/pack.sh
+++ b/test/unit/pack.sh
@@ -1,4 +1,4 @@
#!/bin/sh
# Immediately purge to minimize fragmentation.
-export MALLOC_CONF="decay_time:-1"
+export MALLOC_CONF="dirty_decay_time:0,muzzy_decay_time:0"
diff --git a/test/unit/stats.c b/test/unit/stats.c
index c458d3f..f8c6b10 100644
--- a/test/unit/stats.c
+++ b/test/unit/stats.c
@@ -71,7 +71,8 @@ TEST_BEGIN(test_stats_arenas_summary) {
size_t sz;
int expected = config_stats ? 0 : ENOENT;
size_t mapped;
- uint64_t npurge, nmadvise, purged;
+ uint64_t dirty_npurge, dirty_nmadvise, dirty_purged;
+ uint64_t muzzy_npurge, muzzy_nmadvise, muzzy_purged;
little = mallocx(SMALL_MAXCLASS, MALLOCX_ARENA(0));
assert_ptr_not_null(little, "Unexpected mallocx() failure");
@@ -92,19 +93,34 @@ TEST_BEGIN(test_stats_arenas_summary) {
sz = sizeof(size_t);
assert_d_eq(mallctl("stats.arenas.0.mapped", (void *)&mapped, &sz, NULL,
0), expected, "Unexepected mallctl() result");
+
sz = sizeof(uint64_t);
- assert_d_eq(mallctl("stats.arenas.0.npurge", (void *)&npurge, &sz, NULL,
- 0), expected, "Unexepected mallctl() result");
- assert_d_eq(mallctl("stats.arenas.0.nmadvise", (void *)&nmadvise, &sz,
- NULL, 0), expected, "Unexepected mallctl() result");
- assert_d_eq(mallctl("stats.arenas.0.purged", (void *)&purged, &sz, NULL,
- 0), expected, "Unexepected mallctl() result");
+ assert_d_eq(mallctl("stats.arenas.0.dirty_npurge",
+ (void *)&dirty_npurge, &sz, NULL, 0), expected,
+ "Unexepected mallctl() result");
+ assert_d_eq(mallctl("stats.arenas.0.dirty_nmadvise",
+ (void *)&dirty_nmadvise, &sz, NULL, 0), expected,
+ "Unexepected mallctl() result");
+ assert_d_eq(mallctl("stats.arenas.0.dirty_purged",
+ (void *)&dirty_purged, &sz, NULL, 0), expected,
+ "Unexepected mallctl() result");
+ assert_d_eq(mallctl("stats.arenas.0.muzzy_npurge",
+ (void *)&muzzy_npurge, &sz, NULL, 0), expected,
+ "Unexepected mallctl() result");
+ assert_d_eq(mallctl("stats.arenas.0.muzzy_nmadvise",
+ (void *)&muzzy_nmadvise, &sz, NULL, 0), expected,
+ "Unexepected mallctl() result");
+ assert_d_eq(mallctl("stats.arenas.0.muzzy_purged",
+ (void *)&muzzy_purged, &sz, NULL, 0), expected,
+ "Unexepected mallctl() result");
if (config_stats) {
- assert_u64_gt(npurge, 0,
+ assert_u64_gt(dirty_npurge + muzzy_npurge, 0,
"At least one purge should have occurred");
- assert_u64_le(nmadvise, purged,
- "nmadvise should be no greater than purged");
+ assert_u64_le(dirty_nmadvise, dirty_purged,
+ "dirty_nmadvise should be no greater than dirty_purged");
+ assert_u64_le(muzzy_nmadvise, muzzy_purged,
+ "muzzy_nmadvise should be no greater than muzzy_purged");
}
}
TEST_END