Refactor time_* into nstime_*.

Use a single uint64_t in nstime_t to store nanoseconds rather than using
struct timespec.  This reduces fragility around conversions between long
and uint64_t, especially missing casts that only cause problems on
32-bit platforms.

4 files changed, 246 insertions, 249 deletions

diff --git a/test/unit/decay.c b/test/unit/decay.c
index 20730de..66d54dc 100644
--- a/test/unit/decay.c
+++ b/test/unit/decay.c
@@ -2,19 +2,19 @@
 
 const char *malloc_conf = "purge:decay,decay_time:1";
 
-static time_update_t *time_update_orig;
+static nstime_update_t *nstime_update_orig;
 
 static unsigned nupdates_mock;
-static struct timespec time_mock;
+static nstime_t time_mock;
 static bool nonmonotonic_mock;
 
 static bool
-time_update_mock(struct timespec *time)
+nstime_update_mock(nstime_t *time)
 {
 
 	nupdates_mock++;
 	if (!nonmonotonic_mock)
-		time_copy(time, &time_mock);
+		nstime_copy(time, &time_mock);
 	return (nonmonotonic_mock);
 }
 
@@ -204,7 +204,7 @@ TEST_BEGIN(test_decay_ticker)
 	uint64_t epoch, npurge0, npurge1;
 	size_t sz, tcache_max, large;
 	unsigned i, nupdates0;
-	struct timespec time, decay_time, deadline;
+	nstime_t time, decay_time, deadline;
 
 	test_skip_if(opt_purge != purge_mode_decay);
 
@@ -233,12 +233,12 @@ TEST_BEGIN(test_decay_ticker)
 	}
 
 	nupdates_mock = 0;
-	time_init(&time_mock, 0, 0);
-	time_update(&time_mock);
+	nstime_init(&time_mock, 0);
+	nstime_update(&time_mock);
 	nonmonotonic_mock = false;
 
-	time_update_orig = time_update;
-	time_update = time_update_mock;
+	nstime_update_orig = nstime_update;
+	nstime_update = nstime_update_mock;
 
 	for (i = 0; i < NPS; i++) {
 		dallocx(ps[i], flags);
@@ -246,16 +246,16 @@ TEST_BEGIN(test_decay_ticker)
 		assert_d_eq(mallctl("arena.0.decay", NULL, NULL, NULL, 0), 0,
 		    "Unexpected arena.0.decay failure");
 		assert_u_gt(nupdates_mock, nupdates0,
-		    "Expected time_update() to be called");
+		    "Expected nstime_update() to be called");
 	}
 
-	time_update = time_update_orig;
+	nstime_update = nstime_update_orig;
 
-	time_init(&time, 0, 0);
-	time_update(&time);
-	time_init(&decay_time, opt_decay_time, 0);
-	time_copy(&deadline, &time);
-	time_add(&deadline, &decay_time);
+	nstime_init(&time, 0);
+	nstime_update(&time);
+	nstime_init2(&decay_time, opt_decay_time, 0);
+	nstime_copy(&deadline, &time);
+	nstime_add(&deadline, &decay_time);
 	do {
 		for (i = 0; i < DECAY_NTICKS_PER_UPDATE / 2; i++) {
 			void *p = mallocx(1, flags);
@@ -268,8 +268,8 @@ TEST_BEGIN(test_decay_ticker)
 		assert_d_eq(mallctl("stats.arenas.0.npurge", &npurge1, &sz,
 		    NULL, 0), 0, "Unexpected mallctl failure");
 
-		time_update(&time);
-	} while (time_compare(&time, &deadline) <= 0 && npurge1 == npurge0);
+		nstime_update(&time);
+	} while (nstime_compare(&time, &deadline) <= 0 && npurge1 == npurge0);
 
 	assert_u64_gt(npurge1, npurge0, "Expected purging to occur");
 #undef NPS
@@ -300,12 +300,12 @@ TEST_BEGIN(test_decay_nonmonotonic)
 	    "Unexpected mallctl failure");
 
 	nupdates_mock = 0;
-	time_init(&time_mock, 0, 0);
-	time_update(&time_mock);
+	nstime_init(&time_mock, 0);
+	nstime_update(&time_mock);
 	nonmonotonic_mock = true;
 
-	time_update_orig = time_update;
-	time_update = time_update_mock;
+	nstime_update_orig = nstime_update;
+	nstime_update = nstime_update_mock;
 
 	for (i = 0; i < NPS; i++) {
 		ps[i] = mallocx(large0, flags);
@@ -318,7 +318,7 @@ TEST_BEGIN(test_decay_nonmonotonic)
 		assert_d_eq(mallctl("arena.0.decay", NULL, NULL, NULL, 0), 0,
 		    "Unexpected arena.0.decay failure");
 		assert_u_gt(nupdates_mock, nupdates0,
-		    "Expected time_update() to be called");
+		    "Expected nstime_update() to be called");
 	}
 
 	assert_d_eq(mallctl("epoch", NULL, NULL, &epoch, sizeof(uint64_t)), 0,
@@ -329,7 +329,7 @@ TEST_BEGIN(test_decay_nonmonotonic)
 
 	assert_u64_gt(npurge1, npurge0, "Expected purging to occur");
 
-	time_update = time_update_orig;
+	nstime_update = nstime_update_orig;
 #undef NPS
 }
 TEST_END
diff --git a/test/unit/mallctl.c b/test/unit/mallctl.c
index b312fc6..e8dc492 100644
--- a/test/unit/mallctl.c
+++ b/test/unit/mallctl.c
@@ -401,7 +401,7 @@ TEST_BEGIN(test_arena_i_decay_time)
 	    &decay_time, sizeof(ssize_t)), EFAULT,
 	    "Unexpected mallctl() success");
 
-	decay_time = TIME_SEC_MAX;
+	decay_time = 0x7fffffff;
 	assert_d_eq(mallctl("arena.0.decay_time", NULL, NULL,
 	    &decay_time, sizeof(ssize_t)), 0,
 	    "Unexpected mallctl() failure");
@@ -567,7 +567,7 @@ TEST_BEGIN(test_arenas_decay_time)
 	    &decay_time, sizeof(ssize_t)), EFAULT,
 	    "Unexpected mallctl() success");
 
-	decay_time = TIME_SEC_MAX;
+	decay_time = 0x7fffffff;
 	assert_d_eq(mallctl("arenas.decay_time", NULL, NULL,
 	    &decay_time, sizeof(ssize_t)), 0,
 	    "Expected mallctl() failure");
diff --git a/test/unit/nstime.c b/test/unit/nstime.c
new file mode 100644
index 0000000..cd7d9a6
--- /dev/null
+++ b/test/unit/nstime.c
@@ -0,0 +1,220 @@
+#include "test/jemalloc_test.h"
+
+#define	BILLION	UINT64_C(1000000000)
+
+TEST_BEGIN(test_nstime_init)
+{
+	nstime_t nst;
+
+	nstime_init(&nst, 42000000043);
+	assert_u64_eq(nstime_ns(&nst), 42000000043, "ns incorrectly read");
+	assert_u64_eq(nstime_sec(&nst), 42, "sec incorrectly read");
+	assert_u64_eq(nstime_nsec(&nst), 43, "nsec incorrectly read");
+}
+TEST_END
+
+TEST_BEGIN(test_nstime_init2)
+{
+	nstime_t nst;
+
+	nstime_init2(&nst, 42, 43);
+	assert_u64_eq(nstime_sec(&nst), 42, "sec incorrectly read");
+	assert_u64_eq(nstime_nsec(&nst), 43, "nsec incorrectly read");
+}
+TEST_END
+
+TEST_BEGIN(test_nstime_copy)
+{
+	nstime_t nsta, nstb;
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_init(&nstb, 0);
+	nstime_copy(&nstb, &nsta);
+	assert_u64_eq(nstime_sec(&nstb), 42, "sec incorrectly copied");
+	assert_u64_eq(nstime_nsec(&nstb), 43, "nsec incorrectly copied");
+}
+TEST_END
+
+TEST_BEGIN(test_nstime_compare)
+{
+	nstime_t nsta, nstb;
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_copy(&nstb, &nsta);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 0, "Times should be equal");
+	assert_d_eq(nstime_compare(&nstb, &nsta), 0, "Times should be equal");
+
+	nstime_init2(&nstb, 42, 42);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 1,
+	    "nsta should be greater than nstb");
+	assert_d_eq(nstime_compare(&nstb, &nsta), -1,
+	    "nstb should be less than nsta");
+
+	nstime_init2(&nstb, 42, 44);
+	assert_d_eq(nstime_compare(&nsta, &nstb), -1,
+	    "nsta should be less than nstb");
+	assert_d_eq(nstime_compare(&nstb, &nsta), 1,
+	    "nstb should be greater than nsta");
+
+	nstime_init2(&nstb, 41, BILLION - 1);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 1,
+	    "nsta should be greater than nstb");
+	assert_d_eq(nstime_compare(&nstb, &nsta), -1,
+	    "nstb should be less than nsta");
+
+	nstime_init2(&nstb, 43, 0);
+	assert_d_eq(nstime_compare(&nsta, &nstb), -1,
+	    "nsta should be less than nstb");
+	assert_d_eq(nstime_compare(&nstb, &nsta), 1,
+	    "nstb should be greater than nsta");
+}
+TEST_END
+
+TEST_BEGIN(test_nstime_add)
+{
+	nstime_t nsta, nstb;
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_copy(&nstb, &nsta);
+	nstime_add(&nsta, &nstb);
+	nstime_init2(&nstb, 84, 86);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 0,
+	    "Incorrect addition result");
+
+	nstime_init2(&nsta, 42, BILLION - 1);
+	nstime_copy(&nstb, &nsta);
+	nstime_add(&nsta, &nstb);
+	nstime_init2(&nstb, 85, BILLION - 2);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 0,
+	    "Incorrect addition result");
+}
+TEST_END
+
+TEST_BEGIN(test_nstime_subtract)
+{
+	nstime_t nsta, nstb;
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_copy(&nstb, &nsta);
+	nstime_subtract(&nsta, &nstb);
+	nstime_init(&nstb, 0);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 0,
+	    "Incorrect subtraction result");
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_init2(&nstb, 41, 44);
+	nstime_subtract(&nsta, &nstb);
+	nstime_init2(&nstb, 0, BILLION - 1);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 0,
+	    "Incorrect subtraction result");
+}
+TEST_END
+
+TEST_BEGIN(test_nstime_imultiply)
+{
+	nstime_t nsta, nstb;
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_imultiply(&nsta, 10);
+	nstime_init2(&nstb, 420, 430);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 0,
+	    "Incorrect multiplication result");
+
+	nstime_init2(&nsta, 42, 666666666);
+	nstime_imultiply(&nsta, 3);
+	nstime_init2(&nstb, 127, 999999998);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 0,
+	    "Incorrect multiplication result");
+}
+TEST_END
+
+TEST_BEGIN(test_nstime_idivide)
+{
+	nstime_t nsta, nstb;
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_copy(&nstb, &nsta);
+	nstime_imultiply(&nsta, 10);
+	nstime_idivide(&nsta, 10);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 0,
+	    "Incorrect division result");
+
+	nstime_init2(&nsta, 42, 666666666);
+	nstime_copy(&nstb, &nsta);
+	nstime_imultiply(&nsta, 3);
+	nstime_idivide(&nsta, 3);
+	assert_d_eq(nstime_compare(&nsta, &nstb), 0,
+	    "Incorrect division result");
+}
+TEST_END
+
+TEST_BEGIN(test_nstime_divide)
+{
+	nstime_t nsta, nstb, nstc;
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_copy(&nstb, &nsta);
+	nstime_imultiply(&nsta, 10);
+	assert_u64_eq(nstime_divide(&nsta, &nstb), 10,
+	    "Incorrect division result");
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_copy(&nstb, &nsta);
+	nstime_imultiply(&nsta, 10);
+	nstime_init(&nstc, 1);
+	nstime_add(&nsta, &nstc);
+	assert_u64_eq(nstime_divide(&nsta, &nstb), 10,
+	    "Incorrect division result");
+
+	nstime_init2(&nsta, 42, 43);
+	nstime_copy(&nstb, &nsta);
+	nstime_imultiply(&nsta, 10);
+	nstime_init(&nstc, 1);
+	nstime_subtract(&nsta, &nstc);
+	assert_u64_eq(nstime_divide(&nsta, &nstb), 9,
+	    "Incorrect division result");
+}
+TEST_END
+
+TEST_BEGIN(test_nstime_update)
+{
+	nstime_t nst;
+
+	nstime_init(&nst, 0);
+
+	assert_false(nstime_update(&nst), "Basic time update failed.");
+
+	/* Only Rip Van Winkle sleeps this long. */
+	{
+		nstime_t addend;
+		nstime_init2(&addend, 631152000, 0);
+		nstime_add(&nst, &addend);
+	}
+	{
+		nstime_t nst0;
+		nstime_copy(&nst0, &nst);
+		assert_true(nstime_update(&nst),
+		    "Update should detect time roll-back.");
+		assert_d_eq(nstime_compare(&nst, &nst0), 0,
+		    "Time should not have been modified");
+	}
+
+}
+TEST_END
+
+int
+main(void)
+{
+
+	return (test(
+	    test_nstime_init,
+	    test_nstime_init2,
+	    test_nstime_copy,
+	    test_nstime_compare,
+	    test_nstime_add,
+	    test_nstime_subtract,
+	    test_nstime_imultiply,
+	    test_nstime_idivide,
+	    test_nstime_divide,
+	    test_nstime_update));
+}
diff --git a/test/unit/time.c b/test/unit/time.c
deleted file mode 100644
index 941e6f1..0000000
--- a/test/unit/time.c
+++ /dev/null
@@ -1,223 +0,0 @@
-#include "test/jemalloc_test.h"
-
-#define	BILLION	1000000000
-
-TEST_BEGIN(test_time_init)
-{
-	struct timespec ts;
-
-	time_init(&ts, 42, 43);
-	assert_ld_eq(ts.tv_sec, 42, "tv_sec incorrectly initialized");
-	assert_ld_eq(ts.tv_nsec, 43, "tv_nsec incorrectly initialized");
-}
-TEST_END
-
-TEST_BEGIN(test_time_sec)
-{
-	struct timespec ts;
-
-	time_init(&ts, 42, 43);
-	assert_ld_eq(time_sec(&ts), 42, "tv_sec incorrectly read");
-}
-TEST_END
-
-TEST_BEGIN(test_time_nsec)
-{
-	struct timespec ts;
-
-	time_init(&ts, 42, 43);
-	assert_ld_eq(time_nsec(&ts), 43, "tv_nsec incorrectly read");
-}
-TEST_END
-
-TEST_BEGIN(test_time_copy)
-{
-	struct timespec tsa, tsb;
-
-	time_init(&tsa, 42, 43);
-	time_init(&tsb, 0, 0);
-	time_copy(&tsb, &tsa);
-	assert_ld_eq(time_sec(&tsb), 42, "tv_sec incorrectly copied");
-	assert_ld_eq(time_nsec(&tsb), 43, "tv_nsec incorrectly copied");
-}
-TEST_END
-
-TEST_BEGIN(test_time_compare)
-{
-	struct timespec tsa, tsb;
-
-	time_init(&tsa, 42, 43);
-	time_copy(&tsb, &tsa);
-	assert_d_eq(time_compare(&tsa, &tsb), 0, "Times should be equal");
-	assert_d_eq(time_compare(&tsb, &tsa), 0, "Times should be equal");
-
-	time_init(&tsb, 42, 42);
-	assert_d_eq(time_compare(&tsa, &tsb), 1,
-	    "tsa should be greater than tsb");
-	assert_d_eq(time_compare(&tsb, &tsa), -1,
-	    "tsb should be less than tsa");
-
-	time_init(&tsb, 42, 44);
-	assert_d_eq(time_compare(&tsa, &tsb), -1,
-	    "tsa should be less than tsb");
-	assert_d_eq(time_compare(&tsb, &tsa), 1,
-	    "tsb should be greater than tsa");
-
-	time_init(&tsb, 41, BILLION - 1);
-	assert_d_eq(time_compare(&tsa, &tsb), 1,
-	    "tsa should be greater than tsb");
-	assert_d_eq(time_compare(&tsb, &tsa), -1,
-	    "tsb should be less than tsa");
-
-	time_init(&tsb, 43, 0);
-	assert_d_eq(time_compare(&tsa, &tsb), -1,
-	    "tsa should be less than tsb");
-	assert_d_eq(time_compare(&tsb, &tsa), 1,
-	    "tsb should be greater than tsa");
-}
-TEST_END
-
-TEST_BEGIN(test_time_add)
-{
-	struct timespec tsa, tsb;
-
-	time_init(&tsa, 42, 43);
-	time_copy(&tsb, &tsa);
-	time_add(&tsa, &tsb);
-	time_init(&tsb, 84, 86);
-	assert_d_eq(time_compare(&tsa, &tsb), 0, "Incorrect addition result");
-
-	time_init(&tsa, 42, BILLION - 1);
-	time_copy(&tsb, &tsa);
-	time_add(&tsa, &tsb);
-	time_init(&tsb, 85, BILLION - 2);
-	assert_d_eq(time_compare(&tsa, &tsb), 0, "Incorrect addition result");
-}
-TEST_END
-
-TEST_BEGIN(test_time_subtract)
-{
-	struct timespec tsa, tsb;
-
-	time_init(&tsa, 42, 43);
-	time_copy(&tsb, &tsa);
-	time_subtract(&tsa, &tsb);
-	time_init(&tsb, 0, 0);
-	assert_d_eq(time_compare(&tsa, &tsb), 0,
-	    "Incorrect subtraction result");
-
-	time_init(&tsa, 42, 43);
-	time_init(&tsb, 41, 44);
-	time_subtract(&tsa, &tsb);
-	time_init(&tsb, 0, BILLION - 1);
-	assert_d_eq(time_compare(&tsa, &tsb), 0,
-	    "Incorrect subtraction result");
-}
-TEST_END
-
-TEST_BEGIN(test_time_imultiply)
-{
-	struct timespec tsa, tsb;
-
-	time_init(&tsa, 42, 43);
-	time_imultiply(&tsa, 10);
-	time_init(&tsb, 420, 430);
-	assert_d_eq(time_compare(&tsa, &tsb), 0,
-	    "Incorrect multiplication result");
-
-	time_init(&tsa, 42, 666666666);
-	time_imultiply(&tsa, 3);
-	time_init(&tsb, 127, 999999998);
-	assert_d_eq(time_compare(&tsa, &tsb), 0,
-	    "Incorrect multiplication result");
-}
-TEST_END
-
-TEST_BEGIN(test_time_idivide)
-{
-	struct timespec tsa, tsb;
-
-	time_init(&tsa, 42, 43);
-	time_copy(&tsb, &tsa);
-	time_imultiply(&tsa, 10);
-	time_idivide(&tsa, 10);
-	assert_d_eq(time_compare(&tsa, &tsb), 0, "Incorrect division result");
-
-	time_init(&tsa, 42, 666666666);
-	time_copy(&tsb, &tsa);
-	time_imultiply(&tsa, 3);
-	time_idivide(&tsa, 3);
-	assert_d_eq(time_compare(&tsa, &tsb), 0, "Incorrect division result");
-}
-TEST_END
-
-TEST_BEGIN(test_time_divide)
-{
-	struct timespec tsa, tsb, tsc;
-
-	time_init(&tsa, 42, 43);
-	time_copy(&tsb, &tsa);
-	time_imultiply(&tsa, 10);
-	assert_u64_eq(time_divide(&tsa, &tsb), 10,
-	    "Incorrect division result");
-
-	time_init(&tsa, 42, 43);
-	time_copy(&tsb, &tsa);
-	time_imultiply(&tsa, 10);
-	time_init(&tsc, 0, 1);
-	time_add(&tsa, &tsc);
-	assert_u64_eq(time_divide(&tsa, &tsb), 10,
-	    "Incorrect division result");
-
-	time_init(&tsa, 42, 43);
-	time_copy(&tsb, &tsa);
-	time_imultiply(&tsa, 10);
-	time_init(&tsc, 0, 1);
-	time_subtract(&tsa, &tsc);
-	assert_u64_eq(time_divide(&tsa, &tsb), 9, "Incorrect division result");
-}
-TEST_END
-
-TEST_BEGIN(test_time_update)
-{
-	struct timespec ts;
-
-	time_init(&ts, 0, 0);
-
-	assert_false(time_update(&ts), "Basic time update failed.");
-
-	/* Only Rip Van Winkle sleeps this long. */
-	{
-		struct timespec addend;
-		time_init(&addend, 631152000, 0);
-		time_add(&ts, &addend);
-	}
-	{
-		struct timespec ts0;
-		time_copy(&ts0, &ts);
-		assert_true(time_update(&ts),
-		    "Update should detect time roll-back.");
-		assert_d_eq(time_compare(&ts, &ts0), 0,
-		    "Time should not have been modified");
-	}
-
-}
-TEST_END
-
-int
-main(void)
-{
-
-	return (test(
-	    test_time_init,
-	    test_time_sec,
-	    test_time_nsec,
-	    test_time_copy,
-	    test_time_compare,
-	    test_time_add,
-	    test_time_subtract,
-	    test_time_imultiply,
-	    test_time_idivide,
-	    test_time_divide,
-	    test_time_update));
-}