From 2af67d21b2e4e1d657fe88fc42924cbebab64585 Mon Sep 17 00:00:00 2001 From: Corinna Vinschen Date: Wed, 7 Feb 2018 13:07:44 +0100 Subject: [PATCH] Cygwin: Cleanup time handling * Redefine NSPERSEC to NS100PERSEC * Define NSPERSEC as nanosecs per second * Define USPERSEC as microsecs per second * Use above constants throughout where appropriate * Rename to_us to timespec_to_us and inline * Rename it_bad to timespec_bad and inline Signed-off-by: Corinna Vinschen --- winsup/cygwin/fhandler_disk_file.cc | 4 +- winsup/cygwin/fhandler_proc.cc | 12 ++-- winsup/cygwin/fhandler_process.cc | 8 +-- winsup/cygwin/hires.h | 6 +- winsup/cygwin/posix_ipc.cc | 2 +- winsup/cygwin/resource.cc | 4 +- winsup/cygwin/sched.cc | 8 ++- winsup/cygwin/select.cc | 5 +- winsup/cygwin/signal.cc | 26 +++++---- winsup/cygwin/sysconf.cc | 3 +- winsup/cygwin/thread.cc | 10 ++-- winsup/cygwin/timer.cc | 39 +++++++------ winsup/cygwin/times.cc | 85 ++++++++++++++--------------- 13 files changed, 115 insertions(+), 97 deletions(-) diff --git a/winsup/cygwin/fhandler_disk_file.cc b/winsup/cygwin/fhandler_disk_file.cc index 5dfcae4d9..f0799657c 100644 --- a/winsup/cygwin/fhandler_disk_file.cc +++ b/winsup/cygwin/fhandler_disk_file.cc @@ -1314,8 +1314,8 @@ fhandler_base::utimens_fs (const struct timespec *tvp) tmp[1] = tmp[0] = timeofday; else { - if ((tvp[0].tv_nsec < UTIME_NOW || tvp[0].tv_nsec > 999999999L) - || (tvp[1].tv_nsec < UTIME_NOW || tvp[1].tv_nsec > 999999999L)) + if ((tvp[0].tv_nsec < UTIME_NOW || tvp[0].tv_nsec >= NSPERSEC) + || (tvp[1].tv_nsec < UTIME_NOW || tvp[1].tv_nsec >= NSPERSEC)) { if (closeit) close_fs (); diff --git a/winsup/cygwin/fhandler_proc.cc b/winsup/cygwin/fhandler_proc.cc index ad367e457..771235f0a 100644 --- a/winsup/cygwin/fhandler_proc.cc +++ b/winsup/cygwin/fhandler_proc.cc @@ -535,9 +535,9 @@ format_proc_stat (void *, char *&destbuf) for (unsigned long i = 0; i < wincap.cpu_count (); i++) { kernel_time += (spt[i].KernelTime.QuadPart - spt[i].IdleTime.QuadPart) - * HZ / 10000000ULL; - user_time += spt[i].UserTime.QuadPart * HZ / 10000000ULL; - idle_time += spt[i].IdleTime.QuadPart * HZ / 10000000ULL; + * HZ / NS100PERSEC; + user_time += spt[i].UserTime.QuadPart * HZ / NS100PERSEC; + idle_time += spt[i].IdleTime.QuadPart * HZ / NS100PERSEC; } eobuf += __small_sprintf (eobuf, "cpu %U %U %U %U\n", @@ -546,9 +546,9 @@ format_proc_stat (void *, char *&destbuf) for (unsigned long i = 0; i < wincap.cpu_count (); i++) { interrupt_count += spt[i].InterruptCount; - kernel_time = (spt[i].KernelTime.QuadPart - spt[i].IdleTime.QuadPart) * HZ / 10000000ULL; - user_time = spt[i].UserTime.QuadPart * HZ / 10000000ULL; - idle_time = spt[i].IdleTime.QuadPart * HZ / 10000000ULL; + kernel_time = (spt[i].KernelTime.QuadPart - spt[i].IdleTime.QuadPart) * HZ / NS100PERSEC; + user_time = spt[i].UserTime.QuadPart * HZ / NS100PERSEC; + idle_time = spt[i].IdleTime.QuadPart * HZ / NS100PERSEC; eobuf += __small_sprintf (eobuf, "cpu%d %U %U %U %U\n", i, user_time, 0ULL, kernel_time, idle_time); } diff --git a/winsup/cygwin/fhandler_process.cc b/winsup/cygwin/fhandler_process.cc index eb5a523ff..c74844784 100644 --- a/winsup/cygwin/fhandler_process.cc +++ b/winsup/cygwin/fhandler_process.cc @@ -1139,19 +1139,19 @@ format_process_stat (void *data, char *&destbuf) return 0; } fault_count = vmc.PageFaultCount; - utime = put.UserTime.QuadPart * HZ / 10000000ULL; - stime = put.KernelTime.QuadPart * HZ / 10000000ULL; + utime = put.UserTime.QuadPart * HZ / NS100PERSEC; + stime = put.KernelTime.QuadPart * HZ / NS100PERSEC; #if 0 if (stodi.CurrentTime.QuadPart > put.CreateTime.QuadPart) start_time = (spt.KernelTime.QuadPart + spt.UserTime.QuadPart - - stodi.CurrentTime.QuadPart + put.CreateTime.QuadPart) * HZ / 10000000ULL; + stodi.CurrentTime.QuadPart + put.CreateTime.QuadPart) * HZ / NS100PERSEC; else /* * sometimes stodi.CurrentTime is a bit behind * Note: some older versions of procps are broken and can't cope * with process start times > time(NULL). */ - start_time = (spt.KernelTme.QuadPart + spt.UserTime.QuadPart) * HZ / 10000000ULL; + start_time = (spt.KernelTme.QuadPart + spt.UserTime.QuadPart) * HZ / NS100PERSEC; #endif /* The BasePriority returned to a 32 bit process under WOW64 is apparently broken, for 32 and 64 bit target processes. 64 bit diff --git a/winsup/cygwin/hires.h b/winsup/cygwin/hires.h index c6a286cff..96010a605 100644 --- a/winsup/cygwin/hires.h +++ b/winsup/cygwin/hires.h @@ -29,8 +29,12 @@ details. */ /* 100ns difference between Windows and UNIX timebase. */ #define FACTOR (0x19db1ded53e8000LL) +/* # of nanosecs per second. */ +#define NSPERSEC (1000000000) /* # of 100ns intervals per second. */ -#define NSPERSEC 10000000LL +#define NS100PERSEC (10000000) +/* # of millisecs per second. */ +#define USPERSEC (1000000) class hires_base { diff --git a/winsup/cygwin/posix_ipc.cc b/winsup/cygwin/posix_ipc.cc index f5c4009ff..36e9ed9cf 100644 --- a/winsup/cygwin/posix_ipc.cc +++ b/winsup/cygwin/posix_ipc.cc @@ -183,7 +183,7 @@ ipc_cond_timedwait (HANDLE evt, HANDLE mtx, const struct timespec *abstime) { if (abstime->tv_sec < 0 || abstime->tv_nsec < 0 - || abstime->tv_nsec > 999999999) + || abstime->tv_nsec >= NSPERSEC) return EINVAL; /* If a timeout is set, we create a waitable timer to wait for. diff --git a/winsup/cygwin/resource.cc b/winsup/cygwin/resource.cc index 11a04f13d..9e39d3a04 100644 --- a/winsup/cygwin/resource.cc +++ b/winsup/cygwin/resource.cc @@ -29,9 +29,9 @@ add_timeval (struct timeval *tv1, struct timeval *tv2) { tv1->tv_sec += tv2->tv_sec; tv1->tv_usec += tv2->tv_usec; - if (tv1->tv_usec >= 1000000) + if (tv1->tv_usec >= USPERSEC) { - tv1->tv_usec -= 1000000; + tv1->tv_usec -= USPERSEC; tv1->tv_sec++; } } diff --git a/winsup/cygwin/sched.cc b/winsup/cygwin/sched.cc index 3fd058ff0..b8e0a2b5d 100644 --- a/winsup/cygwin/sched.cc +++ b/winsup/cygwin/sched.cc @@ -12,8 +12,10 @@ #include "miscfuncs.h" #include "cygerrno.h" #include "pinfo.h" +#include "hires.h" /* for getpid */ #include +#include #include "registry.h" /* Win32 priority to UNIX priority Mapping. */ @@ -199,9 +201,9 @@ sched_rr_get_interval (pid_t pid, struct timespec *interval) slindex -= 1; nsec = quantable[vfindex][slindex][qindex] / quantapertick - * clocktickinterval * 1000000; - interval->tv_sec = nsec / 1000000000; - interval->tv_nsec = nsec % 1000000000; + * clocktickinterval * (NSPERSEC / HZ); + interval->tv_sec = nsec / NSPERSEC; + interval->tv_nsec = nsec % NSPERSEC; return 0; } diff --git a/winsup/cygwin/select.cc b/winsup/cygwin/select.cc index 0cd2dc929..ca2cd5ab2 100644 --- a/winsup/cygwin/select.cc +++ b/winsup/cygwin/select.cc @@ -107,7 +107,10 @@ pselect (int maxfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, else { /* Convert to microseconds or -1 if to == NULL */ - LONGLONG us = to ? to->tv_sec * 1000000LL + (to->tv_nsec + 999) / 1000 : -1LL; + LONGLONG us = to ? to->tv_sec * USPERSEC + + (to->tv_nsec + (NSPERSEC/USPERSEC) - 1) + / (NSPERSEC/USPERSEC) + : -1LL; if (to) select_printf ("to->tv_sec %ld, to->tv_nsec %ld, us %D", to->tv_sec, to->tv_nsec, us); diff --git a/winsup/cygwin/signal.cc b/winsup/cygwin/signal.cc index f7c56c591..e581d28da 100644 --- a/winsup/cygwin/signal.cc +++ b/winsup/cygwin/signal.cc @@ -65,7 +65,7 @@ clock_nanosleep (clockid_t clk_id, int flags, const struct timespec *rqtp, sig_dispatch_pending (); pthread_testcancel (); - if (rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 || rqtp->tv_nsec > 999999999L) + if (rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 || rqtp->tv_nsec >= NSPERSEC) return EINVAL; /* Explicitly disallowed by POSIX. Needs to be checked first to avoid @@ -89,8 +89,9 @@ clock_nanosleep (clockid_t clk_id, int flags, const struct timespec *rqtp, LARGE_INTEGER timeout; - timeout.QuadPart = (LONGLONG) rqtp->tv_sec * NSPERSEC - + ((LONGLONG) rqtp->tv_nsec + 99LL) / 100LL; + timeout.QuadPart = (LONGLONG) rqtp->tv_sec * NS100PERSEC + + ((LONGLONG) rqtp->tv_nsec + (NSPERSEC/NS100PERSEC) - 1) + / (NSPERSEC/NS100PERSEC); if (abstime) { @@ -107,7 +108,8 @@ clock_nanosleep (clockid_t clk_id, int flags, const struct timespec *rqtp, else { /* other clocks need to be handled with a relative timeout */ - timeout.QuadPart -= tp.tv_sec * NSPERSEC + tp.tv_nsec / 100LL; + timeout.QuadPart -= tp.tv_sec * NS100PERSEC + + tp.tv_nsec / (NSPERSEC/NS100PERSEC); timeout.QuadPart *= -1LL; } } @@ -123,8 +125,9 @@ clock_nanosleep (clockid_t clk_id, int flags, const struct timespec *rqtp, /* according to POSIX, rmtp is used only if !abstime */ if (rmtp && !abstime) { - rmtp->tv_sec = (time_t) (timeout.QuadPart / NSPERSEC); - rmtp->tv_nsec = (long) ((timeout.QuadPart % NSPERSEC) * 100LL); + rmtp->tv_sec = (time_t) (timeout.QuadPart / NS100PERSEC); + rmtp->tv_nsec = (long) ((timeout.QuadPart % NS100PERSEC) + * (NSPERSEC/NS100PERSEC)); } syscall_printf ("%d = clock_nanosleep(%lu, %d, %ld.%09ld, %ld.%09.ld)", @@ -160,8 +163,8 @@ extern "C" unsigned int usleep (useconds_t useconds) { struct timespec req; - req.tv_sec = useconds / 1000000; - req.tv_nsec = (useconds % 1000000) * 1000; + req.tv_sec = useconds / USPERSEC; + req.tv_nsec = (useconds % USPERSEC) * (NSPERSEC/USPERSEC); int res = clock_nanosleep (CLOCK_REALTIME, 0, &req, NULL); if (res != 0) { @@ -628,14 +631,15 @@ sigtimedwait (const sigset_t *set, siginfo_t *info, const timespec *timeout) if (timeout) { if (timeout->tv_sec < 0 - || timeout->tv_nsec < 0 || timeout->tv_nsec > (NSPERSEC * 100LL)) + || timeout->tv_nsec < 0 || timeout->tv_nsec > NSPERSEC) { set_errno (EINVAL); return -1; } /* convert timespec to 100ns units */ - waittime.QuadPart = (LONGLONG) timeout->tv_sec * NSPERSEC - + ((LONGLONG) timeout->tv_nsec + 99LL) / 100LL; + waittime.QuadPart = (LONGLONG) timeout->tv_sec * NS100PERSEC + + ((LONGLONG) timeout->tv_nsec + (NSPERSEC/NS100PERSEC) - 1) + / (NSPERSEC/NS100PERSEC); } return sigwait_common (set, info, timeout ? &waittime : cw_infinite); diff --git a/winsup/cygwin/sysconf.cc b/winsup/cygwin/sysconf.cc index 9563b889a..7680cfc90 100644 --- a/winsup/cygwin/sysconf.cc +++ b/winsup/cygwin/sysconf.cc @@ -19,6 +19,7 @@ details. */ #include "ntdll.h" #include "tls_pbuf.h" #include "cpuid.h" +#include "hires.h" static long get_open_max (int in) @@ -793,7 +794,7 @@ sysinfo (struct sysinfo *info) sizeof_stodi, NULL); if (NT_SUCCESS (status)) uptime = (stodi->CurrentTime.QuadPart - stodi->BootTime.QuadPart) - / 10000000ULL; + / NS100PERSEC; else debug_printf ("NtQuerySystemInformation(SystemTimeOfDayInformation), " "status %y", status); diff --git a/winsup/cygwin/thread.cc b/winsup/cygwin/thread.cc index 913f7b655..9f2e18357 100644 --- a/winsup/cygwin/thread.cc +++ b/winsup/cygwin/thread.cc @@ -2546,7 +2546,7 @@ pthread_convert_abstime (clockid_t clock_id, const struct timespec *abstime, /* According to SUSv3, the abstime value must be checked for validity. */ if (abstime->tv_sec < 0 || abstime->tv_nsec < 0 - || abstime->tv_nsec > 999999999) + || abstime->tv_nsec >= NSPERSEC) return EINVAL; /* Check for immediate timeout before converting */ @@ -2556,8 +2556,9 @@ pthread_convert_abstime (clockid_t clock_id, const struct timespec *abstime, && tp.tv_nsec > abstime->tv_nsec)) return ETIMEDOUT; - timeout->QuadPart = abstime->tv_sec * NSPERSEC - + (abstime->tv_nsec + 99LL) / 100LL; + timeout->QuadPart = abstime->tv_sec * NS100PERSEC + + (abstime->tv_nsec + (NSPERSEC/NS100PERSEC) - 1) + / (NSPERSEC/NS100PERSEC); switch (clock_id) { case CLOCK_REALTIME: @@ -2565,7 +2566,8 @@ pthread_convert_abstime (clockid_t clock_id, const struct timespec *abstime, break; default: /* other clocks must be handled as relative timeout */ - timeout->QuadPart -= tp.tv_sec * NSPERSEC + tp.tv_nsec / 100LL; + timeout->QuadPart -= tp.tv_sec * NS100PERSEC + tp.tv_nsec + / (NSPERSEC/NS100PERSEC); timeout->QuadPart *= -1LL; break; } diff --git a/winsup/cygwin/timer.cc b/winsup/cygwin/timer.cc index 044cdda40..94679c323 100644 --- a/winsup/cygwin/timer.cc +++ b/winsup/cygwin/timer.cc @@ -14,6 +14,7 @@ details. */ #include "fhandler.h" #include "dtable.h" #include "cygheap.h" +#include #define TT_MAGIC 0x513e4a1c struct timer_tracker @@ -105,12 +106,12 @@ timer_tracker::timer_tracker (clockid_t c, const sigevent *e) } } -static long long -to_us (const timespec& ts) +static inline long long +timespec_to_us (const timespec& ts) { long long res = ts.tv_sec; - res *= 1000000; - res += ts.tv_nsec / 1000 + ((ts.tv_nsec % 1000) ? 1 : 0); + res *= USPERSEC; + res += (ts.tv_nsec + (NSPERSEC/USPERSEC) - 1) / (NSPERSEC/USPERSEC); return res; } @@ -131,7 +132,7 @@ timer_thread (VOID *x) if (sleep_us > 0) { tt->sleepto_us = sleepto_us; - sleep_ms = (sleep_us + 999) / 1000; + sleep_ms = (sleep_us + (USPERSEC/HZ) - 1) / (USPERSEC/HZ); } else { @@ -203,10 +204,10 @@ out: return 0; } -static bool -it_bad (const timespec& t) +static inline bool +timespec_bad (const timespec& t) { - if (t.tv_nsec < 0 || t.tv_nsec >= 1000000000 || t.tv_sec < 0) + if (t.tv_nsec < 0 || t.tv_nsec >= NSPERSEC || t.tv_sec < 0) { set_errno (EINVAL); return true; @@ -227,7 +228,7 @@ timer_tracker::settime (int in_flags, const itimerspec *value, itimerspec *ovalu __leave; } - if (it_bad (value->it_value) || it_bad (value->it_interval)) + if (timespec_bad (value->it_value) || timespec_bad (value->it_interval)) __leave; long long now = in_flags & TIMER_ABSTIME ? 0 : gtod.usecs (); @@ -242,8 +243,8 @@ timer_tracker::settime (int in_flags, const itimerspec *value, itimerspec *ovalu interval_us = sleepto_us = 0; else { - sleepto_us = now + to_us (value->it_value); - interval_us = to_us (value->it_interval); + sleepto_us = now + timespec_to_us (value->it_value); + interval_us = timespec_to_us (value->it_interval); it_interval = value->it_interval; if (!hcancel) hcancel = CreateEvent (&sec_none_nih, TRUE, FALSE, NULL); @@ -274,8 +275,8 @@ timer_tracker::gettime (itimerspec *ovalue) long long left_us = sleepto_us - now; if (left_us < 0) left_us = 0; - ovalue->it_value.tv_sec = left_us / 1000000; - ovalue->it_value.tv_nsec = (left_us % 1000000) * 1000; + ovalue->it_value.tv_sec = left_us / USPERSEC; + ovalue->it_value.tv_nsec = (left_us % USPERSEC) * (NSPERSEC/USPERSEC); } } @@ -481,16 +482,18 @@ ualarm (useconds_t value, useconds_t interval) Interpret negative arguments as zero */ if (value > 0) { - timer.it_value.tv_sec = value / 1000000; - timer.it_value.tv_nsec = (value % 1000000) * 1000; + timer.it_value.tv_sec = value / USPERSEC; + timer.it_value.tv_nsec = (value % USPERSEC) * (NSPERSEC/USPERSEC); } if (interval > 0) { - timer.it_interval.tv_sec = interval / 1000000; - timer.it_interval.tv_nsec = (interval % 1000000) * 1000; + timer.it_interval.tv_sec = interval / USPERSEC; + timer.it_interval.tv_nsec = (interval % USPERSEC) * (NSPERSEC/USPERSEC); } timer_settime ((timer_t) &ttstart, 0, &timer, &otimer); - useconds_t ret = otimer.it_value.tv_sec * 1000000 + (otimer.it_value.tv_nsec + 999) / 1000; + useconds_t ret = otimer.it_value.tv_sec * USPERSEC + + (otimer.it_value.tv_nsec + (NSPERSEC/USPERSEC) - 1) + / (NSPERSEC/USPERSEC); syscall_printf ("%d = ualarm(%ld , %ld)", ret, value, interval); return ret; } diff --git a/winsup/cygwin/times.cc b/winsup/cygwin/times.cc index 5da0bbc7a..86e32b8bf 100644 --- a/winsup/cygwin/times.cc +++ b/winsup/cygwin/times.cc @@ -10,6 +10,7 @@ details. */ #include "winsup.h" #include #include +#include #include #include #include @@ -45,7 +46,7 @@ __to_clock_t (PLARGE_INTEGER src, int flag) if (flag) total -= FACTOR; - total /= NSPERSEC / CLOCKS_PER_SEC; + total /= NS100PERSEC / CLOCKS_PER_SEC; return total; } @@ -72,7 +73,7 @@ times (struct tms *buf) /* uptime */ ticks.QuadPart -= stodi.BootTime.QuadPart; /* ticks is in in 100ns, convert to clock ticks. */ - tc = (clock_t) (ticks.QuadPart * CLOCKS_PER_SEC / NSPERSEC); + tc = (clock_t) (ticks.QuadPart * CLOCKS_PER_SEC / NS100PERSEC); buf->tms_stime = __to_clock_t (&kut.KernelTime, 0); buf->tms_utime = __to_clock_t (&kut.UserTime, 0); @@ -102,7 +103,7 @@ settimeofday (const struct timeval *tv, const struct timezone *tz) __try { - if (tv->tv_usec < 0 || tv->tv_usec >= 1000000) + if (tv->tv_usec < 0 || tv->tv_usec >= USPERSEC) { set_errno (EINVAL); return -1; @@ -116,7 +117,7 @@ settimeofday (const struct timeval *tv, const struct timezone *tz) st.wHour = ptm->tm_hour; st.wMinute = ptm->tm_min; st.wSecond = ptm->tm_sec; - st.wMilliseconds = tv->tv_usec / 1000; + st.wMilliseconds = tv->tv_usec / (USPERSEC/HZ); res = -!SetSystemTime (&st); gtod.reset (); @@ -158,11 +159,11 @@ totimeval (struct timeval *dst, PLARGE_INTEGER src, int sub, int flag) { int64_t x = __to_clock_t (src, flag); - x *= (int64_t) 1000000 / CLOCKS_PER_SEC; /* Turn x into usecs */ - x -= (int64_t) sub * 1000000; + x *= (int64_t) USPERSEC / CLOCKS_PER_SEC; /* Turn x into usecs */ + x -= (int64_t) sub * USPERSEC; - dst->tv_usec = x % 1000000; /* And split */ - dst->tv_sec = x / 1000000; + dst->tv_usec = x % USPERSEC; /* And split */ + dst->tv_sec = x / USPERSEC; } /* FIXME: Make thread safe */ @@ -176,8 +177,8 @@ gettimeofday (struct timeval *__restrict tv, void *__restrict tzvp) if (now == (LONGLONG) -1) return -1; - tv->tv_sec = now / 1000000; - tv->tv_usec = now % 1000000; + tv->tv_sec = now / USPERSEC; + tv->tv_usec = now % USPERSEC; if (tz != NULL) { @@ -202,16 +203,16 @@ timespec_to_filetime (const struct timespec *time_in, PLARGE_INTEGER out) if (time_in->tv_nsec == UTIME_OMIT) out->QuadPart = 0; else - out->QuadPart = time_in->tv_sec * NSPERSEC - + time_in->tv_nsec / (1000000000/NSPERSEC) + FACTOR; + out->QuadPart = time_in->tv_sec * NS100PERSEC + + time_in->tv_nsec / (NSPERSEC/NS100PERSEC) + FACTOR; } /* Cygwin internal */ void __stdcall timeval_to_filetime (const struct timeval *time_in, PLARGE_INTEGER out) { - out->QuadPart = time_in->tv_sec * NSPERSEC - + time_in->tv_usec * (NSPERSEC/1000000) + FACTOR; + out->QuadPart = time_in->tv_sec * NS100PERSEC + + time_in->tv_usec * (NS100PERSEC/USPERSEC) + FACTOR; } /* Cygwin internal */ @@ -232,18 +233,18 @@ timeval_to_timespec (const struct timeval *tvp, struct timespec *tmp) return NULL; tmp[0].tv_sec = tvp[0].tv_sec; - tmp[0].tv_nsec = tvp[0].tv_usec * 1000; + tmp[0].tv_nsec = tvp[0].tv_usec * (NSPERSEC/USPERSEC); if (tmp[0].tv_nsec < 0) tmp[0].tv_nsec = 0; - else if (tmp[0].tv_nsec > 999999999) - tmp[0].tv_nsec = 999999999; + else if (tmp[0].tv_nsec >= NSPERSEC) + tmp[0].tv_nsec = NSPERSEC - 1; tmp[1].tv_sec = tvp[1].tv_sec; - tmp[1].tv_nsec = tvp[1].tv_usec * 1000; + tmp[1].tv_nsec = tvp[1].tv_usec * (NSPERSEC/USPERSEC); if (tmp[1].tv_nsec < 0) tmp[1].tv_nsec = 0; - else if (tmp[1].tv_nsec > 999999999) - tmp[1].tv_nsec = 999999999; + else if (tmp[1].tv_nsec >= NSPERSEC) + tmp[1].tv_nsec = NSPERSEC - 1; return tmp; } @@ -264,7 +265,7 @@ to_time_t (PLARGE_INTEGER ptr) return 0; x -= FACTOR; /* number of 100ns between 1601 and 1970 */ - x /= NSPERSEC; /* number of 100ns in a second */ + x /= NS100PERSEC; /* number of 100ns in a second */ return x; } @@ -277,8 +278,6 @@ to_timestruc_t (PLARGE_INTEGER ptr, timestruc_t *out) stuffed into two long words. A timestruc_t is the number of seconds and microseconds since jan 1 1970 stuffed into a time_t and a long. */ - - int64_t rem; int64_t x = ptr->QuadPart; /* pass "no time" as epoch */ @@ -290,10 +289,8 @@ to_timestruc_t (PLARGE_INTEGER ptr, timestruc_t *out) } x -= FACTOR; /* number of 100ns between 1601 and 1970 */ - rem = x % NSPERSEC; - x /= NSPERSEC; /* number of 100ns in a second */ - out->tv_nsec = rem * 100; /* as tv_nsec is in nanoseconds */ - out->tv_sec = x; + out->tv_sec = x / NS100PERSEC; + out->tv_nsec = (x % NS100PERSEC) * (NSPERSEC/NS100PERSEC); } /* Cygwin internal */ @@ -470,7 +467,7 @@ hires_ns::prime () return; } - freq = (double) ((double) 1000000000. / (double) ifreq.QuadPart); + freq = (double) ((double) NSPERSEC / (double) ifreq.QuadPart); inited = true; SetThreadPriority (GetCurrentThread (), priority); } @@ -534,8 +531,8 @@ clock_gettime (clockid_t clk_id, struct timespec *tp) &kut, sizeof kut, NULL); x = kut.KernelTime.QuadPart + kut.UserTime.QuadPart; - tp->tv_sec = x / NSPERSEC; - tp->tv_nsec = (x % NSPERSEC) * 100LL; + tp->tv_sec = x / NS100PERSEC; + tp->tv_nsec = (x % NS100PERSEC) * (NSPERSEC/NS100PERSEC); CloseHandle (hProcess); return 0; @@ -562,8 +559,8 @@ clock_gettime (clockid_t clk_id, struct timespec *tp) &kut, sizeof kut, NULL); x = kut.KernelTime.QuadPart + kut.UserTime.QuadPart; - tp->tv_sec = x / NSPERSEC; - tp->tv_nsec = (x % NSPERSEC) * 100LL; + tp->tv_sec = x / NS100PERSEC; + tp->tv_nsec = (x % NS100PERSEC) * (NSPERSEC/NS100PERSEC); CloseHandle (hThread); return 0; @@ -576,8 +573,8 @@ clock_gettime (clockid_t clk_id, struct timespec *tp) LONGLONG now = gtod.nsecs (); if (now == (LONGLONG) -1) return -1; - tp->tv_sec = now / NSPERSEC; - tp->tv_nsec = (now % NSPERSEC) * (1000000000 / NSPERSEC); + tp->tv_sec = now / NS100PERSEC; + tp->tv_nsec = (now % NS100PERSEC) * (NSPERSEC / NS100PERSEC); break; } @@ -587,8 +584,8 @@ clock_gettime (clockid_t clk_id, struct timespec *tp) if (now == (LONGLONG) -1) return -1; - tp->tv_sec = now / 1000000000; - tp->tv_nsec = (now % 1000000000); + tp->tv_sec = now / NSPERSEC; + tp->tv_nsec = (now % NSPERSEC); break; } @@ -667,8 +664,8 @@ clock_getres (clockid_t clk_id, struct timespec *tp) ULONG coarsest, finest, actual; NtQueryTimerResolution (&coarsest, &finest, &actual); - tp->tv_sec = coarsest / NSPERSEC; - tp->tv_nsec = (coarsest % NSPERSEC) * 100; + tp->tv_sec = coarsest / NS100PERSEC; + tp->tv_nsec = (coarsest % NS100PERSEC) * (NSPERSEC/NS100PERSEC); return 0; } @@ -677,16 +674,16 @@ clock_getres (clockid_t clk_id, struct timespec *tp) case CLOCK_REALTIME: { DWORD period = gtod.resolution (); - tp->tv_sec = period / NSPERSEC; - tp->tv_nsec = (period % NSPERSEC) * 100; + tp->tv_sec = period / NS100PERSEC; + tp->tv_nsec = (period % NS100PERSEC) * (NSPERSEC/NS100PERSEC); break; } case CLOCK_MONOTONIC: { LONGLONG period = ntod.resolution (); - tp->tv_sec = period / 1000000000; - tp->tv_nsec = period % 1000000000; + tp->tv_sec = period / NSPERSEC; + tp->tv_nsec = period % NSPERSEC; break; } @@ -715,7 +712,9 @@ clock_setres (clockid_t clk_id, struct timespec *tp) is < 430 secs. Actually the coarsest timer resolution is only slightly beyond 15ms, but this might change in future OS versions, so we play nice here. */ - ULONGLONG period = (tp->tv_sec * 10000000ULL) + ((tp->tv_nsec) / 100ULL); + ULONGLONG period = tp->tv_sec * NS100PERSEC + + (tp->tv_nsec + (NSPERSEC/NS100PERSEC) - 1) + / (NSPERSEC/NS100PERSEC); /* clock_setres is non-POSIX/non-Linux. On QNX, the function always rounds the incoming value to the nearest supported value. */