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, 98 insertions, 102 deletions

diff --git a/test/unit/decay.c b/test/unit/decay.c
index 389f6e0..19f76fa 100644
--- a/test/unit/decay.c
+++ b/test/unit/decay.c
@@ -24,7 +24,7 @@ nstime_update_mock(nstime_t *time) {
 }
 
 static unsigned
-do_arena_create(ssize_t dirty_decay_time, ssize_t muzzy_decay_time) {
+do_arena_create(ssize_t dirty_decay_ms, ssize_t muzzy_decay_ms) {
 	unsigned arena_ind;
 	size_t sz = sizeof(unsigned);
 	assert_d_eq(mallctl("arenas.create", (void *)&arena_ind, &sz, NULL, 0),
@@ -32,19 +32,19 @@ do_arena_create(ssize_t dirty_decay_time, ssize_t muzzy_decay_time) {
 	size_t mib[3];
 	size_t miblen = sizeof(mib)/sizeof(size_t);
 
-	assert_d_eq(mallctlnametomib("arena.0.dirty_decay_time", mib, &miblen),
+	assert_d_eq(mallctlnametomib("arena.0.dirty_decay_ms", 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");
+	    (void *)&dirty_decay_ms, sizeof(dirty_decay_ms)), 0,
+	    "Unexpected mallctlbymib() failure");
 
-	assert_d_eq(mallctlnametomib("arena.0.muzzy_decay_time", mib, &miblen),
+	assert_d_eq(mallctlnametomib("arena.0.muzzy_decay_ms", mib, &miblen),
 	    0, "Unexpected mallctlnametomib() failure");
 	mib[1] = (size_t)arena_ind;
 	assert_d_eq(mallctlbymib(mib, miblen, NULL, NULL,
-	    (void *)&muzzy_decay_time,
-	    sizeof(muzzy_decay_time)), 0, "Unexpected mallctlbymib() failure");
+	    (void *)&muzzy_decay_ms, sizeof(muzzy_decay_ms)), 0,
+	    "Unexpected mallctlbymib() failure");
 
 	return arena_ind;
 }
@@ -362,14 +362,14 @@ 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
-	nstime_t time, update_interval, decay_time, deadline;
+	nstime_t time, update_interval, decay_ms, deadline;
 
 	nstime_init(&time, 0);
 	nstime_update(&time);
 
-	nstime_init2(&decay_time, dt, 0);
+	nstime_init2(&decay_ms, dt, 0);
 	nstime_copy(&deadline, &time);
-	nstime_add(&deadline, &decay_time);
+	nstime_add(&deadline, &decay_ms);
 
 	nstime_init2(&update_interval, dt, 0);
 	nstime_idivide(&update_interval, NINTERVALS);
@@ -406,8 +406,8 @@ decay_ticker_helper(unsigned arena_ind, int flags, bool dirty, ssize_t dt,
 
 TEST_BEGIN(test_decay_ticker) {
 #define NPS 2048
-	ssize_t ddt = opt_dirty_decay_time;
-	ssize_t mdt = opt_muzzy_decay_time;
+	ssize_t ddt = opt_dirty_decay_ms;
+	ssize_t mdt = opt_muzzy_decay_ms;
 	unsigned arena_ind = do_arena_create(ddt, mdt);
 	int flags = (MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE);
 	void *ps[NPS];
diff --git a/test/unit/decay.sh b/test/unit/decay.sh
index a41489b..45aeccf 100644
--- a/test/unit/decay.sh
+++ b/test/unit/decay.sh
@@ -1,3 +1,3 @@
 #!/bin/sh
 
-export MALLOC_CONF="dirty_decay_time:1,muzzy_decay_time:1,lg_tcache_max:0"
+export MALLOC_CONF="dirty_decay_ms:1000,muzzy_decay_ms:1000,lg_tcache_max:0"
diff --git a/test/unit/mallctl.c b/test/unit/mallctl.c
index b07a6d0..f721c21 100644
--- a/test/unit/mallctl.c
+++ b/test/unit/mallctl.c
@@ -161,8 +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, dirty_decay_time, always);
-	TEST_MALLCTL_OPT(ssize_t, muzzy_decay_time, always);
+	TEST_MALLCTL_OPT(ssize_t, dirty_decay_ms, always);
+	TEST_MALLCTL_OPT(ssize_t, muzzy_decay_ms, always);
 	TEST_MALLCTL_OPT(bool, stats_print, always);
 	TEST_MALLCTL_OPT(const char *, junk, fill);
 	TEST_MALLCTL_OPT(bool, zero, fill);
@@ -398,68 +398,66 @@ TEST_BEGIN(test_arena_i_initialized) {
 }
 TEST_END
 
-TEST_BEGIN(test_arena_i_dirty_decay_time) {
-	ssize_t dirty_decay_time, orig_dirty_decay_time, prev_dirty_decay_time;
+TEST_BEGIN(test_arena_i_dirty_decay_ms) {
+	ssize_t dirty_decay_ms, orig_dirty_decay_ms, prev_dirty_decay_ms;
 	size_t sz = sizeof(ssize_t);
 
-	assert_d_eq(mallctl("arena.0.dirty_decay_time",
-	    (void *)&orig_dirty_decay_time, &sz, NULL, 0), 0,
+	assert_d_eq(mallctl("arena.0.dirty_decay_ms",
+	    (void *)&orig_dirty_decay_ms, &sz, NULL, 0), 0,
 	    "Unexpected mallctl() failure");
 
-	dirty_decay_time = -2;
-	assert_d_eq(mallctl("arena.0.dirty_decay_time", NULL, NULL,
-	    (void *)&dirty_decay_time, sizeof(ssize_t)), EFAULT,
+	dirty_decay_ms = -2;
+	assert_d_eq(mallctl("arena.0.dirty_decay_ms", NULL, NULL,
+	    (void *)&dirty_decay_ms, sizeof(ssize_t)), EFAULT,
 	    "Unexpected mallctl() success");
 
-	dirty_decay_time = 0x7fffffff;
-	assert_d_eq(mallctl("arena.0.dirty_decay_time", NULL, NULL,
-	    (void *)&dirty_decay_time, sizeof(ssize_t)), 0,
+	dirty_decay_ms = 0x7fffffff;
+	assert_d_eq(mallctl("arena.0.dirty_decay_ms", NULL, NULL,
+	    (void *)&dirty_decay_ms, sizeof(ssize_t)), 0,
 	    "Unexpected 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;
+	for (prev_dirty_decay_ms = dirty_decay_ms, dirty_decay_ms = -1;
+	    dirty_decay_ms < 20; prev_dirty_decay_ms = dirty_decay_ms,
+	    dirty_decay_ms++) {
+		ssize_t old_dirty_decay_ms;
 
-		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_dirty_decay_time, prev_dirty_decay_time,
-		    "Unexpected old arena.0.dirty_decay_time");
+		assert_d_eq(mallctl("arena.0.dirty_decay_ms",
+		    (void *)&old_dirty_decay_ms, &sz, (void *)&dirty_decay_ms,
+		    sizeof(ssize_t)), 0, "Unexpected mallctl() failure");
+		assert_zd_eq(old_dirty_decay_ms, prev_dirty_decay_ms,
+		    "Unexpected old arena.0.dirty_decay_ms");
 	}
 }
 TEST_END
 
-TEST_BEGIN(test_arena_i_muzzy_decay_time) {
-	ssize_t muzzy_decay_time, orig_muzzy_decay_time, prev_muzzy_decay_time;
+TEST_BEGIN(test_arena_i_muzzy_decay_ms) {
+	ssize_t muzzy_decay_ms, orig_muzzy_decay_ms, prev_muzzy_decay_ms;
 	size_t sz = sizeof(ssize_t);
 
-	assert_d_eq(mallctl("arena.0.muzzy_decay_time",
-	    (void *)&orig_muzzy_decay_time, &sz, NULL, 0), 0,
+	assert_d_eq(mallctl("arena.0.muzzy_decay_ms",
+	    (void *)&orig_muzzy_decay_ms, &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,
+	muzzy_decay_ms = -2;
+	assert_d_eq(mallctl("arena.0.muzzy_decay_ms", NULL, NULL,
+	    (void *)&muzzy_decay_ms, 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,
+	muzzy_decay_ms = 0x7fffffff;
+	assert_d_eq(mallctl("arena.0.muzzy_decay_ms", NULL, NULL,
+	    (void *)&muzzy_decay_ms, 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;
+	for (prev_muzzy_decay_ms = muzzy_decay_ms, muzzy_decay_ms = -1;
+	    muzzy_decay_ms < 20; prev_muzzy_decay_ms = muzzy_decay_ms,
+	    muzzy_decay_ms++) {
+		ssize_t old_muzzy_decay_ms;
 
-		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");
+		assert_d_eq(mallctl("arena.0.muzzy_decay_ms",
+		    (void *)&old_muzzy_decay_ms, &sz, (void *)&muzzy_decay_ms,
+		    sizeof(ssize_t)), 0, "Unexpected mallctl() failure");
+		assert_zd_eq(old_muzzy_decay_ms, prev_muzzy_decay_ms,
+		    "Unexpected old arena.0.muzzy_decay_ms");
 	}
 }
 TEST_END
@@ -555,68 +553,66 @@ TEST_BEGIN(test_arena_i_dss) {
 }
 TEST_END
 
-TEST_BEGIN(test_arenas_dirty_decay_time) {
-	ssize_t dirty_decay_time, orig_dirty_decay_time, prev_dirty_decay_time;
+TEST_BEGIN(test_arenas_dirty_decay_ms) {
+	ssize_t dirty_decay_ms, orig_dirty_decay_ms, prev_dirty_decay_ms;
 	size_t sz = sizeof(ssize_t);
 
-	assert_d_eq(mallctl("arenas.dirty_decay_time",
-	    (void *)&orig_dirty_decay_time, &sz, NULL, 0), 0,
+	assert_d_eq(mallctl("arenas.dirty_decay_ms",
+	    (void *)&orig_dirty_decay_ms, &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,
+	dirty_decay_ms = -2;
+	assert_d_eq(mallctl("arenas.dirty_decay_ms", NULL, NULL,
+	    (void *)&dirty_decay_ms, 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,
+	dirty_decay_ms = 0x7fffffff;
+	assert_d_eq(mallctl("arenas.dirty_decay_ms", NULL, NULL,
+	    (void *)&dirty_decay_ms, 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;
+	for (prev_dirty_decay_ms = dirty_decay_ms, dirty_decay_ms = -1;
+	    dirty_decay_ms < 20; prev_dirty_decay_ms = dirty_decay_ms,
+	    dirty_decay_ms++) {
+		ssize_t old_dirty_decay_ms;
 
-		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");
+		assert_d_eq(mallctl("arenas.dirty_decay_ms",
+		    (void *)&old_dirty_decay_ms, &sz, (void *)&dirty_decay_ms,
+		    sizeof(ssize_t)), 0, "Unexpected mallctl() failure");
+		assert_zd_eq(old_dirty_decay_ms, prev_dirty_decay_ms,
+		    "Unexpected old arenas.dirty_decay_ms");
 	}
 }
 TEST_END
 
-TEST_BEGIN(test_arenas_muzzy_decay_time) {
-	ssize_t muzzy_decay_time, orig_muzzy_decay_time, prev_muzzy_decay_time;
+TEST_BEGIN(test_arenas_muzzy_decay_ms) {
+	ssize_t muzzy_decay_ms, orig_muzzy_decay_ms, prev_muzzy_decay_ms;
 	size_t sz = sizeof(ssize_t);
 
-	assert_d_eq(mallctl("arenas.muzzy_decay_time",
-	    (void *)&orig_muzzy_decay_time, &sz, NULL, 0), 0,
+	assert_d_eq(mallctl("arenas.muzzy_decay_ms",
+	    (void *)&orig_muzzy_decay_ms, &sz, NULL, 0), 0,
 	    "Unexpected mallctl() failure");
 
-	muzzy_decay_time = -2;
-	assert_d_eq(mallctl("arenas.muzzy_decay_time", NULL, NULL,
-	    (void *)&muzzy_decay_time, sizeof(ssize_t)), EFAULT,
+	muzzy_decay_ms = -2;
+	assert_d_eq(mallctl("arenas.muzzy_decay_ms", NULL, NULL,
+	    (void *)&muzzy_decay_ms, sizeof(ssize_t)), EFAULT,
 	    "Unexpected mallctl() success");
 
-	muzzy_decay_time = 0x7fffffff;
-	assert_d_eq(mallctl("arenas.muzzy_decay_time", NULL, NULL,
-	    (void *)&muzzy_decay_time, sizeof(ssize_t)), 0,
+	muzzy_decay_ms = 0x7fffffff;
+	assert_d_eq(mallctl("arenas.muzzy_decay_ms", NULL, NULL,
+	    (void *)&muzzy_decay_ms, sizeof(ssize_t)), 0,
 	    "Expected 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;
+	for (prev_muzzy_decay_ms = muzzy_decay_ms, muzzy_decay_ms = -1;
+	    muzzy_decay_ms < 20; prev_muzzy_decay_ms = muzzy_decay_ms,
+	    muzzy_decay_ms++) {
+		ssize_t old_muzzy_decay_ms;
 
-		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");
+		assert_d_eq(mallctl("arenas.muzzy_decay_ms",
+		    (void *)&old_muzzy_decay_ms, &sz, (void *)&muzzy_decay_ms,
+		    sizeof(ssize_t)), 0, "Unexpected mallctl() failure");
+		assert_zd_eq(old_muzzy_decay_ms, prev_muzzy_decay_ms,
+		    "Unexpected old arenas.muzzy_decay_ms");
 	}
 }
 TEST_END
@@ -699,8 +695,8 @@ TEST_BEGIN(test_stats_arenas) {
 
 	TEST_STATS_ARENAS(unsigned, nthreads);
 	TEST_STATS_ARENAS(const char *, dss);
-	TEST_STATS_ARENAS(ssize_t, dirty_decay_time);
-	TEST_STATS_ARENAS(ssize_t, muzzy_decay_time);
+	TEST_STATS_ARENAS(ssize_t, dirty_decay_ms);
+	TEST_STATS_ARENAS(ssize_t, muzzy_decay_ms);
 	TEST_STATS_ARENAS(size_t, pactive);
 	TEST_STATS_ARENAS(size_t, pdirty);
 
@@ -723,13 +719,13 @@ main(void) {
 	    test_tcache,
 	    test_thread_arena,
 	    test_arena_i_initialized,
-	    test_arena_i_dirty_decay_time,
-	    test_arena_i_muzzy_decay_time,
+	    test_arena_i_dirty_decay_ms,
+	    test_arena_i_muzzy_decay_ms,
 	    test_arena_i_purge,
 	    test_arena_i_decay,
 	    test_arena_i_dss,
-	    test_arenas_dirty_decay_time,
-	    test_arenas_muzzy_decay_time,
+	    test_arenas_dirty_decay_ms,
+	    test_arenas_muzzy_decay_ms,
 	    test_arenas_constants,
 	    test_arenas_bin_constants,
 	    test_arenas_lextent_constants,
diff --git a/test/unit/pack.sh b/test/unit/pack.sh
index 76757ac..6f45148 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="dirty_decay_time:0,muzzy_decay_time:0"
+export MALLOC_CONF="dirty_decay_ms:0,muzzy_decay_ms:0"