mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-22 17:55:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 15

gh-110850: Cleanup PyTime API: PyTime_t are nanoseconds (#115753)

Browse source 
PyTime_t no longer uses an arbitrary unit, it's always a number of
nanoseconds (64-bit signed integer).

* Rename _PyTime_FromNanosecondsObject() to _PyTime_FromLong().
* Rename _PyTime_AsNanosecondsObject() to _PyTime_AsLong().
* Remove pytime_from_nanoseconds().
* Remove pytime_as_nanoseconds().
* Remove _PyTime_FromNanoseconds().
This commit is contained in:
Victor Stinner 2024-02-21 11:46:00 +01:00 • committed by GitHub
parent 69ab93082d
commit e4c34f04a1
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
8 changed files with 57 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

13
Include/internal/pycore_time.h
View file

@ -140,17 +140,13 @@ PyAPI_FUNC(PyTime_t) _PyTime_FromSecondsDouble(double seconds, _PyTime_round_t r
#define _PYTIME_FROMSECONDS(seconds) \ #define _PYTIME_FROMSECONDS(seconds) \
((PyTime_t)(seconds) * (1000 * 1000 * 1000)) ((PyTime_t)(seconds) * (1000 * 1000 * 1000))
// Create a timestamp from a number of nanoseconds.
// Export for '_testinternalcapi' shared extension.
PyAPI_FUNC(PyTime_t) _PyTime_FromNanoseconds(PyTime_t ns);
// Create a timestamp from a number of microseconds. // Create a timestamp from a number of microseconds.
// Clamp to [PyTime_MIN; PyTime_MAX] on overflow. // Clamp to [PyTime_MIN; PyTime_MAX] on overflow.
extern PyTime_t _PyTime_FromMicrosecondsClamp(PyTime_t us); extern PyTime_t _PyTime_FromMicrosecondsClamp(PyTime_t us);
// Create a timestamp from nanoseconds (Python int). // Create a timestamp from a Python int object (number of nanoseconds).
// Export for '_lsprof' shared extension. // Export for '_lsprof' shared extension.
PyAPI_FUNC(int) _PyTime_FromNanosecondsObject(PyTime_t *t, PyAPI_FUNC(int) _PyTime_FromLong(PyTime_t *t,
PyObject *obj); PyObject *obj);
// Convert a number of seconds (Python float or int) to a timestamp. // Convert a number of seconds (Python float or int) to a timestamp.
@ -183,10 +179,9 @@ extern PyTime_t _PyTime_As100Nanoseconds(PyTime_t t,
_PyTime_round_t round); _PyTime_round_t round);
#endif #endif
// Convert timestamp to a number of nanoseconds (10^-9 seconds) as a Python int // Convert a timestamp (number of nanoseconds) as a Python int object.
// object.
// Export for '_testinternalcapi' shared extension. // Export for '_testinternalcapi' shared extension.
PyAPI_FUNC(PyObject*) _PyTime_AsNanosecondsObject(PyTime_t t); PyAPI_FUNC(PyObject*) _PyTime_AsLong(PyTime_t t);
#ifndef MS_WINDOWS #ifndef MS_WINDOWS
// Create a timestamp from a timeval structure. // Create a timestamp from a timeval structure.

4
Modules/_lsprof.c
View file

@ -6,7 +6,7 @@
#include "pycore_call.h" // _PyObject_CallNoArgs() #include "pycore_call.h" // _PyObject_CallNoArgs()
#include "pycore_ceval.h" // _PyEval_SetProfile() #include "pycore_ceval.h" // _PyEval_SetProfile()
#include "pycore_pystate.h" // _PyThreadState_GET() #include "pycore_pystate.h" // _PyThreadState_GET()
#include "pycore_time.h" // _PyTime_FromNanosecondsObject() #include "pycore_time.h" // _PyTime_FromLong()
#include "rotatingtree.h" #include "rotatingtree.h"
@ -98,7 +98,7 @@ static PyTime_t CallExternalTimer(ProfilerObject *pObj)
if (pObj->externalTimerUnit > 0.0) { if (pObj->externalTimerUnit > 0.0) {
/* interpret the result as an integer that will be scaled /* interpret the result as an integer that will be scaled
in profiler_getstats() */ in profiler_getstats() */
err = _PyTime_FromNanosecondsObject(&result, o); err = _PyTime_FromLong(&result, o);
} }
else { else {
/* interpret the result as a double measured in seconds. /* interpret the result as a double measured in seconds.

22
Modules/_testinternalcapi/pytime.c
View file

@ -17,7 +17,7 @@ test_pytime_fromseconds(PyObject *self, PyObject *args)
return NULL; return NULL;
} }
PyTime_t ts = _PyTime_FromSeconds(seconds); PyTime_t ts = _PyTime_FromSeconds(seconds);
return _PyTime_AsNanosecondsObject(ts); return _PyTime_AsLong(ts);
} }
static int static int
@ -49,7 +49,7 @@ test_pytime_fromsecondsobject(PyObject *self, PyObject *args)
if (_PyTime_FromSecondsObject(&ts, obj, round) == -1) { if (_PyTime_FromSecondsObject(&ts, obj, round) == -1) {
return NULL; return NULL;
} }
return _PyTime_AsNanosecondsObject(ts); return _PyTime_AsLong(ts);
} }
static PyObject * static PyObject *
@ -64,7 +64,7 @@ test_PyTime_AsTimeval(PyObject *self, PyObject *args)
return NULL; return NULL;
} }
PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromLong(&t, obj) < 0) {
return NULL; return NULL;
} }
struct timeval tv; struct timeval tv;
@ -91,7 +91,7 @@ test_PyTime_AsTimeval_clamp(PyObject *self, PyObject *args)
return NULL; return NULL;
} }
PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromLong(&t, obj) < 0) {
return NULL; return NULL;
} }
struct timeval tv; struct timeval tv;
@ -113,7 +113,7 @@ test_PyTime_AsTimespec(PyObject *self, PyObject *args)
return NULL; return NULL;
} }
PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromLong(&t, obj) < 0) {
return NULL; return NULL;
} }
struct timespec ts; struct timespec ts;
@ -131,7 +131,7 @@ test_PyTime_AsTimespec_clamp(PyObject *self, PyObject *args)
return NULL; return NULL;
} }
PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromLong(&t, obj) < 0) {
return NULL; return NULL;
} }
struct timespec ts; struct timespec ts;
@ -149,15 +149,14 @@ test_PyTime_AsMilliseconds(PyObject *self, PyObject *args)
return NULL; return NULL;
} }
PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromLong(&t, obj) < 0) {
return NULL; return NULL;
} }
if (check_time_rounding(round) < 0) { if (check_time_rounding(round) < 0) {
return NULL; return NULL;
} }
PyTime_t ms = _PyTime_AsMilliseconds(t, round); PyTime_t ms = _PyTime_AsMilliseconds(t, round);
PyTime_t ns = _PyTime_FromNanoseconds(ms); return _PyTime_AsLong(ms);
return _PyTime_AsNanosecondsObject(ns);
} }
static PyObject * static PyObject *
@ -169,15 +168,14 @@ test_PyTime_AsMicroseconds(PyObject *self, PyObject *args)
return NULL; return NULL;
} }
PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromLong(&t, obj) < 0) {
return NULL; return NULL;
} }
if (check_time_rounding(round) < 0) { if (check_time_rounding(round) < 0) {
return NULL; return NULL;
} }
PyTime_t us = _PyTime_AsMicroseconds(t, round); PyTime_t us = _PyTime_AsMicroseconds(t, round);
PyTime_t ns = _PyTime_FromNanoseconds(us); return _PyTime_AsLong(us);
return _PyTime_AsNanosecondsObject(ns);
} }
static PyObject * static PyObject *

33
Modules/timemodule.c
View file

@ -127,7 +127,7 @@ time_time_ns(PyObject *self, PyObject *unused)
if (PyTime_Time(&t) < 0) { if (PyTime_Time(&t) < 0) {
return NULL; return NULL;
} }
return _PyTime_AsNanosecondsObject(t); return _PyTime_AsLong(t);
} }
PyDoc_STRVAR(time_ns_doc, PyDoc_STRVAR(time_ns_doc,
@ -164,8 +164,7 @@ py_clock(time_module_state *state, PyTime_t *tp, _Py_clock_info_t *info)
"or its value cannot be represented"); "or its value cannot be represented");
return -1; return -1;
} }
PyTime_t ns = _PyTimeFraction_Mul(ticks, base); *tp = _PyTimeFraction_Mul(ticks, base);
*tp = _PyTime_FromNanoseconds(ns);
return 0; return 0;
} }
#endif /* HAVE_CLOCK */ #endif /* HAVE_CLOCK */
@ -259,7 +258,7 @@ time_clock_gettime_ns_impl(PyObject *module, clockid_t clk_id)
if (_PyTime_FromTimespec(&t, &ts) < 0) { if (_PyTime_FromTimespec(&t, &ts) < 0) {
return NULL; return NULL;
} }
return _PyTime_AsNanosecondsObject(t); return _PyTime_AsLong(t);
} }
#endif /* HAVE_CLOCK_GETTIME */ #endif /* HAVE_CLOCK_GETTIME */
@ -308,7 +307,7 @@ time_clock_settime_ns(PyObject *self, PyObject *args)
return NULL; return NULL;
} }
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromLong(&t, obj) < 0) {
return NULL; return NULL;
} }
if (_PyTime_AsTimespec(t, &ts) == -1) { if (_PyTime_AsTimespec(t, &ts) == -1) {
@ -1170,7 +1169,7 @@ time_monotonic_ns(PyObject *self, PyObject *unused)
if (PyTime_Monotonic(&t) < 0) { if (PyTime_Monotonic(&t) < 0) {
return NULL; return NULL;
} }
return _PyTime_AsNanosecondsObject(t); return _PyTime_AsLong(t);
} }
PyDoc_STRVAR(monotonic_ns_doc, PyDoc_STRVAR(monotonic_ns_doc,
@ -1202,7 +1201,7 @@ time_perf_counter_ns(PyObject *self, PyObject *unused)
if (PyTime_PerfCounter(&t) < 0) { if (PyTime_PerfCounter(&t) < 0) {
return NULL; return NULL;
} }
return _PyTime_AsNanosecondsObject(t); return _PyTime_AsLong(t);
} }
PyDoc_STRVAR(perf_counter_ns_doc, PyDoc_STRVAR(perf_counter_ns_doc,
@ -1233,7 +1232,7 @@ process_time_times(time_module_state *state, PyTime_t *tp,
PyTime_t ns; PyTime_t ns;
ns = _PyTimeFraction_Mul(process.tms_utime, base); ns = _PyTimeFraction_Mul(process.tms_utime, base);
ns += _PyTimeFraction_Mul(process.tms_stime, base); ns += _PyTimeFraction_Mul(process.tms_stime, base);
*tp = _PyTime_FromNanoseconds(ns); *tp = ns;
return 1; return 1;
} }
#endif #endif
@ -1247,7 +1246,7 @@ py_process_time(time_module_state *state, PyTime_t *tp,
HANDLE process; HANDLE process;
FILETIME creation_time, exit_time, kernel_time, user_time; FILETIME creation_time, exit_time, kernel_time, user_time;
ULARGE_INTEGER large; ULARGE_INTEGER large;
PyTime_t ktime, utime, t; PyTime_t ktime, utime;
BOOL ok; BOOL ok;
process = GetCurrentProcess(); process = GetCurrentProcess();
@ -1274,8 +1273,7 @@ py_process_time(time_module_state *state, PyTime_t *tp,
utime = large.QuadPart; utime = large.QuadPart;
/* ktime and utime have a resolution of 100 nanoseconds */ /* ktime and utime have a resolution of 100 nanoseconds */
t = _PyTime_FromNanoseconds((ktime + utime) * 100); *tp = (ktime + utime) * 100;
*tp = t;
return 0; return 0;
#else #else
@ -1383,7 +1381,7 @@ time_process_time_ns(PyObject *module, PyObject *unused)
if (py_process_time(state, &t, NULL) < 0) { if (py_process_time(state, &t, NULL) < 0) {
return NULL; return NULL;
} }
return _PyTime_AsNanosecondsObject(t); return _PyTime_AsLong(t);
} }
PyDoc_STRVAR(process_time_ns_doc, PyDoc_STRVAR(process_time_ns_doc,
@ -1401,7 +1399,7 @@ _PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info)
HANDLE thread; HANDLE thread;
FILETIME creation_time, exit_time, kernel_time, user_time; FILETIME creation_time, exit_time, kernel_time, user_time;
ULARGE_INTEGER large; ULARGE_INTEGER large;
PyTime_t ktime, utime, t; PyTime_t ktime, utime;
BOOL ok; BOOL ok;
thread = GetCurrentThread(); thread = GetCurrentThread();
@ -1428,8 +1426,7 @@ _PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info)
utime = large.QuadPart; utime = large.QuadPart;
/* ktime and utime have a resolution of 100 nanoseconds */ /* ktime and utime have a resolution of 100 nanoseconds */
t = _PyTime_FromNanoseconds((ktime + utime) * 100); *tp = (ktime + utime) * 100;
*tp = t;
return 0; return 0;
} }
@ -1453,7 +1450,7 @@ _PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info)
info->adjustable = 0; info->adjustable = 0;
info->resolution = 1e-9; info->resolution = 1e-9;
} }
*tp = _PyTime_FromNanoseconds(tc.stime + tc.utime); *tp = (tc.stime + tc.utime);
return 0; return 0;
} }
@ -1470,7 +1467,7 @@ _PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info)
info->monotonic = 1; info->monotonic = 1;
info->adjustable = 0; info->adjustable = 0;
} }
*tp = _PyTime_FromNanoseconds(gethrvtime()); *tp = gethrvtime();
return 0; return 0;
} }
@ -1550,7 +1547,7 @@ time_thread_time_ns(PyObject *self, PyObject *unused)
if (_PyTime_GetThreadTimeWithInfo(&t, NULL) < 0) { if (_PyTime_GetThreadTimeWithInfo(&t, NULL) < 0) {
return NULL; return NULL;
} }
return _PyTime_AsNanosecondsObject(t); return _PyTime_AsLong(t);
} }
PyDoc_STRVAR(thread_time_ns_doc, PyDoc_STRVAR(thread_time_ns_doc,

77
Python/pytime.c
View file

@ -108,22 +108,6 @@ pytime_overflow(void)
} }
static inline PyTime_t
pytime_from_nanoseconds(PyTime_t t)
{
// PyTime_t is a number of nanoseconds
return t;
}
static inline PyTime_t
pytime_as_nanoseconds(PyTime_t t)
{
// PyTime_t is a number of nanoseconds: see pytime_from_nanoseconds()
return t;
}
// Compute t1 + t2. Clamp to [PyTime_MIN; PyTime_MAX] on overflow. // Compute t1 + t2. Clamp to [PyTime_MIN; PyTime_MAX] on overflow.
static inline int static inline int
pytime_add(PyTime_t *t1, PyTime_t t2) pytime_add(PyTime_t *t1, PyTime_t t2)
@ -271,7 +255,7 @@ _PyTime_AsTime_t(PyTime_t t, time_t *t2)
// Convert PyTime_t to long. // Convert PyTime_t to long.
// Return 0 on success. Return -1 and clamp the value on overflow. // Return 0 on success. Return -1 and clamp the value on overflow.
static int static int
_PyTime_AsLong(PyTime_t t, long *t2) _PyTime_AsCLong(PyTime_t t, long *t2)
{ {
#if SIZEOF_LONG < _SIZEOF_PYTIME_T #if SIZEOF_LONG < _SIZEOF_PYTIME_T
if ((PyTime_t)LONG_MAX < t) { if ((PyTime_t)LONG_MAX < t) {
@ -466,14 +450,7 @@ _PyTime_FromSeconds(int seconds)
assert((t >= 0 && t <= PyTime_MAX / SEC_TO_NS) assert((t >= 0 && t <= PyTime_MAX / SEC_TO_NS)
|| (t < 0 && t >= PyTime_MIN / SEC_TO_NS)); || (t < 0 && t >= PyTime_MIN / SEC_TO_NS));
t *= SEC_TO_NS; t *= SEC_TO_NS;
return pytime_from_nanoseconds(t); return t;
}
PyTime_t
_PyTime_FromNanoseconds(PyTime_t ns)
{
return pytime_from_nanoseconds(ns);
} }
@ -481,14 +458,13 @@ PyTime_t
_PyTime_FromMicrosecondsClamp(PyTime_t us) _PyTime_FromMicrosecondsClamp(PyTime_t us)
{ {
PyTime_t ns = _PyTime_Mul(us, US_TO_NS); PyTime_t ns = _PyTime_Mul(us, US_TO_NS);
return pytime_from_nanoseconds(ns); return ns;
} }
int int
_PyTime_FromNanosecondsObject(PyTime_t *tp, PyObject *obj) _PyTime_FromLong(PyTime_t *tp, PyObject *obj)
{ {
if (!PyLong_Check(obj)) { if (!PyLong_Check(obj)) {
PyErr_Format(PyExc_TypeError, "expect int, got %s", PyErr_Format(PyExc_TypeError, "expect int, got %s",
Py_TYPE(obj)->tp_name); Py_TYPE(obj)->tp_name);
@ -506,7 +482,7 @@ _PyTime_FromNanosecondsObject(PyTime_t *tp, PyObject *obj)
} }
PyTime_t t = (PyTime_t)nsec; PyTime_t t = (PyTime_t)nsec;
*tp = pytime_from_nanoseconds(t); *tp = t;
return 0; return 0;
} }
@ -526,7 +502,7 @@ pytime_fromtimespec(PyTime_t *tp, const struct timespec *ts, int raise_exc)
tv_nsec = ts->tv_nsec; tv_nsec = ts->tv_nsec;
int res2 = pytime_add(&t, tv_nsec); int res2 = pytime_add(&t, tv_nsec);
*tp = pytime_from_nanoseconds(t); *tp = t;
if (raise_exc && (res1 < 0 || res2 < 0)) { if (raise_exc && (res1 < 0 || res2 < 0)) {
pytime_overflow(); pytime_overflow();
@ -556,7 +532,7 @@ pytime_fromtimeval(PyTime_t *tp, struct timeval *tv, int raise_exc)
PyTime_t usec = (PyTime_t)tv->tv_usec * US_TO_NS; PyTime_t usec = (PyTime_t)tv->tv_usec * US_TO_NS;
int res2 = pytime_add(&t, usec); int res2 = pytime_add(&t, usec);
*tp = pytime_from_nanoseconds(t); *tp = t;
if (raise_exc && (res1 < 0 || res2 < 0)) { if (raise_exc && (res1 < 0 || res2 < 0)) {
pytime_overflow(); pytime_overflow();
@ -593,7 +569,7 @@ pytime_from_double(PyTime_t *tp, double value, _PyTime_round_t round,
} }
PyTime_t ns = (PyTime_t)d; PyTime_t ns = (PyTime_t)d;
*tp = pytime_from_nanoseconds(ns); *tp = ns;
return 0; return 0;
} }
@ -628,7 +604,7 @@ pytime_from_object(PyTime_t *tp, PyObject *obj, _PyTime_round_t round,
return -1; return -1;
} }
*tp = pytime_from_nanoseconds(ns); *tp = ns;
return 0; return 0;
} }
} }
@ -649,12 +625,11 @@ _PyTime_FromMillisecondsObject(PyTime_t *tp, PyObject *obj, _PyTime_round_t roun
double double
PyTime_AsSecondsDouble(PyTime_t t) PyTime_AsSecondsDouble(PyTime_t ns)
{ {
/* volatile avoids optimization changing how numbers are rounded */ /* volatile avoids optimization changing how numbers are rounded */
volatile double d; volatile double d;
PyTime_t ns = pytime_as_nanoseconds(t);
if (ns % SEC_TO_NS == 0) { if (ns % SEC_TO_NS == 0) {
/* Divide using integers to avoid rounding issues on the integer part. /* Divide using integers to avoid rounding issues on the integer part.
1e-9 cannot be stored exactly in IEEE 64-bit. */ 1e-9 cannot be stored exactly in IEEE 64-bit. */
@ -670,9 +645,8 @@ PyTime_AsSecondsDouble(PyTime_t t)
PyObject * PyObject *
_PyTime_AsNanosecondsObject(PyTime_t t) _PyTime_AsLong(PyTime_t ns)
{ {
PyTime_t ns = pytime_as_nanoseconds(t);
static_assert(sizeof(long long) >= sizeof(PyTime_t), static_assert(sizeof(long long) >= sizeof(PyTime_t),
"PyTime_t is larger than long long"); "PyTime_t is larger than long long");
return PyLong_FromLongLong((long long)ns); return PyLong_FromLongLong((long long)ns);
@ -786,35 +760,31 @@ pytime_divmod(const PyTime_t t, const PyTime_t k,
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
PyTime_t PyTime_t
_PyTime_As100Nanoseconds(PyTime_t t, _PyTime_round_t round) _PyTime_As100Nanoseconds(PyTime_t ns, _PyTime_round_t round)
{ {
PyTime_t ns = pytime_as_nanoseconds(t);
return pytime_divide(ns, NS_TO_100NS, round); return pytime_divide(ns, NS_TO_100NS, round);
} }
#endif #endif
PyTime_t PyTime_t
_PyTime_AsMicroseconds(PyTime_t t, _PyTime_round_t round) _PyTime_AsMicroseconds(PyTime_t ns, _PyTime_round_t round)
{ {
PyTime_t ns = pytime_as_nanoseconds(t);
return pytime_divide(ns, NS_TO_US, round); return pytime_divide(ns, NS_TO_US, round);
} }
PyTime_t PyTime_t
_PyTime_AsMilliseconds(PyTime_t t, _PyTime_round_t round) _PyTime_AsMilliseconds(PyTime_t ns, _PyTime_round_t round)
{ {
PyTime_t ns = pytime_as_nanoseconds(t);
return pytime_divide(ns, NS_TO_MS, round); return pytime_divide(ns, NS_TO_MS, round);
} }
static int static int
pytime_as_timeval(PyTime_t t, PyTime_t *ptv_sec, int *ptv_usec, pytime_as_timeval(PyTime_t ns, PyTime_t *ptv_sec, int *ptv_usec,
_PyTime_round_t round) _PyTime_round_t round)
{ {
PyTime_t ns = pytime_as_nanoseconds(t);
PyTime_t us = pytime_divide(ns, US_TO_NS, round); PyTime_t us = pytime_divide(ns, US_TO_NS, round);
PyTime_t tv_sec, tv_usec; PyTime_t tv_sec, tv_usec;
@ -835,7 +805,7 @@ pytime_as_timeval_struct(PyTime_t t, struct timeval *tv,
int res2; int res2;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
// On Windows, timeval.tv_sec type is long // On Windows, timeval.tv_sec type is long
res2 = _PyTime_AsLong(tv_sec, &tv->tv_sec); res2 = _PyTime_AsCLong(tv_sec, &tv->tv_sec);
#else #else
res2 = _PyTime_AsTime_t(tv_sec, &tv->tv_sec); res2 = _PyTime_AsTime_t(tv_sec, &tv->tv_sec);
#endif #endif
@ -886,9 +856,8 @@ _PyTime_AsTimevalTime_t(PyTime_t t, time_t *p_secs, int *us,
#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE) #if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE)
static int static int
pytime_as_timespec(PyTime_t t, struct timespec *ts, int raise_exc) pytime_as_timespec(PyTime_t ns, struct timespec *ts, int raise_exc)
{ {
PyTime_t ns = pytime_as_nanoseconds(t);
PyTime_t tv_sec, tv_nsec; PyTime_t tv_sec, tv_nsec;
int res = pytime_divmod(ns, SEC_TO_NS, &tv_sec, &tv_nsec); int res = pytime_divmod(ns, SEC_TO_NS, &tv_sec, &tv_nsec);
@ -936,7 +905,7 @@ py_get_system_clock(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
the 1st january 1601 and the 1st january 1970 (369 years + 89 leap the 1st january 1601 and the 1st january 1970 (369 years + 89 leap
days). */ days). */
PyTime_t ns = large.QuadPart * 100 - 11644473600000000000; PyTime_t ns = large.QuadPart * 100 - 11644473600000000000;
*tp = pytime_from_nanoseconds(ns); *tp = ns;
if (info) { if (info) {
DWORD timeAdjustment, timeIncrement; DWORD timeAdjustment, timeIncrement;
BOOL isTimeAdjustmentDisabled, ok; BOOL isTimeAdjustmentDisabled, ok;
@ -1160,12 +1129,10 @@ py_get_monotonic_clock(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
PyTime_t ticks = (PyTime_t)uticks; PyTime_t ticks = (PyTime_t)uticks;
PyTime_t ns = _PyTimeFraction_Mul(ticks, &base); PyTime_t ns = _PyTimeFraction_Mul(ticks, &base);
*tp = pytime_from_nanoseconds(ns); *tp = ns;
#elif defined(__hpux) #elif defined(__hpux)
hrtime_t time; hrtime_t time = gethrtime();
time = gethrtime();
if (time == -1) { if (time == -1) {
if (raise_exc) { if (raise_exc) {
PyErr_SetFromErrno(PyExc_OSError); PyErr_SetFromErrno(PyExc_OSError);
@ -1173,7 +1140,7 @@ py_get_monotonic_clock(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
return -1; return -1;
} }
*tp = pytime_from_nanoseconds(time); *tp = time;
if (info) { if (info) {
info->implementation = "gethrtime()"; info->implementation = "gethrtime()";
@ -1316,7 +1283,7 @@ py_get_win_perf_counter(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
ticks = (PyTime_t)ticksll; ticks = (PyTime_t)ticksll;
PyTime_t ns = _PyTimeFraction_Mul(ticks, &base); PyTime_t ns = _PyTimeFraction_Mul(ticks, &base);
*tp = pytime_from_nanoseconds(ns); *tp = ns;
return 0; return 0;
} }
#endif // MS_WINDOWS #endif // MS_WINDOWS

4
Python/thread.c
View file

@ -20,8 +20,8 @@
// Define PY_TIMEOUT_MAX constant. // Define PY_TIMEOUT_MAX constant.
#ifdef _POSIX_THREADS #ifdef _POSIX_THREADS
// PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000), // PyThread_acquire_lock_timed() uses (us * 1000) to convert microseconds
// convert microseconds to nanoseconds. // to nanoseconds.
# define PY_TIMEOUT_MAX_VALUE (LLONG_MAX / 1000) # define PY_TIMEOUT_MAX_VALUE (LLONG_MAX / 1000)
#elif defined (NT_THREADS) #elif defined (NT_THREADS)
// WaitForSingleObject() accepts timeout in milliseconds in the range // WaitForSingleObject() accepts timeout in milliseconds in the range

2
Python/thread_nt.h
View file

@ -77,7 +77,7 @@ EnterNonRecursiveMutex(PNRMUTEX mutex, DWORD milliseconds)
} }
} else if (milliseconds != 0) { } else if (milliseconds != 0) {
/* wait at least until the deadline */ /* wait at least until the deadline */
PyTime_t nanoseconds = _PyTime_FromNanoseconds((PyTime_t)milliseconds * 1000000); PyTime_t nanoseconds = (PyTime_t)milliseconds * (1000 * 1000);
PyTime_t deadline = _PyTime_Add(_PyTime_PerfCounterUnchecked(), nanoseconds); PyTime_t deadline = _PyTime_Add(_PyTime_PerfCounterUnchecked(), nanoseconds);
while (mutex->locked) { while (mutex->locked) {
PyTime_t microseconds = _PyTime_AsMicroseconds(nanoseconds, PyTime_t microseconds = _PyTime_AsMicroseconds(nanoseconds,

2
Python/thread_pthread.h
View file

@ -495,7 +495,7 @@ PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,
timeout = _PyTime_FromMicrosecondsClamp(microseconds); timeout = _PyTime_FromMicrosecondsClamp(microseconds);
} }
else { else {
timeout = _PyTime_FromNanoseconds(-1); timeout = -1;
} }
#ifdef HAVE_SEM_CLOCKWAIT #ifdef HAVE_SEM_CLOCKWAIT