The R13B03 release.OTP_R13B03

1 files changed, 899 insertions, 0 deletions

diff --git a/erts/emulator/beam/erl_time_sup.c b/erts/emulator/beam/erl_time_sup.c
new file mode 100644
index 0000000000..76bfdecd9f
--- /dev/null
+++ b/erts/emulator/beam/erl_time_sup.c
@@ -0,0 +1,899 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1999-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+
+/*
+** 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).
+**
+*/
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#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 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() */
+
+
+#ifdef HAVE_GETHRTIME
+
+int erts_disable_tolerant_timeofday;
+
+static SysHrTime hr_init_time, hr_last_correction_check, 
+    hr_correction, hr_last_time;
+
+static void init_tolerant_timeofday(void)
+{
+    /* 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;
+	}
+    }
+#endif
+    hr_init_time = sys_gethrtime();
+    hr_last_correction_check = hr_last_time = hr_init_time;
+    hr_correction = 0;
+}
+
+static void get_tolerant_timeofday(SysTimeval *tv)
+{
+    SysHrTime diff_time, curr;
+
+    if (erts_disable_tolerant_timeofday) {
+	sys_gettimeofday(tv);
+	return;
+    }
+    *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");
+    }
+
+    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;
+	    }
+	    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;
+	    }
+	    diff_time = (curr + hr_correction - hr_init_time) / 1000; 
+	} else {
+	    ++done;
+	}
+	if (done) {
+	    hr_last_correction_check = curr;
+	}
+    }
+    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;
+    }
+    hr_last_time = curr;
+}
+
+#define correction (hr_correction/1000000)
+
+#else /* !HAVE_GETHRTIME */
+#if !defined(CORRECT_USING_TIMES) 
+#define init_tolerant_timeofday() 
+#define get_tolerant_timeofday(tvp) sys_gettimeofday(tvp)
+#else
+
+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;
+
+#define KERNEL_TICKS() (sys_times(&dummy_tms) &  \
+			((1UL << ((sizeof(clock_t) * 8) - 1)) - 1)) 
+
+#endif
+
+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;
+}
+
+
+static void get_tolerant_timeofday(SysTimeval *tvp)
+{
+    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;
+    }
+
+#ifdef ERTS_WRAP_SYS_TIMES 
+#define TICK_MS (1000 / SYS_CLK_TCK_WRAP)
+#else
+#define TICK_MS (1000 / SYS_CLK_TCK)
+#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);
+    }
+    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;
+
+    tv_diff = ((((Milli) current_tv.tv_sec) * 1000) + 
+	       (current_tv.tv_usec / 1000)) - init_tv_m;
+
+    current_correction = ((ct_diff - tv_diff) / TICK_MS) * TICK_MS; /* trunc */
+
+    /* 
+     * 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;
+	    }
+	    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
+}
+
+#endif /* CORRECT_USING_TIMES */
+#endif /* !HAVE_GETHRTIME */
+
+/*
+** 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
+#else
+#define CLOCK_RESOLUTION SYS_CLOCK_RESOLUTION
+#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 shold 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.
+*/
+
+#if defined(ERTS_TIMER_THREAD)
+static ERTS_INLINE void init_erts_deliver_time(const SysTimeval *inittv) { }
+static ERTS_INLINE void do_erts_deliver_time(const SysTimeval *current) { }
+#else
+static SysTimeval last_delivered; 
+
+static void init_erts_deliver_time(const SysTimeval *inittv)
+{
+    /* We set the initial values for deliver_time here */
+    last_delivered = *inittv;
+    last_delivered.tv_usec = 1000 * (last_delivered.tv_usec / 1000); 
+                                                   /* ms resolution */
+}
+
+static void do_erts_deliver_time(const SysTimeval *current)
+{
+    SysTimeval cur_time;
+    long 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;
+
+    /* Sometimes the time jump backwards,
+       resulting in a negative elapsed time. We compensate for
+       this by simply pretend as if the time stood still. :) */
+
+    if (elapsed > 0) {
+	do_time_add(elapsed);
+	last_delivered = cur_time;
+    }
+}
+#endif
+
+int 
+erts_init_time_sup(void)
+{
+    erts_smp_mtx_init(&erts_timeofday_mtx, "timeofday");
+
+    last_emu_time.tv_sec = 0;
+    last_emu_time.tv_usec = 0;
+
+#ifndef SYS_CLOCK_RESOLUTION
+    clock_resolution = sys_init_time();
+#else
+    (void) sys_init_time();
+#endif
+    sys_gettimeofday(&inittv);
+    
+#ifdef HAVE_GETHRTIME
+    sys_init_hrtime();
+#endif
+    init_tolerant_timeofday();
+
+    init_erts_deliver_time(&inittv);
+    gtv = inittv;
+    then.tv_sec = then.tv_usec = 0;
+
+    erts_get_emu_time(&erts_first_emu_time);
+
+    return CLOCK_RESOLUTION;
+}    
+/* info functions */
+
+void 
+elapsed_time_both(unsigned long *ms_user, unsigned long *ms_sys, 
+		  unsigned long *ms_user_diff, unsigned long *ms_sys_diff)
+{
+    unsigned long prev_total_user, prev_total_sys;
+    unsigned long total_user, total_sys;
+    SysTimes now;
+
+    sys_times(&now);
+    total_user = (now.tms_utime * 1000) / SYS_CLK_TCK;
+    total_sys = (now.tms_stime * 1000) / SYS_CLK_TCK;
+
+    if (ms_user != NULL)
+	*ms_user = total_user;
+    if (ms_sys != NULL)
+	*ms_sys = total_sys;
+
+    erts_smp_mtx_lock(&erts_timeofday_mtx);
+    
+    prev_total_user = (t_start.tms_utime * 1000) / SYS_CLK_TCK;
+    prev_total_sys = (t_start.tms_stime * 1000) / SYS_CLK_TCK;
+    t_start = now;
+    
+    erts_smp_mtx_unlock(&erts_timeofday_mtx);
+
+    if (ms_user_diff != NULL)
+	*ms_user_diff = total_user - prev_total_user;
+	  
+    if (ms_sys_diff != NULL)
+	*ms_sys_diff = total_sys - prev_total_sys;
+}
+
+
+/* wall clock routines */
+
+void 
+wall_clock_elapsed_time_both(unsigned long *ms_total, unsigned long *ms_diff)
+{
+    unsigned long prev_total;
+    SysTimeval tv;
+
+    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;
+
+    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);
+
+    erts_smp_mtx_unlock(&erts_timeofday_mtx);
+}
+
+/* get current time */
+void 
+get_time(int *hour, int *minute, int *second)
+{
+    time_t the_clock;
+    struct tm *tm;
+#ifdef HAVE_LOCALTIME_R
+    struct tm tmbuf;
+#endif
+    
+    the_clock = time((time_t *)0);
+#ifdef HAVE_LOCALTIME_R
+    localtime_r(&the_clock, (tm = &tmbuf));
+#else
+    tm = localtime(&the_clock);
+#endif
+    *hour = tm->tm_hour;
+    *minute = tm->tm_min;
+    *second = tm->tm_sec;
+}
+
+/* get current date */
+void 
+get_date(int *year, int *month, int *day)
+{
+    time_t the_clock;
+    struct tm *tm;
+#ifdef HAVE_LOCALTIME_R
+    struct tm tmbuf;
+#endif
+
+
+    the_clock = time((time_t *)0);
+#ifdef HAVE_LOCALTIME_R
+    localtime_r(&the_clock, (tm = &tmbuf));
+#else
+    tm = localtime(&the_clock);
+#endif
+    *year = tm->tm_year + 1900;
+    *month = tm->tm_mon +1;
+    *day = tm->tm_mday;
+}
+
+/* get localtime */
+void 
+get_localtime(int *year, int *month, int *day, 
+	      int *hour, int *minute, int *second)
+{
+    time_t the_clock;
+    struct tm *tm;
+#ifdef HAVE_LOCALTIME_R
+    struct tm tmbuf;
+#endif
+
+    the_clock = time((time_t *)0);
+#ifdef HAVE_LOCALTIME_R
+    localtime_r(&the_clock, (tm = &tmbuf));
+#else
+    tm = localtime(&the_clock);
+#endif
+    *year = tm->tm_year + 1900;
+    *month = tm->tm_mon +1;
+    *day = tm->tm_mday;
+    *hour = tm->tm_hour;
+    *minute = tm->tm_min;
+    *second = tm->tm_sec;
+}
+
+
+/* get universaltime */
+void 
+get_universaltime(int *year, int *month, int *day, 
+		  int *hour, int *minute, int *second)
+{
+    time_t the_clock;
+    struct tm *tm;
+#ifdef HAVE_GMTIME_R
+    struct tm tmbuf;
+#endif
+
+    the_clock = time((time_t *)0);
+#ifdef HAVE_GMTIME_R
+    gmtime_r(&the_clock, (tm = &tmbuf));
+#else
+    tm = gmtime(&the_clock);
+#endif
+    *year = tm->tm_year + 1900;
+    *month = tm->tm_mon +1;
+    *day = tm->tm_mday;
+    *hour = tm->tm_hour;
+    *minute = tm->tm_min;
+    *second = tm->tm_sec;
+}
+
+
+/* days in month = 1, 2, ..., 12 */
+static const int mdays[14] = {0, 31, 28, 31, 30, 31, 30,
+                                 31, 31, 30, 31, 30, 31};
+
+#define  IN_RANGE(a,x,b)  (((a) <= (x)) && ((x) <= (b)))
+#define  is_leap_year(y)  (((((y) % 4) == 0) && \
+                            (((y) % 100) != 0)) || \
+                           (((y) % 400) == 0))
+
+#define  BASEYEAR       1970
+
+/*
+ * gregday
+ *
+ * Returns the number of days since Jan 1, 1600, if year is
+ * greater of equal to 1600 , and month [1-12] and day [1-31] 
+ * are within range. Otherwise it returns -1.
+ */
+static int long gregday(int year, int month, int day)
+{
+  int long ndays = 0;
+  int gyear, pyear, m;
+  
+  /* number of days in previous years */
+  gyear = year - 1600;
+  if (gyear > 0) {
+    pyear = gyear - 1;
+    ndays = (pyear/4) - (pyear/100) + (pyear/400) + pyear*365 + 366;
+  }
+  /* number of days in all months preceeding month */
+  for (m = 1; m < month; m++)
+    ndays += mdays[m];
+  /* Extra day if leap year and March or later */
+  if (is_leap_year(year) && (month > 2))
+    ndays++;
+  ndays += day - 1;
+  return ndays - 135140;        /* 135140 = Jan 1, 1970 */
+}
+
+
+
+int 
+local_to_univ(Sint *year, Sint *month, Sint *day, 
+	      Sint *hour, Sint *minute, Sint *second, int isdst)
+{
+    time_t the_clock;
+    struct tm *tm, t;
+#ifdef HAVE_GMTIME_R
+    struct tm tmbuf;
+#endif
+    
+    if (!(IN_RANGE(BASEYEAR, *year, INT_MAX - 1) &&
+          IN_RANGE(1, *month, 12) &&
+          IN_RANGE(1, *day, (mdays[*month] + 
+                             (*month == 2 
+                              && (*year % 4 == 0) 
+                              && (*year % 100 != 0 || *year % 400 == 0)))) &&
+          IN_RANGE(0, *hour, 23) &&
+          IN_RANGE(0, *minute, 59) &&
+          IN_RANGE(0, *second, 59))) {
+      return 0;
+    }
+    
+    t.tm_year = *year - 1900;
+    t.tm_mon = *month - 1;
+    t.tm_mday = *day;
+    t.tm_hour = *hour;
+    t.tm_min = *minute;
+    t.tm_sec = *second;
+    t.tm_isdst = isdst;
+    the_clock = mktime(&t);
+#ifdef HAVE_GMTIME_R
+    gmtime_r(&the_clock, (tm = &tmbuf));
+#else
+    tm = gmtime(&the_clock);
+#endif
+    *year = tm->tm_year + 1900;
+    *month = tm->tm_mon +1;
+    *day = tm->tm_mday;
+    *hour = tm->tm_hour;
+    *minute = tm->tm_min;
+    *second = tm->tm_sec;
+    return 1;
+}
+
+int 
+univ_to_local(Sint *year, Sint *month, Sint *day, 
+	      Sint *hour, Sint *minute, Sint *second)
+{
+    time_t the_clock;
+    struct tm *tm;
+#ifdef HAVE_LOCALTIME_R
+    struct tm tmbuf;
+#endif
+    
+    if (!(IN_RANGE(BASEYEAR, *year, INT_MAX - 1) &&
+          IN_RANGE(1, *month, 12) &&
+          IN_RANGE(1, *day, (mdays[*month] + 
+                             (*month == 2 
+                              && (*year % 4 == 0) 
+                              && (*year % 100 != 0 || *year % 400 == 0)))) &&
+          IN_RANGE(0, *hour, 23) &&
+          IN_RANGE(0, *minute, 59) &&
+          IN_RANGE(0, *second, 59))) {
+      return 0;
+    }
+    
+    the_clock = *second + 60 * (*minute + 60 * (*hour + 24 *
+                                            gregday(*year, *month, *day)));
+#ifdef HAVE_POSIX2TIME
+    /*
+     * Addition from OpenSource - affects FreeBSD.
+     * No valid test case /PaN
+     *
+     * leap-second correction performed
+     * if system is configured so;
+     * do nothing if not
+     * See FreeBSD 6.x and 7.x
+     * /usr/src/lib/libc/stdtime/localtime.c
+     * for the details
+     */
+    the_clock = posix2time(the_clock);
+#endif
+
+#ifdef HAVE_LOCALTIME_R
+    localtime_r(&the_clock, (tm = &tmbuf));
+#else
+    tm = localtime(&the_clock);
+#endif
+    *year = tm->tm_year + 1900;
+    *month = tm->tm_mon +1;
+    *day = tm->tm_mday;
+    *hour = tm->tm_hour;
+    *minute = tm->tm_min;
+    *second = tm->tm_sec;
+    return 1;
+}
+
+
+/* get a timestamp */
+void
+get_now(Uint* megasec, Uint* sec, Uint* microsec)
+{
+    SysTimeval now;
+    
+    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;
+    
+    erts_smp_mtx_unlock(&erts_timeofday_mtx);
+    
+    *megasec = (Uint) (now.tv_sec / 1000000);
+    *sec = (Uint) (now.tv_sec % 1000000);
+    *microsec = (Uint) (now.tv_usec);
+}
+
+void
+get_sys_now(Uint* megasec, Uint* sec, Uint* microsec)
+{
+    SysTimeval now;
+    
+    erts_smp_mtx_lock(&erts_timeofday_mtx);
+    
+    sys_gettimeofday(&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);
+}
+
+
+/* deliver elapsed *ticks* to the machine - takes a pointer
+   to a struct timeval representing current time (to save
+   a gettimeofday() where possible) or NULL */
+
+#if !defined(ERTS_TIMER_THREAD)
+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);
+}
+#endif
+
+/* 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 */
+
+void erts_time_remaining(SysTimeval *rem_time)
+{
+    int ticks;
+#if !defined(ERTS_TIMER_THREAD)
+    SysTimeval cur_time;
+#endif
+    long elapsed;
+
+    /* next_time() returns no of ticks to next timeout or -1 if none */
+
+    if ((ticks = next_time()) == -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;
+	
+#if defined(ERTS_TIMER_THREAD)
+	elapsed = 0;
+#else
+	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);
+	
+	if (ticks <= elapsed) { /* Ooops, better hurry */
+	    rem_time->tv_sec = rem_time->tv_usec = 0;
+	    return;
+	}
+#endif
+	rem_time->tv_sec = (ticks - elapsed) / 1000;
+	rem_time->tv_usec = 1000 * ((ticks - elapsed) % 1000);
+    }
+}
+
+void erts_get_timeval(SysTimeval *tv)
+{
+    erts_smp_mtx_lock(&erts_timeofday_mtx);
+    get_tolerant_timeofday(tv);
+    erts_smp_mtx_unlock(&erts_timeofday_mtx);
+}
+
+long
+erts_get_time(void)
+{
+    SysTimeval sys_tv;
+    
+    erts_smp_mtx_lock(&erts_timeofday_mtx);
+    
+    get_tolerant_timeofday(&sys_tv);
+    
+    erts_smp_mtx_unlock(&erts_timeofday_mtx);
+    
+    return sys_tv.tv_sec;
+}
+
+#ifdef HAVE_ERTS_NOW_CPU
+void erts_get_now_cpu(Uint* megasec, Uint* sec, Uint* microsec) {
+  SysCpuTime t;
+  SysTimespec tp;
+
+  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
+
+
+/*
+ * erts_get_emu_time() is similar to get_now(). You will
+ * always get different times from erts_get_emu_time(), but they
+ * may equal a time from get_now().
+ *
+ * erts_get_emu_time() is only used internally in the emulator in
+ * order to order emulator internal events.
+ */
+
+void
+erts_get_emu_time(SysTimeval *this_emu_time_p)
+{
+    erts_smp_mtx_lock(&erts_timeofday_mtx);
+    
+    get_tolerant_timeofday(this_emu_time_p);
+
+    /* Make sure time is later than last */
+    if (last_emu_time.tv_sec > this_emu_time_p->tv_sec ||
+	(last_emu_time.tv_sec == this_emu_time_p->tv_sec
+	 && last_emu_time.tv_usec >= this_emu_time_p->tv_usec)) {
+	*this_emu_time_p = last_emu_time;
+	this_emu_time_p->tv_usec++;
+    }
+    /* Check for carry from above + general reasonability */
+    if (this_emu_time_p->tv_usec >= 1000000) {
+	this_emu_time_p->tv_usec = 0;
+	this_emu_time_p->tv_sec++;
+    }
+
+    last_emu_time = *this_emu_time_p;
+    
+    erts_smp_mtx_unlock(&erts_timeofday_mtx);
+}