1 files changed, 383 insertions, 15 deletions

diff --git a/erts/emulator/sys/unix/sys_time.c b/erts/emulator/sys/unix/sys_time.c
index fcce54a2c4..9fdb1930b7 100644
--- a/erts/emulator/sys/unix/sys_time.c
+++ b/erts/emulator/sys/unix/sys_time.c
@@ -53,9 +53,40 @@
 
 /******************* Routines for time measurement *********************/
 
-int erts_ticks_per_sec = 0; /* Will be SYS_CLK_TCK in erl_unix_sys.h */
-int erts_ticks_per_sec_wrap = 0; /* Will be SYS_CLK_TCK_WRAP */
-static int ticks_bsr = 0; /* Shift wrapped tick value this much to the right */
+#undef ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
+#undef ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__
+
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+
+#define ERTS_WRAP_SYS_TIMES 1
+#define ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
+#define ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__
+
+/*
+ * Not sure there is a need to use times() anymore, perhaps drop
+ * support for this soon...
+ *
+ * sys_times() might need to be wrapped and the values shifted (right)
+ * a bit to cope with faster ticks, 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
+static clock_t sys_times_wrap(void);
+#define KERNEL_TICKS() (sys_times_wrap() &  \
+			((1UL << ((sizeof(clock_t) * 8) - 1)) - 1)) 
+#define ERTS_KERNEL_TICK_TO_USEC(TCKS) (((TCKS)*(1000*1000)) \
+					/ internal_state.r.o.ticks_per_sec_wrap)
+#else
+
+#define KERNEL_TICKS() (sys_times(&internal_state.w.f.dummy_tms) &  \
+			((1UL << ((sizeof(clock_t) * 8) - 1)) - 1)) 
+#define ERTS_KERNEL_TICK_TO_USEC(TCKS) (((TCKS)*(1000*1000))/SYS_CLK_TCK)
+#endif
+
+#endif
 
 /* 
  * init timers, chose a tick length, and return it.
@@ -63,37 +94,374 @@ static int ticks_bsr = 0; /* Shift wrapped tick value this much to the right */
  * does almost everything. Other platforms have to
  * emulate Unix in this sense.
  */
-int sys_init_time(void)
+
+ErtsSysTimeData__ erts_sys_time_data__ erts_align_attribute(ERTS_CACHE_LINE_SIZE);
+
+#if defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+
+#define ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
+
+ErtsMonotonicTime clock_gettime_monotonic_raw(void);
+ErtsMonotonicTime clock_gettime_monotonic_verified(void);
+
+#endif /* defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME) */
+
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__
+struct sys_time_internal_state_read_only__ {
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+    int ticks_bsr;
+    int ticks_per_sec_wrap;
+#endif
+};
+#endif
+
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
+struct sys_time_internal_state_write_freq__ {
+    erts_smp_mtx_t mtx;
+#if defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+    ErtsMonotonicTime last_delivered;
+#endif
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+    ErtsMonotonicTime last_tick_count;
+    ErtsMonotonicTime last_tick_wrap_count;
+    ErtsMonotonicTime last_tick_monotonic_time;
+    ErtsMonotonicTime last_timeofday_usec;
+#ifndef ERTS_WRAP_SYS_TIMES 
+    SysTimes dummy_tms;
+#endif
+#endif
+};
+#endif
+
+#if defined(ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__)	\
+    || defined(ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__)
+static struct {
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__
+    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;
+#endif
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
+    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;
+#endif
+} internal_state erts_align_attribute(ERTS_CACHE_LINE_SIZE);
+#endif
+
+void
+sys_init_time(ErtsSysInitTimeResult *init_resp)
 {
+#if !defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT)
+
+    init_resp->have_os_monotonic = 0;
+
+#else /* defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT) */
+
+    int major, minor, build, vsn;
+
+    init_resp->os_monotonic_info.resolution = (Uint64) 1000*1000*1000;
+#if defined(HAVE_CLOCK_GETRES) && defined(MONOTONIC_CLOCK_ID)
+    {
+	struct timespec ts;
+	if (clock_getres(MONOTONIC_CLOCK_ID, &ts) == 0
+	    && ts.tv_sec == 0 && ts.tv_nsec != 0) {
+	    init_resp->os_monotonic_info.resolution /= ts.tv_nsec;
+	}
+    }
+#endif
+
+#ifdef MONOTONIC_CLOCK_ID_STR
+    init_resp->os_monotonic_info.clock_id = MONOTONIC_CLOCK_ID_STR;
+#else
+    init_resp->os_monotonic_info.clock_id = NULL;
+#endif
+
+    init_resp->os_monotonic_info.locked_use = 0;
+
+#if defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+    init_resp->os_monotonic_info.func = "clock_gettime";
+#elif defined(OS_MONOTONIC_TIME_USING_MACH_CLOCK_GET_TIME)
+    init_resp->os_monotonic_info.func = "clock_get_time";
+#elif defined(OS_MONOTONIC_TIME_USING_GETHRTIME)
+    init_resp->os_monotonic_info.func = "gethrtime";
+#elif defined(OS_MONOTONIC_TIME_USING_TIMES)
+    init_resp->os_monotonic_info.func = "times";
+    init_resp->os_monotonic_info.locked_use = 1;
+    init_resp->os_monotonic_info.resolution = TICKS_PER_SEC();
+#else
+# error Unknown erts_os_monotonic_time() implementation
+#endif
+
+    init_resp->have_os_monotonic = 1;
+
+    os_version(&major, &minor, &build);
+
+    vsn = ERTS_MK_VSN_INT(major, minor, build);
+
+
+#if defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+    if (vsn >= ERTS_MK_VSN_INT(2, 6, 33))
+	erts_sys_time_data__.r.o.os_monotonic_time =
+	    clock_gettime_monotonic_raw;
+    else {
+	/*
+	 * Linux versions prior to 2.6.33 have a
+	 * known bug that sometimes cause monotonic
+	 * time to take small steps backwards.
+	 */
+	erts_sys_time_data__.r.o.os_monotonic_time =
+	    clock_gettime_monotonic_verified;
+	erts_smp_mtx_init(&internal_state.w.f.mtx,
+			  "os_monotonic_time");
+	internal_state.w.f.last_delivered
+	    = clock_gettime_monotonic_raw();
+	init_resp->os_monotonic_info.locked_use = 1;
+    }
+#else /* !(defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)) */
+    {
+	char flavor[1024];
+
+	os_flavor(flavor, sizeof(flavor));
+
+	if (sys_strcmp(flavor, "sunos") == 0) {
+	    /*
+	     * Don't trust hrtime on multi processors
+	     * on SunOS prior to SunOS 5.8
+	     */
+	    if (vsn < ERTS_MK_VSN_INT(5, 8, 0)) {
+#if defined(HAVE_SYSCONF) && defined(_SC_NPROCESSORS_CONF)
+		if (sysconf(_SC_NPROCESSORS_CONF) > 1)
+#endif
+		    init_resp->have_os_monotonic = 0;
+	    }
+	}
+    }
+#endif /* !(defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)) */
+
+#endif /* defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT) */
+
+    init_resp->os_monotonic_time_unit = ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT;
+    init_resp->sys_clock_resolution = SYS_CLOCK_RESOLUTION;
+
     /* 
-     * This (erts_ticks_per_sec) is only for times() (CLK_TCK), 
-     * the resolution is always one millisecond..
+     * This (erts_sys_time_data__.r.o.ticks_per_sec) is only for
+     * times() (CLK_TCK), the resolution is always one millisecond..
      */
-    if ((erts_ticks_per_sec = TICKS_PER_SEC()) < 0)
-	erl_exit(1, "Can't get clock ticks/sec\n");
-    if (erts_ticks_per_sec >= 1000) {
+    if ((erts_sys_time_data__.r.o.ticks_per_sec = TICKS_PER_SEC()) < 0)
+	erl_exit(ERTS_ABORT_EXIT, "Can't get clock ticks/sec\n");
+    
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+
+    if (erts_sys_time_data__.r.o.ticks_per_sec >= 1000) {
 	/* Workaround for beta linux kernels, need to be done in runtime
 	   to make erlang run on both 2.4 and 2.5 kernels. In the future, 
 	   the kernel ticks might as 
 	   well be used as a high res timer instead, but that's for when the 
 	   majority uses kernels with HZ == 1024 */
-	ticks_bsr = 3;
+	internal_state.r.o.ticks_bsr = 3;
     } else {
-	ticks_bsr = 0;
+	internal_state.r.o.ticks_bsr = 0;
     }
-    erts_ticks_per_sec_wrap = (erts_ticks_per_sec >> ticks_bsr);
-    return SYS_CLOCK_RESOLUTION;
+
+    internal_state.r.o.ticks_per_sec_wrap
+	= (erts_sys_time_data__.r.o.ticks_per_sec
+	   >> internal_state.r.o.ticks_bsr);
+
+    erts_smp_mtx_init(&internal_state.w.f.mtx, "os_monotonic_time");
+    internal_state.w.f.last_tick_count = KERNEL_TICKS();
+    internal_state.w.f.last_tick_wrap_count = 0;    
+    internal_state.w.f.last_tick_monotonic_time
+	= ERTS_KERNEL_TICK_TO_USEC(internal_state.w.f.last_tick_count);
+    {
+	SysTimeval tv;
+	sys_gettimeofday(&tv);
+	internal_state.w.f.last_timeofday_usec = tv.tv_sec*(1000*1000);
+	internal_state.w.f.last_timeofday_usec += tv.tv_usec;
+    }
+
+#endif /* defined(OS_MONOTONIC_TIME_USING_TIMES) */
+
+}
+
+#if defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+
+static ERTS_INLINE ErtsMonotonicTime
+clock_gettime_monotonic(void)
+{
+    ErtsMonotonicTime mtime;
+    struct timespec ts;
+
+    if (clock_gettime(MONOTONIC_CLOCK_ID,&ts) != 0) {
+	int err = errno;
+	char *errstr = err ? strerror(err) : "unknown";
+	erl_exit(ERTS_ABORT_EXIT,
+		 "clock_gettime(%s, _) failed: %s (%d)\n",
+		 MONOTONIC_CLOCK_ID_STR, errstr, err);
+
+    }
+    mtime = (ErtsMonotonicTime) ts.tv_sec;
+    mtime *= (ErtsMonotonicTime) 1000*1000*1000;
+    mtime += (ErtsMonotonicTime) ts.tv_nsec;
+    return mtime;
+}
+
+#if defined(__linux__)
+
+ErtsMonotonicTime clock_gettime_monotonic_verified(void)
+{
+    ErtsMonotonicTime mtime;
+
+    mtime = clock_gettime_monotonic();
+
+    erts_smp_mtx_lock(&internal_state.w.f.mtx);
+    if (mtime < internal_state.w.f.last_delivered)
+	mtime = internal_state.w.f.last_delivered;
+    else
+	internal_state.w.f.last_delivered = mtime;
+    erts_smp_mtx_unlock(&internal_state.w.f.mtx);
+
+    return mtime;
+}
+
+ErtsMonotonicTime clock_gettime_monotonic_raw(void)
+{
+    return clock_gettime_monotonic();
 }
 
-clock_t sys_times_wrap(void)
+#else /* !defined(__linux__) */
+
+ErtsMonotonicTime erts_os_monotonic_time(void)
+{
+    return clock_gettime_monotonic();
+}
+
+#endif /* !defined(__linux__) */
+
+#elif defined(OS_MONOTONIC_TIME_USING_MACH_CLOCK_GET_TIME)
+
+#include <mach/clock.h>
+#include <mach/mach.h>
+
+ErtsMonotonicTime erts_os_monotonic_time(void)
+{
+    ErtsMonotonicTime mtime;
+    kern_return_t res;
+    clock_serv_t clk_srv;
+    mach_timespec_t time_spec;
+    int err;
+
+    host_get_clock_service(mach_host_self(),
+			   MONOTONIC_CLOCK_ID,
+			   &clk_srv);
+    errno = 0;
+    res = clock_get_time(clk_srv, &time_spec);
+    err = errno;
+    mach_port_deallocate(mach_task_self(), clk_srv);
+    if (res != KERN_SUCCESS) {
+	char *errstr = err ? strerror(err) : "unknown";
+	erl_exit(ERTS_ABORT_EXIT,
+		 "clock_get_time(%s, _) failed: %s (%d)\n",
+		 MONOTONIC_CLOCK_ID_STR, errstr, err);
+    }
+
+    mtime = (ErtsMonotonicTime) time_spec.tv_sec;
+    mtime *= (ErtsMonotonicTime) 1000*1000*1000;
+    mtime += (ErtsMonotonicTime) time_spec.tv_nsec;
+    return mtime;
+}
+
+#elif defined(OS_MONOTONIC_TIME_USING_TIMES)
+
+static clock_t sys_times_wrap(void)
 {
     SysTimes dummy;
-    clock_t result = (sys_times(&dummy) >> ticks_bsr);
+    clock_t result = (sys_times(&dummy) >> internal_state.r.o.ticks_bsr);
     return result;
 }
 
+void
+erts_os_time_offset_finalize(void)
+{
+    erts_smp_mtx_lock(&internal_state.w.f.mtx);
+    internal_state.w.f.last_tick_wrap_count = 0;
+    erts_smp_mtx_unlock(&internal_state.w.f.mtx);
+}
+
+#define ERTS_TIME_EXCEED_TICK_LIMIT(SYS_TIME, TCK_TIME)			\
+    (((Uint64) (SYS_TIME)) - (((Uint64) (TCK_TIME))			\
+			      - ERTS_KERNEL_TICK_TO_USEC(1))		\
+     > ERTS_KERNEL_TICK_TO_USEC(2))
+
+/* Returns monotonic time in micro seconds */
+ErtsMonotonicTime
+erts_os_monotonic_time(void)
+{
+    SysTimeval tv;
+    ErtsMonotonicTime res;
+    ErtsMonotonicTime tick_count;
+    ErtsMonotonicTime tick_count_usec;
+    ErtsMonotonicTime tick_monotonic_time;
+    ErtsMonotonicTime timeofday_usec;
+    ErtsMonotonicTime timeofday_diff_usec;
+
+    erts_smp_mtx_lock(&internal_state.w.f.mtx);
 
+    tick_count = (ErtsMonotonicTime) KERNEL_TICKS();
+    sys_gettimeofday(&tv);
+
+    if (internal_state.w.f.last_tick_count > tick_count) {
+	internal_state.w.f.last_tick_wrap_count
+	    += (((ErtsMonotonicTime) 1) << ((sizeof(clock_t) * 8) - 1));
+    }
+    internal_state.w.f.last_tick_count = tick_count;
+    tick_count += internal_state.w.f.last_tick_wrap_count;
+
+    tick_count_usec = ERTS_KERNEL_TICK_TO_USEC(tick_count);
+
+    timeofday_usec = (ErtsMonotonicTime) tv.tv_sec*(1000*1000);
+    timeofday_usec += (ErtsMonotonicTime) tv.tv_usec;
+    timeofday_diff_usec = timeofday_usec;
+    timeofday_diff_usec -= internal_state.w.f.last_timeofday_usec;
+    internal_state.w.f.last_timeofday_usec = timeofday_usec;
+
+    if (timeofday_diff_usec < 0) {
+	/* timeofday jumped backwards use tick count only... */
+	tick_monotonic_time = tick_count_usec;
+    }
+    else {
+	/* Use time diff from of timeofday if not off by too much... */
+	tick_monotonic_time = internal_state.w.f.last_tick_monotonic_time;
+	tick_monotonic_time += timeofday_diff_usec;
+
+	if (ERTS_TIME_EXCEED_TICK_LIMIT(tick_monotonic_time, tick_count_usec)) {
+	    /*
+	     * Value off by more than one tick from tick_count, i.e.
+	     * timofday leaped one way or the other. We use
+	     * tick_count_usec as is instead and unfortunately
+	     * get lousy precision.
+	     */
+	    tick_monotonic_time = tick_count_usec;
+	}
+    }
+
+    if (internal_state.w.f.last_tick_monotonic_time < tick_monotonic_time)
+	internal_state.w.f.last_tick_monotonic_time = tick_monotonic_time;
+
+    res = internal_state.w.f.last_tick_monotonic_time;
+
+    erts_smp_mtx_unlock(&internal_state.w.f.mtx);
+
+    return res;
+}
 
+#endif  /* !defined(OS_MONOTONIC_TIME_USING_TIMES) */
 
 #ifdef HAVE_GETHRVTIME_PROCFS_IOCTL