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.

2 files changed, 55 insertions, 18 deletions

diff --git a/erts/emulator/sys/ose/erl_poll.c b/erts/emulator/sys/ose/erl_poll.c
index 7d2a3d1e0b..36ee2557e8 100644
--- a/erts/emulator/sys/ose/erl_poll.c
+++ b/erts/emulator/sys/ose/erl_poll.c
@@ -114,7 +114,7 @@ struct ErtsPollSet_ {
     Uint item_count;
     PROCESS interrupt;
     erts_atomic32_t wakeup_state;
-    erts_smp_atomic32_t timeout;
+    erts_atomic64_t timeout_time;
 #ifdef ERTS_SMP
     erts_smp_mtx_t mtx;
 #endif
@@ -122,6 +122,26 @@ struct ErtsPollSet_ {
 
 static int max_fds = -1;
 
+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) (1 << 0))
 #define ERTS_POLL_WOKEN_INTR		((erts_aint32_t) (1 << 1))
 #define ERTS_POLL_WOKEN_TIMEDOUT	((erts_aint32_t) (1 << 2))
@@ -386,12 +406,14 @@ void erts_poll_interrupt(ErtsPollSet ps,int set) {
 
 }
 
-void erts_poll_interrupt_timed(ErtsPollSet ps,int set,erts_short_time_t msec) {
+void erts_poll_interrupt_timed(ErtsPollSet ps,
+			       int set,
+			       ErtsTimeoutTime timeout_time) {
     HARDTRACEF("erts_poll_interrupt_timed called!\n");
 
     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);
 }
 
@@ -453,12 +475,14 @@ done:
 }
 
 int erts_poll_wait(ErtsPollSet ps,
-	   ErtsPollResFd pr[],
-	   int *len,
-	   SysTimeval *utvp) {
+		   ErtsPollResFd pr[],
+		   int *len,
+		   ErtsMonotonicTime timeout_time)
+{
     int res = ETIMEDOUT, no_fds, currid = 0;
     OSTIME timeout;
     union SIGNAL *sig;
+    ErtsMonotonicTime current_time, diff_time, timeout;
     // HARDTRACEF("%ux: In erts_poll_wait",ps);
     if (ps->interrupt == (PROCESS)0)
       ps->interrupt = current_process();
@@ -472,16 +496,29 @@ int erts_poll_wait(ErtsPollSet ps,
 
     *len = 0;
 
-    ASSERT(utvp);
+    /* erts_printf("Entering erts_poll_wait(), timeout_time=%bps\n",
+		   timeout_time); */
 
-    /* erts_printf("Entering erts_poll_wait(), timeout=%d\n",
-		 (int) utvp->tv_sec*1000 + utvp->tv_usec/1000); */
-
-    timeout = utvp->tv_sec*1000 + utvp->tv_usec/1000;
+    if (timeout_time == ERTS_POLL_NO_TIMEOUT) {
+    no_timeout:
+	timeout = (OSTIME) 0;
+	save_timeout_time = ERTS_MONOTONIC_TIME_MIN;
+    }
+    else {
+	ErtsMonotonicTime current_time, diff_time;
+	current_time = erts_get_monotonic_time();
+	diff_time = timeout_time - current_time;
+	if (diff_time <= 0)
+	    goto no_timeout;
+	diff_time = (ERTS_MONOTONIC_TO_MSEC(diff_time - 1) + 1);
+	if (diff_time > INT_MAX)
+	    diff_time = INT_MAX;
+	timeout = (OSTIME) diff_time;
+	save_timeout_time = current_time;
+	save_timeout_time += ERTS_MSEC_TO_MONOTONIC(diff_time);
+    }
 
-    if (timeout > ((time_t) ERTS_AINT32_T_MAX))
-      timeout = ERTS_AINT32_T_MAX;
-    erts_smp_atomic32_set_relb(&ps->timeout, (erts_aint32_t) timeout);
+    set_timeout_time(ps, save_timeout_time);
 
     while (currid < no_fds) {
       if (timeout > 0) {
@@ -627,7 +664,7 @@ int erts_poll_wait(ErtsPollSet ps,
     }
 
     erts_atomic32_set_nob(&ps->wakeup_state, ERTS_POLL_NOT_WOKEN);
-    erts_smp_atomic32_set_nob(&ps->timeout, ERTS_AINT32_T_MAX);
+    set_timeout_time(ps, ERTS_MONOTONIC_TIME_MAX);
 
     *len = currid;
 
@@ -690,7 +727,7 @@ ErtsPollSet erts_poll_create_pollset(void)
     ps->info       = NULL;
     ps->interrupt  = (PROCESS)0;
     erts_atomic32_init_nob(&ps->wakeup_state, ERTS_POLL_NOT_WOKEN);
-    erts_smp_atomic32_init_nob(&ps->timeout, ERTS_AINT32_T_MAX);
+    init_timeout_time(ps);
 #ifdef ERTS_SMP
     erts_smp_mtx_init(&ps->mtx, "pollset");
 #endif
diff --git a/erts/emulator/sys/ose/sys.c b/erts/emulator/sys/ose/sys.c
index 5b950a7dae..13a5b71496 100644
--- a/erts/emulator/sys/ose/sys.c
+++ b/erts/emulator/sys/ose/sys.c
@@ -298,9 +298,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_CHK_IO_INTR_TMD(set, msec);
+    ERTS_CHK_IO_INTR_TMD(set, timeout_time);
 }
 #endif