Issue #22117: Add a new Python timestamp format _PyTime_t to pytime.h

vstinner · vstinner · commit cb29f0177c91 · 2015-03-27T13:31:18.000+01:00
In practice, _PyTime_t is a number of nanoseconds. Its C type is a 64-bit
signed number. It's integer value is in the range [-2^63; 2^63-1]. In seconds,
the range is around [-292 years; +292 years]. In term of Epoch timestamp
(1970-01-01), it can store a date between 1677-09-21 and 2262-04-11.

The API has a resolution of 1 nanosecond and use integer number. With a
resolution on 1 nanosecond, 64-bit IEEE 754 floating point numbers loose
precision after 194 days. It's not the case with this API. The drawback is
overflow for values outside [-2^63; 2^63-1], but these values are unlikely for
most Python modules, except of the datetime module.

New functions:

- _PyTime_GetMonotonicClock()
- _PyTime_FromObject()
- _PyTime_AsMilliseconds()
- _PyTime_AsTimeval()

This change uses these new functions in time.sleep() to avoid rounding issues.

The new API will be extended step by step, and the old API will be removed step
by step. Currently, some code is duplicated just to be able to move
incrementally, instead of pushing a large change at once.
diff --git a/Include/pytime.h b/Include/pytime.h
@@ -111,6 +111,40 @@ _PyTime_AddDouble(_PyTime_timeval *tv, double interval,
    Return 0 on success, raise an exception and return -1 on error. */
 PyAPI_FUNC(int) _PyTime_Init(void);
 
+/****************** NEW _PyTime_t API **********************/
+
+#ifdef PY_INT64_T
+typedef PY_INT64_T _PyTime_t;
+#else
+#  error "_PyTime_t need signed 64-bit integer type"
+#endif
+
+/* Convert a Python float or int to a timetamp.
+   Raise an exception and return -1 on error, return 0 on success. */
+PyAPI_FUNC(int) _PyTime_FromObject(_PyTime_t *t,
+    PyObject *obj,
+    _PyTime_round_t round);
+
+/* Convert timestamp to a number of milliseconds (10^-3 seconds). */
+PyAPI_FUNC(_PyTime_t)
+_PyTime_AsMilliseconds(_PyTime_t t,
+    _PyTime_round_t round);
+
+/* Convert a timestamp to a timeval structure. */
+PyAPI_FUNC(int) _PyTime_AsTimeval(_PyTime_t t,
+    struct timeval *tv,
+    _PyTime_round_t round);
+
+/* 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
+   results of consecutive calls is valid.
+
+   The function cannot fail. _PyTime_Init() ensures that a monotonic clock
+   is available and works. */
+PyAPI_FUNC(_PyTime_t) _PyTime_GetMonotonicClock(void);
+
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/Modules/timemodule.c b/Modules/timemodule.c
@@ -31,7 +31,7 @@
 #endif /* !__WATCOMC__ || __QNX__ */
 
 /* Forward declarations */
-static int floatsleep(double);
+static int pysleep(_PyTime_t);
 static PyObject* floattime(_Py_clock_info_t *info);
 
 static PyObject *
@@ -218,17 +218,17 @@ Return the resolution (precision) of the specified clock clk_id.");
 #endif   /* HAVE_CLOCK_GETTIME */
 
 static PyObject *
-time_sleep(PyObject *self, PyObject *args)
+time_sleep(PyObject *self, PyObject *obj)
 {
-    double secs;
-    if (!PyArg_ParseTuple(args, "d:sleep", &secs))
+    _PyTime_t secs;
+    if (_PyTime_FromObject(&secs, obj, _PyTime_ROUND_UP))
         return NULL;
     if (secs < 0) {
         PyErr_SetString(PyExc_ValueError,
                         "sleep length must be non-negative");
         return NULL;
     }
-    if (floatsleep(secs) != 0)
+    if (pysleep(secs) != 0)
         return NULL;
     Py_INCREF(Py_None);
     return Py_None;
@@ -1258,7 +1258,7 @@ static PyMethodDef time_methods[] = {
     {"clock_settime",   time_clock_settime, METH_VARARGS, clock_settime_doc},
     {"clock_getres",    time_clock_getres, METH_VARARGS, clock_getres_doc},
 #endif
-    {"sleep",           time_sleep, METH_VARARGS, sleep_doc},
+    {"sleep",           time_sleep, METH_O, sleep_doc},
     {"gmtime",          time_gmtime, METH_VARARGS, gmtime_doc},
     {"localtime",       time_localtime, METH_VARARGS, localtime_doc},
     {"asctime",         time_asctime, METH_VARARGS, asctime_doc},
@@ -1379,34 +1379,30 @@ floattime(_Py_clock_info_t *info)
 }
 
 
-/* Implement floatsleep() for various platforms.
+/* Implement pysleep() for various platforms.
    When interrupted (or when another error occurs), return -1 and
    set an exception; else return 0. */
 
 static int
-floatsleep(double secs)
+pysleep(_PyTime_t secs)
 {
-    _PyTime_timeval deadline, monotonic;
+    _PyTime_t deadline, monotonic;
 #ifndef MS_WINDOWS
     struct timeval timeout;
-    double frac;
     int err = 0;
 #else
-    double millisecs;
+    _PyTime_t millisecs;
     unsigned long ul_millis;
     DWORD rc;
     HANDLE hInterruptEvent;
 #endif
 
-    _PyTime_monotonic(&deadline);
-    _PyTime_AddDouble(&deadline, secs, _PyTime_ROUND_UP);
+    deadline = _PyTime_GetMonotonicClock() + secs;
 
     do {
 #ifndef MS_WINDOWS
-        frac = fmod(secs, 1.0);
-        secs = floor(secs);
-        timeout.tv_sec = (long)secs;
-        timeout.tv_usec = (long)(frac*1e6);
+        if (_PyTime_AsTimeval(secs, &timeout, _PyTime_ROUND_UP) < 0)
+            return -1;
 
         Py_BEGIN_ALLOW_THREADS
         err = select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &timeout);
@@ -1420,7 +1416,7 @@ floatsleep(double secs)
             return -1;
         }
 #else
-        millisecs = secs * 1000.0;
+        millisecs = _PyTime_AsMilliseconds(secs, _PyTime_ROUND_UP);
         if (millisecs > (double)ULONG_MAX) {
             PyErr_SetString(PyExc_OverflowError,
                             "sleep length is too large");
@@ -1453,9 +1449,9 @@ floatsleep(double secs)
         if (PyErr_CheckSignals())
             return -1;
 
-        _PyTime_monotonic(&monotonic);
-        secs = _PyTime_INTERVAL(monotonic, deadline);
-        if (secs <= 0.0)
+        monotonic = _PyTime_GetMonotonicClock();
+        secs = deadline - monotonic;
+        if (secs <= 00)
             break;
         /* retry with the recomputed delay */
     } while (1);
diff --git a/Python/pytime.c b/Python/pytime.c
