diff options
Diffstat (limited to 'erts/emulator/beam/erl_time_sup.c')
| -rw-r--r-- | erts/emulator/beam/erl_time_sup.c | 899 |
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(¤t_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); +} |