Merge branch 'rickard/time_api/master/OTP-11997'

* rickard/time_api/master/OTP-11997: (22 commits)
  Update primary bootstrap
  inets: Suppress deprecated warning on erlang:now/0
  inets: Cleanup of multiple copies of functions Add inets_lib with common functions used by multiple modules
  inets: Update comments
  Suppress deprecated warning on erlang:now/0
  Use new time API and be back-compatible in inets Remove unused functions and removed redundant test
  asn1 test SUITE: Eliminate use of now/0
  Disable deprecated warning on erlang:now/0 in diameter_lib
  Use new time API and be back-compatible in ssh
  Replace all calls to now/0 in CT with new time API functions
  test_server: Replace usage of erlang:now() with usage of new API
  Replace usage of erlang:now() with usage of new API
  Replace usage of erlang:now() with usage of new API
  Replace usage of erlang:now() with usage of new API
  Replace usage of erlang:now() with usage of new API
  otp_SUITE: Warn for calls to erlang:now/0
  Replace usage of erlang:now() with usage of new API
  Multiple timer wheels
  Erlang based BIF timer implementation for scalability
  Implement ethread events with timeout
  ...

1 files changed, 1406 insertions, 453 deletions

diff --git a/erts/emulator/beam/erl_time_sup.c b/erts/emulator/beam/erl_time_sup.c
index 3272a5326d..d47d1682d7 100644
--- a/erts/emulator/beam/erl_time_sup.c
+++ b/erts/emulator/beam/erl_time_sup.c
@@ -18,60 +18,8 @@
  */
 
 /*
-** Support routines for the timer wheel
-**
-** This code contains two strategies for dealing with 
-** date/time changes in the system. 
-** If the system has some kind of high resolution timer (HAVE_GETHRTIME),
-** the high resolution timer is used to correct the time-of-day and the
-** timeouts, the base source is the hrtimer, but at certain intervals the 
-** OS time-of-day is checked and if it is not within certain bounds, the 
-** delivered time gets slowly adjusted for each call until
-** it corresponds to the system time (built-in adjtime...). 
-** The call gethrtime() is detected by autoconf on Unix, but other 
-** platforms may define it in erl_*_sys.h and implement 
-** their own high resolution timer. The high resolution timer
-** strategy is (probably) best on all systems where the timer have 
-** a resolution higher or equal to gettimeofday (or what's implemented
-** is sys_gettimeofday()). The actual resolution is the interesting thing,
-** not the unit's thats used (i.e. on VxWorks, nanoseconds can be
-** retrieved in terms of units, but the actual resolution is the same as 
-** for the clock ticks).
-** If the systems best timer routine is kernel ticks returned from 
-** sys_times(), and the actual resolution of sys_gettimeofday() is
-** better (like most unixes that does not have any realtime extensions), 
-** another strategy is used. The tolerant gettimeofday() corrects 
-** the value with respect to uptime (sys_times() return value) and checks 
-** for correction both when delivering timeticks and delivering nowtime.
-** this strategy is slower, but accurate on systems without better timer 
-** routines. The kernel tick resolution is not enough to implement
-** a gethrtime routine. On Linux and other non solaris unix-boxes the second 
-** strategy is used, on all other platforms we use the first.
-** 
-** The following is expected (from sys.[ch] and erl_*_sys.h):
-**
-** 64 bit integers. So it is, and so it will be.
-**
-** sys_init_time(), will return the clock resolution in MS and
-** that's about it. More could be added of course
-** If the clock-rate is constant (i.e. 1 ms) one can define 
-** SYS_CLOCK_RESOLUTION (to 1),
-** which makes erts_deliver_time/erts_time_remaining a bit faster.
-**
-** if HAVE_GETHRTIME is defined:
-**    sys_gethrtime() will return a SysHrTime (long long) representing 
-**    nanoseconds, sys_init_hrtime() will do any initialization.
-** else
-**    a long (64bit) integer type called Sint64 should be defined.
-**
-** sys_times() will return clock_ticks since start and 
-**    fill in a SysTimes structure (struct tms). Instead of CLK_TCK, 
-**    SYS_CLK_TCK is used to determine the resolution of kernel ticks.
-**
-** sys_gettimeofday() will take a SysTimeval (a struct timeval) as parameter
-**    and fill it in as gettimeofday(X,NULL).
-**
-*/
+ * Support routines for the time
+ */
 
 #ifdef HAVE_CONFIG_H
 #  include "config.h"
@@ -80,384 +28,1029 @@
 #include "sys.h"
 #include "erl_vm.h"
 #include "global.h"
-
+ 
 static erts_smp_mtx_t erts_timeofday_mtx;
-
-static SysTimeval inittv; /* Used everywhere, the initial time-of-day */
+static erts_smp_mtx_t erts_get_time_mtx;
 
 static SysTimes t_start; /* Used in elapsed_time_both */
-static SysTimeval gtv; /* Used in wall_clock_elapsed_time_both */
-static SysTimeval then; /* Used in get_now */
-static SysTimeval last_emu_time; /* Used in erts_get_emu_time() */
-SysTimeval erts_first_emu_time; /* Used in erts_get_emu_time() */
+static ErtsMonotonicTime prev_wall_clock_elapsed; /* Used in wall_clock_elapsed_time_both */
+static ErtsMonotonicTime previous_now; /* Used in get_now */
+
+static ErtsMonitor *time_offset_monitors = NULL;
+static Uint no_time_offset_monitors = 0;
 
-union {
-    erts_smp_atomic_t time;
-    char align[ERTS_CACHE_LINE_SIZE];
-} approx erts_align_attribute(ERTS_CACHE_LINE_SIZE);
+#ifdef DEBUG
+static int time_sup_initialized = 0;
+#endif
+
+#define ERTS_MONOTONIC_TIME_KILO \
+    ((ErtsMonotonicTime) 1000)
+#define ERTS_MONOTONIC_TIME_MEGA \
+    (ERTS_MONOTONIC_TIME_KILO*ERTS_MONOTONIC_TIME_KILO)
+#define ERTS_MONOTONIC_TIME_GIGA \
+    (ERTS_MONOTONIC_TIME_MEGA*ERTS_MONOTONIC_TIME_KILO)
+#define ERTS_MONOTONIC_TIME_TERA \
+    (ERTS_MONOTONIC_TIME_GIGA*ERTS_MONOTONIC_TIME_KILO)
 
 static void
-init_approx_time(void)
+schedule_send_time_offset_changed_notifications(ErtsMonotonicTime new_offset);
+
+/*
+ * NOTE! ERTS_MONOTONIC_TIME_START *need* to be a multiple
+ *       of ERTS_MONOTONIC_TIME_UNIT.
+ */
+
+#if ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT
+
+#ifdef ARCH_32
+/*
+ * Want to use a big-num of arity 2 as long as possible (584 years
+ * in the nano-second time unit case).
+ */
+#define ERTS_MONOTONIC_TIME_START		\
+    (((((((ErtsMonotonicTime) 1) << 32)-1)	\
+       / ERTS_MONOTONIC_TIME_UNIT)		\
+      * ERTS_MONOTONIC_TIME_UNIT)		\
+     + ERTS_MONOTONIC_TIME_UNIT)
+
+#else /* ARCH_64 */
+
+#if ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT <= 1000*1000
+
+/*
+ * Using micro second time unit or lower. Start at zero since
+ * time will remain an immediate for a very long time anyway
+ * (18279 years in the micro second case)...
+ */
+#define ERTS_MONOTONIC_TIME_START ((ErtsMonotonicTime) 0)
+
+#else /* ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT > 1000*1000 */
+
+/*
+ * Want to use an immediate as long as possible (36 years in the
+ * nano-second time unit case).
+*/
+#define ERTS_MONOTONIC_TIME_START 		\
+    ((((ErtsMonotonicTime) MIN_SMALL)		\
+      / ERTS_MONOTONIC_TIME_UNIT)		\
+     * ERTS_MONOTONIC_TIME_UNIT)
+
+#endif /* ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT > 1000*1000 */
+
+#endif /* ARCH_64 */
+
+#define ERTS_MONOTONIC_OFFSET_NATIVE ERTS_MONOTONIC_TIME_START
+#define ERTS_MONOTONIC_OFFSET_NSEC ERTS_MONOTONIC_TO_NSEC__(ERTS_MONOTONIC_TIME_START)
+#define ERTS_MONOTONIC_OFFSET_USEC ERTS_MONOTONIC_TO_USEC__(ERTS_MONOTONIC_TIME_START)
+#define ERTS_MONOTONIC_OFFSET_MSEC ERTS_MONOTONIC_TO_MSEC__(ERTS_MONOTONIC_TIME_START)
+#define ERTS_MONOTONIC_OFFSET_SEC ERTS_MONOTONIC_TO_SEC__(ERTS_MONOTONIC_TIME_START)
+
+#else /* ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT */
+
+/*
+ * Initialized in erts_init_time_sup()...
+ */
+
+#define ERTS_MONOTONIC_TIME_START (time_sup.r.o.start)
+#define ERTS_MONOTONIC_OFFSET_NATIVE (time_sup.r.o.start_offset.native)
+#define ERTS_MONOTONIC_OFFSET_NSEC (time_sup.r.o.start_offset.nsec)
+#define ERTS_MONOTONIC_OFFSET_USEC (time_sup.r.o.start_offset.usec)
+#define ERTS_MONOTONIC_OFFSET_MSEC (time_sup.r.o.start_offset.msec)
+#define ERTS_MONOTONIC_OFFSET_SEC (time_sup.r.o.start_offset.sec)
+
+#endif /* ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT */
+
+#define ERTS_MONOTONIC_TO_SYS_TIME_VAL(TVP, MT)				\
+    do {								\
+	ErtsMonotonicTime sec__, usec__;				\
+	sec__ = ERTS_MONOTONIC_TO_SEC((MT));				\
+	usec__ = ERTS_MONOTONIC_TO_USEC((MT)) - sec__*1000000;		\
+	ASSERT(usec__ < 1000000);					\
+	(TVP)->tv_sec = sec__;						\
+	(TVP)->tv_usec = usec__;					\
+    } while (0)
+
+#define ERTS_MAX_SYSTEM_TIME_DIFF ERTS_MSEC_TO_MONOTONIC(10)
+#define ERTS_SYSTEM_TIME_DIFF_EXCEED_LIMIT(ESYSTIME, OSSYSTIME)		\
+    (((Uint64) (ESYSTIME)) - (((Uint64) (OSSYSTIME))			\
+			      - ERTS_MAX_SYSTEM_TIME_DIFF)		\
+     > 2*ERTS_MAX_SYSTEM_TIME_DIFF)
+
+#define ERTS_TIME_CORRECTION_LARGE_ADJ_DIFF (ERTS_MAX_SYSTEM_TIME_DIFF/2)
+#define ERTS_TIME_CORRECTION_SMALL_ADJ_DIFF ERTS_USEC_TO_MONOTONIC(500)
+
+struct time_sup_read_only__ {
+    ErtsMonotonicTime (*get_time)(void);
+    int correction;
+    ErtsTimeWarpMode warp_mode;
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+    ErtsMonotonicTime moffset;
+    int os_monotonic_disable;
+    char *os_monotonic_func;
+    char *os_monotonic_clock_id;
+    int os_monotonic_locked;
+    Uint64 os_monotonic_resolution;
+#endif
+#if !ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT
+    ErtsMonotonicTime start;
+    struct {
+	ErtsMonotonicTime native;
+	ErtsMonotonicTime nsec;
+	ErtsMonotonicTime usec;
+	ErtsMonotonicTime msec;
+	ErtsMonotonicTime sec;
+    } start_offset;
+#endif
+};
+
+typedef struct {
+#ifndef ERTS_HAVE_CORRECTED_OS_MONOTONIC
+    ErtsMonotonicTime drift; /* Correction for os monotonic drift */
+#endif
+    ErtsMonotonicTime error; /* Correction for error between system times */
+} ErtsMonotonicCorrection;
+
+typedef struct {
+    ErtsMonotonicTime erl_mtime;
+    ErtsMonotonicTime os_mtime;
+    ErtsMonotonicCorrection correction;
+} ErtsMonotonicCorrectionInstance;
+
+#define ERTS_DRIFT_INTERVALS 5
+typedef struct {
+    struct {
+	struct {
+	    ErtsMonotonicTime sys;
+	    ErtsMonotonicTime mon;
+	} diff;
+	struct {
+	    ErtsMonotonicTime sys;
+	    ErtsMonotonicTime mon;
+	} time;
+    } intervals[ERTS_DRIFT_INTERVALS];
+    struct {
+	ErtsMonotonicTime sys;
+	ErtsMonotonicTime mon;
+    } acc;
+    int ix;
+    int dirty_counter;
+} ErtsMonotonicDriftData;
+
+typedef struct {
+    ErtsMonotonicCorrectionInstance prev;
+    ErtsMonotonicCorrectionInstance curr;    
+#ifndef ERTS_HAVE_CORRECTED_OS_MONOTONIC
+    ErtsMonotonicDriftData drift;
+#endif
+    ErtsMonotonicTime last_check;
+    int short_check_interval;
+} ErtsMonotonicCorrectionData;
+
+struct time_sup_infrequently_changed__ {
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+    struct {
+	erts_smp_rwmtx_t rwmtx;
+	ErlTimer timer;
+	ErtsMonotonicCorrectionData cdata;
+    } parmon;
+    ErtsMonotonicTime minit;
+#endif
+    int finalized_offset;
+    SysTimeval inittv; /* Used everywhere, the initial time-of-day */
+    ErtsMonotonicTime not_corrected_moffset;
+    erts_atomic64_t offset;
+};
+
+struct time_sup_frequently_changed__ {
+    ErtsMonotonicTime last_not_corrected_time;
+};
+
+static struct {
+    union {
+	struct time_sup_read_only__ o;
+	char align__[ERTS_ALC_CACHE_LINE_ALIGN_SIZE(sizeof(struct time_sup_read_only__))];
+    } r;
+    union {
+	struct time_sup_infrequently_changed__ c;
+	char align__[ERTS_ALC_CACHE_LINE_ALIGN_SIZE(sizeof(struct time_sup_infrequently_changed__))];
+    } inf;
+    union {
+	struct time_sup_frequently_changed__ c;
+	char align__[ERTS_ALC_CACHE_LINE_ALIGN_SIZE(sizeof(struct time_sup_frequently_changed__))];
+    } f;
+} time_sup erts_align_attribute(ERTS_CACHE_LINE_SIZE);
+
+ErtsTimeSupData erts_time_sup__ erts_align_attribute(ERTS_CACHE_LINE_SIZE);
+
+/*
+ * erts_get_approx_time() returns an *approximate* time
+ * in seconds. NOTE that this time may jump backwards!!!
+ */
+erts_approx_time_t
+erts_get_approx_time(void)
 {
-    erts_smp_atomic_init_nob(&approx.time, 0);
+    SysTimeval tv;
+    sys_gettimeofday(&tv);
+
+    return (erts_approx_time_t) tv.tv_sec;
 }
 
-static ERTS_INLINE erts_approx_time_t
-get_approx_time(void)
+static ERTS_INLINE void
+init_time_offset(ErtsMonotonicTime offset)
 {
-    return (erts_approx_time_t) erts_smp_atomic_read_nob(&approx.time);
+    erts_atomic64_init_nob(&time_sup.inf.c.offset, (erts_aint64_t) offset);
 }
 
 static ERTS_INLINE void
-update_approx_time(SysTimeval *tv)
+set_time_offset(ErtsMonotonicTime offset)
 {
-    erts_approx_time_t new_secs = (erts_approx_time_t) tv->tv_sec;
-    erts_approx_time_t old_secs = get_approx_time();
-    if (old_secs != new_secs)
-	erts_smp_atomic_set_nob(&approx.time, new_secs);
+    erts_atomic64_set_relb(&time_sup.inf.c.offset, (erts_aint64_t) offset);
 }
 
-/*
- * erts_get_approx_time() returns an *approximate* time
- * in seconds. NOTE that this time may jump backwards!!!
- */
-erts_approx_time_t
-erts_get_approx_time(void)
+static ERTS_INLINE ErtsMonotonicTime
+get_time_offset(void)
 {
-    return get_approx_time();
+    return (ErtsMonotonicTime) erts_atomic64_read_acqb(&time_sup.inf.c.offset);
 }
 
-#ifdef HAVE_GETHRTIME
 
-int erts_disable_tolerant_timeofday;
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+
+/*
+ * Time correction adjustments made due to
+ * error between Erlang system time and OS
+ * system time:
+ * - Large adjustment ~1%
+ * - Small adjustment ~0.05%
+ */
+#define ERTS_TCORR_ERR_UNIT 2048
+#define ERTS_TCORR_ERR_LARGE_ADJ 20
+#define ERTS_TCORR_ERR_SMALL_ADJ 1
 
-static SysHrTime hr_init_time, hr_last_correction_check, 
-    hr_correction, hr_last_time;
+#define ERTS_INIT_SHORT_INTERVAL_COUNTER 10
+#define ERTS_LONG_TIME_CORRECTION_CHECK ERTS_SEC_TO_MONOTONIC(60)
+#define ERTS_SHORT_TIME_CORRECTION_CHECK ERTS_SEC_TO_MONOTONIC(15)
 
-static void init_tolerant_timeofday(void)
+#define ERTS_TIME_DRIFT_MAX_ADJ_DIFF ERTS_USEC_TO_MONOTONIC(100)
+#define ERTS_TIME_DRIFT_MIN_ADJ_DIFF ERTS_USEC_TO_MONOTONIC(5)
+
+static ERTS_INLINE ErtsMonotonicTime
+calc_corrected_erl_mtime(ErtsMonotonicTime os_mtime,
+			 ErtsMonotonicCorrectionInstance *cip,
+			 ErtsMonotonicTime *os_mdiff_p)
 {
-    /* Should be in sys.c */
-#if defined(HAVE_SYSCONF) && defined(_SC_NPROCESSORS_CONF)
-    if (sysconf(_SC_NPROCESSORS_CONF) > 1) {
-	char b[1024];
-	int maj,min,build;
-	os_flavor(b,1024);
-	os_version(&maj,&min,&build);
-	if (!strcmp(b,"sunos") && maj <= 5 && min <= 7) {
-	    erts_disable_tolerant_timeofday = 1;
-	}
-    }
+    ErtsMonotonicTime erl_mtime, diff = os_mtime - cip->os_mtime;
+    ERTS_TIME_ASSERT(diff >= 0);
+#ifndef ERTS_HAVE_CORRECTED_OS_MONOTONIC
+    diff += (cip->correction.drift*diff)/ERTS_MONOTONIC_TIME_UNIT;
 #endif
-    hr_init_time = sys_gethrtime();
-    hr_last_correction_check = hr_last_time = hr_init_time;
-    hr_correction = 0;
+    erl_mtime = cip->erl_mtime;
+    erl_mtime += diff;
+    erl_mtime += cip->correction.error*(diff/ERTS_TCORR_ERR_UNIT);
+    if (os_mdiff_p)
+	*os_mdiff_p = diff;
+    return erl_mtime;
 }
 
-static void get_tolerant_timeofday(SysTimeval *tv)
+static ErtsMonotonicTime get_corrected_time(void)
 {
-    SysHrTime diff_time, curr;
+    ErtsMonotonicTime os_mtime;
+    ErtsMonotonicCorrectionData cdata;
+    ErtsMonotonicCorrectionInstance *cip;
+
+    erts_smp_rwmtx_rlock(&time_sup.inf.c.parmon.rwmtx);
+
+    os_mtime = erts_os_monotonic_time();
+
+    cdata = time_sup.inf.c.parmon.cdata;
 
-    if (erts_disable_tolerant_timeofday) {
-	sys_gettimeofday(tv);
-	return;
+    erts_smp_rwmtx_runlock(&time_sup.inf.c.parmon.rwmtx);
+
+    if (os_mtime >= cdata.curr.os_mtime)
+	cip = &cdata.curr;
+    else {
+	if (os_mtime < cdata.prev.os_mtime)
+	    erl_exit(ERTS_ABORT_EXIT,
+		     "OS monotonic time stepped backwards\n");
+	cip = &cdata.prev;
     }
-    *tv = inittv;
-    diff_time = ((curr = sys_gethrtime()) + hr_correction - hr_init_time) / 1000; 
 
-    if (curr < hr_init_time) {
-	erl_exit(1,"Unexpected behaviour from operating system high "
-		 "resolution timer");
+    return calc_corrected_erl_mtime(os_mtime, cip, NULL);
+}
+
+static void
+check_time_correction(void *unused)
+{
+    ErtsMonotonicCorrectionData cdata;
+    ErtsMonotonicCorrection new_correction;
+    ErtsMonotonicCorrectionInstance *cip;
+    ErtsMonotonicTime mdiff, sdiff, os_mtime, erl_mtime, os_stime, erl_stime, time_offset;
+    Uint timeout;
+    SysTimeval tod;
+    int set_new_correction, begin_short_intervals = 0;
+
+    erts_smp_rwmtx_rlock(&time_sup.inf.c.parmon.rwmtx);
+
+    ASSERT(time_sup.inf.c.finalized_offset);
+
+    os_mtime = erts_os_monotonic_time();
+    sys_gettimeofday(&tod);
+
+    cdata = time_sup.inf.c.parmon.cdata;
+
+    erts_smp_rwmtx_runlock(&time_sup.inf.c.parmon.rwmtx);
+
+    if (os_mtime < cdata.curr.os_mtime)
+	erl_exit(ERTS_ABORT_EXIT,
+		 "OS monotonic time stepped backwards\n");
+    cip = &cdata.curr;
+
+    erl_mtime = calc_corrected_erl_mtime(os_mtime, cip, &mdiff);
+    time_offset = get_time_offset();
+    erl_stime = erl_mtime + time_offset;
+
+    os_stime = ERTS_SEC_TO_MONOTONIC(tod.tv_sec);
+    os_stime += ERTS_USEC_TO_MONOTONIC(tod.tv_usec);
+
+    sdiff = erl_stime - os_stime;
+
+    new_correction = cip->correction;
+    
+    if (time_sup.r.o.warp_mode == ERTS_MULTI_TIME_WARP_MODE
+	&& (sdiff < -2*ERTS_TIME_CORRECTION_SMALL_ADJ_DIFF
+	    || 2*ERTS_TIME_CORRECTION_SMALL_ADJ_DIFF < sdiff)) {
+	/* System time diff exeeded limits; change time offset... */
+	time_offset -= sdiff;
+	sdiff = 0;
+	set_time_offset(time_offset);
+	schedule_send_time_offset_changed_notifications(time_offset);
+	begin_short_intervals = 1;
+	if (cdata.curr.correction.error == 0)
+	    set_new_correction = 0;
+	else {
+	    set_new_correction = 1;
+	    new_correction.error = 0;
+	}
+    }
+    else if (cdata.curr.correction.error == 0) {
+	if (sdiff < -ERTS_TIME_CORRECTION_SMALL_ADJ_DIFF) {
+	    set_new_correction = 1;
+	    if (sdiff < -ERTS_TIME_CORRECTION_LARGE_ADJ_DIFF)
+		new_correction.error = ERTS_TCORR_ERR_LARGE_ADJ;
+	    else
+		new_correction.error = ERTS_TCORR_ERR_SMALL_ADJ;
+	}
+	else if (sdiff > ERTS_TIME_CORRECTION_SMALL_ADJ_DIFF) {
+	    set_new_correction = 1;
+	    if (sdiff > ERTS_TIME_CORRECTION_LARGE_ADJ_DIFF)
+		new_correction.error = -ERTS_TCORR_ERR_LARGE_ADJ;
+	    else
+		new_correction.error = -ERTS_TCORR_ERR_SMALL_ADJ;
+	}
+	else {
+	    set_new_correction = 0;
+	}
+    }
+    else if (cdata.curr.correction.error > 0) {
+	if (sdiff < 0) {
+	    if (cdata.curr.correction.error == ERTS_TCORR_ERR_LARGE_ADJ
+		|| -ERTS_TIME_CORRECTION_LARGE_ADJ_DIFF <= sdiff)
+		set_new_correction = 0;
+	    else {
+		new_correction.error = ERTS_TCORR_ERR_LARGE_ADJ;
+		set_new_correction = 1;
+	    }
+	}
+	else if (sdiff > ERTS_TIME_CORRECTION_SMALL_ADJ_DIFF) {
+	    set_new_correction = 1;
+	    if (sdiff > ERTS_TIME_CORRECTION_LARGE_ADJ_DIFF)
+		new_correction.error = -ERTS_TCORR_ERR_LARGE_ADJ;
+	    else
+		new_correction.error = -ERTS_TCORR_ERR_SMALL_ADJ;
+	}
+	else {
+	    set_new_correction = 1;
+	    new_correction.error = 0;
+	}
+    }
+    else /* if (cdata.curr.correction.error < 0) */ { 
+	if (0 < sdiff) {
+	    if (cdata.curr.correction.error == -ERTS_TCORR_ERR_LARGE_ADJ
+		|| sdiff <= ERTS_TIME_CORRECTION_LARGE_ADJ_DIFF)
+		set_new_correction = 0;
+	    else {
+		new_correction.error = -ERTS_TCORR_ERR_LARGE_ADJ;
+		set_new_correction = 1;
+	    }
+	    set_new_correction = 0;
+	}
+	else if (sdiff < -ERTS_TIME_CORRECTION_SMALL_ADJ_DIFF) {
+	    set_new_correction = 1;
+	    if (sdiff < -ERTS_TIME_CORRECTION_LARGE_ADJ_DIFF)
+		new_correction.error = ERTS_TCORR_ERR_LARGE_ADJ;
+	    else
+		new_correction.error = ERTS_TCORR_ERR_SMALL_ADJ;
+	}
+	else {
+	    set_new_correction = 1;
+	    new_correction.error = 0;
+	}
     }
 
-    if ((curr - hr_last_correction_check) / 1000 > 1000000) {
-	/* Check the correction need */
-	SysHrTime tv_diff, diffdiff;
-	SysTimeval tmp;
-	int done = 0;
-
-	sys_gettimeofday(&tmp);
-	tv_diff = ((SysHrTime) tmp.tv_sec) * 1000000 + tmp.tv_usec;
-	tv_diff -= ((SysHrTime) inittv.tv_sec) * 1000000 + inittv.tv_usec;
-	diffdiff = diff_time - tv_diff;
-	if (diffdiff > 10000) {
-	    SysHrTime corr = (curr - hr_last_time) / 100;
-	    if (corr / 1000 >= diffdiff) {
-		++done;
-		hr_correction -= ((SysHrTime)diffdiff) * 1000;
-	    } else {
-		hr_correction -= corr;
+#ifndef ERTS_HAVE_CORRECTED_OS_MONOTONIC
+    {
+	ErtsMonotonicDriftData *ddp = &time_sup.inf.c.parmon.cdata.drift;
+	int ix = ddp->ix;
+	ErtsMonotonicTime mtime_diff, old_os_mtime;
+
+	old_os_mtime = ddp->intervals[ix].time.mon;
+	mtime_diff = os_mtime - old_os_mtime;
+
+	if (mtime_diff >= ERTS_SEC_TO_MONOTONIC(10)) {
+	    ErtsMonotonicTime drift_adj, drift_adj_diff, old_os_stime,
+		stime_diff, mtime_acc, stime_acc, avg_drift_adj;
+
+	    old_os_stime = ddp->intervals[ix].time.sys;
+
+	    mtime_acc = ddp->acc.mon;
+	    stime_acc = ddp->acc.sys;
+
+	    avg_drift_adj = ((stime_acc - mtime_acc)*ERTS_MONOTONIC_TIME_UNIT) / mtime_acc;
+
+	    mtime_diff = os_mtime - old_os_mtime;
+	    stime_diff = os_stime - old_os_stime;
+	    drift_adj = ((stime_diff - mtime_diff)*ERTS_MONOTONIC_TIME_UNIT) / mtime_diff;
+	    
+	    ix++;
+	    if (ix >= ERTS_DRIFT_INTERVALS)
+		ix = 0;
+	    mtime_acc -= ddp->intervals[ix].diff.mon;
+	    mtime_acc += mtime_diff;
+	    stime_acc -= ddp->intervals[ix].diff.sys;
+	    stime_acc += stime_diff;
+
+	    ddp->intervals[ix].diff.mon = mtime_diff;
+	    ddp->intervals[ix].diff.sys = stime_diff;
+	    ddp->intervals[ix].time.mon = os_mtime;
+	    ddp->intervals[ix].time.sys = os_stime;
+
+	    ddp->ix = ix;
+	    ddp->acc.mon = mtime_acc;
+	    ddp->acc.sys = stime_acc;
+
+	    /*
+	     * If calculated drift adjustment is if off by more than 20% from the
+	     * average drift we interpret this as a discontinous leap in system
+	     * time and ignore it. If it actually is a change in drift we will
+	     * later detect this when the average drift change.
+	     */
+	    drift_adj_diff = avg_drift_adj - drift_adj;
+	    if (drift_adj_diff < -ERTS_TIME_DRIFT_MAX_ADJ_DIFF
+		|| ERTS_TIME_DRIFT_MAX_ADJ_DIFF < drift_adj_diff) {
+		ddp->dirty_counter = ERTS_DRIFT_INTERVALS;
+		begin_short_intervals = 1;
 	    }
-	    diff_time = (curr + hr_correction - hr_init_time) / 1000; 
-	} else if (diffdiff < -10000) {
-	    SysHrTime corr = (curr - hr_last_time) / 100;
-	    if (corr / 1000 >= -diffdiff) {
-		++done;
-		hr_correction -= ((SysHrTime)diffdiff) * 1000;
-	    } else {
-		hr_correction += corr;
+	    else {
+		if (ddp->dirty_counter <= 0) {
+		    drift_adj = ((stime_acc - mtime_acc)*ERTS_MONOTONIC_TIME_UNIT) / mtime_acc;
+		}
+		if (ddp->dirty_counter >= 0) {
+		    if (ddp->dirty_counter == 0) {
+			/* Force set new drift correction... */
+			set_new_correction = 1;
+		    }
+		    ddp->dirty_counter--;
+		}
+		drift_adj_diff = drift_adj - new_correction.drift;
+		if (drift_adj_diff) {
+		    if (drift_adj_diff > ERTS_TIME_DRIFT_MAX_ADJ_DIFF)
+			drift_adj_diff = ERTS_TIME_DRIFT_MAX_ADJ_DIFF;
+		    else if (drift_adj_diff < -ERTS_TIME_DRIFT_MAX_ADJ_DIFF)
+			drift_adj_diff = -ERTS_TIME_DRIFT_MAX_ADJ_DIFF;
+		    new_correction.drift += drift_adj_diff;
+
+		    if (drift_adj_diff < -ERTS_TIME_DRIFT_MIN_ADJ_DIFF
+			|| ERTS_TIME_DRIFT_MIN_ADJ_DIFF < drift_adj_diff) {
+			set_new_correction = 1;
+		    }
+		}
 	    }
-	    diff_time = (curr + hr_correction - hr_init_time) / 1000; 
-	} else {
-	    ++done;
 	}
-	if (done) {
-	    hr_last_correction_check = curr;
+    }
+#endif
+
+    begin_short_intervals |= set_new_correction;
+    
+    if (begin_short_intervals) {
+	time_sup.inf.c.parmon.cdata.short_check_interval
+	    = ERTS_INIT_SHORT_INTERVAL_COUNTER;
+    }
+    else if ((os_mtime - time_sup.inf.c.parmon.cdata.last_check
+	      >= ERTS_SHORT_TIME_CORRECTION_CHECK - ERTS_MONOTONIC_TIME_UNIT)
+	     && time_sup.inf.c.parmon.cdata.short_check_interval > 0) {
+	time_sup.inf.c.parmon.cdata.short_check_interval--;
+    }
+    time_sup.inf.c.parmon.cdata.last_check = os_mtime;
+
+    if (new_correction.error == 0)
+	timeout = ERTS_MONOTONIC_TO_MSEC(ERTS_LONG_TIME_CORRECTION_CHECK);
+    else {
+	ErtsMonotonicTime ecorr = new_correction.error;
+	if (sdiff < 0)
+	    sdiff = -1*sdiff;
+	if (ecorr < 0)
+	    ecorr = -1*ecorr;
+	if (sdiff > ecorr*(ERTS_LONG_TIME_CORRECTION_CHECK/ERTS_TCORR_ERR_UNIT))
+	    timeout = ERTS_MONOTONIC_TO_MSEC(ERTS_LONG_TIME_CORRECTION_CHECK);
+	else {
+	    timeout = ERTS_MONOTONIC_TO_MSEC((ERTS_TCORR_ERR_UNIT*sdiff)/ecorr);
+	    if (timeout < 10)
+		timeout = 10;
 	}
     }
-    tv->tv_sec += (int) (diff_time / ((SysHrTime) 1000000));
-    tv->tv_usec += (int) (diff_time % ((SysHrTime) 1000000));
-    if (tv->tv_usec >= 1000000) {
-	tv->tv_usec -= 1000000;
-	tv->tv_sec += 1;
+
+    if (timeout > ERTS_MONOTONIC_TO_MSEC(ERTS_SHORT_TIME_CORRECTION_CHECK)
+	&& time_sup.inf.c.parmon.cdata.short_check_interval) {
+	timeout = ERTS_MONOTONIC_TO_MSEC(ERTS_SHORT_TIME_CORRECTION_CHECK);
     }
-    hr_last_time = curr;
-}
+    
+    if (set_new_correction) {
+	erts_smp_rwmtx_rwlock(&time_sup.inf.c.parmon.rwmtx);
 
-#define correction (hr_correction/1000000)
+	os_mtime = erts_os_monotonic_time();
 
-#else /* !HAVE_GETHRTIME */
-#if !defined(CORRECT_USING_TIMES) 
-#define init_tolerant_timeofday() 
-#define get_tolerant_timeofday(tvp) sys_gettimeofday(tvp)
-#else
+	/* Save previous correction instance */
+	time_sup.inf.c.parmon.cdata.prev = *cip;
 
-typedef Sint64 Milli;
-
-static clock_t init_ct;
-static Sint64 ct_wrap;
-static Milli init_tv_m;
-static Milli correction_supress; 
-static Milli last_ct_diff;
-static Milli last_cc; 
-static clock_t last_ct;
-
-/* sys_times() might need to be wrapped and the values shifted (right)
-   a bit to cope with newer linux (2.5.*) kernels, this has to be taken care 
-   of dynamically to start with, a special version that uses
-   the times() return value as a high resolution timer can be made
-   to fully utilize the faster ticks, like on windows, but for now, we'll
-   settle with this silly workaround */
-#ifdef ERTS_WRAP_SYS_TIMES 
-#define KERNEL_TICKS() (sys_times_wrap() &  \
-			((1UL << ((sizeof(clock_t) * 8) - 1)) - 1)) 
-#else
-SysTimes dummy_tms;
+	/*
+	 * Current correction instance begin when
+	 * OS monotonic time has increased one unit.
+	 */
+	os_mtime++;
 
-#define KERNEL_TICKS() (sys_times(&dummy_tms) &  \
-			((1UL << ((sizeof(clock_t) * 8) - 1)) - 1)) 
+	/*
+	 * Erlang monotonic time corresponding to
+	 * next OS monotonic time using previous
+	 * correction.
+	 */
+	erl_mtime = calc_corrected_erl_mtime(os_mtime, cip, NULL);
 
-#endif
+	/*
+	 * Save new current correction instance.
+	 */
+	time_sup.inf.c.parmon.cdata.curr.erl_mtime = erl_mtime;
+	time_sup.inf.c.parmon.cdata.curr.os_mtime = os_mtime;
+	time_sup.inf.c.parmon.cdata.curr.correction = new_correction;
 
-static void init_tolerant_timeofday(void)
-{
-    last_ct = init_ct = KERNEL_TICKS();
-    last_cc = 0;
-    init_tv_m = (((Milli) inittv.tv_sec) * 1000) + 
-	(inittv.tv_usec / 1000);
-    ct_wrap = 0;
-    correction_supress = 0;
+	erts_smp_rwmtx_rwunlock(&time_sup.inf.c.parmon.rwmtx);
+    }
+
+    erts_set_timer(&time_sup.inf.c.parmon.timer,
+		   check_time_correction,
+		   NULL,
+		   NULL,
+		   timeout);
 }
 
+#ifndef ERTS_HAVE_CORRECTED_OS_MONOTONIC
 
-static void get_tolerant_timeofday(SysTimeval *tvp)
+static void
+init_check_time_correction(void *unused)
 {
-    clock_t current_ct;
-    SysTimeval current_tv;
-    Milli ct_diff;
-    Milli tv_diff;
-    Milli current_correction;
-    Milli act_correction;	/* long shown to be too small */
-    Milli max_adjust;
-
-    if (erts_disable_tolerant_timeofday) {
-	sys_gettimeofday(tvp);
-	return;
+    ErtsMonotonicDriftData *ddp;
+    ErtsMonotonicTime old_mtime, old_stime, mtime, stime, mtime_diff, stime_diff;
+    int ix;
+    SysTimeval tod;
+
+    ddp = &time_sup.inf.c.parmon.cdata.drift;
+    ix = ddp->ix;
+    old_mtime = ddp->intervals[0].time.mon;
+    old_stime = ddp->intervals[0].time.sys;
+
+    mtime = erts_os_monotonic_time();
+    sys_gettimeofday(&tod);
+
+    stime = ERTS_SEC_TO_MONOTONIC(tod.tv_sec);
+    stime += ERTS_USEC_TO_MONOTONIC(tod.tv_usec);
+
+    mtime_diff = mtime - old_mtime;
+    stime_diff = stime - old_stime;
+    if (100*stime_diff  < 80*mtime_diff || 120*mtime_diff < 100*stime_diff ) {
+	/* Had a system time leap... pretend no drift... */
+	stime_diff = mtime_diff;
+    }
+    
+    /*
+     * We use old time values in order to trigger
+     * a drift adjustment, and repeat this interval
+     * in all slots...
+     */
+    for (ix = 0; ix < ERTS_DRIFT_INTERVALS; ix++) {
+	ddp->intervals[ix].diff.mon = mtime_diff;
+	ddp->intervals[ix].diff.sys = stime_diff;
+	ddp->intervals[ix].time.mon = old_mtime;
+	ddp->intervals[ix].time.sys = old_stime;
     }
 
-#ifdef ERTS_WRAP_SYS_TIMES 
-#define TICK_MS (1000 / SYS_CLK_TCK_WRAP)
+    ddp->acc.sys = stime_diff*ERTS_DRIFT_INTERVALS;
+    ddp->acc.mon = mtime_diff*ERTS_DRIFT_INTERVALS;
+    ddp->ix = 0;
+    ddp->dirty_counter = ERTS_DRIFT_INTERVALS;
+
+    check_time_correction(NULL);
+}
+
+#endif
+
+static ErtsMonotonicTime
+finalize_corrected_time_offset(SysTimeval *todp)
+{
+    ErtsMonotonicTime os_mtime;
+    ErtsMonotonicCorrectionData cdata;
+    ErtsMonotonicCorrectionInstance *cip;
+
+    erts_smp_rwmtx_rlock(&time_sup.inf.c.parmon.rwmtx);
+
+    os_mtime = erts_os_monotonic_time();
+    sys_gettimeofday(todp);
+
+    cdata = time_sup.inf.c.parmon.cdata;
+
+    erts_smp_rwmtx_runlock(&time_sup.inf.c.parmon.rwmtx);
+
+    if (os_mtime < cdata.curr.os_mtime)
+	erl_exit(ERTS_ABORT_EXIT,
+		 "OS monotonic time stepped backwards\n");
+    cip = &cdata.curr;
+
+    return calc_corrected_erl_mtime(os_mtime, cip, NULL);
+}
+
+static void
+late_init_time_correction(void)
+{
+    if (time_sup.inf.c.finalized_offset) {
+	erts_init_timer(&time_sup.inf.c.parmon.timer);
+	erts_set_timer(&time_sup.inf.c.parmon.timer,
+#ifndef ERTS_HAVE_CORRECTED_OS_MONOTONIC
+		       init_check_time_correction,
 #else
-#define TICK_MS (1000 / SYS_CLK_TCK)
+		       check_time_correction,
 #endif
-    current_ct = KERNEL_TICKS();
-    sys_gettimeofday(&current_tv);
-
-    /* I dont know if uptime can move some units backwards
-       on some systems, but I allow for small backward 
-       jumps to avoid such problems if they exist...*/
-    if (last_ct > 100 && current_ct < (last_ct - 100)) {
-	ct_wrap += ((Sint64) 1) << ((sizeof(clock_t) * 8) - 1);
+		       NULL,
+		       NULL,
+		       ERTS_MONOTONIC_TO_MSEC(ERTS_SHORT_TIME_CORRECTION_CHECK));
     }
-    last_ct = current_ct;
-    ct_diff = ((ct_wrap + current_ct) - init_ct) * TICK_MS;
+}
 
-    /*
-     * We will adjust the time in milliseconds and we allow for 1% 
-     * adjustments, but if this function is called more often then every 100 
-     * millisecond (which is obviously possible), we will never adjust, so 
-     * we accumulate small times by setting last_ct_diff iff max_adjust > 0
-     */
-    if ((max_adjust = (ct_diff - last_ct_diff)/100) > 0)
-	last_ct_diff = ct_diff;
+#endif /* ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT */
 
-    tv_diff = ((((Milli) current_tv.tv_sec) * 1000) + 
-	       (current_tv.tv_usec / 1000)) - init_tv_m;
+static ErtsMonotonicTime get_not_corrected_time(void)
+{
+    SysTimeval tmp_tv;
+    ErtsMonotonicTime stime, mtime;
 
-    current_correction = ((ct_diff - tv_diff) / TICK_MS) * TICK_MS; /* trunc */
+    erts_smp_mtx_lock(&erts_get_time_mtx);
 
-    /* 
-     * We allow the current_correction value to wobble a little, as it
-     * suffers from the low resolution of the kernel ticks. 
-     * if it hasn't changed more than one tick in either direction, 
-     * we will keep the old value.
-     */
-    if ((last_cc > current_correction + TICK_MS) ||
-	(last_cc < current_correction - TICK_MS)) {
-	last_cc = current_correction;
-    } else {
-	current_correction = last_cc;
-    }
-    
-    /*
-     * As time goes, we try to get the actual correction to 0, 
-     * that is, make erlangs time correspond to the systems dito.
-     * The act correction is what we seem to need (current_correction)
-     * minus the correction suppression. The correction supression
-     * will change slowly (max 1% of elapsed time) but in millisecond steps.
-     */
-    act_correction = current_correction - correction_supress;
-    if (max_adjust > 0) {
-	/*
-	 * Here we slowly adjust erlangs time to correspond with the 
-	 * system time by changing the correction_supress variable.
-	 * It can change max_adjust milliseconds which is 1% of elapsed time
-	 */
-	if (act_correction > 0) {
-	    if (current_correction - correction_supress > max_adjust) {
-		correction_supress += max_adjust;
-	    } else {
-		correction_supress = current_correction;
-	    }
-	    act_correction = current_correction - correction_supress;
-	} else if (act_correction < 0) {
-	    if (correction_supress - current_correction > max_adjust) {
-		correction_supress -= max_adjust;
-	    } else {
-		correction_supress = current_correction;
+    sys_gettimeofday(&tmp_tv);
+
+    stime = ERTS_SEC_TO_MONOTONIC(tmp_tv.tv_sec);
+    stime += ERTS_USEC_TO_MONOTONIC(tmp_tv.tv_usec);
+
+    mtime = stime - time_sup.inf.c.not_corrected_moffset;
+
+    if (mtime >= time_sup.f.c.last_not_corrected_time)
+	time_sup.f.c.last_not_corrected_time = mtime;
+    else {
+	mtime = time_sup.f.c.last_not_corrected_time;
+
+	if (time_sup.r.o.warp_mode == ERTS_MULTI_TIME_WARP_MODE) {
+	    ErtsMonotonicTime new_offset = stime - mtime;
+	    new_offset = ERTS_MONOTONIC_TO_USEC(new_offset);
+	    new_offset = ERTS_USEC_TO_MONOTONIC(new_offset);
+	    if (time_sup.inf.c.not_corrected_moffset != new_offset) {
+		time_sup.inf.c.not_corrected_moffset = new_offset;
+		set_time_offset(new_offset);
+		schedule_send_time_offset_changed_notifications(new_offset);
 	    }
-	    act_correction = current_correction - correction_supress;
 	}
+
     }
-    /*
-     * The actual correction will correct the timeval so that system 
-     * time warps gets smothed down.
-     */
-    current_tv.tv_sec += act_correction / 1000;
-    current_tv.tv_usec += (act_correction % 1000) * 1000;
-
-    if (current_tv.tv_usec >= 1000000) {
-	++current_tv.tv_sec ;
-	current_tv.tv_usec -= 1000000;
-    } else if (current_tv.tv_usec < 0) {
-	--current_tv.tv_sec;
-	current_tv.tv_usec += 1000000;
-    }
-    *tvp = current_tv;
-#undef TICK_MS
+
+    ASSERT(stime == mtime + time_sup.inf.c.not_corrected_moffset);
+
+    erts_smp_mtx_unlock(&erts_get_time_mtx);
+
+    return mtime;
 }
 
-#endif /* CORRECT_USING_TIMES */
-#endif /* !HAVE_GETHRTIME */
+int erts_check_time_adj_support(int time_correction,
+				ErtsTimeWarpMode time_warp_mode)
+{
+    if (!time_correction)
+	return 1;
 
-/*
-** Why this? Well, most platforms have a constant clock resolution of 1,
-** we dont want the deliver_time/time_remaining routines to waste 
-** time dividing and multiplying by/with a variable that's always one.
-** so the return value of sys_init_time is ignored on those platforms.
-*/
- 
-#ifndef SYS_CLOCK_RESOLUTION
-static int clock_resolution;
-#define CLOCK_RESOLUTION clock_resolution
+    /* User wants time correction */
+
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+    return !time_sup.r.o.os_monotonic_disable;
 #else
-#define CLOCK_RESOLUTION SYS_CLOCK_RESOLUTION
+    return 0;
 #endif
+}
 
-/*
-** The clock resolution should really be the resolution of the 
-** time function in use, which on most platforms 
-** is 1. On VxWorks the resolution should be
-** the number of ticks per second (or 1, which would work nicely to).
-**
-** Setting lower resolutions is mostly interesting when timers are used
-** instead of something like select.
-*/
-
-static SysTimeval last_delivered; 
-
-static void init_erts_deliver_time(const SysTimeval *inittv)
+int
+erts_has_time_correction(void)
 {
-    /* We set the initial values for deliver_time here */
-    last_delivered = *inittv;
-    last_delivered.tv_usec = 1000 * (last_delivered.tv_usec / 1000); 
-                                                   /* ms resolution */
+    return time_sup.r.o.correction;
 }
 
-static void do_erts_deliver_time(const SysTimeval *current)
+void
+erts_early_init_time_sup(void)
 {
-    SysTimeval cur_time;
-    erts_time_t elapsed;
-    
-    /* calculate and deliver appropriate number of ticks */
-    cur_time = *current;
-    cur_time.tv_usec = 1000 * (cur_time.tv_usec / 1000); /* ms resolution */
-    elapsed = (1000 * (cur_time.tv_sec - last_delivered.tv_sec) +
-	       (cur_time.tv_usec - last_delivered.tv_usec) / 1000) / 
-	CLOCK_RESOLUTION;
+    ErtsSysInitTimeResult sys_init_time_res
+	= ERTS_SYS_INIT_TIME_RESULT_INITER;
 
-    /* Sometimes the time jump backwards,
-       resulting in a negative elapsed time. We compensate for
-       this by simply pretend as if the time stood still. :) */
+    sys_init_time(&sys_init_time_res);
 
-    if (elapsed > 0) {
+    erts_time_sup__.r.o.monotonic_time_unit
+	= sys_init_time_res.os_monotonic_time_unit;
 
-	ASSERT(elapsed < ((erts_time_t) ERTS_SHORT_TIME_T_MAX));
+#ifndef SYS_CLOCK_RESOLUTION
+    erts_time_sup__.r.o.clktck_resolution
+	= sys_init_time_res.sys_clock_resolution;
+    erts_time_sup__.r.o.clktck_resolution *= 1000;
+#endif
 
-	erts_do_time_add((erts_short_time_t) elapsed);
-	last_delivered = cur_time;
-    }
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+    time_sup.r.o.os_monotonic_disable
+	= !sys_init_time_res.have_os_monotonic;
+    time_sup.r.o.os_monotonic_func
+	= sys_init_time_res.os_monotonic_info.func;
+    time_sup.r.o.os_monotonic_clock_id
+	= sys_init_time_res.os_monotonic_info.clock_id;
+    time_sup.r.o.os_monotonic_locked
+	= sys_init_time_res.os_monotonic_info.locked_use;
+    time_sup.r.o.os_monotonic_resolution
+	= sys_init_time_res.os_monotonic_info.resolution;
+#endif
 }
 
 int 
-erts_init_time_sup(void)
+erts_init_time_sup(int time_correction, ErtsTimeWarpMode time_warp_mode)
 {
+#if !ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT
+    ErtsMonotonicTime abs_start;
+#endif
+
+    ASSERT(ERTS_MONOTONIC_TIME_MIN < ERTS_MONOTONIC_TIME_MAX);
+
     erts_smp_mtx_init(&erts_timeofday_mtx, "timeofday");
+    erts_smp_mtx_init(&erts_get_time_mtx, "get_time");
 
-    init_approx_time();
+    time_sup.r.o.correction = time_correction;
+    time_sup.r.o.warp_mode = time_warp_mode;
+ 
+    if (time_warp_mode == ERTS_SINGLE_TIME_WARP_MODE)
+	time_sup.inf.c.finalized_offset = 0;
+    else
+	time_sup.inf.c.finalized_offset = ~0;
+
+#if !ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT
+
+#ifdef ARCH_32
+    time_sup.r.o.start = ((((ErtsMonotonicTime) 1) << 32)-1);
+    time_sup.r.o.start /= ERTS_MONOTONIC_TIME_UNIT;
+    time_sup.r.o.start *= ERTS_MONOTONIC_TIME_UNIT;
+    time_sup.r.o.start += ERTS_MONOTONIC_TIME_UNIT;
+    abs_start = time_sup.r.o.start;
+#else /* ARCH_64 */
+    if (ERTS_MONOTONIC_TIME_UNIT <= 1000*1000)
+	abs_start = time_sup.r.o.start = 0;
+    else {
+	time_sup.r.o.start = ((ErtsMonotonicTime) MIN_SMALL);
+	time_sup.r.o.start /= ERTS_MONOTONIC_TIME_UNIT;
+	time_sup.r.o.start *= ERTS_MONOTONIC_TIME_UNIT;
+	abs_start = -1*time_sup.r.o.start;
+    }
+#endif
 
-    last_emu_time.tv_sec = 0;
-    last_emu_time.tv_usec = 0;
+    time_sup.r.o.start_offset.native = time_sup.r.o.start;
+    time_sup.r.o.start_offset.nsec = (ErtsMonotonicTime)
+	erts_time_unit_conversion((Uint64) abs_start,
+				  (Uint32) ERTS_MONOTONIC_TIME_UNIT,
+				  (Uint32) 1000*1000*1000);
+    time_sup.r.o.start_offset.usec = (ErtsMonotonicTime)
+	erts_time_unit_conversion((Uint64) abs_start,
+				  (Uint32) ERTS_MONOTONIC_TIME_UNIT,
+				  (Uint32) 1000*1000);
+    time_sup.r.o.start_offset.msec = (ErtsMonotonicTime)
+	erts_time_unit_conversion((Uint64) abs_start,
+				  (Uint32) ERTS_MONOTONIC_TIME_UNIT,
+				  (Uint32) 1000);
+    time_sup.r.o.start_offset.sec = (ErtsMonotonicTime)
+	erts_time_unit_conversion((Uint64) abs_start,
+				  (Uint32) ERTS_MONOTONIC_TIME_UNIT,
+				  (Uint32) 1);
+    if (time_sup.r.o.start < 0) {
+	time_sup.r.o.start_offset.nsec *= -1;
+	time_sup.r.o.start_offset.usec *= -1;
+	time_sup.r.o.start_offset.msec *= -1;
+	time_sup.r.o.start_offset.sec *= -1;
+    }
 
-#ifndef SYS_CLOCK_RESOLUTION
-    clock_resolution = sys_init_time();
-#else
-    (void) sys_init_time();
 #endif
-    sys_gettimeofday(&inittv);
+
+    if (ERTS_MONOTONIC_TIME_UNIT < ERTS_CLKTCK_RESOLUTION)
+	ERTS_INTERNAL_ERROR("Too small monotonic time time unit");
+
+#ifndef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+    time_sup.r.o.correction = 0;
+#else
+    if (time_sup.r.o.os_monotonic_disable)
+	time_sup.r.o.correction = 0;
+
+    if (time_sup.r.o.correction) {
+	ErtsMonotonicCorrectionData *cdatap;
+	erts_smp_rwmtx_opt_t rwmtx_opts = ERTS_SMP_RWMTX_OPT_DEFAULT_INITER;
+	ErtsMonotonicTime offset;
+	time_sup.inf.c.minit = erts_os_monotonic_time();
+	sys_gettimeofday(&time_sup.inf.c.inittv);
+	time_sup.r.o.moffset = -1*time_sup.inf.c.minit;
+	offset = ERTS_SEC_TO_MONOTONIC(time_sup.inf.c.inittv.tv_sec);
+	offset += ERTS_USEC_TO_MONOTONIC(time_sup.inf.c.inittv.tv_usec);
+	init_time_offset(offset);
+
+	rwmtx_opts.type = ERTS_SMP_RWMTX_TYPE_EXTREMELY_FREQUENT_READ;
+	rwmtx_opts.lived = ERTS_SMP_RWMTX_LONG_LIVED;
+
+	erts_smp_rwmtx_init_opt(&time_sup.inf.c.parmon.rwmtx,
+				&rwmtx_opts, "get_corrected_time");
+
+	cdatap = &time_sup.inf.c.parmon.cdata;
     
-#ifdef HAVE_GETHRTIME
-    sys_init_hrtime();
+#ifndef ERTS_HAVE_CORRECTED_OS_MONOTONIC
+	cdatap->drift.intervals[0].time.sys
+	    = ERTS_SEC_TO_MONOTONIC(time_sup.inf.c.inittv.tv_sec);
+	cdatap->drift.intervals[0].time.sys
+	    += ERTS_USEC_TO_MONOTONIC(time_sup.inf.c.inittv.tv_usec);
+	cdatap->drift.intervals[0].time.mon = time_sup.inf.c.minit;
+	cdatap->curr.correction.drift = 0;
+#endif
+	cdatap->curr.correction.error = 0;
+	cdatap->curr.erl_mtime = 0;
+	cdatap->curr.os_mtime = time_sup.inf.c.minit;
+	cdatap->last_check = time_sup.inf.c.minit;
+	cdatap->short_check_interval = ERTS_INIT_SHORT_INTERVAL_COUNTER;
+	cdatap->prev = cdatap->curr;
+
+	time_sup.r.o.get_time = get_corrected_time;
+    }
+    else
 #endif
-    init_tolerant_timeofday();
+    {
+	ErtsMonotonicTime stime, offset;
+	time_sup.r.o.get_time = get_not_corrected_time;
+	stime = ERTS_SEC_TO_MONOTONIC(time_sup.inf.c.inittv.tv_sec);
+	stime += ERTS_USEC_TO_MONOTONIC(time_sup.inf.c.inittv.tv_usec);
+	offset = stime;
+	time_sup.inf.c.not_corrected_moffset = offset;
+	init_time_offset(offset);
+	time_sup.f.c.last_not_corrected_time = 0;
+    }
+
+    prev_wall_clock_elapsed = 0;
 
-    init_erts_deliver_time(&inittv);
-    gtv = inittv;
-    then.tv_sec = then.tv_usec = 0;
+    previous_now = ERTS_MONOTONIC_TO_USEC(get_time_offset());
 
-    erts_deliver_time();
+#ifdef DEBUG
+    time_sup_initialized = 1;
+#endif
 
-    return CLOCK_RESOLUTION;
+    return ERTS_CLKTCK_RESOLUTION/1000;
 }    
+
+void
+erts_late_init_time_sup(void)
+{
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+    /* Timer wheel must be initialized */
+    if (time_sup.r.o.get_time == get_corrected_time)
+	late_init_time_correction();
+#endif
+}
+
+ErtsTimeWarpMode erts_time_warp_mode(void)
+{
+    return time_sup.r.o.warp_mode;
+}
+
+ErtsTimeOffsetState erts_time_offset_state(void)
+{
+    switch (time_sup.r.o.warp_mode) {
+    case ERTS_NO_TIME_WARP_MODE:
+	return ERTS_TIME_OFFSET_FINAL;
+    case ERTS_SINGLE_TIME_WARP_MODE:
+	if (time_sup.inf.c.finalized_offset)
+	    return ERTS_TIME_OFFSET_FINAL;
+	return ERTS_TIME_OFFSET_PRELIMINARY;
+    case ERTS_MULTI_TIME_WARP_MODE:
+	return ERTS_TIME_OFFSET_VOLATILE;
+    default:
+	ERTS_INTERNAL_ERROR("Invalid time warp mode");
+	return ERTS_TIME_OFFSET_VOLATILE;
+    }
+}
+
+/*
+ * erts_finalize_time_offset() will only change time offset
+ * the first time it is called when the emulator has been
+ * started in "single time warp" mode. Returns previous
+ * state:
+ * * ERTS_TIME_OFFSET_PRELIMINARY - Finalization performed
+ * * ERTS_TIME_OFFSET_FINAL - Already finialized; nothing changed
+ * * ERTS_TIME_OFFSET_VOLATILE - Not supported, either in
+ * * no correction mode (or multi time warp mode; not yet implemented).
+ */
+
+ErtsTimeOffsetState
+erts_finalize_time_offset(void)
+{
+    switch (time_sup.r.o.warp_mode) {
+    case ERTS_NO_TIME_WARP_MODE:
+	return ERTS_TIME_OFFSET_FINAL;
+    case ERTS_MULTI_TIME_WARP_MODE:
+	return ERTS_TIME_OFFSET_VOLATILE;
+    case ERTS_SINGLE_TIME_WARP_MODE: {
+	ErtsTimeOffsetState res = ERTS_TIME_OFFSET_FINAL;
+
+	erts_smp_mtx_lock(&erts_get_time_mtx);
+
+	if (!time_sup.inf.c.finalized_offset) {
+	    ErtsMonotonicTime mtime, new_offset;
+	    SysTimeval tv;
+
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+	    if (!time_sup.r.o.correction)
+#endif
+	    {
+		ErtsMonotonicTime stime;
+		sys_gettimeofday(&tv);
+
+		stime = ERTS_SEC_TO_MONOTONIC(tv.tv_sec);
+		stime += ERTS_USEC_TO_MONOTONIC(tv.tv_usec);
+
+		mtime = stime - time_sup.inf.c.not_corrected_moffset;
+
+		if (mtime >= time_sup.f.c.last_not_corrected_time) {
+		    time_sup.f.c.last_not_corrected_time = mtime;
+		    new_offset = time_sup.inf.c.not_corrected_moffset;
+		}
+		else {
+		    mtime = time_sup.f.c.last_not_corrected_time;
+
+		    ASSERT(time_sup.inf.c.not_corrected_moffset != stime - mtime);
+		    new_offset = stime - mtime;
+		    time_sup.inf.c.not_corrected_moffset = new_offset;
+		}
+
+	    }
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+	    else {
+		mtime = finalize_corrected_time_offset(&tv);
+		new_offset = ERTS_SEC_TO_MONOTONIC(tv.tv_sec);
+		new_offset += ERTS_USEC_TO_MONOTONIC(tv.tv_usec);
+		new_offset -= mtime;
+
+	    }
+#endif
+	    new_offset = ERTS_MONOTONIC_TO_USEC(new_offset);
+	    new_offset = ERTS_USEC_TO_MONOTONIC(new_offset);
+
+	    set_time_offset(new_offset);
+	    schedule_send_time_offset_changed_notifications(new_offset);
+
+	    time_sup.inf.c.finalized_offset = ~0;
+	    res = ERTS_TIME_OFFSET_PRELIMINARY;
+	}
+
+	erts_smp_mtx_unlock(&erts_get_time_mtx);
+
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+	if (res == ERTS_TIME_OFFSET_PRELIMINARY
+	    && time_sup.r.o.get_time == get_corrected_time) {
+	    late_init_time_correction();
+	}
+#endif
+
+	return res;
+    }
+    default:
+	ERTS_INTERNAL_ERROR("Invalid time warp mode");
+	return ERTS_TIME_OFFSET_VOLATILE;
+    }
+}
+
 /* info functions */
 
 void 
@@ -498,23 +1091,16 @@ elapsed_time_both(UWord *ms_user, UWord *ms_sys,
 void 
 wall_clock_elapsed_time_both(UWord *ms_total, UWord *ms_diff)
 {
-    UWord prev_total;
-    SysTimeval tv;
+    ErtsMonotonicTime now, elapsed;
 
     erts_smp_mtx_lock(&erts_timeofday_mtx);
 
-    get_tolerant_timeofday(&tv);
-
-    *ms_total = 1000 * (tv.tv_sec - inittv.tv_sec) +
-	(tv.tv_usec - inittv.tv_usec) / 1000;
+    now = time_sup.r.o.get_time();
 
-    prev_total = 1000 * (gtv.tv_sec - inittv.tv_sec) +
-	(gtv.tv_usec - inittv.tv_usec) / 1000;
-    *ms_diff = *ms_total - prev_total;
-    gtv = tv;
-
-    /* must sync the machine's idea of time here */
-    do_erts_deliver_time(&tv);
+    elapsed = ERTS_MONOTONIC_TO_MSEC(now);
+    *ms_total = (UWord) elapsed;
+    *ms_diff = (UWord) (elapsed - prev_wall_clock_elapsed);
+    prev_wall_clock_elapsed = elapsed;
 
     erts_smp_mtx_unlock(&erts_timeofday_mtx);
 }
@@ -890,38 +1476,41 @@ univ_to_local(Sint *year, Sint *month, Sint *day,
     return 0;
 }
 
-
 /* get a timestamp */
 void
 get_now(Uint* megasec, Uint* sec, Uint* microsec)
 {
-    SysTimeval now;
+    ErtsMonotonicTime now_megasec, now_sec, now, mtime, time_offset;
     
+    mtime = time_sup.r.o.get_time();
+    time_offset = get_time_offset();
+    now = ERTS_MONOTONIC_TO_USEC(mtime + time_offset);
+
     erts_smp_mtx_lock(&erts_timeofday_mtx);
-    
-    get_tolerant_timeofday(&now);
-    do_erts_deliver_time(&now);
-
-    /* Make sure time is later than last */
-    if (then.tv_sec > now.tv_sec ||
-	(then.tv_sec == now.tv_sec && then.tv_usec >= now.tv_usec)) {
-	now = then;
-	now.tv_usec++;
-    }
-    /* Check for carry from above + general reasonability */
-    if (now.tv_usec >= 1000000) {
-	now.tv_usec = 0;
-	now.tv_sec++;
-    }
-    then = now;
+
+    /* Make sure now time is later than last time */
+    if (now <= previous_now)
+	now = previous_now + 1;
+
+    previous_now = now;
     
     erts_smp_mtx_unlock(&erts_timeofday_mtx);
-    
-    *megasec = (Uint) (now.tv_sec / 1000000);
-    *sec = (Uint) (now.tv_sec % 1000000);
-    *microsec = (Uint) (now.tv_usec);
 
-    update_approx_time(&now);
+    now_megasec = now / ERTS_MONOTONIC_TIME_TERA;
+    now_sec = now / ERTS_MONOTONIC_TIME_MEGA;
+    *megasec = (Uint) now_megasec;
+    *sec = (Uint) (now_sec - now_megasec*ERTS_MONOTONIC_TIME_MEGA);
+    *microsec = (Uint) (now - now_sec*ERTS_MONOTONIC_TIME_MEGA);
+
+    ASSERT(((ErtsMonotonicTime) *megasec)*ERTS_MONOTONIC_TIME_TERA
+	   + ((ErtsMonotonicTime) *sec)*ERTS_MONOTONIC_TIME_MEGA
+	   + ((ErtsMonotonicTime) *microsec) == now);
+}
+
+ErtsMonotonicTime
+erts_get_monotonic_time(void)
+{
+    return time_sup.r.o.get_time();
 }
 
 void
@@ -934,102 +1523,466 @@ get_sys_now(Uint* megasec, Uint* sec, Uint* microsec)
     *megasec = (Uint) (now.tv_sec / 1000000);
     *sec = (Uint) (now.tv_sec % 1000000);
     *microsec = (Uint) (now.tv_usec);
-
-    update_approx_time(&now);
 }
 
+#ifdef HAVE_ERTS_NOW_CPU
+void erts_get_now_cpu(Uint* megasec, Uint* sec, Uint* microsec) {
+  SysCpuTime t;
+  SysTimespec tp;
 
-/* deliver elapsed *ticks* to the machine - takes a pointer
-   to a struct timeval representing current time (to save
-   a gettimeofday() where possible) or NULL */
+  sys_get_proc_cputime(t, tp);
+  *microsec = (Uint)(tp.tv_nsec / 1000);
+  t = (tp.tv_sec / 1000000);
+  *megasec = (Uint)(t % 1000000);
+  *sec = (Uint)(tp.tv_sec % 1000000);
+}
+#endif
 
-void erts_deliver_time(void) {
-    SysTimeval now;
-    
-    erts_smp_mtx_lock(&erts_timeofday_mtx);
-    
-    get_tolerant_timeofday(&now);
-    do_erts_deliver_time(&now);
-    
-    erts_smp_mtx_unlock(&erts_timeofday_mtx);
+#include "big.h"
 
-    update_approx_time(&now);
+void
+erts_monitor_time_offset(Eterm id, Eterm ref)
+{
+    erts_smp_mtx_lock(&erts_get_time_mtx);
+    erts_add_monitor(&time_offset_monitors, MON_TIME_OFFSET, ref, id, NIL);
+    no_time_offset_monitors++;
+    erts_smp_mtx_unlock(&erts_get_time_mtx);
 }
 
-/* get *real* time (not ticks) remaining until next timeout - if there
-   isn't one, give a "long" time, that is guaranteed
-   to not cause overflow when we report elapsed time later on */
+int
+erts_demonitor_time_offset(Eterm ref)
+{
+    int res;
+    ErtsMonitor *mon;
+    ASSERT(is_internal_ref(ref));
+    erts_smp_mtx_lock(&erts_get_time_mtx);
+    mon = erts_remove_monitor(&time_offset_monitors, ref);
+    if (!mon)
+	res = 0;
+    else {
+	ASSERT(no_time_offset_monitors > 0);
+	no_time_offset_monitors--;
+	res = 1;
+    }
+    erts_smp_mtx_unlock(&erts_get_time_mtx);
+    if (res)
+	erts_destroy_monitor(mon);
+    return res;
+}
 
-void erts_time_remaining(SysTimeval *rem_time)
+typedef struct {
+    Eterm pid;
+    Eterm ref;
+    Eterm heap[REF_THING_SIZE];
+} ErtsTimeOffsetMonitorInfo;
+
+typedef struct {
+    Uint ix;
+    ErtsTimeOffsetMonitorInfo *to_mon_info;
+} ErtsTimeOffsetMonitorContext;
+
+static void
+save_time_offset_monitor(ErtsMonitor *mon, void *vcntxt)
 {
-    erts_time_t ticks;
-    SysTimeval cur_time;
-    erts_time_t elapsed;
-
-    /* erts_next_time() returns no of ticks to next timeout or -1 if none */
-
-    ticks = (erts_time_t) erts_next_time();
-    if (ticks == (erts_time_t) -1) {
-	/* timer queue empty */
-	/* this will cause at most 100000000 ticks */
-	rem_time->tv_sec = 100000;
-	rem_time->tv_usec = 0;
-    } else {
-	/* next timeout after ticks ticks */
-	ticks *= CLOCK_RESOLUTION;
-	
-	erts_smp_mtx_lock(&erts_timeofday_mtx);
-	
-	get_tolerant_timeofday(&cur_time);
-	cur_time.tv_usec = 1000 * 
-	    (cur_time.tv_usec / 1000);/* ms resolution*/
-	elapsed = 1000 * (cur_time.tv_sec - last_delivered.tv_sec) +
-	    (cur_time.tv_usec - last_delivered.tv_usec) / 1000;
-	
-	erts_smp_mtx_unlock(&erts_timeofday_mtx);
+    ErtsTimeOffsetMonitorContext *cntxt;
+    Eterm *from_hp, *to_hp;
+    Uint mix;
+    int hix;
+
+    cntxt = (ErtsTimeOffsetMonitorContext *) vcntxt;
+    mix = (cntxt->ix)++;
+    cntxt->to_mon_info[mix].pid = mon->pid;
+    to_hp = &cntxt->to_mon_info[mix].heap[0];
+
+    ASSERT(is_internal_ref(mon->ref));
+    from_hp = internal_ref_val(mon->ref);
+    ASSERT(thing_arityval(*from_hp) + 1 == REF_THING_SIZE);
+
+    for (hix = 0; hix < REF_THING_SIZE; hix++)
+	to_hp[hix] = from_hp[hix];
+
+    cntxt->to_mon_info[mix].ref
+	= make_internal_ref(&cntxt->to_mon_info[mix].heap[0]);
+
+}
+
+static void
+send_time_offset_changed_notifications(void *new_offsetp)
+{
+    ErtsMonotonicTime new_offset;
+    ErtsTimeOffsetMonitorInfo *to_mon_info;
+    Uint no_monitors;
+    char *tmp = NULL;
+
+#ifdef ARCH_64
+    new_offset = (ErtsMonotonicTime) new_offsetp;
+#else
+    new_offset = *((ErtsMonotonicTime *) new_offsetp);
+    erts_free(ERTS_ALC_T_NEW_TIME_OFFSET, new_offsetp);
+#endif
+    new_offset -= ERTS_MONOTONIC_OFFSET_NATIVE;
+
+    erts_smp_mtx_lock(&erts_get_time_mtx);
+
+    no_monitors = no_time_offset_monitors;
+    if (no_monitors) {
+	ErtsTimeOffsetMonitorContext cntxt;
+	Uint alloc_sz;
 	
-	if (ticks <= elapsed) { /* Ooops, better hurry */
-	    rem_time->tv_sec = rem_time->tv_usec = 0;
-	    return;
+	/* Monitor info array size */
+	alloc_sz = no_monitors*sizeof(ErtsTimeOffsetMonitorInfo);
+	/* + template max size */
+	alloc_sz += 6*sizeof(Eterm); /* 5-tuple */
+	alloc_sz += ERTS_MAX_SINT64_HEAP_SIZE*sizeof(Eterm); /* max offset size */
+	tmp = erts_alloc(ERTS_ALC_T_TMP, alloc_sz);
+
+	to_mon_info = (ErtsTimeOffsetMonitorInfo *) tmp;
+	cntxt.ix = 0;
+	cntxt.to_mon_info = to_mon_info;
+
+	erts_doforall_monitors(time_offset_monitors,
+			       save_time_offset_monitor,
+			       &cntxt);
+
+	ASSERT(cntxt.ix == no_monitors);
+    }
+
+    erts_smp_mtx_unlock(&erts_get_time_mtx);
+
+    if (no_monitors) {
+	Eterm *hp, *patch_refp, new_offset_term, message_template;
+	Uint mix, hsz;
+
+	/* Make message template */
+
+	hp = (Eterm *) (tmp + no_monitors*sizeof(ErtsTimeOffsetMonitorInfo));
+
+	hsz = 6; /* 5-tuple */
+	hsz += REF_THING_SIZE;
+	hsz += ERTS_SINT64_HEAP_SIZE(new_offset);
+
+	if (IS_SSMALL(new_offset))
+	    new_offset_term = make_small(new_offset);
+	else
+	    new_offset_term = erts_sint64_to_big(new_offset, &hp);
+	message_template = TUPLE5(hp,
+				  am_CHANGE,
+				  THE_NON_VALUE, /* Patch point for ref */
+				  am_time_offset,
+				  am_clock_service,
+				  new_offset_term);
+	patch_refp = &hp[2];
+
+	ASSERT(*patch_refp == THE_NON_VALUE);
+
+	for (mix = 0; mix < no_monitors; mix++) {
+	    Process *rp = erts_proc_lookup(to_mon_info[mix].pid);
+	    if (rp) {
+		Eterm ref = to_mon_info[mix].ref;
+		ErtsProcLocks rp_locks = ERTS_PROC_LOCK_LINK;
+		erts_smp_proc_lock(rp, ERTS_PROC_LOCK_LINK);
+		if (erts_lookup_monitor(ERTS_P_MONITORS(rp), ref)) {
+		    ErlHeapFragment *bp;
+		    ErlOffHeap *ohp;
+		    Eterm message;
+
+		    hp = erts_alloc_message_heap(hsz, &bp, &ohp, rp, &rp_locks);
+		    *patch_refp = ref;
+		    ASSERT(hsz == size_object(message_template));
+		    message = copy_struct(message_template, hsz, &hp, ohp);
+		    erts_queue_message(rp, &rp_locks, bp, message, NIL
+#ifdef USE_VM_PROBES
+				       , NIL
+#endif
+			);
+		}
+		erts_smp_proc_unlock(rp, rp_locks);
+	    }
 	}
-	rem_time->tv_sec = (ticks - elapsed) / 1000;
-	rem_time->tv_usec = 1000 * ((ticks - elapsed) % 1000);
+
+	erts_free(ERTS_ALC_T_TMP, tmp);
     }
 }
 
-void erts_get_timeval(SysTimeval *tv)
+static void
+schedule_send_time_offset_changed_notifications(ErtsMonotonicTime new_offset)
 {
-    erts_smp_mtx_lock(&erts_timeofday_mtx);
-    get_tolerant_timeofday(tv);
-    erts_smp_mtx_unlock(&erts_timeofday_mtx);
-    update_approx_time(tv);
+#ifdef ARCH_64
+    void *new_offsetp = (void *) new_offset;
+    ASSERT(sizeof(void *) == sizeof(ErtsMonotonicTime));
+#else
+    void *new_offsetp = erts_alloc(ERTS_ALC_T_NEW_TIME_OFFSET,
+				   sizeof(ErtsMonotonicTime));
+    *((ErtsMonotonicTime *) new_offsetp) = new_offset;
+#endif
+    erts_schedule_misc_aux_work(1,
+				send_time_offset_changed_notifications,
+				new_offsetp);
 }
 
-erts_time_t
-erts_get_time(void)
+static ERTS_INLINE Eterm
+make_time_val(Process *c_p, ErtsMonotonicTime time_val)
 {
-    SysTimeval sys_tv;
-    
-    erts_smp_mtx_lock(&erts_timeofday_mtx);
-    
-    get_tolerant_timeofday(&sys_tv);
-    
-    erts_smp_mtx_unlock(&erts_timeofday_mtx);
+    Sint64 val = (Sint64) time_val;
+    Eterm *hp;
+    Uint sz;
 
-    update_approx_time(&sys_tv);
+    if (IS_SSMALL(val))
+	return make_small(val);
 
-    return sys_tv.tv_sec;
+    sz = ERTS_SINT64_HEAP_SIZE(val);
+    hp = HAlloc(c_p, sz);
+    return erts_sint64_to_big(val, &hp);
 }
 
-#ifdef HAVE_ERTS_NOW_CPU
-void erts_get_now_cpu(Uint* megasec, Uint* sec, Uint* microsec) {
-  SysCpuTime t;
-  SysTimespec tp;
+Eterm
+erts_get_monotonic_start_time(struct process *c_p)
+{
+    return make_time_val(c_p, ERTS_MONOTONIC_OFFSET_NATIVE);
+}
 
-  sys_get_proc_cputime(t, tp);
-  *microsec = (Uint)(tp.tv_nsec / 1000);
-  t = (tp.tv_sec / 1000000);
-  *megasec = (Uint)(t % 1000000);
-  *sec = (Uint)(tp.tv_sec % 1000000);
+static Eterm
+bld_monotonic_time_source(Uint **hpp, Uint *szp, Sint64 os_mtime)
+{
+#ifndef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+    return NIL;
+#else
+    int i = 0;
+    Eterm k[5];
+    Eterm v[5];
+
+    if (time_sup.r.o.os_monotonic_disable)
+	return NIL;
+
+    k[i] = erts_bld_atom(hpp, szp, "function");
+    v[i++] = erts_bld_atom(hpp, szp, time_sup.r.o.os_monotonic_func);
+
+    if (time_sup.r.o.os_monotonic_clock_id) {
+	k[i] = erts_bld_atom(hpp, szp, "clock_id");
+	v[i++] = erts_bld_atom(hpp, szp, time_sup.r.o.os_monotonic_clock_id);
+    }
+
+    if (time_sup.r.o.os_monotonic_resolution) {
+	k[i] = erts_bld_atom(hpp, szp, "resolution");
+	v[i++] = erts_bld_uint64(hpp, szp, time_sup.r.o.os_monotonic_resolution);
+    }
+
+    k[i] = erts_bld_atom(hpp, szp, "parallel");
+    v[i++] = time_sup.r.o.os_monotonic_locked ? am_no : am_yes;
+
+    k[i] = erts_bld_atom(hpp, szp, "time");
+    v[i++] = erts_bld_sint64(hpp, szp, os_mtime);
+
+    return erts_bld_2tup_list(hpp, szp, (Sint) i, k, v);
+#endif
 }
+
+Eterm
+erts_monotonic_time_source(struct process *c_p)
+{
+    Uint hsz = 0;
+    Eterm *hp = NULL;
+    Sint64 os_mtime = 0;
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+    if (!time_sup.r.o.os_monotonic_disable)
+	os_mtime = (Sint64) erts_os_monotonic_time();
+#endif
+
+    bld_monotonic_time_source(NULL, &hsz, os_mtime);
+    if (hsz)
+	hp = HAlloc(c_p, hsz);
+    return bld_monotonic_time_source(&hp, NULL, os_mtime);
+}
+
+
+#include "bif.h"
+
+static ERTS_INLINE Eterm
+time_unit_conversion(Process *c_p, Eterm term, ErtsMonotonicTime val, ErtsMonotonicTime muloff)
+{
+    ErtsMonotonicTime result;
+    BIF_RETTYPE ret;
+
+    if (val < 0)
+	goto trap_to_erlang_code;
+
+    /* Convert to common user specified time units */
+    switch (term) {
+    case am_seconds:
+    case make_small(1):
+	result = ERTS_MONOTONIC_TO_SEC(val) + muloff*ERTS_MONOTONIC_OFFSET_SEC;
+	ERTS_BIF_PREP_RET(ret, make_time_val(c_p, result));
+	break;
+    case am_milli_seconds:
+    case make_small(1000):
+	result = ERTS_MONOTONIC_TO_MSEC(val) + muloff*ERTS_MONOTONIC_OFFSET_MSEC;
+	ERTS_BIF_PREP_RET(ret, make_time_val(c_p, result));
+	break;
+    case am_micro_seconds:
+    case make_small(1000*1000):
+	result = ERTS_MONOTONIC_TO_USEC(val) + muloff*ERTS_MONOTONIC_OFFSET_USEC;
+	ERTS_BIF_PREP_RET(ret, make_time_val(c_p, result));
+	break;
+#ifdef ARCH_64
+    case am_nano_seconds:
+    case make_small(1000*1000*1000):
+	result = ERTS_MONOTONIC_TO_NSEC(val) + muloff*ERTS_MONOTONIC_OFFSET_NSEC;
+	ERTS_BIF_PREP_RET(ret, make_time_val(c_p, result));
+	break;
 #endif
+    default: {
+	Eterm value, native_res;
+#ifndef ARCH_64
+	Sint user_res;
+	if (term == am_nano_seconds)
+	    goto to_nano_seconds;
+	if (term_to_Sint(term, &user_res)) {
+	    if (user_res == 1000*1000*1000) {
+	    to_nano_seconds:
+		result = (ERTS_MONOTONIC_TO_NSEC(val)
+			  + muloff*ERTS_MONOTONIC_OFFSET_NSEC);
+		ERTS_BIF_PREP_RET(ret, make_time_val(c_p, result));
+		break;
+	    }
+	    if (user_res <= 0)
+		goto badarg;
+	}
+#else
+	if (is_small(term)) {
+	    if (signed_val(term) <= 0)
+		goto badarg;
+	}
+#endif
+	else if (is_big(term)) {
+	    if (big_sign(term))
+		goto badarg;
+	}
+	else {
+	badarg:
+	    ERTS_BIF_PREP_ERROR(ret, c_p, BADARG);
+	    break;
+	}
+
+	trap_to_erlang_code:
+	/* Do it in erlang code instead; pass along values to use... */
+	value = make_time_val(c_p, val + muloff*ERTS_MONOTONIC_OFFSET_NATIVE);
+	native_res = make_time_val(c_p, ERTS_MONOTONIC_TIME_UNIT);
+
+	ERTS_BIF_PREP_TRAP3(ret, erts_convert_time_unit_trap, c_p,
+			    value, native_res, term);
+
+	break;
+    }
+    }
+
+    return ret;
+}
+
+/* Built in functions */
+
+BIF_RETTYPE monotonic_time_0(BIF_ALIST_0)
+{
+    ErtsMonotonicTime mtime = time_sup.r.o.get_time();
+    mtime += ERTS_MONOTONIC_OFFSET_NATIVE;
+    BIF_RET(make_time_val(BIF_P, mtime));
+}
+
+BIF_RETTYPE monotonic_time_1(BIF_ALIST_1)
+{
+    BIF_RET(time_unit_conversion(BIF_P, BIF_ARG_1, time_sup.r.o.get_time(), 1));
+}
+
+BIF_RETTYPE system_time_0(BIF_ALIST_0)
+{
+    ErtsMonotonicTime mtime, offset;
+    mtime = time_sup.r.o.get_time();
+    offset = get_time_offset();
+    BIF_RET(make_time_val(BIF_P, mtime + offset));
+}
+
+BIF_RETTYPE system_time_1(BIF_ALIST_0)
+{
+    ErtsMonotonicTime mtime, offset;
+    mtime = time_sup.r.o.get_time();
+    offset = get_time_offset();
+    BIF_RET(time_unit_conversion(BIF_P, BIF_ARG_1, mtime + offset, 0));
+}
+
+BIF_RETTYPE erts_internal_time_unit_0(BIF_ALIST_0)
+{
+    BIF_RET(make_time_val(BIF_P, ERTS_MONOTONIC_TIME_UNIT));
+}
+
+BIF_RETTYPE time_offset_0(BIF_ALIST_0)
+{
+    ErtsMonotonicTime time_offset = get_time_offset();
+    time_offset -= ERTS_MONOTONIC_OFFSET_NATIVE;
+    BIF_RET(make_time_val(BIF_P, time_offset));
+}
+
+BIF_RETTYPE time_offset_1(BIF_ALIST_1)
+{
+    BIF_RET(time_unit_conversion(BIF_P, BIF_ARG_1, get_time_offset(), -1));
+}
+
+
+BIF_RETTYPE timestamp_0(BIF_ALIST_0)
+{
+    Eterm *hp, res;
+    ErtsMonotonicTime stime, mtime, all_sec, offset;
+    Uint mega_sec, sec, micro_sec;
+
+    mtime = time_sup.r.o.get_time();
+    offset = get_time_offset();
+    stime = ERTS_MONOTONIC_TO_USEC(mtime + offset);
+    all_sec = stime / ERTS_MONOTONIC_TIME_MEGA;
+    mega_sec = (Uint) (stime / ERTS_MONOTONIC_TIME_TERA);
+    sec = (Uint) (all_sec - (((ErtsMonotonicTime) mega_sec)
+			     * ERTS_MONOTONIC_TIME_MEGA));
+    micro_sec = (Uint) (stime - all_sec*ERTS_MONOTONIC_TIME_MEGA);
+
+    ASSERT(((ErtsMonotonicTime) mega_sec)*ERTS_MONOTONIC_TIME_TERA
+	   + ((ErtsMonotonicTime) sec)*ERTS_MONOTONIC_TIME_MEGA
+	   + micro_sec == stime);
+
+    /*
+     * Mega seconds is the only value that potentially
+     * ever could be a bignum. However, that wont happen
+     * during at least the next 4 million years...
+     *
+     * (System time will also have wrapped in the
+     * 64-bit integer before we get there...)
+     */
+
+    ASSERT(IS_USMALL(0, mega_sec));
+    ASSERT(IS_USMALL(0, sec));
+    ASSERT(IS_USMALL(0, micro_sec));
+
+    hp = HAlloc(BIF_P, 4);
+    res = TUPLE3(hp,
+		 make_small(mega_sec),
+		 make_small(sec),
+		 make_small(micro_sec));
+    BIF_RET(res);
+}
+
+BIF_RETTYPE os_system_time_0(BIF_ALIST_0)
+{
+    ErtsMonotonicTime stime;
+    SysTimeval tod;
+    sys_gettimeofday(&tod);
+    stime = ERTS_SEC_TO_MONOTONIC(tod.tv_sec);
+    stime += ERTS_USEC_TO_MONOTONIC(tod.tv_usec);
+    BIF_RET(make_time_val(BIF_P, stime));
+}
+
+BIF_RETTYPE os_system_time_1(BIF_ALIST_0)
+{
+    ErtsMonotonicTime stime;
+    SysTimeval tod;
+    sys_gettimeofday(&tod);
+    stime = ERTS_SEC_TO_MONOTONIC(tod.tv_sec);
+    stime += ERTS_USEC_TO_MONOTONIC(tod.tv_usec);
+    BIF_RET(time_unit_conversion(BIF_P, BIF_ARG_1, stime, 0));
+}
+