Issue #22117: time.time() now uses the new _PyTime_t API

* Add _PyTime_GetSystemClockWithInfo()

3 files changed, 133 insertions, 12 deletions

diff --git a/Include/pytime.h b/Include/pytime.h
index 9446b33..1648d03 100644
--- a/Include/pytime.h
+++ b/Include/pytime.h
@@ -145,6 +145,14 @@ PyAPI_FUNC(int) _PyTime_AsTimeval(_PyTime_t t,
     struct timeval *tv,
     _PyTime_round_t round);
 
+/* Get the current time from the system clock.
+ * Fill clock information if info is not NULL.
+ * Raise an exception and return -1 on error, return 0 on success.
+ */
+PyAPI_FUNC(int) _PyTime_GetSystemClockWithInfo(
+    _PyTime_t *t,
+    _Py_clock_info_t *info);
+
 /* Get the time of a monotonic clock, i.e. a clock that cannot go backwards.
    The clock is not affected by system clock updates. The reference point of
    the returned value is undefined, so that only the difference between the
diff --git a/Modules/timemodule.c b/Modules/timemodule.c
index 6563d83..880f3d2 100644
--- a/Modules/timemodule.c
+++ b/Modules/timemodule.c
@@ -1372,12 +1372,14 @@ PyInit_time(void)
 static PyObject*
 floattime(_Py_clock_info_t *info)
 {
-    _PyTime_timeval t;
-    if (_PyTime_gettimeofday_info(&t, info) < 0) {
+    _PyTime_t t;
+    double d;
+    if (_PyTime_GetSystemClockWithInfo(&t, info) < 0) {
         assert(info != NULL);
         return NULL;
     }
-    return PyFloat_FromDouble((double)t.tv_sec + t.tv_usec * 1e-6);
+    d = _PyTime_AsSecondsDouble(t);
+    return PyFloat_FromDouble(d);
 }
 
 
diff --git a/Python/pytime.c b/Python/pytime.c
index a496335..0f30f42 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -119,12 +119,6 @@ _PyTime_gettimeofday(_PyTime_timeval *tp)
     }
 }
 
-int
-_PyTime_gettimeofday_info(_PyTime_timeval *tp, _Py_clock_info_t *info)
-{
-    return pygettimeofday(tp, info, 1);
-}
-
 static int
 pymonotonic(_PyTime_timeval *tp, _Py_clock_info_t *info, int raise)
 {
@@ -414,7 +408,7 @@ _PyTime_FromNanoseconds(PY_LONG_LONG ns)
     return t;
 }
 
-#if !defined(MS_WINDOWS) && !defined(__APPLE__)
+#ifdef HAVE_CLOCK_GETTIME
 static int
 _PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts)
 {
@@ -430,6 +424,23 @@ _PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts)
     *tp = t;
     return 0;
 }
+#else
+static int
+_PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv)
+{
+    _PyTime_t t;
+
+    t = (_PyTime_t)tv->tv_sec * SEC_TO_NS;
+    if (t / SEC_TO_NS != tv->tv_sec) {
+        _PyTime_overflow();
+        return -1;
+    }
+
+    t += (_PyTime_t)tv->tv_usec * US_TO_NS;
+
+    *tp = t;
+    return 0;
+}
 #endif
 
 int
@@ -562,6 +573,102 @@ _PyTime_AsTimeval(_PyTime_t t, struct timeval *tv, _PyTime_round_t round)
 }
 
 static int
+pygettimeofday_new(_PyTime_t *tp, _Py_clock_info_t *info, int raise)
+{
+#ifdef MS_WINDOWS
+    FILETIME system_time;
+    ULARGE_INTEGER large;
+
+    assert(info == NULL || raise);
+
+    GetSystemTimeAsFileTime(&system_time);
+    large.u.LowPart = system_time.dwLowDateTime;
+    large.u.HighPart = system_time.dwHighDateTime;
+    /* 11,644,473,600,000,000,000: number of nanoseconds between
+       the 1st january 1601 and the 1st january 1970 (369 years + 89 leap
+       days). */
+    *tp = large.QuadPart * 100 - 11644473600000000000;
+    if (info) {
+        DWORD timeAdjustment, timeIncrement;
+        BOOL isTimeAdjustmentDisabled, ok;
+
+        info->implementation = "GetSystemTimeAsFileTime()";
+        info->monotonic = 0;
+        ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement,
+                                     &isTimeAdjustmentDisabled);
+        if (!ok) {
+            PyErr_SetFromWindowsErr(0);
+            return -1;
+        }
+        info->resolution = timeIncrement * 1e-7;
+        info->adjustable = 1;
+    }
+
+#else   /* MS_WINDOWS */
+    int err;
+#ifdef HAVE_CLOCK_GETTIME
+    struct timespec ts;
+#else
+    struct timeval tv;
+#endif
+
+    assert(info == NULL || raise);
+
+#ifdef HAVE_CLOCK_GETTIME
+    err = clock_gettime(CLOCK_REALTIME, &ts);
+    if (err) {
+        if (raise)
+            PyErr_SetFromErrno(PyExc_OSError);
+        return -1;
+    }
+    if (_PyTime_FromTimespec(tp, &ts) < 0)
+        return -1;
+
+    if (info) {
+        struct timespec res;
+        info->implementation = "clock_gettime(CLOCK_REALTIME)";
+        info->monotonic = 0;
+        info->adjustable = 1;
+        if (clock_getres(CLOCK_REALTIME, &res) == 0)
+            info->resolution = res.tv_sec + res.tv_nsec * 1e-9;
+        else
+            info->resolution = 1e-9;
+    }
+#else   /* HAVE_CLOCK_GETTIME */
+
+     /* test gettimeofday() */
+#ifdef GETTIMEOFDAY_NO_TZ
+    err = gettimeofday(&tv);
+#else
+    err = gettimeofday(&tv, (struct timezone *)NULL);
+#endif
+    if (err) {
+        if (raise)
+            PyErr_SetFromErrno(PyExc_OSError);
+        return -1;
+    }
+    if (_PyTime_FromTimeval(tp, &tv) < 0)
+        return -1;
+
+    if (info) {
+        info->implementation = "gettimeofday()";
+        info->resolution = 1e-6;
+        info->monotonic = 0;
+        info->adjustable = 1;
+    }
+#endif   /* !HAVE_CLOCK_GETTIME */
+#endif   /* !MS_WINDOWS */
+    return 0;
+}
+
+int
+_PyTime_GetSystemClockWithInfo(_PyTime_t *t, _Py_clock_info_t *info)
+{
+    return pygettimeofday_new(t, info, 1);
+}
+
+
+static int
 pymonotonic_new(_PyTime_t *tp, _Py_clock_info_t *info, int raise)
 {
 #ifdef Py_DEBUG
@@ -693,7 +800,11 @@ _PyTime_Init(void)
     _PyTime_t t;
 
     /* ensure that the system clock works */
-    if (_PyTime_gettimeofday_info(&tv, NULL) < 0)
+    if (pygettimeofday(&tv, NULL, 1) < 0)
+        return -1;
+
+    /* ensure that the system clock works */
+    if (_PyTime_GetSystemClockWithInfo(&t, NULL) < 0)
         return -1;
 
     /* ensure that the operating system provides a monotonic clock */
@@ -701,7 +812,7 @@ _PyTime_Init(void)
         return -1;
 
     /* ensure that the operating system provides a monotonic clock */
-    if (pymonotonic_new(&t, NULL, 1) < 0)
+    if (_PyTime_GetMonotonicClockWithInfo(&t, NULL) < 0)
         return -1;
     return 0;
 }