Introduce a new time API

The old time API is based on erlang:now/0. The major issue with
erlang:now/0 is that it was intended to be used for so many
unrelated things. This tied these unrelated operations together
and unnecessarily caused performance, scalability as well as
accuracy, and precision issues for operations that do not need
to have such issues. The new API spreads different functionality
over multiple functions in order to improve on this.

The new API consists of a number of new BIFs:
- erlang:convert_time_unit/3
- erlang:monotonic_time/0
- erlang:monotonic_time/1
- erlang:system_time/0
- erlang:system_time/1
- erlang:time_offset/0
- erlang:time_offset/1
- erlang:timestamp/0
- erlang:unique_integer/0
- erlang:unique_integer/1
- os:system_time/0
- os:system_time/1

and a number of extensions of existing BIFs:
- erlang:monitor(time_offset, clock_service)
- erlang:system_flag(time_offset, finalize)
- erlang:system_info(os_monotonic_time_source)
- erlang:system_info(time_offset)
- erlang:system_info(time_warp_mode)
- erlang:system_info(time_correction)
- erlang:system_info(start_time)

See the "Time and Time Correction in Erlang" chapter of the
ERTS User's Guide for more information.

4 files changed, 242 insertions, 74 deletions

diff --git a/erts/emulator/sys/win32/erl_poll.c b/erts/emulator/sys/win32/erl_poll.c
index 972170d465..5a62b00a68 100644
--- a/erts/emulator/sys/win32/erl_poll.c
+++ b/erts/emulator/sys/win32/erl_poll.c
@@ -285,7 +285,7 @@ struct ErtsPollSet_ {
 #ifdef ERTS_SMP
     erts_smp_mtx_t mtx;
 #endif
-    erts_smp_atomic32_t timeout;
+    erts_atomic64_t timeout_time;
 };
 
 #ifdef ERTS_SMP
@@ -363,6 +363,26 @@ do { \
     wait_standby(PS); \
  } while(0)
 
+static ERTS_INLINE void
+init_timeout_time(ErtsPollSet ps)
+{
+    erts_atomic64_init_nob(&ps->timeout_time,
+			   (erts_aint64_t) ERTS_MONOTONIC_TIME_MAX);
+}
+
+static ERTS_INLINE void
+set_timeout_time(ErtsPollSet ps, ErtsMonotonicTime time)
+{
+    erts_atomic64_set_relb(&ps->timeout_time,
+			   (erts_aint64_t) time);
+}
+
+static ERTS_INLINE ErtsMonotonicTime
+get_timeout_time(ErtsPollSet ps)
+{
+    return (ErtsMonotonicTime) erts_atomic64_read_acqb(&ps->timeout_time);
+}
+
 #define ERTS_POLL_NOT_WOKEN		((erts_aint32_t) 0)
 #define ERTS_POLL_WOKEN_IO_READY	((erts_aint32_t) 1)
 #define ERTS_POLL_WOKEN_INTR		((erts_aint32_t) 2)
@@ -422,15 +442,29 @@ wakeup_cause(ErtsPollSet ps)
 }
 
 static ERTS_INLINE DWORD
-poll_wait_timeout(ErtsPollSet ps, SysTimeval *tvp)
+poll_wait_timeout(ErtsPollSet ps, ErtsMonotonicTime timeout_time)
 {
-    time_t timeout = tvp->tv_sec * 1000 + tvp->tv_usec / 1000;
+    ErtsMonotonicTime current_time, diff_time, timeout;
 
-    if (timeout <= 0) {
+    if (timeout_time == ERTS_POLL_NO_TIMEOUT) {
+    no_timeout:
+	set_timeout_time(ps, ERTS_MONOTONIC_TIME_MIN);
 	woke_up(ps);
 	return (DWORD) 0;
     }
 
+    current_time = erts_get_monotonic_time();
+    diff_time = timeout_time - current_time;
+    if (diff_time <= 0)
+	goto no_timeout;
+
+    /* Round up to nearest milli second */
+    timeout = (ERTS_MONOTONIC_TO_MSEC(diff_time - 1) + 1);
+    if (timeout > INT_MAX)
+	timeout = INT_MAX; /* Also prevents DWORD overflow */
+
+    set_timeout_time(ps, current_time + ERTS_MSEC_TO_MONOTONIC(timeout));
+
     ResetEvent(ps->event_io_ready);
     /*
      * Since we don't know the internals of ResetEvent() we issue
@@ -442,10 +476,6 @@ poll_wait_timeout(ErtsPollSet ps, SysTimeval *tvp)
     if (erts_atomic32_read_nob(&ps->wakeup_state) != ERTS_POLL_NOT_WOKEN)
 	return (DWORD) 0;
 
-    if (timeout > ((time_t) ERTS_AINT32_T_MAX))
-	timeout = ERTS_AINT32_T_MAX; /* Also prevents DWORD overflow */
-
-    erts_smp_atomic32_set_relb(&ps->timeout, (erts_aint32_t) timeout);
     return (DWORD) timeout;
 }
 
@@ -1012,12 +1042,12 @@ void  erts_poll_interrupt(ErtsPollSet ps, int set /* bool */)
 
 void erts_poll_interrupt_timed(ErtsPollSet ps,
 			       int set /* bool */,
-			       erts_short_time_t msec)
+			       ErtsMonotonicTime timeout_time)
 {
-    HARDTRACEF(("In erts_poll_interrupt_timed(%d,%ld)",set,msec));
+    HARDTRACEF(("In erts_poll_interrupt_timed(%d,%ld)",set,timeout_time));
     if (!set)
 	reset_interrupt(ps);
-    else if (erts_smp_atomic32_read_acqb(&ps->timeout) > (erts_aint32_t) msec)
+    else if (get_timeout_time(ps) > timeout_time)
 	set_interrupt(ps);
     HARDTRACEF(("Out erts_poll_interrupt_timed"));
 }
@@ -1092,7 +1122,7 @@ void erts_poll_controlv(ErtsPollSet ps,
 int erts_poll_wait(ErtsPollSet ps,
 		   ErtsPollResFd pr[],
 		   int *len,
-		   SysTimeval *tvp)
+		   ErtsMonotonicTime timeout_time)
 {
     int no_fds;
     DWORD timeout;
@@ -1149,7 +1179,7 @@ int erts_poll_wait(ErtsPollSet ps,
 	no_fds = ERTS_POLL_MAX_RES;
 #endif
 
-    timeout = poll_wait_timeout(ps, tvp);
+    timeout = poll_wait_timeout(ps, timeout_time);
 
     /*HARDDEBUGF(("timeout = %ld",(long) timeout));*/
 
@@ -1242,7 +1272,7 @@ int erts_poll_wait(ErtsPollSet ps,
 	erts_mtx_unlock(&w->mtx);
     }
  done:
-    erts_smp_atomic32_set_nob(&ps->timeout, ERTS_AINT32_T_MAX);
+    set_timeout_time(ps, ERTS_MONOTONIC_TIME_MAX);
     *len = num;
     ERTS_POLLSET_UNLOCK(ps);
     HARDTRACEF(("Out erts_poll_wait"));
@@ -1326,7 +1356,7 @@ ErtsPollSet erts_poll_create_pollset(void)
 #ifdef ERTS_SMP
     erts_smp_mtx_init(&ps->mtx, "pollset");
 #endif
-    erts_smp_atomic32_init_nob(&ps->timeout, ERTS_AINT32_T_MAX);
+    init_timeout_time(ps);
 
     HARDTRACEF(("Out erts_poll_create_pollset"));
     return ps;
diff --git a/erts/emulator/sys/win32/erl_win_sys.h b/erts/emulator/sys/win32/erl_win_sys.h
index 838f0c61eb..f04bb6a0e5 100644
--- a/erts/emulator/sys/win32/erl_win_sys.h
+++ b/erts/emulator/sys/win32/erl_win_sys.h
@@ -120,9 +120,6 @@
 /*
  * For erl_time_sup
  */
-#define HAVE_GETHRTIME
-
-#define sys_init_hrtime() /* Nothing */
 
 #define SYS_CLK_TCK 1000
 #define SYS_CLOCK_RESOLUTION 1
@@ -164,18 +161,58 @@ typedef struct {
 #if defined (__GNUC__)
 typedef unsigned long long Uint64;
 typedef long long          Sint64;
-
-typedef long long SysHrTime;
+#  ifdef ULLONG_MAX
+#    define ERTS_UINT64_MAX ULLONG_MAX
+#  endif
+#  ifdef LLONG_MAX
+#    define ERTS_SINT64_MAX LLONG_MAX
+#  endif
+#  ifdef LLONG_MIN
+#    define ERTS_SINT64_MIN LLONG_MIN
+#  endif
+
+typedef long long ErtsMonotonicTime;
 #else
 typedef ULONGLONG Uint64;
 typedef LONGLONG  Sint64;
 
-typedef LONGLONG SysHrTime;
+typedef LONGLONG ErtsMonotonicTime;
 #endif
 
-extern int sys_init_time(void);
+#define ERTS_MONOTONIC_TIME_MIN (((ErtsMonotonicTime) 1) << 63)
+#define ERTS_MONOTONIC_TIME_MAX (~ERTS_MONOTONIC_TIME_MIN)
+
+#define ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT 1
+#define ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT 0
+
+struct erts_sys_time_read_only_data__ {
+    ErtsMonotonicTime (*os_monotonic_time)(void);
+};
+
+typedef struct {
+    union {
+	struct erts_sys_time_read_only_data__ o;
+	char align__[(((sizeof(struct erts_sys_time_read_only_data__) - 1)
+		       / ASSUMED_CACHE_LINE_SIZE) + 1)
+		     * ASSUMED_CACHE_LINE_SIZE];
+    } r;
+} ErtsSysTimeData__;
+
+extern ErtsSysTimeData__ erts_sys_time_data__;
+
+ERTS_GLB_INLINE ErtsMonotonicTime erts_os_monotonic_time(void);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE ErtsMonotonicTime
+erts_os_monotonic_time(void)
+{
+    return (*erts_sys_time_data__.r.o.os_monotonic_time)();
+}
+
+#endif /* ERTS_GLB_INLINE_INCL_FUNC_DEF */
+
 extern void sys_gettimeofday(SysTimeval *tv);
-extern SysHrTime sys_gethrtime(void);
 extern clock_t sys_times(SysTimes *buffer);
 
 extern char *win_build_environment(char *);
diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c
index 0ded6b274e..8eed1c6d9b 100644
--- a/erts/emulator/sys/win32/sys.c
+++ b/erts/emulator/sys/win32/sys.c
@@ -3258,9 +3258,9 @@ erts_sys_schedule_interrupt(int set)
 
 #ifdef ERTS_SMP
 void
-erts_sys_schedule_interrupt_timed(int set, erts_short_time_t msec)
+erts_sys_schedule_interrupt_timed(int set, ErtsMonotonicTime timeout_time)
 {
-    erts_check_io_interrupt_timed(set, msec);
+    erts_check_io_interrupt_timed(set, timeout_time);
 }
 #endif
 
diff --git a/erts/emulator/sys/win32/sys_time.c b/erts/emulator/sys/win32/sys_time.c
index b84c8f85ce..3a10125c81 100644
--- a/erts/emulator/sys/win32/sys_time.c
+++ b/erts/emulator/sys/win32/sys_time.c
@@ -61,11 +61,6 @@
 	(epoch) = ((ull.QuadPart / TICKS_PER_SECOND) - EPOCH_JULIAN_DIFF); \
     } while(0)
  
-static SysHrTime wrap = 0;
-static DWORD last_tick_count = 0;
-static erts_smp_mtx_t wrap_lock;
-static ULONGLONG (WINAPI *pGetTickCount64)(void) = NULL;
-
 /* Getting timezone information is a heavy operation, so we want to do this 
    only once */
 
@@ -76,17 +71,161 @@ static int days_in_month[2][13] = {
     {0,31,28,31,30,31,30,31,31,30,31,30,31},
     {0,31,29,31,30,31,30,31,31,30,31,30,31}};
 
-int 
-sys_init_time(void)
+/*
+ * erts_os_monotonic_time()
+ */
+
+struct sys_time_internal_state_read_only__ {
+    ULONGLONG (WINAPI *pGetTickCount64)(void);
+    BOOL (WINAPI *pQueryPerformanceCounter)(LARGE_INTEGER *);
+};
+
+struct sys_time_internal_state_write_freq__ {
+    erts_smp_mtx_t mtime_mtx;
+    ULONGLONG wrap;
+    ULONGLONG last_tick_count;
+};
+
+__declspec(align(ASSUMED_CACHE_LINE_SIZE)) struct {
+    union {
+	struct sys_time_internal_state_read_only__ o;
+	char align__[(((sizeof(struct sys_time_internal_state_read_only__) - 1)
+		       / ASSUMED_CACHE_LINE_SIZE) + 1)
+		     * ASSUMED_CACHE_LINE_SIZE];
+    } r;
+    union {
+	struct sys_time_internal_state_write_freq__ f;
+	char align__[(((sizeof(struct sys_time_internal_state_write_freq__) - 1)
+		       / ASSUMED_CACHE_LINE_SIZE) + 1)
+		     * ASSUMED_CACHE_LINE_SIZE];
+    } w;
+} internal_state;
+
+__declspec(align(ASSUMED_CACHE_LINE_SIZE)) ErtsSysTimeData__ erts_sys_time_data__;
+
+static ErtsMonotonicTime
+os_monotonic_time_qpc(void)
 {
+    LARGE_INTEGER pc;
+
+    if (!(*internal_state.r.o.pQueryPerformanceCounter)(&pc))
+	erl_exit(ERTS_ABORT_EXIT, "QueryPerformanceCounter() failed\n");
+
+    return (ErtsMonotonicTime) pc.QuadPart;
+}
+
+static ErtsMonotonicTime
+os_monotonic_time_gtc32(void) 
+{
+    ULONGLONG res, ticks;
+
+    erts_smp_mtx_lock(&internal_state.w.f.mtime_mtx);
+
+    ticks = (ULONGLONG) (GetTickCount() & 0x7FFFFFFF);
+    if (ticks < internal_state.w.f.last_tick_count)
+	internal_state.w.f.wrap += (ULONGLONG) LL_LITERAL(1) << 31;
+    internal_state.w.f.last_tick_count = ticks;
+    res = ticks + internal_state.w.f.wrap;
+
+    erts_smp_mtx_unlock(&internal_state.w.f.mtime_mtx);
+
+    return (ErtsMonotonicTime) res*1000;
+}
+
+static ErtsMonotonicTime
+os_monotonic_time_gtc64(void) 
+{
+    ULONGLONG ticks = (*internal_state.r.o.pGetTickCount64)();
+    return (ErtsMonotonicTime) ticks*1000;
+}
+
+/*
+ * Init
+ */
+
+void
+sys_init_time(ErtsSysInitTimeResult *init_resp)
+{
+    ErtsMonotonicTime (*os_mtime_func)(void);
+    ErtsMonotonicTime time_unit;
     char kernel_dll_name[] = "kernel32";
     HMODULE module;
 
+    init_resp->os_monotonic_info.clock_id = NULL;
+
     module = GetModuleHandle(kernel_dll_name);
-    pGetTickCount64 = (module != NULL) ? 
-	(ULONGLONG (WINAPI *)(void)) 
-	GetProcAddress(module,"GetTickCount64") : 
-	NULL;
+    if (!module) {
+    get_tick_count:
+	erts_smp_mtx_init(&internal_state.w.f.mtime_mtx,
+			  "os_monotonic_time");
+	internal_state.w.f.wrap = 0;
+	internal_state.w.f.last_tick_count = 0;
+
+	init_resp->os_monotonic_info.func = "GetTickCount";
+	init_resp->os_monotonic_info.locked_use = 1;
+	init_resp->os_monotonic_info.resolution = 1000;
+	time_unit = (ErtsMonotonicTime) 1000*1000;
+	os_mtime_func = os_monotonic_time_gtc32;
+    }
+    else {
+	int major, minor, build;
+
+	os_version(&major, &minor, &build);
+
+	if (major < 6) {
+
+	get_tick_count64:
+
+	    internal_state.r.o.pGetTickCount64
+		= ((ULONGLONG (WINAPI *)(void))
+		   GetProcAddress(module, "GetTickCount64"));
+	    if (!internal_state.r.o.pGetTickCount64)
+		goto get_tick_count;
+
+	    init_resp->os_monotonic_info.func = "GetTickCount64";
+	    init_resp->os_monotonic_info.locked_use = 0;
+	    init_resp->os_monotonic_info.resolution = 1000;
+	    time_unit = (ErtsMonotonicTime) 1000*1000;
+	    os_mtime_func = os_monotonic_time_gtc64;
+	}
+	else { /* Vista or newer... */
+
+	    LARGE_INTEGER pf;
+	    BOOL (WINAPI *QPF)(LARGE_INTEGER *);
+
+	    QPF = ((BOOL (WINAPI *)(LARGE_INTEGER *))
+		   GetProcAddress(module, "QueryPerformanceFrequency"));
+	    if (!QPF)
+		goto get_tick_count64;
+	    if (!(*QPF)(&pf))
+		goto get_tick_count64;
+	    /*
+	     * We only use QueryPerformanceCounter() if
+	     * its frequency is equal to, or larger than
+	     * GHz in order to ensure that the user wont
+	     * be able to observe faulty order between
+	     * values retrieved on different threads.
+	     */
+	    if (pf.QuadPart < (LONGLONG) 1000*1000*1000)
+		goto get_tick_count64;
+	    internal_state.r.o.pQueryPerformanceCounter
+		= ((BOOL (WINAPI *)(LARGE_INTEGER *))
+		   GetProcAddress(module, "QueryPerformanceCounter"));
+	    if (!internal_state.r.o.pQueryPerformanceCounter)
+		goto get_tick_count64;
+
+	    init_resp->os_monotonic_info.func = "QueryPerformanceCounter";
+	    init_resp->os_monotonic_info.locked_use = 0;
+	    time_unit = (ErtsMonotonicTime) pf.QuadPart;
+	    init_resp->os_monotonic_info.resolution = time_unit;
+	    os_mtime_func = os_monotonic_time_qpc;
+	}
+    }
+
+    erts_sys_time_data__.r.o.os_monotonic_time = os_mtime_func;
+    init_resp->os_monotonic_time_unit = time_unit;
+    init_resp->have_os_monotonic = 1;
+    init_resp->sys_clock_resolution = 1;
 
     if(GetTimeZoneInformation(&static_tzi) && 
        static_tzi.StandardDate.wMonth != 0 &&
@@ -94,9 +233,6 @@ sys_init_time(void)
 	have_static_tzi = 1;
     }
 
-    erts_smp_mtx_init(&wrap_lock, "sys_gethrtime");
-
-    return 1;
 }
 
 /* Returns a switchtimes for DST as UTC filetimes given data from a 
@@ -377,41 +513,6 @@ sys_gettimeofday(SysTimeval *tv)
 			 EPOCH_JULIAN_DIFF);
 }
 
-extern int erts_initialized;
-SysHrTime 
-sys_gethrtime(void) 
-{
-    if (pGetTickCount64 != NULL) {
-	return ((SysHrTime) pGetTickCount64()) * LL_LITERAL(1000000);
-    } else {
-	DWORD ticks;
-	SysHrTime res;
-	erts_smp_mtx_lock(&wrap_lock);
-	ticks = (SysHrTime) (GetTickCount() & 0x7FFFFFFF);
-	if (ticks < (SysHrTime) last_tick_count) {
-	    /* Detect a race that should no longer be here... */
-	    if ((((SysHrTime) last_tick_count) - ((SysHrTime) ticks)) > 1000) {
-		wrap += LL_LITERAL(1) << 31;
-	    } else {
-		/* 
-		 * XXX Debug: Violates locking order, remove all this,
-		 * after testing!
-		 */
-		erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
-		erts_dsprintf(dsbufp, "Did not wrap when last_tick %d "
-			      "and tick %d", 
-			      last_tick_count, ticks);
-		erts_send_error_to_logger_nogl(dsbufp);
-		ticks = last_tick_count;
-	    }
-	}
-	last_tick_count = ticks;
-	res = ((((LONGLONG) ticks) + wrap) * LL_LITERAL(1000000));
-	erts_smp_mtx_unlock(&wrap_lock);
-	return res;
-    }
-}
-
 clock_t 
 sys_times(SysTimes *buffer) {
     clock_t kernel_ticks = (GetTickCount() /