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.

src/arena.c

@@ -1224,27 +1224,24 @@ arena_decay_deadline_init(arena_t *arena)
 	 * Generate a new deadline that is uniformly random within the next
 	 * epoch after the current one.
 	 */
-	time_copy(&arena->decay_deadline, &arena->decay_epoch);
-	time_add(&arena->decay_deadline, &arena->decay_interval);
+	nstime_copy(&arena->decay_deadline, &arena->decay_epoch);
+	nstime_add(&arena->decay_deadline, &arena->decay_interval);
 	if (arena->decay_time > 0) {
-		uint64_t decay_interval_ns, r;
-		struct timespec jitter;
+		nstime_t jitter;
 
-		decay_interval_ns = time_sec(&arena->decay_interval) *
-		    1000000000 + time_nsec(&arena->decay_interval);
-		r = prng_range(&arena->decay_jitter_state, decay_interval_ns);
-		time_init(&jitter, r / 1000000000, r % 1000000000);
-		time_add(&arena->decay_deadline, &jitter);
+		nstime_init(&jitter, prng_range(&arena->decay_jitter_state,
+		    nstime_ns(&arena->decay_interval)));
+		nstime_add(&arena->decay_deadline, &jitter);
 	}
 }
 
 static bool
-arena_decay_deadline_reached(const arena_t *arena, const struct timespec *time)
+arena_decay_deadline_reached(const arena_t *arena, const nstime_t *time)
 {
 
 	assert(opt_purge == purge_mode_decay);
 
-	return (time_compare(&arena->decay_deadline, time) <= 0);
+	return (nstime_compare(&arena->decay_deadline, time) <= 0);
 }
 
 static size_t
@@ -1276,24 +1273,24 @@ arena_decay_backlog_npages_limit(const arena_t *arena)
 }
 
 static void
-arena_decay_epoch_advance(arena_t *arena, const struct timespec *time)
+arena_decay_epoch_advance(arena_t *arena, const nstime_t *time)
 {
 	uint64_t nadvance;
-	struct timespec delta;
+	nstime_t delta;
 	size_t ndirty_delta;
 
 	assert(opt_purge == purge_mode_decay);
 	assert(arena_decay_deadline_reached(arena, time));
 
-	time_copy(&delta, time);
-	time_subtract(&delta, &arena->decay_epoch);
-	nadvance = time_divide(&delta, &arena->decay_interval);
+	nstime_copy(&delta, time);
+	nstime_subtract(&delta, &arena->decay_epoch);
+	nadvance = nstime_divide(&delta, &arena->decay_interval);
 	assert(nadvance > 0);
 
 	/* Add nadvance decay intervals to epoch. */
-	time_copy(&delta, &arena->decay_interval);
-	time_imultiply(&delta, nadvance);
-	time_add(&arena->decay_epoch, &delta);
+	nstime_copy(&delta, &arena->decay_interval);
+	nstime_imultiply(&delta, nadvance);
+	nstime_add(&arena->decay_epoch, &delta);
 
 	/* Set a new deadline. */
 	arena_decay_deadline_init(arena);
@@ -1340,12 +1337,12 @@ arena_decay_init(arena_t *arena, ssize_t decay_time)
 
 	arena->decay_time = decay_time;
 	if (decay_time > 0) {
-		time_init(&arena->decay_interval, decay_time, 0);
-		time_idivide(&arena->decay_interval, SMOOTHSTEP_NSTEPS);
+		nstime_init2(&arena->decay_interval, decay_time, 0);
+		nstime_idivide(&arena->decay_interval, SMOOTHSTEP_NSTEPS);
 	}
 
-	time_init(&arena->decay_epoch, 0, 0);
-	time_update(&arena->decay_epoch);
+	nstime_init(&arena->decay_epoch, 0);
+	nstime_update(&arena->decay_epoch);
 	arena->decay_jitter_state = (uint64_t)(uintptr_t)arena;
 	arena_decay_deadline_init(arena);
 	arena->decay_ndirty = arena->ndirty;
@@ -1357,7 +1354,7 @@ static bool
 arena_decay_time_valid(ssize_t decay_time)
 {
 
-	return (decay_time >= -1 && decay_time <= TIME_SEC_MAX);
+	return (decay_time >= -1 && decay_time <= NSTIME_SEC_MAX);
 }
 
 ssize_t
@@ -1426,7 +1423,7 @@ arena_maybe_purge_ratio(arena_t *arena)
 static void
 arena_maybe_purge_decay(arena_t *arena)
 {
-	struct timespec time;
+	nstime_t time;
 	size_t ndirty_limit;
 
 	assert(opt_purge == purge_mode_decay);
@@ -1438,10 +1435,10 @@ arena_maybe_purge_decay(arena_t *arena)
 		return;
 	}
 
-	time_copy(&time, &arena->decay_epoch);
-	if (unlikely(time_update(&time))) {
+	nstime_copy(&time, &arena->decay_epoch);
+	if (unlikely(nstime_update(&time))) {
 		/* Time went backwards.  Force an epoch advance. */
-		time_copy(&time, &arena->decay_deadline);
+		nstime_copy(&time, &arena->decay_deadline);
 	}
 
 	if (arena_decay_deadline_reached(arena, &time))

src/jemalloc.c

@@ -1151,7 +1151,7 @@ malloc_conf_init(void)
 			CONF_HANDLE_SSIZE_T(opt_lg_dirty_mult, "lg_dirty_mult",
 			    -1, (sizeof(size_t) << 3) - 1)
 			CONF_HANDLE_SSIZE_T(opt_decay_time, "decay_time", -1,
-			    TIME_SEC_MAX);
+			    NSTIME_SEC_MAX);
 			CONF_HANDLE_BOOL(opt_stats_print, "stats_print", true)
 			if (config_fill) {
 				if (CONF_MATCH("junk")) {

src/nstime.c

@@ -0,0 +1,148 @@
+#include "jemalloc/internal/jemalloc_internal.h"
+
+#define	BILLION	UINT64_C(1000000000)
+
+void
+nstime_init(nstime_t *time, uint64_t ns)
+{
+
+	time->ns = ns;
+}
+
+void
+nstime_init2(nstime_t *time, uint64_t sec, uint64_t nsec)
+{
+
+	time->ns = sec * BILLION + nsec;
+}
+
+uint64_t
+nstime_ns(const nstime_t *time)
+{
+
+	return (time->ns);
+}
+
+uint64_t
+nstime_sec(const nstime_t *time)
+{
+
+	return (time->ns / BILLION);
+}
+
+uint64_t
+nstime_nsec(const nstime_t *time)
+{
+
+	return (time->ns % BILLION);
+}
+
+void
+nstime_copy(nstime_t *time, const nstime_t *source)
+{
+
+	*time = *source;
+}
+
+int
+nstime_compare(const nstime_t *a, const nstime_t *b)
+{
+
+	return ((a->ns > b->ns) - (a->ns < b->ns));
+}
+
+void
+nstime_add(nstime_t *time, const nstime_t *addend)
+{
+
+	assert(UINT64_MAX - time->ns >= addend->ns);
+
+	time->ns += addend->ns;
+}
+
+void
+nstime_subtract(nstime_t *time, const nstime_t *subtrahend)
+{
+
+	assert(nstime_compare(time, subtrahend) >= 0);
+
+	time->ns -= subtrahend->ns;
+}
+
+void
+nstime_imultiply(nstime_t *time, uint64_t multiplier)
+{
+
+	assert((((time->ns | multiplier) & (UINT64_MAX << (sizeof(uint64_t) <<
+	    2))) == 0) || ((time->ns * multiplier) / multiplier == time->ns));
+
+	time->ns *= multiplier;
+}
+
+void
+nstime_idivide(nstime_t *time, uint64_t divisor)
+{
+
+	assert(divisor != 0);
+
+	time->ns /= divisor;
+}
+
+uint64_t
+nstime_divide(const nstime_t *time, const nstime_t *divisor)
+{
+
+	assert(divisor->ns != 0);
+
+	return (time->ns / divisor->ns);
+}
+
+#ifdef JEMALLOC_JET
+#undef nstime_update
+#define	nstime_update JEMALLOC_N(nstime_update_impl)
+#endif
+bool
+nstime_update(nstime_t *time)
+{
+	nstime_t old_time;
+
+	nstime_copy(&old_time, time);
+
+#ifdef _WIN32
+	{
+		FILETIME ft;
+		uint64_t ticks;
+		GetSystemTimeAsFileTime(&ft);
+		ticks = (((uint64_t)ft.dwHighDateTime) << 32) |
+		    ft.dwLowDateTime;
+		time->ns = ticks * 100;
+	}
+#elif JEMALLOC_CLOCK_GETTIME
+	{
+		struct timespec ts;
+
+		if (sysconf(_SC_MONOTONIC_CLOCK) > 0)
+			clock_gettime(CLOCK_MONOTONIC, &ts);
+		else
+			clock_gettime(CLOCK_REALTIME, &ts);
+		time->ns = ts.tv_sec * BILLION + ts.tv_nsec;
+	}
+#else
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	time->ns = tv.tv_sec * BILLION + tv.tv_usec * 1000;
+#endif
+
+	/* Handle non-monotonic clocks. */
+	if (unlikely(nstime_compare(&old_time, time) > 0)) {
+		nstime_copy(time, &old_time);
+		return (true);
+	}
+
+	return (false);
+}
+#ifdef JEMALLOC_JET
+#undef nstime_update
+#define	nstime_update JEMALLOC_N(nstime_update)
+nstime_update_t *nstime_update = JEMALLOC_N(nstime_update_impl);
+#endif

src/time.c

@@ -1,198 +0,0 @@
-#include "jemalloc/internal/jemalloc_internal.h"
-
-#define	BILLION		1000000000
-
-UNUSED static bool
-time_valid(const struct timespec *time)
-{
-
-	if (time->tv_sec > TIME_SEC_MAX)
-		return (false);
-	if (time->tv_nsec >= BILLION)
-		return (false);
-
-	return (true);
-}
-
-void
-time_init(struct timespec *time, time_t sec, long nsec)
-{
-
-	time->tv_sec = sec;
-	time->tv_nsec = nsec;
-
-	assert(time_valid(time));
-}
-
-time_t
-time_sec(const struct timespec *time)
-{
-
-	assert(time_valid(time));
-
-	return (time->tv_sec);
-}
-
-long
-time_nsec(const struct timespec *time)
-{
-
-	assert(time_valid(time));
-
-	return (time->tv_nsec);
-}
-
-void
-time_copy(struct timespec *time, const struct timespec *source)
-{
-
-	assert(time_valid(source));
-
-	*time = *source;
-}
-
-int
-time_compare(const struct timespec *a, const struct timespec *b)
-{
-	int ret;
-
-	assert(time_valid(a));
-	assert(time_valid(b));
-
-	ret = (a->tv_sec > b->tv_sec) - (a->tv_sec < b->tv_sec);
-	if (ret == 0)
-		ret = (a->tv_nsec > b->tv_nsec) - (a->tv_nsec < b->tv_nsec);
-
-	return (ret);
-}
-
-void
-time_add(struct timespec *time, const struct timespec *addend)
-{
-
-	assert(time_valid(time));
-	assert(time_valid(addend));
-
-	time->tv_sec += addend->tv_sec;
-	time->tv_nsec += addend->tv_nsec;
-	if (time->tv_nsec >= BILLION) {
-		time->tv_sec++;
-		time->tv_nsec -= BILLION;
-	}
-
-	assert(time_valid(time));
-}
-
-void
-time_subtract(struct timespec *time, const struct timespec *subtrahend)
-{
-
-	assert(time_valid(time));
-	assert(time_valid(subtrahend));
-	assert(time_compare(time, subtrahend) >= 0);
-
-	time->tv_sec -= subtrahend->tv_sec;
-	if (time->tv_nsec < subtrahend->tv_nsec) {
-		time->tv_sec--;
-		time->tv_nsec += BILLION;
-	}
-	time->tv_nsec -= subtrahend->tv_nsec;
-}
-
-void
-time_imultiply(struct timespec *time, uint64_t multiplier)
-{
-	time_t sec;
-	uint64_t nsec;
-
-	assert(time_valid(time));
-
-	sec = time->tv_sec * multiplier;
-	nsec = time->tv_nsec * multiplier;
-	sec += nsec / BILLION;
-	nsec %= BILLION;
-	time_init(time, sec, (long)nsec);
-
-	assert(time_valid(time));
-}
-
-void
-time_idivide(struct timespec *time, uint64_t divisor)
-{
-	time_t sec;
-	uint64_t nsec;
-
-	assert(time_valid(time));
-
-	sec = time->tv_sec / divisor;
-	nsec = ((time->tv_sec % divisor) * BILLION + time->tv_nsec) / divisor;
-	sec += nsec / BILLION;
-	nsec %= BILLION;
-	time_init(time, sec, (long)nsec);
-
-	assert(time_valid(time));
-}
-
-uint64_t
-time_divide(const struct timespec *time, const struct timespec *divisor)
-{
-	uint64_t t, d;
-
-	assert(time_valid(time));
-	assert(time_valid(divisor));
-
-	t = time_sec(time) * BILLION + time_nsec(time);
-	d = time_sec(divisor) * BILLION + time_nsec(divisor);
-	assert(d != 0);
-	return (t / d);
-}
-
-#ifdef JEMALLOC_JET
-#undef time_update
-#define	time_update JEMALLOC_N(time_update_impl)
-#endif
-bool
-time_update(struct timespec *time)
-{
-	struct timespec old_time;
-
-	assert(time_valid(time));
-
-	time_copy(&old_time, time);
-
-#ifdef _WIN32
-	{
-		FILETIME ft;
-		uint64_t ticks;
-		GetSystemTimeAsFileTime(&ft);
-		ticks = (((uint64_t)ft.dwHighDateTime) << 32) |
-		    ft.dwLowDateTime;
-		time->tv_sec = ticks / 10000000;
-		time->tv_nsec = ((ticks % 10000000) * 100);
-	}
-#elif JEMALLOC_CLOCK_GETTIME
-	if (sysconf(_SC_MONOTONIC_CLOCK) > 0)
-		clock_gettime(CLOCK_MONOTONIC, time);
-	else
-		clock_gettime(CLOCK_REALTIME, time);
-#else
-	struct timeval tv;
-	gettimeofday(&tv, NULL);
-	time->tv_sec = tv.tv_sec;
-	time->tv_nsec = tv.tv_usec * 1000;
-#endif
-
-	/* Handle non-monotonic clocks. */
-	if (unlikely(time_compare(&old_time, time) > 0)) {
-		time_copy(time, &old_time);
-		return (true);
-	}
-
-	assert(time_valid(time));
-	return (false);
-}
-#ifdef JEMALLOC_JET
-#undef time_update
-#define	time_update JEMALLOC_N(time_update)
-time_update_t *time_update = JEMALLOC_N(time_update_impl);
-#endif