Alexander Belopolsky | 6fc4ade | 2010-08-05 17:34:27 +0000 | [diff] [blame] | 1 | #include "Python.h" |
Victor Stinner | 09225b7 | 2012-02-07 23:41:01 +0100 | [diff] [blame] | 2 | #ifdef MS_WINDOWS |
| 3 | #include <windows.h> |
| 4 | #endif |
Alexander Belopolsky | 6fc4ade | 2010-08-05 17:34:27 +0000 | [diff] [blame] | 5 | |
Victor Stinner | ae58649 | 2014-09-02 23:18:25 +0200 | [diff] [blame] | 6 | #if defined(__APPLE__) |
| 7 | #include <mach/mach_time.h> /* mach_absolute_time(), mach_timebase_info() */ |
| 8 | #endif |
| 9 | |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 10 | /* To millisecond (10^-3) */ |
Victor Stinner | 580ef13 | 2015-03-20 01:55:04 +0100 | [diff] [blame] | 11 | #define SEC_TO_MS 1000 |
Victor Stinner | 580ef13 | 2015-03-20 01:55:04 +0100 | [diff] [blame] | 12 | |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 13 | /* To microseconds (10^-6) */ |
| 14 | #define MS_TO_US 1000 |
Victor Stinner | 580ef13 | 2015-03-20 01:55:04 +0100 | [diff] [blame] | 15 | #define SEC_TO_US (SEC_TO_MS * MS_TO_US) |
| 16 | |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 17 | /* To nanoseconds (10^-9) */ |
| 18 | #define US_TO_NS 1000 |
| 19 | #define MS_TO_NS (MS_TO_US * US_TO_NS) |
| 20 | #define SEC_TO_NS (SEC_TO_MS * MS_TO_NS) |
| 21 | |
Victor Stinner | 62d1c70 | 2015-04-01 17:47:07 +0200 | [diff] [blame] | 22 | /* Conversion from nanoseconds */ |
| 23 | #define NS_TO_MS (1000 * 1000) |
| 24 | #define NS_TO_US (1000) |
| 25 | |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 26 | static void |
| 27 | error_time_t_overflow(void) |
Victor Stinner | 643cd68 | 2012-03-02 22:54:03 +0100 | [diff] [blame] | 28 | { |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 29 | PyErr_SetString(PyExc_OverflowError, |
| 30 | "timestamp out of range for platform time_t"); |
| 31 | } |
| 32 | |
Larry Hastings | 76ad59b | 2012-05-03 00:30:07 -0700 | [diff] [blame] | 33 | time_t |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 34 | _PyLong_AsTime_t(PyObject *obj) |
| 35 | { |
| 36 | #if defined(HAVE_LONG_LONG) && SIZEOF_TIME_T == SIZEOF_LONG_LONG |
| 37 | PY_LONG_LONG val; |
| 38 | val = PyLong_AsLongLong(obj); |
| 39 | #else |
| 40 | long val; |
| 41 | assert(sizeof(time_t) <= sizeof(long)); |
| 42 | val = PyLong_AsLong(obj); |
| 43 | #endif |
| 44 | if (val == -1 && PyErr_Occurred()) { |
| 45 | if (PyErr_ExceptionMatches(PyExc_OverflowError)) |
| 46 | error_time_t_overflow(); |
| 47 | return -1; |
| 48 | } |
| 49 | return (time_t)val; |
| 50 | } |
| 51 | |
Larry Hastings | 6fe20b3 | 2012-04-19 15:07:49 -0700 | [diff] [blame] | 52 | PyObject * |
| 53 | _PyLong_FromTime_t(time_t t) |
| 54 | { |
| 55 | #if defined(HAVE_LONG_LONG) && SIZEOF_TIME_T == SIZEOF_LONG_LONG |
| 56 | return PyLong_FromLongLong((PY_LONG_LONG)t); |
| 57 | #else |
| 58 | assert(sizeof(time_t) <= sizeof(long)); |
| 59 | return PyLong_FromLong((long)t); |
| 60 | #endif |
| 61 | } |
| 62 | |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 63 | static int |
| 64 | _PyTime_ObjectToDenominator(PyObject *obj, time_t *sec, long *numerator, |
Victor Stinner | 3c1b379 | 2014-02-17 00:02:43 +0100 | [diff] [blame] | 65 | double denominator, _PyTime_round_t round) |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 66 | { |
| 67 | assert(denominator <= LONG_MAX); |
Victor Stinner | 643cd68 | 2012-03-02 22:54:03 +0100 | [diff] [blame] | 68 | if (PyFloat_Check(obj)) { |
Victor Stinner | bd273c1 | 2012-03-13 19:12:23 +0100 | [diff] [blame] | 69 | double d, intpart, err; |
| 70 | /* volatile avoids unsafe optimization on float enabled by gcc -O3 */ |
| 71 | volatile double floatpart; |
Victor Stinner | 643cd68 | 2012-03-02 22:54:03 +0100 | [diff] [blame] | 72 | |
| 73 | d = PyFloat_AsDouble(obj); |
| 74 | floatpart = modf(d, &intpart); |
| 75 | if (floatpart < 0) { |
| 76 | floatpart = 1.0 + floatpart; |
| 77 | intpart -= 1.0; |
| 78 | } |
| 79 | |
Victor Stinner | 3c1b379 | 2014-02-17 00:02:43 +0100 | [diff] [blame] | 80 | floatpart *= denominator; |
Victor Stinner | a695f83 | 2015-03-30 03:57:14 +0200 | [diff] [blame] | 81 | if (round == _PyTime_ROUND_CEILING) { |
Victor Stinner | f81f0f9 | 2015-03-30 00:44:06 +0200 | [diff] [blame] | 82 | floatpart = ceil(floatpart); |
| 83 | if (floatpart >= denominator) { |
| 84 | floatpart = 0.0; |
| 85 | intpart += 1.0; |
Victor Stinner | 3c1b379 | 2014-02-17 00:02:43 +0100 | [diff] [blame] | 86 | } |
Victor Stinner | f81f0f9 | 2015-03-30 00:44:06 +0200 | [diff] [blame] | 87 | } |
| 88 | else { |
| 89 | floatpart = floor(floatpart); |
Victor Stinner | 3c1b379 | 2014-02-17 00:02:43 +0100 | [diff] [blame] | 90 | } |
| 91 | |
Victor Stinner | 643cd68 | 2012-03-02 22:54:03 +0100 | [diff] [blame] | 92 | *sec = (time_t)intpart; |
| 93 | err = intpart - (double)*sec; |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 94 | if (err <= -1.0 || err >= 1.0) { |
| 95 | error_time_t_overflow(); |
| 96 | return -1; |
| 97 | } |
Victor Stinner | 643cd68 | 2012-03-02 22:54:03 +0100 | [diff] [blame] | 98 | |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 99 | *numerator = (long)floatpart; |
Victor Stinner | 643cd68 | 2012-03-02 22:54:03 +0100 | [diff] [blame] | 100 | return 0; |
| 101 | } |
| 102 | else { |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 103 | *sec = _PyLong_AsTime_t(obj); |
| 104 | if (*sec == (time_t)-1 && PyErr_Occurred()) |
| 105 | return -1; |
| 106 | *numerator = 0; |
Victor Stinner | 643cd68 | 2012-03-02 22:54:03 +0100 | [diff] [blame] | 107 | return 0; |
| 108 | } |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 109 | } |
Victor Stinner | 643cd68 | 2012-03-02 22:54:03 +0100 | [diff] [blame] | 110 | |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 111 | int |
Victor Stinner | 3c1b379 | 2014-02-17 00:02:43 +0100 | [diff] [blame] | 112 | _PyTime_ObjectToTime_t(PyObject *obj, time_t *sec, _PyTime_round_t round) |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 113 | { |
| 114 | if (PyFloat_Check(obj)) { |
| 115 | double d, intpart, err; |
| 116 | |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 117 | d = PyFloat_AsDouble(obj); |
Victor Stinner | a695f83 | 2015-03-30 03:57:14 +0200 | [diff] [blame] | 118 | if (round == _PyTime_ROUND_CEILING) |
Victor Stinner | f81f0f9 | 2015-03-30 00:44:06 +0200 | [diff] [blame] | 119 | d = ceil(d); |
| 120 | else |
| 121 | d = floor(d); |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 122 | (void)modf(d, &intpart); |
| 123 | |
| 124 | *sec = (time_t)intpart; |
| 125 | err = intpart - (double)*sec; |
| 126 | if (err <= -1.0 || err >= 1.0) { |
| 127 | error_time_t_overflow(); |
| 128 | return -1; |
| 129 | } |
| 130 | return 0; |
| 131 | } |
| 132 | else { |
| 133 | *sec = _PyLong_AsTime_t(obj); |
| 134 | if (*sec == (time_t)-1 && PyErr_Occurred()) |
| 135 | return -1; |
| 136 | return 0; |
| 137 | } |
| 138 | } |
| 139 | |
| 140 | int |
Victor Stinner | 3c1b379 | 2014-02-17 00:02:43 +0100 | [diff] [blame] | 141 | _PyTime_ObjectToTimespec(PyObject *obj, time_t *sec, long *nsec, |
| 142 | _PyTime_round_t round) |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 143 | { |
Victor Stinner | 3c1b379 | 2014-02-17 00:02:43 +0100 | [diff] [blame] | 144 | return _PyTime_ObjectToDenominator(obj, sec, nsec, 1e9, round); |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 145 | } |
| 146 | |
| 147 | int |
Victor Stinner | 3c1b379 | 2014-02-17 00:02:43 +0100 | [diff] [blame] | 148 | _PyTime_ObjectToTimeval(PyObject *obj, time_t *sec, long *usec, |
| 149 | _PyTime_round_t round) |
Victor Stinner | 5d272cc | 2012-03-13 13:35:55 +0100 | [diff] [blame] | 150 | { |
Victor Stinner | 3c1b379 | 2014-02-17 00:02:43 +0100 | [diff] [blame] | 151 | return _PyTime_ObjectToDenominator(obj, sec, usec, 1e6, round); |
Victor Stinner | 643cd68 | 2012-03-02 22:54:03 +0100 | [diff] [blame] | 152 | } |
| 153 | |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 154 | static void |
| 155 | _PyTime_overflow(void) |
| 156 | { |
| 157 | PyErr_SetString(PyExc_OverflowError, |
| 158 | "timestamp too large to convert to C _PyTime_t"); |
| 159 | } |
| 160 | |
Victor Stinner | 4bfb460 | 2015-03-27 22:27:24 +0100 | [diff] [blame] | 161 | _PyTime_t |
Victor Stinner | 13019fd | 2015-04-03 13:10:54 +0200 | [diff] [blame] | 162 | _PyTime_FromSeconds(int seconds) |
| 163 | { |
| 164 | _PyTime_t t; |
| 165 | /* ensure that integer overflow cannot happen, int type should have 32 |
| 166 | bits, whereas _PyTime_t type has at least 64 bits (SEC_TO_MS takes 30 |
| 167 | bits). */ |
| 168 | assert((seconds >= 0 && seconds <= _PyTime_MAX / SEC_TO_NS) |
| 169 | || (seconds < 0 && seconds >= _PyTime_MIN / SEC_TO_NS)); |
| 170 | t = (_PyTime_t)seconds * SEC_TO_NS; |
| 171 | return t; |
| 172 | } |
| 173 | |
| 174 | _PyTime_t |
Victor Stinner | 4bfb460 | 2015-03-27 22:27:24 +0100 | [diff] [blame] | 175 | _PyTime_FromNanoseconds(PY_LONG_LONG ns) |
| 176 | { |
| 177 | _PyTime_t t; |
| 178 | assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t)); |
| 179 | t = Py_SAFE_DOWNCAST(ns, PY_LONG_LONG, _PyTime_t); |
| 180 | return t; |
| 181 | } |
| 182 | |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 183 | #ifdef HAVE_CLOCK_GETTIME |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 184 | static int |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 185 | _PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts, int raise) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 186 | { |
| 187 | _PyTime_t t; |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 188 | int res = 0; |
| 189 | |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 190 | t = (_PyTime_t)ts->tv_sec * SEC_TO_NS; |
| 191 | if (t / SEC_TO_NS != ts->tv_sec) { |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 192 | if (raise) |
| 193 | _PyTime_overflow(); |
| 194 | res = -1; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 195 | } |
| 196 | |
| 197 | t += ts->tv_nsec; |
| 198 | |
| 199 | *tp = t; |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 200 | return res; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 201 | } |
Victor Stinner | 1bd18ba | 2015-03-30 00:25:38 +0200 | [diff] [blame] | 202 | #elif !defined(MS_WINDOWS) |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 203 | static int |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 204 | _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv, int raise) |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 205 | { |
| 206 | _PyTime_t t; |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 207 | int res = 0; |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 208 | |
| 209 | t = (_PyTime_t)tv->tv_sec * SEC_TO_NS; |
| 210 | if (t / SEC_TO_NS != tv->tv_sec) { |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 211 | if (raise) |
| 212 | _PyTime_overflow(); |
| 213 | res = -1; |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 214 | } |
| 215 | |
| 216 | t += (_PyTime_t)tv->tv_usec * US_TO_NS; |
| 217 | |
| 218 | *tp = t; |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 219 | return res; |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 220 | } |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 221 | #endif |
| 222 | |
Victor Stinner | fa09beb | 2015-03-30 21:36:10 +0200 | [diff] [blame] | 223 | static int |
| 224 | _PyTime_FromObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round, |
| 225 | long to_nanoseconds) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 226 | { |
| 227 | if (PyFloat_Check(obj)) { |
Victor Stinner | 45cff0c | 2015-03-30 10:22:16 +0200 | [diff] [blame] | 228 | /* volatile avoids unsafe optimization on float enabled by gcc -O3 */ |
| 229 | volatile double d, err; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 230 | |
| 231 | /* convert to a number of nanoseconds */ |
| 232 | d = PyFloat_AsDouble(obj); |
Victor Stinner | fa09beb | 2015-03-30 21:36:10 +0200 | [diff] [blame] | 233 | d *= to_nanoseconds; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 234 | |
Victor Stinner | a695f83 | 2015-03-30 03:57:14 +0200 | [diff] [blame] | 235 | if (round == _PyTime_ROUND_CEILING) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 236 | d = ceil(d); |
| 237 | else |
| 238 | d = floor(d); |
| 239 | |
| 240 | *t = (_PyTime_t)d; |
| 241 | err = d - (double)*t; |
| 242 | if (fabs(err) >= 1.0) { |
| 243 | _PyTime_overflow(); |
| 244 | return -1; |
| 245 | } |
| 246 | return 0; |
| 247 | } |
| 248 | else { |
| 249 | #ifdef HAVE_LONG_LONG |
| 250 | PY_LONG_LONG sec; |
| 251 | sec = PyLong_AsLongLong(obj); |
| 252 | assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t)); |
| 253 | #else |
| 254 | long sec; |
| 255 | sec = PyLong_AsLong(obj); |
| 256 | assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t)); |
| 257 | #endif |
| 258 | if (sec == -1 && PyErr_Occurred()) { |
| 259 | if (PyErr_ExceptionMatches(PyExc_OverflowError)) |
| 260 | _PyTime_overflow(); |
| 261 | return -1; |
| 262 | } |
Victor Stinner | fa09beb | 2015-03-30 21:36:10 +0200 | [diff] [blame] | 263 | *t = sec * to_nanoseconds; |
| 264 | if (*t / to_nanoseconds != sec) { |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 265 | _PyTime_overflow(); |
| 266 | return -1; |
| 267 | } |
| 268 | return 0; |
| 269 | } |
| 270 | } |
| 271 | |
Victor Stinner | fa09beb | 2015-03-30 21:36:10 +0200 | [diff] [blame] | 272 | int |
| 273 | _PyTime_FromSecondsObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round) |
| 274 | { |
| 275 | return _PyTime_FromObject(t, obj, round, SEC_TO_NS); |
| 276 | } |
| 277 | |
| 278 | int |
| 279 | _PyTime_FromMillisecondsObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round) |
| 280 | { |
| 281 | return _PyTime_FromObject(t, obj, round, MS_TO_NS); |
| 282 | } |
| 283 | |
Victor Stinner | 4bfb460 | 2015-03-27 22:27:24 +0100 | [diff] [blame] | 284 | double |
| 285 | _PyTime_AsSecondsDouble(_PyTime_t t) |
| 286 | { |
| 287 | _PyTime_t sec, ns; |
| 288 | /* Divide using integers to avoid rounding issues on the integer part. |
| 289 | 1e-9 cannot be stored exactly in IEEE 64-bit. */ |
| 290 | sec = t / SEC_TO_NS; |
| 291 | ns = t % SEC_TO_NS; |
| 292 | return (double)sec + (double)ns * 1e-9; |
| 293 | } |
| 294 | |
Victor Stinner | 992c43f | 2015-03-27 17:12:45 +0100 | [diff] [blame] | 295 | PyObject * |
| 296 | _PyTime_AsNanosecondsObject(_PyTime_t t) |
| 297 | { |
| 298 | #ifdef HAVE_LONG_LONG |
| 299 | assert(sizeof(PY_LONG_LONG) >= sizeof(_PyTime_t)); |
| 300 | return PyLong_FromLongLong((PY_LONG_LONG)t); |
| 301 | #else |
| 302 | assert(sizeof(long) >= sizeof(_PyTime_t)); |
| 303 | return PyLong_FromLong((long)t); |
| 304 | #endif |
| 305 | } |
| 306 | |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 307 | static _PyTime_t |
Victor Stinner | ec26f83 | 2015-09-18 14:21:14 +0200 | [diff] [blame] | 308 | _PyTime_Divide(const _PyTime_t t, const _PyTime_t k, |
| 309 | const _PyTime_round_t round) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 310 | { |
Victor Stinner | 62d1c70 | 2015-04-01 17:47:07 +0200 | [diff] [blame] | 311 | assert(k > 1); |
| 312 | if (round == _PyTime_ROUND_CEILING) { |
| 313 | if (t >= 0) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 314 | return (t + k - 1) / k; |
| 315 | else |
Victor Stinner | ec26f83 | 2015-09-18 14:21:14 +0200 | [diff] [blame] | 316 | return t / k; |
| 317 | } |
| 318 | else { |
| 319 | if (t >= 0) |
| 320 | return t / k; |
| 321 | else |
Victor Stinner | 62d1c70 | 2015-04-01 17:47:07 +0200 | [diff] [blame] | 322 | return (t - (k - 1)) / k; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 323 | } |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 324 | } |
| 325 | |
| 326 | _PyTime_t |
| 327 | _PyTime_AsMilliseconds(_PyTime_t t, _PyTime_round_t round) |
| 328 | { |
Victor Stinner | 62d1c70 | 2015-04-01 17:47:07 +0200 | [diff] [blame] | 329 | return _PyTime_Divide(t, NS_TO_MS, round); |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 330 | } |
| 331 | |
Victor Stinner | f5faad2 | 2015-03-28 03:52:05 +0100 | [diff] [blame] | 332 | _PyTime_t |
| 333 | _PyTime_AsMicroseconds(_PyTime_t t, _PyTime_round_t round) |
| 334 | { |
Victor Stinner | 62d1c70 | 2015-04-01 17:47:07 +0200 | [diff] [blame] | 335 | return _PyTime_Divide(t, NS_TO_US, round); |
Victor Stinner | f5faad2 | 2015-03-28 03:52:05 +0100 | [diff] [blame] | 336 | } |
| 337 | |
Victor Stinner | ea9c0dd | 2015-03-30 02:51:13 +0200 | [diff] [blame] | 338 | static int |
Victor Stinner | 9a8b177 | 2015-09-18 13:36:17 +0200 | [diff] [blame] | 339 | _PyTime_AsTimeval_impl(_PyTime_t t, _PyTime_t *p_secs, int *p_us, |
| 340 | _PyTime_round_t round) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 341 | { |
| 342 | _PyTime_t secs, ns; |
Victor Stinner | 9a8b177 | 2015-09-18 13:36:17 +0200 | [diff] [blame] | 343 | int usec; |
Victor Stinner | 95e9cef | 2015-03-28 01:26:47 +0100 | [diff] [blame] | 344 | int res = 0; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 345 | |
| 346 | secs = t / SEC_TO_NS; |
| 347 | ns = t % SEC_TO_NS; |
Victor Stinner | 9a8b177 | 2015-09-18 13:36:17 +0200 | [diff] [blame] | 348 | |
| 349 | usec = (int)_PyTime_Divide(ns, US_TO_NS, round); |
| 350 | if (usec < 0) { |
| 351 | usec += SEC_TO_US; |
| 352 | if (secs != _PyTime_MIN) |
| 353 | secs -= 1; |
| 354 | else |
| 355 | res = -1; |
Victor Stinner | 95e9cef | 2015-03-28 01:26:47 +0100 | [diff] [blame] | 356 | } |
Victor Stinner | 9a8b177 | 2015-09-18 13:36:17 +0200 | [diff] [blame] | 357 | else if (usec >= SEC_TO_US) { |
| 358 | usec -= SEC_TO_US; |
| 359 | if (secs != _PyTime_MAX) |
| 360 | secs += 1; |
| 361 | else |
| 362 | res = -1; |
| 363 | } |
| 364 | assert(0 <= usec && usec < SEC_TO_US); |
| 365 | |
| 366 | *p_secs = secs; |
| 367 | *p_us = usec; |
| 368 | |
| 369 | return res; |
| 370 | } |
| 371 | |
| 372 | static int |
| 373 | _PyTime_AsTimevalStruct_impl(_PyTime_t t, struct timeval *tv, |
| 374 | _PyTime_round_t round, int raise) |
| 375 | { |
| 376 | _PyTime_t secs; |
| 377 | int us; |
| 378 | int res; |
| 379 | |
| 380 | res = _PyTime_AsTimeval_impl(t, &secs, &us, round); |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 381 | |
| 382 | #ifdef MS_WINDOWS |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 383 | tv->tv_sec = (long)secs; |
| 384 | #else |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 385 | tv->tv_sec = secs; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 386 | #endif |
Victor Stinner | 9a8b177 | 2015-09-18 13:36:17 +0200 | [diff] [blame] | 387 | tv->tv_usec = us; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 388 | |
Victor Stinner | 9a8b177 | 2015-09-18 13:36:17 +0200 | [diff] [blame] | 389 | if (res < 0 || (_PyTime_t)tv->tv_sec != secs) { |
| 390 | if (raise) |
| 391 | error_time_t_overflow(); |
| 392 | return -1; |
Victor Stinner | 95e9cef | 2015-03-28 01:26:47 +0100 | [diff] [blame] | 393 | } |
Victor Stinner | 9a8b177 | 2015-09-18 13:36:17 +0200 | [diff] [blame] | 394 | return 0; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 395 | } |
| 396 | |
Victor Stinner | ea9c0dd | 2015-03-30 02:51:13 +0200 | [diff] [blame] | 397 | int |
| 398 | _PyTime_AsTimeval(_PyTime_t t, struct timeval *tv, _PyTime_round_t round) |
| 399 | { |
Victor Stinner | 9a8b177 | 2015-09-18 13:36:17 +0200 | [diff] [blame] | 400 | return _PyTime_AsTimevalStruct_impl(t, tv, round, 1); |
Victor Stinner | ea9c0dd | 2015-03-30 02:51:13 +0200 | [diff] [blame] | 401 | } |
| 402 | |
| 403 | int |
| 404 | _PyTime_AsTimeval_noraise(_PyTime_t t, struct timeval *tv, _PyTime_round_t round) |
| 405 | { |
Victor Stinner | 9a8b177 | 2015-09-18 13:36:17 +0200 | [diff] [blame] | 406 | return _PyTime_AsTimevalStruct_impl(t, tv, round, 0); |
| 407 | } |
| 408 | |
| 409 | int |
| 410 | _PyTime_AsTimevalTime_t(_PyTime_t t, time_t *p_secs, int *us, |
| 411 | _PyTime_round_t round) |
| 412 | { |
| 413 | _PyTime_t secs; |
| 414 | int res; |
| 415 | |
| 416 | res = _PyTime_AsTimeval_impl(t, &secs, us, round); |
| 417 | |
| 418 | *p_secs = secs; |
| 419 | |
| 420 | if (res < 0 || (_PyTime_t)*p_secs != secs) { |
| 421 | error_time_t_overflow(); |
| 422 | return -1; |
| 423 | } |
| 424 | return 0; |
Victor Stinner | ea9c0dd | 2015-03-30 02:51:13 +0200 | [diff] [blame] | 425 | } |
| 426 | |
Victor Stinner | c337838 | 2015-03-28 05:07:51 +0100 | [diff] [blame] | 427 | #if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE) |
Victor Stinner | 34dc0f4 | 2015-03-27 18:19:03 +0100 | [diff] [blame] | 428 | int |
| 429 | _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts) |
| 430 | { |
Victor Stinner | 95e9cef | 2015-03-28 01:26:47 +0100 | [diff] [blame] | 431 | _PyTime_t secs, nsec; |
| 432 | |
| 433 | secs = t / SEC_TO_NS; |
Victor Stinner | 34dc0f4 | 2015-03-27 18:19:03 +0100 | [diff] [blame] | 434 | nsec = t % SEC_TO_NS; |
| 435 | if (nsec < 0) { |
| 436 | nsec += SEC_TO_NS; |
Victor Stinner | 95e9cef | 2015-03-28 01:26:47 +0100 | [diff] [blame] | 437 | secs -= 1; |
Victor Stinner | 34dc0f4 | 2015-03-27 18:19:03 +0100 | [diff] [blame] | 438 | } |
Victor Stinner | 95e9cef | 2015-03-28 01:26:47 +0100 | [diff] [blame] | 439 | ts->tv_sec = (time_t)secs; |
| 440 | if ((_PyTime_t)ts->tv_sec != secs) { |
Victor Stinner | 34dc0f4 | 2015-03-27 18:19:03 +0100 | [diff] [blame] | 441 | _PyTime_overflow(); |
| 442 | return -1; |
| 443 | } |
| 444 | ts->tv_nsec = nsec; |
Victor Stinner | edddf99 | 2015-03-30 02:54:57 +0200 | [diff] [blame] | 445 | |
| 446 | assert(0 <= ts->tv_nsec && ts->tv_nsec <= 999999999); |
Victor Stinner | 34dc0f4 | 2015-03-27 18:19:03 +0100 | [diff] [blame] | 447 | return 0; |
| 448 | } |
| 449 | #endif |
| 450 | |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 451 | static int |
Victor Stinner | c379ade | 2015-11-10 12:11:39 +0100 | [diff] [blame] | 452 | pygettimeofday(_PyTime_t *tp, _Py_clock_info_t *info, int raise) |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 453 | { |
| 454 | #ifdef MS_WINDOWS |
| 455 | FILETIME system_time; |
| 456 | ULARGE_INTEGER large; |
| 457 | |
| 458 | assert(info == NULL || raise); |
| 459 | |
| 460 | GetSystemTimeAsFileTime(&system_time); |
| 461 | large.u.LowPart = system_time.dwLowDateTime; |
| 462 | large.u.HighPart = system_time.dwHighDateTime; |
| 463 | /* 11,644,473,600,000,000,000: number of nanoseconds between |
| 464 | the 1st january 1601 and the 1st january 1970 (369 years + 89 leap |
| 465 | days). */ |
| 466 | *tp = large.QuadPart * 100 - 11644473600000000000; |
| 467 | if (info) { |
| 468 | DWORD timeAdjustment, timeIncrement; |
| 469 | BOOL isTimeAdjustmentDisabled, ok; |
| 470 | |
| 471 | info->implementation = "GetSystemTimeAsFileTime()"; |
| 472 | info->monotonic = 0; |
| 473 | ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement, |
| 474 | &isTimeAdjustmentDisabled); |
| 475 | if (!ok) { |
| 476 | PyErr_SetFromWindowsErr(0); |
| 477 | return -1; |
| 478 | } |
| 479 | info->resolution = timeIncrement * 1e-7; |
| 480 | info->adjustable = 1; |
| 481 | } |
| 482 | |
| 483 | #else /* MS_WINDOWS */ |
| 484 | int err; |
| 485 | #ifdef HAVE_CLOCK_GETTIME |
| 486 | struct timespec ts; |
| 487 | #else |
| 488 | struct timeval tv; |
| 489 | #endif |
| 490 | |
| 491 | assert(info == NULL || raise); |
| 492 | |
| 493 | #ifdef HAVE_CLOCK_GETTIME |
| 494 | err = clock_gettime(CLOCK_REALTIME, &ts); |
| 495 | if (err) { |
| 496 | if (raise) |
| 497 | PyErr_SetFromErrno(PyExc_OSError); |
| 498 | return -1; |
| 499 | } |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 500 | if (_PyTime_FromTimespec(tp, &ts, raise) < 0) |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 501 | return -1; |
| 502 | |
| 503 | if (info) { |
| 504 | struct timespec res; |
| 505 | info->implementation = "clock_gettime(CLOCK_REALTIME)"; |
| 506 | info->monotonic = 0; |
| 507 | info->adjustable = 1; |
| 508 | if (clock_getres(CLOCK_REALTIME, &res) == 0) |
| 509 | info->resolution = res.tv_sec + res.tv_nsec * 1e-9; |
| 510 | else |
| 511 | info->resolution = 1e-9; |
| 512 | } |
| 513 | #else /* HAVE_CLOCK_GETTIME */ |
| 514 | |
| 515 | /* test gettimeofday() */ |
| 516 | #ifdef GETTIMEOFDAY_NO_TZ |
| 517 | err = gettimeofday(&tv); |
| 518 | #else |
| 519 | err = gettimeofday(&tv, (struct timezone *)NULL); |
| 520 | #endif |
| 521 | if (err) { |
| 522 | if (raise) |
| 523 | PyErr_SetFromErrno(PyExc_OSError); |
| 524 | return -1; |
| 525 | } |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 526 | if (_PyTime_FromTimeval(tp, &tv, raise) < 0) |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 527 | return -1; |
| 528 | |
| 529 | if (info) { |
| 530 | info->implementation = "gettimeofday()"; |
| 531 | info->resolution = 1e-6; |
| 532 | info->monotonic = 0; |
| 533 | info->adjustable = 1; |
| 534 | } |
| 535 | #endif /* !HAVE_CLOCK_GETTIME */ |
| 536 | #endif /* !MS_WINDOWS */ |
| 537 | return 0; |
| 538 | } |
| 539 | |
Victor Stinner | 09e5cf2 | 2015-03-30 00:09:18 +0200 | [diff] [blame] | 540 | _PyTime_t |
| 541 | _PyTime_GetSystemClock(void) |
| 542 | { |
| 543 | _PyTime_t t; |
Victor Stinner | c379ade | 2015-11-10 12:11:39 +0100 | [diff] [blame] | 544 | if (pygettimeofday(&t, NULL, 0) < 0) { |
Victor Stinner | 09e5cf2 | 2015-03-30 00:09:18 +0200 | [diff] [blame] | 545 | /* should not happen, _PyTime_Init() checked the clock at startup */ |
| 546 | assert(0); |
| 547 | |
| 548 | /* use a fixed value instead of a random value from the stack */ |
| 549 | t = 0; |
| 550 | } |
| 551 | return t; |
| 552 | } |
| 553 | |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 554 | int |
| 555 | _PyTime_GetSystemClockWithInfo(_PyTime_t *t, _Py_clock_info_t *info) |
| 556 | { |
Victor Stinner | c379ade | 2015-11-10 12:11:39 +0100 | [diff] [blame] | 557 | return pygettimeofday(t, info, 1); |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 558 | } |
| 559 | |
| 560 | |
| 561 | static int |
Victor Stinner | 5ad5821 | 2015-09-03 00:14:58 +0200 | [diff] [blame] | 562 | pymonotonic(_PyTime_t *tp, _Py_clock_info_t *info, int raise) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 563 | { |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 564 | #if defined(MS_WINDOWS) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 565 | ULONGLONG result; |
| 566 | |
| 567 | assert(info == NULL || raise); |
| 568 | |
Victor Stinner | eb35229 | 2015-03-27 14:12:08 +0100 | [diff] [blame] | 569 | result = GetTickCount64(); |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 570 | |
| 571 | *tp = result * MS_TO_NS; |
| 572 | if (*tp / MS_TO_NS != result) { |
| 573 | if (raise) { |
| 574 | _PyTime_overflow(); |
| 575 | return -1; |
| 576 | } |
| 577 | /* Hello, time traveler! */ |
| 578 | assert(0); |
| 579 | } |
| 580 | |
| 581 | if (info) { |
| 582 | DWORD timeAdjustment, timeIncrement; |
| 583 | BOOL isTimeAdjustmentDisabled, ok; |
Victor Stinner | eb35229 | 2015-03-27 14:12:08 +0100 | [diff] [blame] | 584 | info->implementation = "GetTickCount64()"; |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 585 | info->monotonic = 1; |
| 586 | ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement, |
| 587 | &isTimeAdjustmentDisabled); |
| 588 | if (!ok) { |
| 589 | PyErr_SetFromWindowsErr(0); |
| 590 | return -1; |
| 591 | } |
| 592 | info->resolution = timeIncrement * 1e-7; |
| 593 | info->adjustable = 0; |
| 594 | } |
| 595 | |
| 596 | #elif defined(__APPLE__) |
| 597 | static mach_timebase_info_data_t timebase; |
| 598 | uint64_t time; |
| 599 | |
| 600 | if (timebase.denom == 0) { |
| 601 | /* According to the Technical Q&A QA1398, mach_timebase_info() cannot |
| 602 | fail: https://developer.apple.com/library/mac/#qa/qa1398/ */ |
| 603 | (void)mach_timebase_info(&timebase); |
| 604 | } |
| 605 | |
| 606 | time = mach_absolute_time(); |
| 607 | |
| 608 | /* apply timebase factor */ |
| 609 | time *= timebase.numer; |
| 610 | time /= timebase.denom; |
| 611 | |
| 612 | *tp = time; |
| 613 | |
| 614 | if (info) { |
| 615 | info->implementation = "mach_absolute_time()"; |
| 616 | info->resolution = (double)timebase.numer / timebase.denom * 1e-9; |
| 617 | info->monotonic = 1; |
| 618 | info->adjustable = 0; |
| 619 | } |
| 620 | |
| 621 | #else |
| 622 | struct timespec ts; |
| 623 | #ifdef CLOCK_HIGHRES |
| 624 | const clockid_t clk_id = CLOCK_HIGHRES; |
| 625 | const char *implementation = "clock_gettime(CLOCK_HIGHRES)"; |
| 626 | #else |
| 627 | const clockid_t clk_id = CLOCK_MONOTONIC; |
| 628 | const char *implementation = "clock_gettime(CLOCK_MONOTONIC)"; |
| 629 | #endif |
| 630 | |
| 631 | assert(info == NULL || raise); |
| 632 | |
| 633 | if (clock_gettime(clk_id, &ts) != 0) { |
| 634 | if (raise) { |
| 635 | PyErr_SetFromErrno(PyExc_OSError); |
| 636 | return -1; |
| 637 | } |
| 638 | return -1; |
| 639 | } |
| 640 | |
| 641 | if (info) { |
| 642 | struct timespec res; |
| 643 | info->monotonic = 1; |
| 644 | info->implementation = implementation; |
| 645 | info->adjustable = 0; |
| 646 | if (clock_getres(clk_id, &res) != 0) { |
| 647 | PyErr_SetFromErrno(PyExc_OSError); |
| 648 | return -1; |
| 649 | } |
| 650 | info->resolution = res.tv_sec + res.tv_nsec * 1e-9; |
| 651 | } |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 652 | if (_PyTime_FromTimespec(tp, &ts, raise) < 0) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 653 | return -1; |
| 654 | #endif |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 655 | return 0; |
| 656 | } |
| 657 | |
| 658 | _PyTime_t |
| 659 | _PyTime_GetMonotonicClock(void) |
| 660 | { |
| 661 | _PyTime_t t; |
Victor Stinner | 5ad5821 | 2015-09-03 00:14:58 +0200 | [diff] [blame] | 662 | if (pymonotonic(&t, NULL, 0) < 0) { |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 663 | /* should not happen, _PyTime_Init() checked that monotonic clock at |
| 664 | startup */ |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 665 | assert(0); |
Victor Stinner | cb0c602 | 2015-03-28 05:24:19 +0100 | [diff] [blame] | 666 | |
| 667 | /* use a fixed value instead of a random value from the stack */ |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 668 | t = 0; |
| 669 | } |
| 670 | return t; |
| 671 | } |
| 672 | |
Victor Stinner | 0011124 | 2014-08-29 16:31:59 +0200 | [diff] [blame] | 673 | int |
Victor Stinner | 4bfb460 | 2015-03-27 22:27:24 +0100 | [diff] [blame] | 674 | _PyTime_GetMonotonicClockWithInfo(_PyTime_t *tp, _Py_clock_info_t *info) |
| 675 | { |
Victor Stinner | 5ad5821 | 2015-09-03 00:14:58 +0200 | [diff] [blame] | 676 | return pymonotonic(tp, info, 1); |
Victor Stinner | 4bfb460 | 2015-03-27 22:27:24 +0100 | [diff] [blame] | 677 | } |
| 678 | |
| 679 | int |
Victor Stinner | 0011124 | 2014-08-29 16:31:59 +0200 | [diff] [blame] | 680 | _PyTime_Init(void) |
Alexander Belopolsky | 6fc4ade | 2010-08-05 17:34:27 +0000 | [diff] [blame] | 681 | { |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 682 | _PyTime_t t; |
| 683 | |
Victor Stinner | 0011124 | 2014-08-29 16:31:59 +0200 | [diff] [blame] | 684 | /* ensure that the system clock works */ |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 685 | if (_PyTime_GetSystemClockWithInfo(&t, NULL) < 0) |
Victor Stinner | 0011124 | 2014-08-29 16:31:59 +0200 | [diff] [blame] | 686 | return -1; |
Victor Stinner | ae58649 | 2014-09-02 23:18:25 +0200 | [diff] [blame] | 687 | |
| 688 | /* ensure that the operating system provides a monotonic clock */ |
Victor Stinner | a47b881 | 2015-03-27 18:16:17 +0100 | [diff] [blame] | 689 | if (_PyTime_GetMonotonicClockWithInfo(&t, NULL) < 0) |
Victor Stinner | cb29f01 | 2015-03-27 13:31:18 +0100 | [diff] [blame] | 690 | return -1; |
Victor Stinner | 13019fd | 2015-04-03 13:10:54 +0200 | [diff] [blame] | 691 | |
| 692 | /* check that _PyTime_FromSeconds() cannot overflow */ |
| 693 | assert(INT_MAX <= _PyTime_MAX / SEC_TO_NS); |
| 694 | assert(INT_MIN >= _PyTime_MIN / SEC_TO_NS); |
Victor Stinner | 0011124 | 2014-08-29 16:31:59 +0200 | [diff] [blame] | 695 | return 0; |
Alexander Belopolsky | 6fc4ade | 2010-08-05 17:34:27 +0000 | [diff] [blame] | 696 | } |