Refactor *decay_time into *decay_ms.

Support millisecond resolution for decay times.  Among other use cases
this makes it possible to specify a short initial dirty-->muzzy decay
phase, followed by a longer muzzy-->clean decay phase.

This resolves #812.

4 files changed, 136 insertions, 143 deletions

diff --git a/src/arena.c b/src/arena.c
index 03680e0..42bfc6b 100644
--- a/src/arena.c
+++ b/src/arena.c
@@ -18,11 +18,11 @@ const char	*percpu_arena_mode_names[] = {
 const char	*opt_percpu_arena = OPT_PERCPU_ARENA_DEFAULT;
 percpu_arena_mode_t	percpu_arena_mode = PERCPU_ARENA_MODE_DEFAULT;
 
-ssize_t opt_dirty_decay_time = DIRTY_DECAY_TIME_DEFAULT;
-ssize_t opt_muzzy_decay_time = MUZZY_DECAY_TIME_DEFAULT;
+ssize_t opt_dirty_decay_ms = DIRTY_DECAY_MS_DEFAULT;
+ssize_t opt_muzzy_decay_ms = MUZZY_DECAY_MS_DEFAULT;
 
-static atomic_zd_t dirty_decay_time_default;
-static atomic_zd_t muzzy_decay_time_default;
+static atomic_zd_t dirty_decay_ms_default;
+static atomic_zd_t muzzy_decay_ms_default;
 
 const arena_bin_info_t	arena_bin_info[NBINS] = {
 #define BIN_INFO_bin_yes(reg_size, slab_size, nregs)			\
@@ -196,13 +196,12 @@ arena_stats_mapped_add(tsdn_t *tsdn, arena_stats_t *arena_stats, size_t size) {
 
 void
 arena_basic_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads,
-    const char **dss, ssize_t *dirty_decay_time, ssize_t *muzzy_decay_time,
-    size_t *nactive, size_t *ndirty,
-    size_t *nmuzzy) {
+    const char **dss, ssize_t *dirty_decay_ms, ssize_t *muzzy_decay_ms,
+    size_t *nactive, size_t *ndirty, size_t *nmuzzy) {
 	*nthreads += arena_nthreads_get(arena, false);
 	*dss = dss_prec_names[arena_dss_prec_get(arena)];
-	*dirty_decay_time = arena_dirty_decay_time_get(arena);
-	*muzzy_decay_time = arena_muzzy_decay_time_get(arena);
+	*dirty_decay_ms = arena_dirty_decay_ms_get(arena);
+	*muzzy_decay_ms = arena_muzzy_decay_ms_get(arena);
 	*nactive += atomic_load_zu(&arena->nactive, ATOMIC_RELAXED);
 	*ndirty += extents_npages_get(&arena->extents_dirty);
 	*nmuzzy += extents_npages_get(&arena->extents_muzzy);
@@ -210,13 +209,13 @@ arena_basic_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads,
 
 void
 arena_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads,
-    const char **dss, ssize_t *dirty_decay_time, ssize_t *muzzy_decay_time,
+    const char **dss, ssize_t *dirty_decay_ms, ssize_t *muzzy_decay_ms,
     size_t *nactive, size_t *ndirty, size_t *nmuzzy, arena_stats_t *astats,
     malloc_bin_stats_t *bstats, malloc_large_stats_t *lstats) {
 	cassert(config_stats);
 
-	arena_basic_stats_merge(tsdn, arena, nthreads, dss, dirty_decay_time,
-	    muzzy_decay_time, nactive, ndirty, nmuzzy);
+	arena_basic_stats_merge(tsdn, arena, nthreads, dss, dirty_decay_ms,
+	    muzzy_decay_ms, nactive, ndirty, nmuzzy);
 
 	size_t base_allocated, base_resident, base_mapped;
 	base_stats_get(tsdn, arena->base, &base_allocated, &base_resident,
@@ -359,7 +358,7 @@ arena_extents_dirty_dalloc(tsdn_t *tsdn, arena_t *arena,
 
 	extents_dalloc(tsdn, arena, r_extent_hooks, &arena->extents_dirty,
 	    extent);
-	if (arena_dirty_decay_time_get(arena) == 0) {
+	if (arena_dirty_decay_ms_get(arena) == 0) {
 		arena_decay_dirty(tsdn, arena, true);
 	}
 }
@@ -574,13 +573,13 @@ arena_extent_ralloc_large_expand(tsdn_t *tsdn, arena_t *arena, extent_t *extent,
 }
 
 static ssize_t
-arena_decay_time_read(arena_decay_t *decay) {
-	return atomic_load_zd(&decay->time, ATOMIC_RELAXED);
+arena_decay_ms_read(arena_decay_t *decay) {
+	return atomic_load_zd(&decay->time_ms, ATOMIC_RELAXED);
 }
 
 static void
-arena_decay_time_write(arena_decay_t *decay, ssize_t decay_time) {
-	atomic_store_zd(&decay->time, decay_time, ATOMIC_RELAXED);
+arena_decay_ms_write(arena_decay_t *decay, ssize_t decay_ms) {
+	atomic_store_zd(&decay->time_ms, decay_ms, ATOMIC_RELAXED);
 }
 
 static void
@@ -591,7 +590,7 @@ arena_decay_deadline_init(arena_decay_t *decay) {
 	 */
 	nstime_copy(&decay->deadline, &decay->epoch);
 	nstime_add(&decay->deadline, &decay->interval);
-	if (arena_decay_time_read(decay) > 0) {
+	if (arena_decay_ms_read(decay) > 0) {
 		nstime_t jitter;
 
 		nstime_init(&jitter, prng_range_u64(&decay->jitter_state,
@@ -711,11 +710,11 @@ arena_decay_epoch_advance(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay,
 }
 
 static void
-arena_decay_reinit(arena_decay_t *decay, extents_t *extents,
-    ssize_t decay_time) {
-	arena_decay_time_write(decay, decay_time);
-	if (decay_time > 0) {
-		nstime_init2(&decay->interval, decay_time, 0);
+arena_decay_reinit(arena_decay_t *decay, extents_t *extents, ssize_t decay_ms) {
+	arena_decay_ms_write(decay, decay_ms);
+	if (decay_ms > 0) {
+		nstime_init(&decay->interval, (uint64_t)decay_ms *
+		    KQU(1000000));
 		nstime_idivide(&decay->interval, SMOOTHSTEP_NSTEPS);
 	}
 
@@ -728,7 +727,7 @@ arena_decay_reinit(arena_decay_t *decay, extents_t *extents,
 }
 
 static bool
-arena_decay_init(arena_decay_t *decay, extents_t *extents, ssize_t decay_time,
+arena_decay_init(arena_decay_t *decay, extents_t *extents, ssize_t decay_ms,
     decay_stats_t *stats) {
 	if (config_debug) {
 		for (size_t i = 0; i < sizeof(arena_decay_t); i++) {
@@ -739,7 +738,7 @@ arena_decay_init(arena_decay_t *decay, extents_t *extents, ssize_t decay_time,
 		return true;
 	}
 	decay->purging = false;
-	arena_decay_reinit(decay, extents, decay_time);
+	arena_decay_reinit(decay, extents, decay_ms);
 	/* Memory is zeroed, so there is no need to clear stats. */
 	if (config_stats) {
 		decay->stats = stats;
@@ -748,11 +747,12 @@ arena_decay_init(arena_decay_t *decay, extents_t *extents, ssize_t decay_time,
 }
 
 static bool
-arena_decay_time_valid(ssize_t decay_time) {
-	if (decay_time < -1) {
+arena_decay_ms_valid(ssize_t decay_ms) {
+	if (decay_ms < -1) {
 		return false;
 	}
-	if (decay_time == -1 || (uint64_t)decay_time <= NSTIME_SEC_MAX) {
+	if (decay_ms == -1 || (uint64_t)decay_ms <= NSTIME_SEC_MAX *
+	    KQU(1000)) {
 		return true;
 	}
 	return false;
@@ -764,9 +764,9 @@ arena_maybe_decay(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay,
 	malloc_mutex_assert_owner(tsdn, &decay->mtx);
 
 	/* Purge all or nothing if the option is disabled. */
-	ssize_t decay_time = arena_decay_time_read(decay);
-	if (decay_time <= 0) {
-		if (decay_time == 0) {
+	ssize_t decay_ms = arena_decay_ms_read(decay);
+	if (decay_ms <= 0) {
+		if (decay_ms == 0) {
 			arena_decay_to_limit(tsdn, arena, decay, extents, false,
 			    0);
 		}
@@ -806,24 +806,24 @@ arena_maybe_decay(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay,
 }
 
 static ssize_t
-arena_decay_time_get(arena_decay_t *decay) {
-	return arena_decay_time_read(decay);
+arena_decay_ms_get(arena_decay_t *decay) {
+	return arena_decay_ms_read(decay);
 }
 
 ssize_t
-arena_dirty_decay_time_get(arena_t *arena) {
-	return arena_decay_time_get(&arena->decay_dirty);
+arena_dirty_decay_ms_get(arena_t *arena) {
+	return arena_decay_ms_get(&arena->decay_dirty);
 }
 
 ssize_t
-arena_muzzy_decay_time_get(arena_t *arena) {
-	return arena_decay_time_get(&arena->decay_muzzy);
+arena_muzzy_decay_ms_get(arena_t *arena) {
+	return arena_decay_ms_get(&arena->decay_muzzy);
 }
 
 static bool
-arena_decay_time_set(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay,
-    extents_t *extents, ssize_t decay_time) {
-	if (!arena_decay_time_valid(decay_time)) {
+arena_decay_ms_set(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay,
+    extents_t *extents, ssize_t decay_ms) {
+	if (!arena_decay_ms_valid(decay_ms)) {
 		return true;
 	}
 
@@ -832,11 +832,11 @@ arena_decay_time_set(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay,
 	 * Restart decay backlog from scratch, which may cause many dirty pages
 	 * to be immediately purged.  It would conceptually be possible to map
 	 * the old backlog onto the new backlog, but there is no justification
-	 * for such complexity since decay_time changes are intended to be
+	 * for such complexity since decay_ms changes are intended to be
 	 * infrequent, either between the {-1, 0, >0} states, or a one-time
 	 * arbitrary change during initial arena configuration.
 	 */
-	arena_decay_reinit(decay, extents, decay_time);
+	arena_decay_reinit(decay, extents, decay_ms);
 	arena_maybe_decay(tsdn, arena, decay, extents);
 	malloc_mutex_unlock(tsdn, &decay->mtx);
 
@@ -844,15 +844,17 @@ arena_decay_time_set(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay,
 }
 
 bool
-arena_dirty_decay_time_set(tsdn_t *tsdn, arena_t *arena, ssize_t decay_time) {
-	return arena_decay_time_set(tsdn, arena, &arena->decay_dirty,
-	    &arena->extents_dirty, decay_time);
+arena_dirty_decay_ms_set(tsdn_t *tsdn, arena_t *arena,
+    ssize_t decay_ms) {
+	return arena_decay_ms_set(tsdn, arena, &arena->decay_dirty,
+	    &arena->extents_dirty, decay_ms);
 }
 
 bool
-arena_muzzy_decay_time_set(tsdn_t *tsdn, arena_t *arena, ssize_t decay_time) {
-	return arena_decay_time_set(tsdn, arena, &arena->decay_muzzy,
-	    &arena->extents_muzzy, decay_time);
+arena_muzzy_decay_ms_set(tsdn_t *tsdn, arena_t *arena,
+    ssize_t decay_ms) {
+	return arena_decay_ms_set(tsdn, arena, &arena->decay_muzzy,
+	    &arena->extents_muzzy, decay_ms);
 }
 
 static size_t
@@ -885,7 +887,7 @@ arena_decay_stashed(tsdn_t *tsdn, arena_t *arena,
 	}
 	npurged = 0;
 
-	ssize_t muzzy_decay_time = arena_muzzy_decay_time_get(arena);
+	ssize_t muzzy_decay_ms = arena_muzzy_decay_ms_get(arena);
 	for (extent_t *extent = extent_list_first(decay_extents); extent !=
 	    NULL; extent = extent_list_first(decay_extents)) {
 		if (config_stats) {
@@ -898,7 +900,7 @@ arena_decay_stashed(tsdn_t *tsdn, arena_t *arena,
 		case extent_state_active:
 			not_reached();
 		case extent_state_dirty:
-			if (!all && muzzy_decay_time != 0 &&
+			if (!all && muzzy_decay_ms != 0 &&
 			    !extent_purge_lazy_wrapper(tsdn, arena,
 			    r_extent_hooks, extent, 0,
 			    extent_size_get(extent))) {
@@ -1789,30 +1791,30 @@ arena_dss_prec_set(arena_t *arena, dss_prec_t dss_prec) {
 }
 
 ssize_t
-arena_dirty_decay_time_default_get(void) {
-	return atomic_load_zd(&dirty_decay_time_default, ATOMIC_RELAXED);
+arena_dirty_decay_ms_default_get(void) {
+	return atomic_load_zd(&dirty_decay_ms_default, ATOMIC_RELAXED);
 }
 
 bool
-arena_dirty_decay_time_default_set(ssize_t decay_time) {
-	if (!arena_decay_time_valid(decay_time)) {
+arena_dirty_decay_ms_default_set(ssize_t decay_ms) {
+	if (!arena_decay_ms_valid(decay_ms)) {
 		return true;
 	}
-	atomic_store_zd(&dirty_decay_time_default, decay_time, ATOMIC_RELAXED);
+	atomic_store_zd(&dirty_decay_ms_default, decay_ms, ATOMIC_RELAXED);
 	return false;
 }
 
 ssize_t
-arena_muzzy_decay_time_default_get(void) {
-	return atomic_load_zd(&muzzy_decay_time_default, ATOMIC_RELAXED);
+arena_muzzy_decay_ms_default_get(void) {
+	return atomic_load_zd(&muzzy_decay_ms_default, ATOMIC_RELAXED);
 }
 
 bool
-arena_muzzy_decay_time_default_set(ssize_t decay_time) {
-	if (!arena_decay_time_valid(decay_time)) {
+arena_muzzy_decay_ms_default_set(ssize_t decay_ms) {
+	if (!arena_decay_ms_valid(decay_ms)) {
 		return true;
 	}
-	atomic_store_zd(&muzzy_decay_time_default, decay_time, ATOMIC_RELAXED);
+	atomic_store_zd(&muzzy_decay_ms_default, decay_ms, ATOMIC_RELAXED);
 	return false;
 }
 
@@ -1933,11 +1935,11 @@ arena_new(tsdn_t *tsdn, unsigned ind, extent_hooks_t *extent_hooks) {
 	}
 
 	if (arena_decay_init(&arena->decay_dirty, &arena->extents_dirty,
-	    arena_dirty_decay_time_default_get(), &arena->stats.decay_dirty)) {
+	    arena_dirty_decay_ms_default_get(), &arena->stats.decay_dirty)) {
 		goto label_error;
 	}
 	if (arena_decay_init(&arena->decay_muzzy, &arena->extents_muzzy,
-	    arena_muzzy_decay_time_default_get(), &arena->stats.decay_muzzy)) {
+	    arena_muzzy_decay_ms_default_get(), &arena->stats.decay_muzzy)) {
 		goto label_error;
 	}
 
@@ -1993,8 +1995,8 @@ label_error:
 
 void
 arena_boot(void) {
-	arena_dirty_decay_time_default_set(opt_dirty_decay_time);
-	arena_muzzy_decay_time_default_set(opt_muzzy_decay_time);
+	arena_dirty_decay_ms_default_set(opt_dirty_decay_ms);
+	arena_muzzy_decay_ms_default_set(opt_muzzy_decay_ms);
 }
 
 void
diff --git a/src/ctl.c b/src/ctl.c
index 79f2447..296e74f 100644
--- a/src/ctl.c
+++ b/src/ctl.c
@@ -78,8 +78,8 @@ CTL_PROTO(opt_retain)
 CTL_PROTO(opt_dss)
 CTL_PROTO(opt_narenas)
 CTL_PROTO(opt_percpu_arena)
-CTL_PROTO(opt_dirty_decay_time)
-CTL_PROTO(opt_muzzy_decay_time)
+CTL_PROTO(opt_dirty_decay_ms)
+CTL_PROTO(opt_muzzy_decay_ms)
 CTL_PROTO(opt_stats_print)
 CTL_PROTO(opt_junk)
 CTL_PROTO(opt_zero)
@@ -106,8 +106,8 @@ CTL_PROTO(arena_i_purge)
 CTL_PROTO(arena_i_reset)
 CTL_PROTO(arena_i_destroy)
 CTL_PROTO(arena_i_dss)
-CTL_PROTO(arena_i_dirty_decay_time)
-CTL_PROTO(arena_i_muzzy_decay_time)
+CTL_PROTO(arena_i_dirty_decay_ms)
+CTL_PROTO(arena_i_muzzy_decay_ms)
 CTL_PROTO(arena_i_extent_hooks)
 INDEX_PROTO(arena_i)
 CTL_PROTO(arenas_bin_i_size)
@@ -117,8 +117,8 @@ INDEX_PROTO(arenas_bin_i)
 CTL_PROTO(arenas_lextent_i_size)
 INDEX_PROTO(arenas_lextent_i)
 CTL_PROTO(arenas_narenas)
-CTL_PROTO(arenas_dirty_decay_time)
-CTL_PROTO(arenas_muzzy_decay_time)
+CTL_PROTO(arenas_dirty_decay_ms)
+CTL_PROTO(arenas_muzzy_decay_ms)
 CTL_PROTO(arenas_quantum)
 CTL_PROTO(arenas_page)
 CTL_PROTO(arenas_tcache_max)
@@ -159,8 +159,8 @@ INDEX_PROTO(stats_arenas_i_lextents_j)
 CTL_PROTO(stats_arenas_i_nthreads)
 CTL_PROTO(stats_arenas_i_uptime)
 CTL_PROTO(stats_arenas_i_dss)
-CTL_PROTO(stats_arenas_i_dirty_decay_time)
-CTL_PROTO(stats_arenas_i_muzzy_decay_time)
+CTL_PROTO(stats_arenas_i_dirty_decay_ms)
+CTL_PROTO(stats_arenas_i_muzzy_decay_ms)
 CTL_PROTO(stats_arenas_i_pactive)
 CTL_PROTO(stats_arenas_i_pdirty)
 CTL_PROTO(stats_arenas_i_pmuzzy)
@@ -265,8 +265,8 @@ static const ctl_named_node_t opt_node[] = {
 	{NAME("dss"),		CTL(opt_dss)},
 	{NAME("narenas"),	CTL(opt_narenas)},
 	{NAME("percpu_arena"),	CTL(opt_percpu_arena)},
-	{NAME("dirty_decay_time"), CTL(opt_dirty_decay_time)},
-	{NAME("muzzy_decay_time"), CTL(opt_muzzy_decay_time)},
+	{NAME("dirty_decay_ms"), CTL(opt_dirty_decay_ms)},
+	{NAME("muzzy_decay_ms"), CTL(opt_muzzy_decay_ms)},
 	{NAME("stats_print"),	CTL(opt_stats_print)},
 	{NAME("junk"),		CTL(opt_junk)},
 	{NAME("zero"),		CTL(opt_zero)},
@@ -299,8 +299,8 @@ static const ctl_named_node_t arena_i_node[] = {
 	{NAME("reset"),		CTL(arena_i_reset)},
 	{NAME("destroy"),	CTL(arena_i_destroy)},
 	{NAME("dss"),		CTL(arena_i_dss)},
-	{NAME("dirty_decay_time"), CTL(arena_i_dirty_decay_time)},
-	{NAME("muzzy_decay_time"), CTL(arena_i_muzzy_decay_time)},
+	{NAME("dirty_decay_ms"), CTL(arena_i_dirty_decay_ms)},
+	{NAME("muzzy_decay_ms"), CTL(arena_i_muzzy_decay_ms)},
 	{NAME("extent_hooks"),	CTL(arena_i_extent_hooks)}
 };
 static const ctl_named_node_t super_arena_i_node[] = {
@@ -337,8 +337,8 @@ static const ctl_indexed_node_t arenas_lextent_node[] = {
 
 static const ctl_named_node_t arenas_node[] = {
 	{NAME("narenas"),	CTL(arenas_narenas)},
-	{NAME("dirty_decay_time"), CTL(arenas_dirty_decay_time)},
-	{NAME("muzzy_decay_time"), CTL(arenas_muzzy_decay_time)},
+	{NAME("dirty_decay_ms"), CTL(arenas_dirty_decay_ms)},
+	{NAME("muzzy_decay_ms"), CTL(arenas_muzzy_decay_ms)},
 	{NAME("quantum"),	CTL(arenas_quantum)},
 	{NAME("page"),		CTL(arenas_page)},
 	{NAME("tcache_max"),	CTL(arenas_tcache_max)},
@@ -444,8 +444,8 @@ static const ctl_named_node_t stats_arenas_i_node[] = {
 	{NAME("nthreads"),	CTL(stats_arenas_i_nthreads)},
 	{NAME("uptime"),	CTL(stats_arenas_i_uptime)},
 	{NAME("dss"),		CTL(stats_arenas_i_dss)},
-	{NAME("dirty_decay_time"), CTL(stats_arenas_i_dirty_decay_time)},
-	{NAME("muzzy_decay_time"), CTL(stats_arenas_i_muzzy_decay_time)},
+	{NAME("dirty_decay_ms"), CTL(stats_arenas_i_dirty_decay_ms)},
+	{NAME("muzzy_decay_ms"), CTL(stats_arenas_i_muzzy_decay_ms)},
 	{NAME("pactive"),	CTL(stats_arenas_i_pactive)},
 	{NAME("pdirty"),	CTL(stats_arenas_i_pdirty)},
 	{NAME("pmuzzy"),	CTL(stats_arenas_i_pmuzzy)},
@@ -644,8 +644,8 @@ static void
 ctl_arena_clear(ctl_arena_t *ctl_arena) {
 	ctl_arena->nthreads = 0;
 	ctl_arena->dss = dss_prec_names[dss_prec_limit];
-	ctl_arena->dirty_decay_time = -1;
-	ctl_arena->muzzy_decay_time = -1;
+	ctl_arena->dirty_decay_ms = -1;
+	ctl_arena->muzzy_decay_ms = -1;
 	ctl_arena->pactive = 0;
 	ctl_arena->pdirty = 0;
 	ctl_arena->pmuzzy = 0;
@@ -668,8 +668,8 @@ ctl_arena_stats_amerge(tsdn_t *tsdn, ctl_arena_t *ctl_arena, arena_t *arena) {
 
 	if (config_stats) {
 		arena_stats_merge(tsdn, arena, &ctl_arena->nthreads,
-		    &ctl_arena->dss, &ctl_arena->dirty_decay_time,
-		    &ctl_arena->muzzy_decay_time, &ctl_arena->pactive,
+		    &ctl_arena->dss, &ctl_arena->dirty_decay_ms,
+		    &ctl_arena->muzzy_decay_ms, &ctl_arena->pactive,
 		    &ctl_arena->pdirty, &ctl_arena->pmuzzy,
 		    &ctl_arena->astats->astats, ctl_arena->astats->bstats,
 		    ctl_arena->astats->lstats);
@@ -687,8 +687,8 @@ ctl_arena_stats_amerge(tsdn_t *tsdn, ctl_arena_t *ctl_arena, arena_t *arena) {
 		}
 	} else {
 		arena_basic_stats_merge(tsdn, arena, &ctl_arena->nthreads,
-		    &ctl_arena->dss, &ctl_arena->dirty_decay_time,
-		    &ctl_arena->muzzy_decay_time, &ctl_arena->pactive,
+		    &ctl_arena->dss, &ctl_arena->dirty_decay_ms,
+		    &ctl_arena->muzzy_decay_ms, &ctl_arena->pactive,
 		    &ctl_arena->pdirty, &ctl_arena->pmuzzy);
 	}
 }
@@ -1465,8 +1465,8 @@ CTL_RO_NL_GEN(opt_retain, opt_retain, bool)
 CTL_RO_NL_GEN(opt_dss, opt_dss, const char *)
 CTL_RO_NL_GEN(opt_narenas, opt_narenas, unsigned)
 CTL_RO_NL_GEN(opt_percpu_arena, opt_percpu_arena, const char *)
-CTL_RO_NL_GEN(opt_dirty_decay_time, opt_dirty_decay_time, ssize_t)
-CTL_RO_NL_GEN(opt_muzzy_decay_time, opt_muzzy_decay_time, ssize_t)
+CTL_RO_NL_GEN(opt_dirty_decay_ms, opt_dirty_decay_ms, ssize_t)
+CTL_RO_NL_GEN(opt_muzzy_decay_ms, opt_muzzy_decay_ms, ssize_t)
 CTL_RO_NL_GEN(opt_stats_print, opt_stats_print, bool)
 CTL_RO_NL_CGEN(config_fill, opt_junk, opt_junk, const char *)
 CTL_RO_NL_CGEN(config_fill, opt_zero, opt_zero, bool)
@@ -1955,7 +1955,7 @@ label_return:
 }
 
 static int
-arena_i_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen,
+arena_i_decay_ms_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen,
     void *oldp, size_t *oldlenp, void *newp, size_t newlen, bool dirty) {
 	int ret;
 	unsigned arena_ind;
@@ -1969,8 +1969,8 @@ arena_i_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen,
 	}
 
 	if (oldp != NULL && oldlenp != NULL) {
-		size_t oldval = dirty ? arena_dirty_decay_time_get(arena) :
-		    arena_muzzy_decay_time_get(arena);
+		size_t oldval = dirty ? arena_dirty_decay_ms_get(arena) :
+		    arena_muzzy_decay_ms_get(arena);
 		READ(oldval, ssize_t);
 	}
 	if (newp != NULL) {
@@ -1978,10 +1978,9 @@ arena_i_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen,
 			ret = EINVAL;
 			goto label_return;
 		}
-		if (dirty ? arena_dirty_decay_time_set(tsd_tsdn(tsd), arena,
-		    *(ssize_t *)newp) :
-		    arena_muzzy_decay_time_set(tsd_tsdn(tsd), arena,
-		    *(ssize_t *)newp)) {
+		if (dirty ? arena_dirty_decay_ms_set(tsd_tsdn(tsd), arena,
+		    *(ssize_t *)newp) : arena_muzzy_decay_ms_set(tsd_tsdn(tsd),
+		    arena, *(ssize_t *)newp)) {
 			ret = EFAULT;
 			goto label_return;
 		}
@@ -1993,17 +1992,17 @@ label_return:
 }
 
 static int
-arena_i_dirty_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
+arena_i_dirty_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
     void *oldp, size_t *oldlenp, void *newp, size_t newlen) {
-	return arena_i_decay_time_ctl_impl(tsd, mib, miblen, oldp, oldlenp,
-	    newp, newlen, true);
+	return arena_i_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,
+	    newlen, true);
 }
 
 static int
-arena_i_muzzy_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
+arena_i_muzzy_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
     void *oldp, size_t *oldlenp, void *newp, size_t newlen) {
-	return arena_i_decay_time_ctl_impl(tsd, mib, miblen, oldp, oldlenp,
-	    newp, newlen, false);
+	return arena_i_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,
+	    newlen, false);
 }
 
 static int
@@ -2087,13 +2086,13 @@ label_return:
 }
 
 static int
-arenas_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen,
+arenas_decay_ms_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen,
     void *oldp, size_t *oldlenp, void *newp, size_t newlen, bool dirty) {
 	int ret;
 
 	if (oldp != NULL && oldlenp != NULL) {
-		size_t oldval = (dirty ? arena_dirty_decay_time_default_get() :
-		    arena_muzzy_decay_time_default_get());
+		size_t oldval = (dirty ? arena_dirty_decay_ms_default_get() :
+		    arena_muzzy_decay_ms_default_get());
 		READ(oldval, ssize_t);
 	}
 	if (newp != NULL) {
@@ -2101,8 +2100,8 @@ arenas_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen,
 			ret = EINVAL;
 			goto label_return;
 		}
-		if (dirty ? arena_dirty_decay_time_default_set(*(ssize_t *)newp)
-		    : arena_muzzy_decay_time_default_set(*(ssize_t *)newp)) {
+		if (dirty ?  arena_dirty_decay_ms_default_set(*(ssize_t *)newp)
+		    : arena_muzzy_decay_ms_default_set(*(ssize_t *)newp)) {
 			ret = EFAULT;
 			goto label_return;
 		}
@@ -2114,16 +2113,16 @@ label_return:
 }
 
 static int
-arenas_dirty_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
+arenas_dirty_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
     void *oldp, size_t *oldlenp, void *newp, size_t newlen) {
-	return arenas_decay_time_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,
+	return arenas_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,
 	    newlen, true);
 }
 
 static int
-arenas_muzzy_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
+arenas_muzzy_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
     void *oldp, size_t *oldlenp, void *newp, size_t newlen) {
-	return arenas_decay_time_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,
+	return arenas_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp,
 	    newlen, false);
 }
 
@@ -2318,9 +2317,9 @@ CTL_RO_CGEN(config_stats, stats_mapped, ctl_stats->mapped, size_t)
 CTL_RO_CGEN(config_stats, stats_retained, ctl_stats->retained, size_t)
 
 CTL_RO_GEN(stats_arenas_i_dss, arenas_i(mib[2])->dss, const char *)
-CTL_RO_GEN(stats_arenas_i_dirty_decay_time, arenas_i(mib[2])->dirty_decay_time,
+CTL_RO_GEN(stats_arenas_i_dirty_decay_ms, arenas_i(mib[2])->dirty_decay_ms,
     ssize_t)
-CTL_RO_GEN(stats_arenas_i_muzzy_decay_time, arenas_i(mib[2])->muzzy_decay_time,
+CTL_RO_GEN(stats_arenas_i_muzzy_decay_ms, arenas_i(mib[2])->muzzy_decay_ms,
     ssize_t)
 CTL_RO_GEN(stats_arenas_i_nthreads, arenas_i(mib[2])->nthreads, unsigned)
 CTL_RO_GEN(stats_arenas_i_uptime,
diff --git a/src/jemalloc.c b/src/jemalloc.c
index 1321844..47133ed 100644
--- a/src/jemalloc.c
+++ b/src/jemalloc.c
@@ -1070,10 +1070,14 @@ malloc_conf_init(void) {
 			}
 			CONF_HANDLE_UNSIGNED(opt_narenas, "narenas", 1,
 			    UINT_MAX, yes, no, false)
-			CONF_HANDLE_SSIZE_T(opt_dirty_decay_time,
-			    "dirty_decay_time", -1, NSTIME_SEC_MAX);
-			CONF_HANDLE_SSIZE_T(opt_muzzy_decay_time,
-			    "muzzy_decay_time", -1, NSTIME_SEC_MAX);
+			CONF_HANDLE_SSIZE_T(opt_dirty_decay_ms,
+			    "dirty_decay_ms", -1, NSTIME_SEC_MAX * KQU(1000) <
+			    QU(SSIZE_MAX) ? NSTIME_SEC_MAX * KQU(1000) :
+			    SSIZE_MAX);
+			CONF_HANDLE_SSIZE_T(opt_muzzy_decay_ms,
+			    "muzzy_decay_ms", -1, NSTIME_SEC_MAX * KQU(1000) <
+			    QU(SSIZE_MAX) ? NSTIME_SEC_MAX * KQU(1000) :
+			    SSIZE_MAX);
 			CONF_HANDLE_BOOL(opt_stats_print, "stats_print")
 			if (config_fill) {
 				if (CONF_MATCH("junk")) {
diff --git a/src/stats.c b/src/stats.c
index 883c7d1..3c9eb35 100644
--- a/src/stats.c
+++ b/src/stats.c
@@ -411,7 +411,7 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque,
     bool json, unsigned i, bool bins, bool large, bool mutex) {
 	unsigned nthreads;
 	const char *dss;
-	ssize_t dirty_decay_time, muzzy_decay_time;
+	ssize_t dirty_decay_ms, muzzy_decay_ms;
 	size_t page, pactive, pdirty, pmuzzy, mapped, retained;
 	size_t base, internal, resident;
 	uint64_t dirty_npurge, dirty_nmadvise, dirty_purged;
@@ -452,9 +452,9 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque,
 		    "dss allocation precedence: %s\n", dss);
 	}
 
-	CTL_M2_GET("stats.arenas.0.dirty_decay_time", i, &dirty_decay_time,
+	CTL_M2_GET("stats.arenas.0.dirty_decay_ms", i, &dirty_decay_ms,
 	    ssize_t);
-	CTL_M2_GET("stats.arenas.0.muzzy_decay_time", i, &muzzy_decay_time,
+	CTL_M2_GET("stats.arenas.0.muzzy_decay_ms", i, &muzzy_decay_ms,
 	    ssize_t);
 	CTL_M2_GET("stats.arenas.0.pactive", i, &pactive, size_t);
 	CTL_M2_GET("stats.arenas.0.pdirty", i, &pdirty, size_t);
@@ -469,9 +469,9 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque,
 	CTL_M2_GET("stats.arenas.0.muzzy_purged", i, &muzzy_purged, uint64_t);
 	if (json) {
 		malloc_cprintf(write_cb, cbopaque,
-		    "\t\t\t\t\"dirty_decay_time\": %zd,\n", dirty_decay_time);
+		    "\t\t\t\t\"dirty_decay_ms\": %zd,\n", dirty_decay_ms);
 		malloc_cprintf(write_cb, cbopaque,
-		    "\t\t\t\t\"muzzy_decay_time\": %zd,\n", muzzy_decay_time);
+		    "\t\t\t\t\"muzzy_decay_ms\": %zd,\n", muzzy_decay_ms);
 		malloc_cprintf(write_cb, cbopaque,
 		    "\t\t\t\t\"pactive\": %zu,\n", pactive);
 		malloc_cprintf(write_cb, cbopaque,
@@ -494,10 +494,10 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque,
 		malloc_cprintf(write_cb, cbopaque,
 		    "decaying:  time       npages       sweeps     madvises"
 		    "       purged\n");
-		if (dirty_decay_time >= 0) {
+		if (dirty_decay_ms >= 0) {
 			malloc_cprintf(write_cb, cbopaque,
 			    "   dirty: %5zd %12zu %12"FMTu64" %12"FMTu64" %12"
-			    FMTu64"\n", dirty_decay_time, pdirty, dirty_npurge,
+			    FMTu64"\n", dirty_decay_ms, pdirty, dirty_npurge,
 			    dirty_nmadvise, dirty_purged);
 		} else {
 			malloc_cprintf(write_cb, cbopaque,
@@ -505,10 +505,10 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque,
 			    FMTu64"\n", pdirty, dirty_npurge, dirty_nmadvise,
 			    dirty_purged);
 		}
-		if (muzzy_decay_time >= 0) {
+		if (muzzy_decay_ms >= 0) {
 			malloc_cprintf(write_cb, cbopaque,
 			    "   muzzy: %5zd %12zu %12"FMTu64" %12"FMTu64" %12"
-			    FMTu64"\n", muzzy_decay_time, pmuzzy, muzzy_npurge,
+			    FMTu64"\n", muzzy_decay_ms, pmuzzy, muzzy_npurge,
 			    muzzy_nmadvise, muzzy_purged);
 		} else {
 			malloc_cprintf(write_cb, cbopaque,
@@ -816,10 +816,8 @@ stats_general_print(void (*write_cb)(void *, const char *), void *cbopaque,
 	OPT_WRITE_CHAR_P(dss, ",")
 	OPT_WRITE_UNSIGNED(narenas, ",")
 	OPT_WRITE_CHAR_P(percpu_arena, ",")
-	OPT_WRITE_SSIZE_T_MUTABLE(dirty_decay_time, arenas.dirty_decay_time,
-	    ",")
-	OPT_WRITE_SSIZE_T_MUTABLE(muzzy_decay_time, arenas.muzzy_decay_time,
-	    ",")
+	OPT_WRITE_SSIZE_T_MUTABLE(dirty_decay_ms, arenas.dirty_decay_ms, ",")
+	OPT_WRITE_SSIZE_T_MUTABLE(muzzy_decay_ms, arenas.muzzy_decay_ms, ",")
 	OPT_WRITE_CHAR_P(junk, ",")
 	OPT_WRITE_BOOL(zero, ",")
 	OPT_WRITE_BOOL(utrace, ",")
@@ -867,24 +865,14 @@ stats_general_print(void (*write_cb)(void *, const char *), void *cbopaque,
 		malloc_cprintf(write_cb, cbopaque, "Arenas: %u\n", uv);
 	}
 
-	CTL_GET("arenas.dirty_decay_time", &ssv, ssize_t);
 	if (json) {
+		CTL_GET("arenas.dirty_decay_ms", &ssv, ssize_t);
 		malloc_cprintf(write_cb, cbopaque,
-		    "\t\t\t\"dirty_decay_time\": %zd,\n", ssv);
-	} else {
-		malloc_cprintf(write_cb, cbopaque,
-		    "Unused dirty page decay time: %zd%s\n", ssv, (ssv < 0) ?
-		    " (no decay)" : "");
-	}
+		    "\t\t\t\"dirty_decay_ms\": %zd,\n", ssv);
 
-	CTL_GET("arenas.muzzy_decay_time", &ssv, ssize_t);
-	if (json) {
-		malloc_cprintf(write_cb, cbopaque,
-		    "\t\t\t\"muzzy_decay_time\": %zd,\n", ssv);
-	} else {
+		CTL_GET("arenas.muzzy_decay_ms", &ssv, ssize_t);
 		malloc_cprintf(write_cb, cbopaque,
-		    "Unused muzzy page decay time: %zd%s\n", ssv, (ssv < 0) ?
-		    " (no decay)" : "");
+		    "\t\t\t\"muzzy_decay_ms\": %zd,\n", ssv);
 	}
 
 	CTL_GET("arenas.quantum", &sv, size_t);