Implement two-phase decay-based purging.

Split decay-based purging into two phases, the first of which uses lazy
purging to convert dirty pages to "muzzy", and the second of which uses
forced purging, decommit, or unmapping to convert pages to clean or
destroy them altogether.  Not all operating systems support lazy
purging, yet the application may provide extent hooks that implement
lazy purging, so care must be taken to dynamically omit the first phase
when necessary.

The mallctl interfaces change as follows:
- opt.decay_time --> opt.{dirty,muzzy}_decay_time
- arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time
- arenas.decay_time --> arenas.{dirty,muzzy}_decay_time
- stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy}
- stats.arenas.<i>.{npurge,nmadvise,purged} -->
  stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged}

This resolves #521.

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