mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-30 05:35:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

gh-110850: Replace _PyTime_t with PyTime_t (#115719)

Browse source 
Run command:

sed -i -e 's!\<_PyTime_t\>!PyTime_t!g' $(find -name "*.c" -o -name "*.h")
This commit is contained in:
Victor Stinner 2024-02-20 16:02:27 +01:00 • committed by GitHub
parent 0749244d13
commit 9af80ec83d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
31 changed files with 341 additions and 341 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Include/internal/pycore_import.h
View file

@ -11,7 +11,7 @@ extern "C" {
#include "pycore_lock.h" // PyMutex #include "pycore_lock.h" // PyMutex
#include "pycore_hashtable.h" // _Py_hashtable_t #include "pycore_hashtable.h" // _Py_hashtable_t
#include "pycore_time.h" // _PyTime_t #include "pycore_time.h" // PyTime_t
extern int _PyImport_IsInitialized(PyInterpreterState *); extern int _PyImport_IsInitialized(PyInterpreterState *);
@ -103,7 +103,7 @@ struct _import_state {
/* diagnostic info in PyImport_ImportModuleLevelObject() */ /* diagnostic info in PyImport_ImportModuleLevelObject() */
struct { struct {
int import_level; int import_level;
_PyTime_t accumulated; PyTime_t accumulated;
int header; int header;
} find_and_load; } find_and_load;
}; };

6
Include/internal/pycore_lock.h
View file

@ -13,7 +13,7 @@ extern "C" {
# error "this header requires Py_BUILD_CORE define" # error "this header requires Py_BUILD_CORE define"
#endif #endif
#include "pycore_time.h" // _PyTime_t #include "pycore_time.h" // PyTime_t
// A mutex that occupies one byte. The lock can be zero initialized. // A mutex that occupies one byte. The lock can be zero initialized.
@ -113,7 +113,7 @@ typedef enum _PyLockFlags {
// Lock a mutex with an optional timeout and additional options. See // Lock a mutex with an optional timeout and additional options. See
// _PyLockFlags for details. // _PyLockFlags for details.
extern PyLockStatus extern PyLockStatus
_PyMutex_LockTimed(PyMutex *m, _PyTime_t timeout_ns, _PyLockFlags flags); _PyMutex_LockTimed(PyMutex *m, PyTime_t timeout_ns, _PyLockFlags flags);
// Lock a mutex with aditional options. See _PyLockFlags for details. // Lock a mutex with aditional options. See _PyLockFlags for details.
static inline void static inline void
@ -146,7 +146,7 @@ PyAPI_FUNC(void) PyEvent_Wait(PyEvent *evt);
// Wait for the event to be set, or until the timeout expires. If the event is // Wait for the event to be set, or until the timeout expires. If the event is
// already set, then this returns immediately. Returns 1 if the event was set, // already set, then this returns immediately. Returns 1 if the event was set,
// and 0 if the timeout expired or thread was interrupted. // and 0 if the timeout expired or thread was interrupted.
PyAPI_FUNC(int) PyEvent_WaitTimed(PyEvent *evt, _PyTime_t timeout_ns); PyAPI_FUNC(int) PyEvent_WaitTimed(PyEvent *evt, PyTime_t timeout_ns);
// _PyRawMutex implements a word-sized mutex that that does not depend on the // _PyRawMutex implements a word-sized mutex that that does not depend on the

4
Include/internal/pycore_parking_lot.h
View file

@ -18,7 +18,7 @@ extern "C" {
# error "this header requires Py_BUILD_CORE define" # error "this header requires Py_BUILD_CORE define"
#endif #endif
#include "pycore_time.h" // _PyTime_t #include "pycore_time.h" // PyTime_t
enum { enum {
@ -61,7 +61,7 @@ enum {
// } // }
PyAPI_FUNC(int) PyAPI_FUNC(int)
_PyParkingLot_Park(const void *address, const void *expected, _PyParkingLot_Park(const void *address, const void *expected,
size_t address_size, _PyTime_t timeout_ns, size_t address_size, PyTime_t timeout_ns,
void *park_arg, int detach); void *park_arg, int detach);
// Callback for _PyParkingLot_Unpark: // Callback for _PyParkingLot_Unpark:

2
Include/internal/pycore_pythread.h
View file

@ -96,7 +96,7 @@ extern void _PyThread_AfterFork(struct _pythread_runtime_state *state);
// unset: -1 seconds, in nanoseconds // unset: -1 seconds, in nanoseconds
#define PyThread_UNSET_TIMEOUT ((_PyTime_t)(-1 * 1000 * 1000 * 1000)) #define PyThread_UNSET_TIMEOUT ((PyTime_t)(-1 * 1000 * 1000 * 1000))
// Exported for the _xxinterpchannels module. // Exported for the _xxinterpchannels module.
PyAPI_FUNC(int) PyThread_ParseTimeoutArg( PyAPI_FUNC(int) PyThread_ParseTimeoutArg(

4
Include/internal/pycore_semaphore.h
View file

@ -8,7 +8,7 @@
#endif #endif
#include "pycore_pythread.h" // _POSIX_SEMAPHORES #include "pycore_pythread.h" // _POSIX_SEMAPHORES
#include "pycore_time.h" // _PyTime_t #include "pycore_time.h" // PyTime_t
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
# define WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN
@ -48,7 +48,7 @@ typedef struct _PySemaphore {
// If `detach` is true, then the thread will detach/release the GIL while // If `detach` is true, then the thread will detach/release the GIL while
// sleeping. // sleeping.
PyAPI_FUNC(int) PyAPI_FUNC(int)
_PySemaphore_Wait(_PySemaphore *sema, _PyTime_t timeout_ns, int detach); _PySemaphore_Wait(_PySemaphore *sema, PyTime_t timeout_ns, int detach);
// Wakes up a single thread waiting on sema. Note that _PySemaphore_Wakeup() // Wakes up a single thread waiting on sema. Note that _PySemaphore_Wakeup()
// can be called before _PySemaphore_Wait(). // can be called before _PySemaphore_Wait().

74
Include/internal/pycore_time.h
View file

@ -62,7 +62,7 @@ extern "C" {
struct timeval; struct timeval;
#endif #endif
typedef PyTime_t _PyTime_t; typedef PyTime_t PyTime_t;
#define _SIZEOF_PYTIME_T 8 #define _SIZEOF_PYTIME_T 8
typedef enum { typedef enum {
@ -130,69 +130,69 @@ PyAPI_FUNC(int) _PyTime_ObjectToTimespec(
// Create a timestamp from a number of seconds. // Create a timestamp from a number of seconds.
// Export for '_socket' shared extension. // Export for '_socket' shared extension.
PyAPI_FUNC(_PyTime_t) _PyTime_FromSeconds(int seconds); PyAPI_FUNC(PyTime_t) _PyTime_FromSeconds(int seconds);
// Create a timestamp from a number of seconds in double. // Create a timestamp from a number of seconds in double.
// Export for '_socket' shared extension. // Export for '_socket' shared extension.
PyAPI_FUNC(_PyTime_t) _PyTime_FromSecondsDouble(double seconds, _PyTime_round_t round); PyAPI_FUNC(PyTime_t) _PyTime_FromSecondsDouble(double seconds, _PyTime_round_t round);
// Macro to create a timestamp from a number of seconds, no integer overflow. // Macro to create a timestamp from a number of seconds, no integer overflow.
// Only use the macro for small values, prefer _PyTime_FromSeconds(). // Only use the macro for small values, prefer _PyTime_FromSeconds().
#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. // Create a timestamp from a number of nanoseconds.
// Export for '_testinternalcapi' shared extension. // Export for '_testinternalcapi' shared extension.
PyAPI_FUNC(_PyTime_t) _PyTime_FromNanoseconds(_PyTime_t ns); 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 nanoseconds (Python int).
// Export for '_lsprof' shared extension. // Export for '_lsprof' shared extension.
PyAPI_FUNC(int) _PyTime_FromNanosecondsObject(_PyTime_t *t, PyAPI_FUNC(int) _PyTime_FromNanosecondsObject(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.
// Raise an exception and return -1 on error, return 0 on success. // Raise an exception and return -1 on error, return 0 on success.
// Export for '_socket' shared extension. // Export for '_socket' shared extension.
PyAPI_FUNC(int) _PyTime_FromSecondsObject(_PyTime_t *t, PyAPI_FUNC(int) _PyTime_FromSecondsObject(PyTime_t *t,
PyObject *obj, PyObject *obj,
_PyTime_round_t round); _PyTime_round_t round);
// Convert a number of milliseconds (Python float or int, 10^-3) to a timestamp. // Convert a number of milliseconds (Python float or int, 10^-3) to a timestamp.
// Raise an exception and return -1 on error, return 0 on success. // Raise an exception and return -1 on error, return 0 on success.
// Export for 'select' shared extension. // Export for 'select' shared extension.
PyAPI_FUNC(int) _PyTime_FromMillisecondsObject(_PyTime_t *t, PyAPI_FUNC(int) _PyTime_FromMillisecondsObject(PyTime_t *t,
PyObject *obj, PyObject *obj,
_PyTime_round_t round); _PyTime_round_t round);
// Convert timestamp to a number of milliseconds (10^-3 seconds). // Convert timestamp to a number of milliseconds (10^-3 seconds).
// Export for '_ssl' shared extension. // Export for '_ssl' shared extension.
PyAPI_FUNC(_PyTime_t) _PyTime_AsMilliseconds(_PyTime_t t, PyAPI_FUNC(PyTime_t) _PyTime_AsMilliseconds(PyTime_t t,
_PyTime_round_t round); _PyTime_round_t round);
// Convert timestamp to a number of microseconds (10^-6 seconds). // Convert timestamp to a number of microseconds (10^-6 seconds).
// Export for '_queue' shared extension. // Export for '_queue' shared extension.
PyAPI_FUNC(_PyTime_t) _PyTime_AsMicroseconds(_PyTime_t t, PyAPI_FUNC(PyTime_t) _PyTime_AsMicroseconds(PyTime_t t,
_PyTime_round_t round); _PyTime_round_t round);
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
// Convert timestamp to a number of 100 nanoseconds (10^-7 seconds). // Convert timestamp to a number of 100 nanoseconds (10^-7 seconds).
extern _PyTime_t _PyTime_As100Nanoseconds(_PyTime_t t, 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 timestamp to a number of nanoseconds (10^-9 seconds) 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_AsNanosecondsObject(PyTime_t t);
#ifndef MS_WINDOWS #ifndef MS_WINDOWS
// Create a timestamp from a timeval structure. // Create a timestamp from a timeval structure.
// Raise an exception and return -1 on overflow, return 0 on success. // Raise an exception and return -1 on overflow, return 0 on success.
extern int _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv); extern int _PyTime_FromTimeval(PyTime_t *tp, struct timeval *tv);
#endif #endif
// Convert a timestamp to a timeval structure (microsecond resolution). // Convert a timestamp to a timeval structure (microsecond resolution).
@ -200,14 +200,14 @@ extern int _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv);
// Raise an exception and return -1 if the conversion overflowed, // Raise an exception and return -1 if the conversion overflowed,
// return 0 on success. // return 0 on success.
// Export for 'select' shared extension. // Export for 'select' shared extension.
PyAPI_FUNC(int) _PyTime_AsTimeval(_PyTime_t t, PyAPI_FUNC(int) _PyTime_AsTimeval(PyTime_t t,
struct timeval *tv, struct timeval *tv,
_PyTime_round_t round); _PyTime_round_t round);
// Similar to _PyTime_AsTimeval() but don't raise an exception on overflow. // Similar to _PyTime_AsTimeval() but don't raise an exception on overflow.
// On overflow, clamp tv_sec to _PyTime_t min/max. // On overflow, clamp tv_sec to PyTime_t min/max.
// Export for 'select' shared extension. // Export for 'select' shared extension.
PyAPI_FUNC(void) _PyTime_AsTimeval_clamp(_PyTime_t t, PyAPI_FUNC(void) _PyTime_AsTimeval_clamp(PyTime_t t,
struct timeval *tv, struct timeval *tv,
_PyTime_round_t round); _PyTime_round_t round);
@ -219,7 +219,7 @@ PyAPI_FUNC(void) _PyTime_AsTimeval_clamp(_PyTime_t t,
// return 0 on success. // return 0 on success.
// Export for '_datetime' shared extension. // Export for '_datetime' shared extension.
PyAPI_FUNC(int) _PyTime_AsTimevalTime_t( PyAPI_FUNC(int) _PyTime_AsTimevalTime_t(
_PyTime_t t, PyTime_t t,
time_t *secs, time_t *secs,
int *us, int *us,
_PyTime_round_t round); _PyTime_round_t round);
@ -227,23 +227,23 @@ PyAPI_FUNC(int) _PyTime_AsTimevalTime_t(
#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE) #if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE)
// Create a timestamp from a timespec structure. // Create a timestamp from a timespec structure.
// Raise an exception and return -1 on overflow, return 0 on success. // Raise an exception and return -1 on overflow, return 0 on success.
extern int _PyTime_FromTimespec(_PyTime_t *tp, const struct timespec *ts); extern int _PyTime_FromTimespec(PyTime_t *tp, const struct timespec *ts);
// Convert a timestamp to a timespec structure (nanosecond resolution). // Convert a timestamp to a timespec structure (nanosecond resolution).
// tv_nsec is always positive. // tv_nsec is always positive.
// Raise an exception and return -1 on error, return 0 on success. // Raise an exception and return -1 on error, return 0 on success.
// Export for '_testinternalcapi' shared extension. // Export for '_testinternalcapi' shared extension.
PyAPI_FUNC(int) _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts); PyAPI_FUNC(int) _PyTime_AsTimespec(PyTime_t t, struct timespec *ts);
// Similar to _PyTime_AsTimespec() but don't raise an exception on overflow. // Similar to _PyTime_AsTimespec() but don't raise an exception on overflow.
// On overflow, clamp tv_sec to _PyTime_t min/max. // On overflow, clamp tv_sec to PyTime_t min/max.
// Export for '_testinternalcapi' shared extension. // Export for '_testinternalcapi' shared extension.
PyAPI_FUNC(void) _PyTime_AsTimespec_clamp(_PyTime_t t, struct timespec *ts); PyAPI_FUNC(void) _PyTime_AsTimespec_clamp(PyTime_t t, struct timespec *ts);
#endif #endif
// Compute t1 + t2. Clamp to [PyTime_MIN; PyTime_MAX] on overflow. // Compute t1 + t2. Clamp to [PyTime_MIN; PyTime_MAX] on overflow.
extern _PyTime_t _PyTime_Add(_PyTime_t t1, _PyTime_t t2); extern PyTime_t _PyTime_Add(PyTime_t t1, PyTime_t t2);
// Structure used by time.get_clock_info() // Structure used by time.get_clock_info()
typedef struct { typedef struct {
@ -262,13 +262,13 @@ typedef struct {
// Use _PyTime_GetSystemClockWithInfo or the public PyTime_Time() to check // Use _PyTime_GetSystemClockWithInfo or the public PyTime_Time() to check
// for failure. // for failure.
// Export for '_random' shared extension. // Export for '_random' shared extension.
PyAPI_FUNC(_PyTime_t) _PyTime_GetSystemClock(void); PyAPI_FUNC(PyTime_t) _PyTime_GetSystemClock(void);
// Get the current time from the system clock. // Get the current time from the system clock.
// On success, set *t and *info (if not NULL), and return 0. // On success, set *t and *info (if not NULL), and return 0.
// On error, raise an exception and return -1. // On error, raise an exception and return -1.
extern int _PyTime_GetSystemClockWithInfo( extern int _PyTime_GetSystemClockWithInfo(
_PyTime_t *t, PyTime_t *t,
_Py_clock_info_t *info); _Py_clock_info_t *info);
// Get the time of a monotonic clock, i.e. a clock that cannot go backwards. // Get the time of a monotonic clock, i.e. a clock that cannot go backwards.
@ -283,7 +283,7 @@ extern int _PyTime_GetSystemClockWithInfo(
// Use _PyTime_GetMonotonicClockWithInfo or the public PyTime_Monotonic() // Use _PyTime_GetMonotonicClockWithInfo or the public PyTime_Monotonic()
// to check for failure. // to check for failure.
// Export for '_random' shared extension. // Export for '_random' shared extension.
PyAPI_FUNC(_PyTime_t) _PyTime_GetMonotonicClock(void); PyAPI_FUNC(PyTime_t) _PyTime_GetMonotonicClock(void);
// Get the time of a monotonic clock, i.e. a clock that cannot go backwards. // 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 clock is not affected by system clock updates. The reference point of
@ -295,7 +295,7 @@ PyAPI_FUNC(_PyTime_t) _PyTime_GetMonotonicClock(void);
// Return 0 on success, raise an exception and return -1 on error. // Return 0 on success, raise an exception and return -1 on error.
// Export for '_testsinglephase' shared extension. // Export for '_testsinglephase' shared extension.
PyAPI_FUNC(int) _PyTime_GetMonotonicClockWithInfo( PyAPI_FUNC(int) _PyTime_GetMonotonicClockWithInfo(
_PyTime_t *t, PyTime_t *t,
_Py_clock_info_t *info); _Py_clock_info_t *info);
@ -319,7 +319,7 @@ PyAPI_FUNC(int) _PyTime_gmtime(time_t t, struct tm *tm);
// Use _PyTime_GetPerfCounterWithInfo() or the public PyTime_PerfCounter // Use _PyTime_GetPerfCounterWithInfo() or the public PyTime_PerfCounter
// to check for failure. // to check for failure.
// Export for '_lsprof' shared extension. // Export for '_lsprof' shared extension.
PyAPI_FUNC(_PyTime_t) _PyTime_GetPerfCounter(void); PyAPI_FUNC(PyTime_t) _PyTime_GetPerfCounter(void);
// Get the performance counter: clock with the highest available resolution to // Get the performance counter: clock with the highest available resolution to
@ -329,7 +329,7 @@ PyAPI_FUNC(_PyTime_t) _PyTime_GetPerfCounter(void);
// //
// Return 0 on success, raise an exception and return -1 on error. // Return 0 on success, raise an exception and return -1 on error.
extern int _PyTime_GetPerfCounterWithInfo( extern int _PyTime_GetPerfCounterWithInfo(
_PyTime_t *t, PyTime_t *t,
_Py_clock_info_t *info); _Py_clock_info_t *info);
// Alias for backward compatibility // Alias for backward compatibility
@ -343,19 +343,19 @@ extern int _PyTime_GetPerfCounterWithInfo(
// Create a deadline. // Create a deadline.
// Pseudo code: _PyTime_GetMonotonicClock() + timeout. // Pseudo code: _PyTime_GetMonotonicClock() + timeout.
// Export for '_ssl' shared extension. // Export for '_ssl' shared extension.
PyAPI_FUNC(_PyTime_t) _PyDeadline_Init(_PyTime_t timeout); PyAPI_FUNC(PyTime_t) _PyDeadline_Init(PyTime_t timeout);
// Get remaining time from a deadline. // Get remaining time from a deadline.
// Pseudo code: deadline - _PyTime_GetMonotonicClock(). // Pseudo code: deadline - _PyTime_GetMonotonicClock().
// Export for '_ssl' shared extension. // Export for '_ssl' shared extension.
PyAPI_FUNC(_PyTime_t) _PyDeadline_Get(_PyTime_t deadline); PyAPI_FUNC(PyTime_t) _PyDeadline_Get(PyTime_t deadline);
// --- _PyTimeFraction ------------------------------------------------------- // --- _PyTimeFraction -------------------------------------------------------
typedef struct { typedef struct {
_PyTime_t numer; PyTime_t numer;
_PyTime_t denom; PyTime_t denom;
} _PyTimeFraction; } _PyTimeFraction;
// Set a fraction. // Set a fraction.
@ -363,13 +363,13 @@ typedef struct {
// Return -1 if the fraction is invalid. // Return -1 if the fraction is invalid.
extern int _PyTimeFraction_Set( extern int _PyTimeFraction_Set(
_PyTimeFraction *frac, _PyTimeFraction *frac,
_PyTime_t numer, PyTime_t numer,
_PyTime_t denom); PyTime_t denom);
// Compute ticks * frac.numer / frac.denom. // Compute ticks * frac.numer / frac.denom.
// Clamp to [_PyTime_MIN; _PyTime_MAX] on overflow. // Clamp to [_PyTime_MIN; _PyTime_MAX] on overflow.
extern _PyTime_t _PyTimeFraction_Mul( extern PyTime_t _PyTimeFraction_Mul(
_PyTime_t ticks, PyTime_t ticks,
const _PyTimeFraction *frac); const _PyTimeFraction *frac);
// Compute a clock resolution: frac.numer / frac.denom / 1e9. // Compute a clock resolution: frac.numer / frac.denom / 1e9.

2
Modules/_datetimemodule.c
View file

@ -5131,7 +5131,7 @@ datetime_from_timestamp(PyObject *cls, TM_FUNC f, PyObject *timestamp,
static PyObject * static PyObject *
datetime_best_possible(PyObject *cls, TM_FUNC f, PyObject *tzinfo) datetime_best_possible(PyObject *cls, TM_FUNC f, PyObject *tzinfo)
{ {
_PyTime_t ts = _PyTime_GetSystemClock(); PyTime_t ts = _PyTime_GetSystemClock();
time_t secs; time_t secs;
int us; int us;

26
Modules/_lsprof.c
View file

@ -17,8 +17,8 @@ struct _ProfilerEntry;
/* represents a function called from another function */ /* represents a function called from another function */
typedef struct _ProfilerSubEntry { typedef struct _ProfilerSubEntry {
rotating_node_t header; rotating_node_t header;
_PyTime_t tt; PyTime_t tt;
_PyTime_t it; PyTime_t it;
long callcount; long callcount;
long recursivecallcount; long recursivecallcount;
long recursionLevel; long recursionLevel;
@ -28,8 +28,8 @@ typedef struct _ProfilerSubEntry {
typedef struct _ProfilerEntry { typedef struct _ProfilerEntry {
rotating_node_t header; rotating_node_t header;
PyObject *userObj; /* PyCodeObject, or a descriptive str for builtins */ PyObject *userObj; /* PyCodeObject, or a descriptive str for builtins */
_PyTime_t tt; /* total time in this entry */ PyTime_t tt; /* total time in this entry */
_PyTime_t it; /* inline time in this entry (not in subcalls) */ PyTime_t it; /* inline time in this entry (not in subcalls) */
long callcount; /* how many times this was called */ long callcount; /* how many times this was called */
long recursivecallcount; /* how many times called recursively */ long recursivecallcount; /* how many times called recursively */
long recursionLevel; long recursionLevel;
@ -37,8 +37,8 @@ typedef struct _ProfilerEntry {
} ProfilerEntry; } ProfilerEntry;
typedef struct _ProfilerContext { typedef struct _ProfilerContext {
_PyTime_t t0; PyTime_t t0;
_PyTime_t subt; PyTime_t subt;
struct _ProfilerContext *previous; struct _ProfilerContext *previous;
ProfilerEntry *ctxEntry; ProfilerEntry *ctxEntry;
} ProfilerContext; } ProfilerContext;
@ -84,7 +84,7 @@ _lsprof_get_state(PyObject *module)
/*** External Timers ***/ /*** External Timers ***/
static _PyTime_t CallExternalTimer(ProfilerObject *pObj) static PyTime_t CallExternalTimer(ProfilerObject *pObj)
{ {
PyObject *o = _PyObject_CallNoArgs(pObj->externalTimer); PyObject *o = _PyObject_CallNoArgs(pObj->externalTimer);
if (o == NULL) { if (o == NULL) {
@ -92,7 +92,7 @@ static _PyTime_t CallExternalTimer(ProfilerObject *pObj)
return 0; return 0;
} }
_PyTime_t result; PyTime_t result;
int err; int err;
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
@ -101,7 +101,7 @@ static _PyTime_t CallExternalTimer(ProfilerObject *pObj)
} }
else { else {
/* interpret the result as a double measured in seconds. /* interpret the result as a double measured in seconds.
As the profiler works with _PyTime_t internally As the profiler works with PyTime_t internally
we convert it to a large integer */ we convert it to a large integer */
err = _PyTime_FromSecondsObject(&result, o, _PyTime_ROUND_FLOOR); err = _PyTime_FromSecondsObject(&result, o, _PyTime_ROUND_FLOOR);
} }
@ -113,7 +113,7 @@ static _PyTime_t CallExternalTimer(ProfilerObject *pObj)
return result; return result;
} }
static inline _PyTime_t static inline PyTime_t
call_timer(ProfilerObject *pObj) call_timer(ProfilerObject *pObj)
{ {
if (pObj->externalTimer != NULL) { if (pObj->externalTimer != NULL) {
@ -311,8 +311,8 @@ initContext(ProfilerObject *pObj, ProfilerContext *self, ProfilerEntry *entry)
static void static void
Stop(ProfilerObject *pObj, ProfilerContext *self, ProfilerEntry *entry) Stop(ProfilerObject *pObj, ProfilerContext *self, ProfilerEntry *entry)
{ {
_PyTime_t tt = call_timer(pObj) - self->t0; PyTime_t tt = call_timer(pObj) - self->t0;
_PyTime_t it = tt - self->subt; PyTime_t it = tt - self->subt;
if (self->previous) if (self->previous)
self->previous->subt += tt; self->previous->subt += tt;
pObj->currentProfilerContext = self->previous; pObj->currentProfilerContext = self->previous;
@ -557,7 +557,7 @@ _lsprof_Profiler_getstats_impl(ProfilerObject *self, PyTypeObject *cls)
return NULL; return NULL;
} }
if (!self->externalTimer || self->externalTimerUnit == 0.0) { if (!self->externalTimer || self->externalTimerUnit == 0.0) {
_PyTime_t onesec = _PyTime_FromSeconds(1); PyTime_t onesec = _PyTime_FromSeconds(1);
collect.factor = (double)1 / onesec; collect.factor = (double)1 / onesec;
} }
else { else {

6
Modules/_queuemodule.c
View file

@ -6,7 +6,7 @@
#include "pycore_ceval.h" // Py_MakePendingCalls() #include "pycore_ceval.h" // Py_MakePendingCalls()
#include "pycore_moduleobject.h" // _PyModule_GetState() #include "pycore_moduleobject.h" // _PyModule_GetState()
#include "pycore_parking_lot.h" #include "pycore_parking_lot.h"
#include "pycore_time.h" // _PyTime_t #include "pycore_time.h" // PyTime_t
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h> // offsetof() #include <stddef.h> // offsetof()
@ -372,13 +372,13 @@ _queue_SimpleQueue_get_impl(simplequeueobject *self, PyTypeObject *cls,
int block, PyObject *timeout_obj) int block, PyObject *timeout_obj)
/*[clinic end generated code: output=5c2cca914cd1e55b input=f7836c65e5839c51]*/ /*[clinic end generated code: output=5c2cca914cd1e55b input=f7836c65e5839c51]*/
{ {
_PyTime_t endtime = 0; PyTime_t endtime = 0;
// XXX Use PyThread_ParseTimeoutArg(). // XXX Use PyThread_ParseTimeoutArg().
if (block != 0 && !Py_IsNone(timeout_obj)) { if (block != 0 && !Py_IsNone(timeout_obj)) {
/* With timeout */ /* With timeout */
_PyTime_t timeout; PyTime_t timeout;
if (_PyTime_FromSecondsObject(&timeout, if (_PyTime_FromSecondsObject(&timeout,
timeout_obj, _PyTime_ROUND_CEILING) < 0) { timeout_obj, _PyTime_ROUND_CEILING) < 0) {
return NULL; return NULL;

14
Modules/_ssl.c
View file

@ -369,7 +369,7 @@ class _ssl.SSLSession "PySSLSession *" "get_state_type(type)->PySSLSession_Type"
#include "clinic/_ssl.c.h" #include "clinic/_ssl.c.h"
static int PySSL_select(PySocketSockObject *s, int writing, _PyTime_t timeout); static int PySSL_select(PySocketSockObject *s, int writing, PyTime_t timeout);
static int PySSL_set_owner(PySSLSocket *, PyObject *, void *); static int PySSL_set_owner(PySSLSocket *, PyObject *, void *);
static int PySSL_set_session(PySSLSocket *, PyObject *, void *); static int PySSL_set_session(PySSLSocket *, PyObject *, void *);
@ -963,7 +963,7 @@ _ssl__SSLSocket_do_handshake_impl(PySSLSocket *self)
_PySSLError err; _PySSLError err;
int sockstate, nonblocking; int sockstate, nonblocking;
PySocketSockObject *sock = GET_SOCKET(self); PySocketSockObject *sock = GET_SOCKET(self);
_PyTime_t timeout, deadline = 0; PyTime_t timeout, deadline = 0;
int has_timeout; int has_timeout;
if (sock) { if (sock) {
@ -2273,12 +2273,12 @@ PySSL_dealloc(PySSLSocket *self)
*/ */
static int static int
PySSL_select(PySocketSockObject *s, int writing, _PyTime_t timeout) PySSL_select(PySocketSockObject *s, int writing, PyTime_t timeout)
{ {
int rc; int rc;
#ifdef HAVE_POLL #ifdef HAVE_POLL
struct pollfd pollfd; struct pollfd pollfd;
_PyTime_t ms; PyTime_t ms;
#else #else
int nfds; int nfds;
fd_set fds; fd_set fds;
@ -2357,7 +2357,7 @@ _ssl__SSLSocket_write_impl(PySSLSocket *self, Py_buffer *b)
_PySSLError err; _PySSLError err;
int nonblocking; int nonblocking;
PySocketSockObject *sock = GET_SOCKET(self); PySocketSockObject *sock = GET_SOCKET(self);
_PyTime_t timeout, deadline = 0; PyTime_t timeout, deadline = 0;
int has_timeout; int has_timeout;
if (sock != NULL) { if (sock != NULL) {
@ -2495,7 +2495,7 @@ _ssl__SSLSocket_read_impl(PySSLSocket *self, Py_ssize_t len,
_PySSLError err; _PySSLError err;
int nonblocking; int nonblocking;
PySocketSockObject *sock = GET_SOCKET(self); PySocketSockObject *sock = GET_SOCKET(self);
_PyTime_t timeout, deadline = 0; PyTime_t timeout, deadline = 0;
int has_timeout; int has_timeout;
if (!group_right_1 && len < 0) { if (!group_right_1 && len < 0) {
@ -2627,7 +2627,7 @@ _ssl__SSLSocket_shutdown_impl(PySSLSocket *self)
int sockstate, nonblocking, ret; int sockstate, nonblocking, ret;
int zeros = 0; int zeros = 0;
PySocketSockObject *sock = GET_SOCKET(self); PySocketSockObject *sock = GET_SOCKET(self);
_PyTime_t timeout, deadline = 0; PyTime_t timeout, deadline = 0;
int has_timeout; int has_timeout;
if (sock != NULL) { if (sock != NULL) {

24
Modules/_testinternalcapi/pytime.c
View file

@ -16,7 +16,7 @@ test_pytime_fromseconds(PyObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "i", &seconds)) { if (!PyArg_ParseTuple(args, "i", &seconds)) {
return NULL; return NULL;
} }
_PyTime_t ts = _PyTime_FromSeconds(seconds); PyTime_t ts = _PyTime_FromSeconds(seconds);
return _PyTime_AsNanosecondsObject(ts); return _PyTime_AsNanosecondsObject(ts);
} }
@ -45,7 +45,7 @@ test_pytime_fromsecondsobject(PyObject *self, PyObject *args)
if (check_time_rounding(round) < 0) { if (check_time_rounding(round) < 0) {
return NULL; return NULL;
} }
_PyTime_t ts; PyTime_t ts;
if (_PyTime_FromSecondsObject(&ts, obj, round) == -1) { if (_PyTime_FromSecondsObject(&ts, obj, round) == -1) {
return NULL; return NULL;
} }
@ -63,7 +63,7 @@ test_PyTime_AsTimeval(PyObject *self, PyObject *args)
if (check_time_rounding(round) < 0) { if (check_time_rounding(round) < 0) {
return NULL; return NULL;
} }
_PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
return NULL; return NULL;
} }
@ -90,7 +90,7 @@ test_PyTime_AsTimeval_clamp(PyObject *self, PyObject *args)
if (check_time_rounding(round) < 0) { if (check_time_rounding(round) < 0) {
return NULL; return NULL;
} }
_PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
return NULL; return NULL;
} }
@ -112,7 +112,7 @@ test_PyTime_AsTimespec(PyObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "O", &obj)) { if (!PyArg_ParseTuple(args, "O", &obj)) {
return NULL; return NULL;
} }
_PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
return NULL; return NULL;
} }
@ -130,7 +130,7 @@ test_PyTime_AsTimespec_clamp(PyObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "O", &obj)) { if (!PyArg_ParseTuple(args, "O", &obj)) {
return NULL; return NULL;
} }
_PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
return NULL; return NULL;
} }
@ -148,15 +148,15 @@ test_PyTime_AsMilliseconds(PyObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "Oi", &obj, &round)) { if (!PyArg_ParseTuple(args, "Oi", &obj, &round)) {
return NULL; return NULL;
} }
_PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromNanosecondsObject(&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); PyTime_t ns = _PyTime_FromNanoseconds(ms);
return _PyTime_AsNanosecondsObject(ns); return _PyTime_AsNanosecondsObject(ns);
} }
@ -168,15 +168,15 @@ test_PyTime_AsMicroseconds(PyObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "Oi", &obj, &round)) { if (!PyArg_ParseTuple(args, "Oi", &obj, &round)) {
return NULL; return NULL;
} }
_PyTime_t t; PyTime_t t;
if (_PyTime_FromNanosecondsObject(&t, obj) < 0) { if (_PyTime_FromNanosecondsObject(&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); PyTime_t ns = _PyTime_FromNanoseconds(us);
return _PyTime_AsNanosecondsObject(ns); return _PyTime_AsNanosecondsObject(ns);
} }

4
Modules/_testinternalcapi/test_lock.c
View file

@ -289,7 +289,7 @@ _testinternalcapi_benchmark_locks_impl(PyObject *module,
goto exit; goto exit;
} }
_PyTime_t start = _PyTime_GetMonotonicClock(); PyTime_t start = _PyTime_GetMonotonicClock();
for (Py_ssize_t i = 0; i < num_threads; i++) { for (Py_ssize_t i = 0; i < num_threads; i++) {
thread_data[i].bench_data = &bench_data; thread_data[i].bench_data = &bench_data;
@ -306,7 +306,7 @@ _testinternalcapi_benchmark_locks_impl(PyObject *module,
} }
Py_ssize_t total_iters = bench_data.total_iters; Py_ssize_t total_iters = bench_data.total_iters;
_PyTime_t end = _PyTime_GetMonotonicClock(); PyTime_t end = _PyTime_GetMonotonicClock();
// Return the total number of acquisitions and the number of acquisitions // Return the total number of acquisitions and the number of acquisitions
// for each thread. // for each thread.

10
Modules/_testsinglephase.c
View file

@ -8,11 +8,11 @@
//#include <time.h> //#include <time.h>
#include "Python.h" #include "Python.h"
#include "pycore_namespace.h" // _PyNamespace_New() #include "pycore_namespace.h" // _PyNamespace_New()
#include "pycore_time.h" // _PyTime_t #include "pycore_time.h" // PyTime_t
typedef struct { typedef struct {
_PyTime_t initialized; PyTime_t initialized;
PyObject *error; PyObject *error;
PyObject *int_const; PyObject *int_const;
PyObject *str_const; PyObject *str_const;
@ -67,15 +67,15 @@ clear_state(module_state *state)
} }
static int static int
_set_initialized(_PyTime_t *initialized) _set_initialized(PyTime_t *initialized)
{ {
/* We go strictly monotonic to ensure each time is unique. */ /* We go strictly monotonic to ensure each time is unique. */
_PyTime_t prev; PyTime_t prev;
if (_PyTime_GetMonotonicClockWithInfo(&prev, NULL) != 0) { if (_PyTime_GetMonotonicClockWithInfo(&prev, NULL) != 0) {
return -1; return -1;
} }
/* We do a busy sleep since the interval should be super short. */ /* We do a busy sleep since the interval should be super short. */
_PyTime_t t; PyTime_t t;
do { do {
if (_PyTime_GetMonotonicClockWithInfo(&t, NULL) != 0) { if (_PyTime_GetMonotonicClockWithInfo(&t, NULL) != 0) {
return -1; return -1;

12
Modules/_threadmodule.c
View file

@ -235,14 +235,14 @@ lock_dealloc(lockobject *self)
} }
static inline PyLockStatus static inline PyLockStatus
acquire_timed(PyThread_type_lock lock, _PyTime_t timeout) acquire_timed(PyThread_type_lock lock, PyTime_t timeout)
{ {
return PyThread_acquire_lock_timed_with_retries(lock, timeout); return PyThread_acquire_lock_timed_with_retries(lock, timeout);
} }
static int static int
lock_acquire_parse_args(PyObject *args, PyObject *kwds, lock_acquire_parse_args(PyObject *args, PyObject *kwds,
_PyTime_t *timeout) PyTime_t *timeout)
{ {
char *kwlist[] = {"blocking", "timeout", NULL}; char *kwlist[] = {"blocking", "timeout", NULL};
int blocking = 1; int blocking = 1;
@ -253,7 +253,7 @@ lock_acquire_parse_args(PyObject *args, PyObject *kwds,
// XXX Use PyThread_ParseTimeoutArg(). // XXX Use PyThread_ParseTimeoutArg().
const _PyTime_t unset_timeout = _PyTime_FromSeconds(-1); const PyTime_t unset_timeout = _PyTime_FromSeconds(-1);
*timeout = unset_timeout; *timeout = unset_timeout;
if (timeout_obj if (timeout_obj
@ -274,7 +274,7 @@ lock_acquire_parse_args(PyObject *args, PyObject *kwds,
if (!blocking) if (!blocking)
*timeout = 0; *timeout = 0;
else if (*timeout != unset_timeout) { else if (*timeout != unset_timeout) {
_PyTime_t microseconds; PyTime_t microseconds;
microseconds = _PyTime_AsMicroseconds(*timeout, _PyTime_ROUND_TIMEOUT); microseconds = _PyTime_AsMicroseconds(*timeout, _PyTime_ROUND_TIMEOUT);
if (microseconds > PY_TIMEOUT_MAX) { if (microseconds > PY_TIMEOUT_MAX) {
@ -289,7 +289,7 @@ lock_acquire_parse_args(PyObject *args, PyObject *kwds,
static PyObject * static PyObject *
lock_PyThread_acquire_lock(lockobject *self, PyObject *args, PyObject *kwds) lock_PyThread_acquire_lock(lockobject *self, PyObject *args, PyObject *kwds)
{ {
_PyTime_t timeout; PyTime_t timeout;
if (lock_acquire_parse_args(args, kwds, &timeout) < 0) if (lock_acquire_parse_args(args, kwds, &timeout) < 0)
return NULL; return NULL;
@ -501,7 +501,7 @@ rlock_is_owned_by(rlockobject *self, PyThread_ident_t tid)
static PyObject * static PyObject *
rlock_acquire(rlockobject *self, PyObject *args, PyObject *kwds) rlock_acquire(rlockobject *self, PyObject *args, PyObject *kwds)
{ {
_PyTime_t timeout; PyTime_t timeout;
PyThread_ident_t tid; PyThread_ident_t tid;
PyLockStatus r = PY_LOCK_ACQUIRED; PyLockStatus r = PY_LOCK_ACQUIRED;

4
Modules/faulthandler.c
View file

@ -623,7 +623,7 @@ cancel_dump_traceback_later(void)
#define SEC_TO_US (1000 * 1000) #define SEC_TO_US (1000 * 1000)
static char* static char*
format_timeout(_PyTime_t us) format_timeout(PyTime_t us)
{ {
unsigned long sec, min, hour; unsigned long sec, min, hour;
char buffer[100]; char buffer[100];
@ -656,7 +656,7 @@ faulthandler_dump_traceback_later(PyObject *self,
{ {
static char *kwlist[] = {"timeout", "repeat", "file", "exit", NULL}; static char *kwlist[] = {"timeout", "repeat", "file", "exit", NULL};
PyObject *timeout_obj; PyObject *timeout_obj;
_PyTime_t timeout, timeout_us; PyTime_t timeout, timeout_us;
int repeat = 0; int repeat = 0;
PyObject *file = NULL; PyObject *file = NULL;
int fd; int fd;

2
Modules/posixmodule.c
View file

@ -10410,7 +10410,7 @@ build_itimerspec(const struct itimerspec* curr_value)
static PyObject * static PyObject *
build_itimerspec_ns(const struct itimerspec* curr_value) build_itimerspec_ns(const struct itimerspec* curr_value)
{ {
_PyTime_t value, interval; PyTime_t value, interval;
if (_PyTime_FromTimespec(&value, &curr_value->it_value) < 0) { if (_PyTime_FromTimespec(&value, &curr_value->it_value) < 0) {
return NULL; return NULL;
} }

12
Modules/selectmodule.c
View file

@ -15,7 +15,7 @@
#include "Python.h" #include "Python.h"
#include "pycore_fileutils.h" // _Py_set_inheritable() #include "pycore_fileutils.h" // _Py_set_inheritable()
#include "pycore_import.h" // _PyImport_GetModuleAttrString() #include "pycore_import.h" // _PyImport_GetModuleAttrString()
#include "pycore_time.h" // _PyTime_t #include "pycore_time.h" // PyTime_t
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h> // offsetof() #include <stddef.h> // offsetof()
@ -297,7 +297,7 @@ select_select_impl(PyObject *module, PyObject *rlist, PyObject *wlist,
struct timeval tv, *tvp; struct timeval tv, *tvp;
int imax, omax, emax, max; int imax, omax, emax, max;
int n; int n;
_PyTime_t timeout, deadline = 0; PyTime_t timeout, deadline = 0;
if (timeout_obj == Py_None) if (timeout_obj == Py_None)
tvp = (struct timeval *)NULL; tvp = (struct timeval *)NULL;
@ -619,7 +619,7 @@ select_poll_poll_impl(pollObject *self, PyObject *timeout_obj)
PyObject *result_list = NULL; PyObject *result_list = NULL;
int poll_result, i, j; int poll_result, i, j;
PyObject *value = NULL, *num = NULL; PyObject *value = NULL, *num = NULL;
_PyTime_t timeout = -1, ms = -1, deadline = 0; PyTime_t timeout = -1, ms = -1, deadline = 0;
int async_err = 0; int async_err = 0;
if (timeout_obj != Py_None) { if (timeout_obj != Py_None) {
@ -946,7 +946,7 @@ select_devpoll_poll_impl(devpollObject *self, PyObject *timeout_obj)
PyObject *result_list = NULL; PyObject *result_list = NULL;
int poll_result, i; int poll_result, i;
PyObject *value, *num1, *num2; PyObject *value, *num1, *num2;
_PyTime_t timeout, ms, deadline = 0; PyTime_t timeout, ms, deadline = 0;
if (self->fd_devpoll < 0) if (self->fd_devpoll < 0)
return devpoll_err_closed(); return devpoll_err_closed();
@ -1559,7 +1559,7 @@ select_epoll_poll_impl(pyEpoll_Object *self, PyObject *timeout_obj,
int nfds, i; int nfds, i;
PyObject *elist = NULL, *etuple = NULL; PyObject *elist = NULL, *etuple = NULL;
struct epoll_event *evs = NULL; struct epoll_event *evs = NULL;
_PyTime_t timeout = -1, ms = -1, deadline = 0; PyTime_t timeout = -1, ms = -1, deadline = 0;
if (self->epfd < 0) if (self->epfd < 0)
return pyepoll_err_closed(); return pyepoll_err_closed();
@ -2242,7 +2242,7 @@ select_kqueue_control_impl(kqueue_queue_Object *self, PyObject *changelist,
struct kevent *chl = NULL; struct kevent *chl = NULL;
struct timespec timeoutspec; struct timespec timeoutspec;
struct timespec *ptimeoutspec; struct timespec *ptimeoutspec;
_PyTime_t timeout, deadline = 0; PyTime_t timeout, deadline = 0;
_selectstate *state = _selectstate_by_type(Py_TYPE(self)); _selectstate *state = _selectstate_by_type(Py_TYPE(self));
if (self->kqfd < 0) if (self->kqfd < 0)

6
Modules/signalmodule.c
View file

@ -173,7 +173,7 @@ timeval_from_double(PyObject *obj, struct timeval *tv)
return 0; return 0;
} }
_PyTime_t t; PyTime_t t;
if (_PyTime_FromSecondsObject(&t, obj, _PyTime_ROUND_CEILING) < 0) { if (_PyTime_FromSecondsObject(&t, obj, _PyTime_ROUND_CEILING) < 0) {
return -1; return -1;
} }
@ -1207,7 +1207,7 @@ signal_sigtimedwait_impl(PyObject *module, sigset_t sigset,
PyObject *timeout_obj) PyObject *timeout_obj)
/*[clinic end generated code: output=59c8971e8ae18a64 input=87fd39237cf0b7ba]*/ /*[clinic end generated code: output=59c8971e8ae18a64 input=87fd39237cf0b7ba]*/
{ {
_PyTime_t timeout; PyTime_t timeout;
if (_PyTime_FromSecondsObject(&timeout, if (_PyTime_FromSecondsObject(&timeout,
timeout_obj, _PyTime_ROUND_CEILING) < 0) timeout_obj, _PyTime_ROUND_CEILING) < 0)
return NULL; return NULL;
@ -1217,7 +1217,7 @@ signal_sigtimedwait_impl(PyObject *module, sigset_t sigset,
return NULL; return NULL;
} }
_PyTime_t deadline = _PyDeadline_Init(timeout); PyTime_t deadline = _PyDeadline_Init(timeout);
siginfo_t si; siginfo_t si;
do { do {

24
Modules/socketmodule.c
View file

@ -547,7 +547,7 @@ typedef struct _socket_state {
PyObject *socket_gaierror; PyObject *socket_gaierror;
/* Default timeout for new sockets */ /* Default timeout for new sockets */
_PyTime_t defaulttimeout; PyTime_t defaulttimeout;
#if defined(HAVE_ACCEPT) || defined(HAVE_ACCEPT4) #if defined(HAVE_ACCEPT) || defined(HAVE_ACCEPT4)
#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC) #if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
@ -772,13 +772,13 @@ internal_setblocking(PySocketSockObject *s, int block)
} }
static int static int
internal_select(PySocketSockObject *s, int writing, _PyTime_t interval, internal_select(PySocketSockObject *s, int writing, PyTime_t interval,
int connect) int connect)
{ {
int n; int n;
#ifdef HAVE_POLL #ifdef HAVE_POLL
struct pollfd pollfd; struct pollfd pollfd;
_PyTime_t ms; PyTime_t ms;
#else #else
fd_set fds, efds; fd_set fds, efds;
struct timeval tv, *tvp; struct timeval tv, *tvp;
@ -888,10 +888,10 @@ sock_call_ex(PySocketSockObject *s,
void *data, void *data,
int connect, int connect,
int *err, int *err,
_PyTime_t timeout) PyTime_t timeout)
{ {
int has_timeout = (timeout > 0); int has_timeout = (timeout > 0);
_PyTime_t deadline = 0; PyTime_t deadline = 0;
int deadline_initialized = 0; int deadline_initialized = 0;
int res; int res;
@ -905,7 +905,7 @@ sock_call_ex(PySocketSockObject *s,
runs asynchronously. */ runs asynchronously. */
if (has_timeout || connect) { if (has_timeout || connect) {
if (has_timeout) { if (has_timeout) {
_PyTime_t interval; PyTime_t interval;
if (deadline_initialized) { if (deadline_initialized) {
/* recompute the timeout */ /* recompute the timeout */
@ -3011,13 +3011,13 @@ Returns True if socket is in blocking mode, or False if it\n\
is in non-blocking mode."); is in non-blocking mode.");
static int static int
socket_parse_timeout(_PyTime_t *timeout, PyObject *timeout_obj) socket_parse_timeout(PyTime_t *timeout, PyObject *timeout_obj)
{ {
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
struct timeval tv; struct timeval tv;
#endif #endif
#ifndef HAVE_POLL #ifndef HAVE_POLL
_PyTime_t ms; PyTime_t ms;
#endif #endif
int overflow = 0; int overflow = 0;
@ -3060,7 +3060,7 @@ socket_parse_timeout(_PyTime_t *timeout, PyObject *timeout_obj)
static PyObject * static PyObject *
sock_settimeout(PySocketSockObject *s, PyObject *arg) sock_settimeout(PySocketSockObject *s, PyObject *arg)
{ {
_PyTime_t timeout; PyTime_t timeout;
if (socket_parse_timeout(&timeout, arg) < 0) if (socket_parse_timeout(&timeout, arg) < 0)
return NULL; return NULL;
@ -4382,8 +4382,8 @@ sock_sendall(PySocketSockObject *s, PyObject *args)
Py_buffer pbuf; Py_buffer pbuf;
struct sock_send ctx; struct sock_send ctx;
int has_timeout = (s->sock_timeout > 0); int has_timeout = (s->sock_timeout > 0);
_PyTime_t timeout = s->sock_timeout; PyTime_t timeout = s->sock_timeout;
_PyTime_t deadline = 0; PyTime_t deadline = 0;
int deadline_initialized = 0; int deadline_initialized = 0;
PyObject *res = NULL; PyObject *res = NULL;
@ -6931,7 +6931,7 @@ When the socket module is first imported, the default is None.");
static PyObject * static PyObject *
socket_setdefaulttimeout(PyObject *self, PyObject *arg) socket_setdefaulttimeout(PyObject *self, PyObject *arg)
{ {
_PyTime_t timeout; PyTime_t timeout;
if (socket_parse_timeout(&timeout, arg) < 0) if (socket_parse_timeout(&timeout, arg) < 0)
return NULL; return NULL;

4
Modules/socketmodule.h
View file

@ -1,6 +1,6 @@
/* Socket module header file */ /* Socket module header file */
#include "pycore_time.h" // _PyTime_t #include "pycore_time.h" // PyTime_t
/* Includes needed for the sockaddr_* symbols below */ /* Includes needed for the sockaddr_* symbols below */
#ifndef MS_WINDOWS #ifndef MS_WINDOWS
@ -324,7 +324,7 @@ typedef struct {
PyObject *(*errorhandler)(void); /* Error handler; checks PyObject *(*errorhandler)(void); /* Error handler; checks
errno, returns NULL and errno, returns NULL and
sets a Python exception */ sets a Python exception */
_PyTime_t sock_timeout; /* Operation timeout in seconds; PyTime_t sock_timeout; /* Operation timeout in seconds;
0.0 means non-blocking */ 0.0 means non-blocking */
struct _socket_state *state; struct _socket_state *state;
} PySocketSockObject; } PySocketSockObject;

74
Modules/timemodule.c
View file

@ -70,7 +70,7 @@ module time
/* Forward declarations */ /* Forward declarations */
static int pysleep(_PyTime_t timeout); static int pysleep(PyTime_t timeout);
typedef struct { typedef struct {
@ -95,7 +95,7 @@ get_time_state(PyObject *module)
static PyObject* static PyObject*
_PyFloat_FromPyTime(_PyTime_t t) _PyFloat_FromPyTime(PyTime_t t)
{ {
double d = _PyTime_AsSecondsDouble(t); double d = _PyTime_AsSecondsDouble(t);
return PyFloat_FromDouble(d); return PyFloat_FromDouble(d);
@ -103,7 +103,7 @@ _PyFloat_FromPyTime(_PyTime_t t)
static int static int
get_system_time(_PyTime_t *t) get_system_time(PyTime_t *t)
{ {
// Avoid _PyTime_GetSystemClock() which silently ignores errors. // Avoid _PyTime_GetSystemClock() which silently ignores errors.
return _PyTime_GetSystemClockWithInfo(t, NULL); return _PyTime_GetSystemClockWithInfo(t, NULL);
@ -113,7 +113,7 @@ get_system_time(_PyTime_t *t)
static PyObject * static PyObject *
time_time(PyObject *self, PyObject *unused) time_time(PyObject *self, PyObject *unused)
{ {
_PyTime_t t; PyTime_t t;
if (get_system_time(&t) < 0) { if (get_system_time(&t) < 0) {
return NULL; return NULL;
} }
@ -130,7 +130,7 @@ Fractions of a second may be present if the system clock provides them.");
static PyObject * static PyObject *
time_time_ns(PyObject *self, PyObject *unused) time_time_ns(PyObject *self, PyObject *unused)
{ {
_PyTime_t t; PyTime_t t;
if (get_system_time(&t) < 0) { if (get_system_time(&t) < 0) {
return NULL; return NULL;
} }
@ -153,7 +153,7 @@ Return the current time in nanoseconds since the Epoch.");
#endif #endif
static int static int
py_clock(time_module_state *state, _PyTime_t *tp, _Py_clock_info_t *info) py_clock(time_module_state *state, PyTime_t *tp, _Py_clock_info_t *info)
{ {
_PyTimeFraction *base = &state->clock_base; _PyTimeFraction *base = &state->clock_base;
@ -171,7 +171,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); PyTime_t ns = _PyTimeFraction_Mul(ticks, base);
*tp = _PyTime_FromNanoseconds(ns); *tp = _PyTime_FromNanoseconds(ns);
return 0; return 0;
} }
@ -262,7 +262,7 @@ time_clock_gettime_ns_impl(PyObject *module, clockid_t clk_id)
return NULL; return NULL;
} }
_PyTime_t t; PyTime_t t;
if (_PyTime_FromTimespec(&t, &ts) < 0) { if (_PyTime_FromTimespec(&t, &ts) < 0) {
return NULL; return NULL;
} }
@ -276,7 +276,7 @@ time_clock_settime(PyObject *self, PyObject *args)
{ {
int clk_id; int clk_id;
PyObject *obj; PyObject *obj;
_PyTime_t t; PyTime_t t;
struct timespec tp; struct timespec tp;
int ret; int ret;
@ -307,7 +307,7 @@ time_clock_settime_ns(PyObject *self, PyObject *args)
{ {
int clk_id; int clk_id;
PyObject *obj; PyObject *obj;
_PyTime_t t; PyTime_t t;
struct timespec ts; struct timespec ts;
int ret; int ret;
@ -402,7 +402,7 @@ time_sleep(PyObject *self, PyObject *timeout_obj)
return NULL; return NULL;
} }
_PyTime_t timeout; PyTime_t timeout;
if (_PyTime_FromSecondsObject(&timeout, timeout_obj, _PyTime_ROUND_TIMEOUT)) if (_PyTime_FromSecondsObject(&timeout, timeout_obj, _PyTime_ROUND_TIMEOUT))
return NULL; return NULL;
if (timeout < 0) { if (timeout < 0) {
@ -1156,7 +1156,7 @@ should not be relied on.");
static int static int
get_monotonic(_PyTime_t *t) get_monotonic(PyTime_t *t)
{ {
// Avoid _PyTime_GetMonotonicClock() which silently ignores errors. // Avoid _PyTime_GetMonotonicClock() which silently ignores errors.
return _PyTime_GetMonotonicClockWithInfo(t, NULL); return _PyTime_GetMonotonicClockWithInfo(t, NULL);
@ -1166,7 +1166,7 @@ get_monotonic(_PyTime_t *t)
static PyObject * static PyObject *
time_monotonic(PyObject *self, PyObject *unused) time_monotonic(PyObject *self, PyObject *unused)
{ {
_PyTime_t t; PyTime_t t;
if (get_monotonic(&t) < 0) { if (get_monotonic(&t) < 0) {
return NULL; return NULL;
} }
@ -1181,7 +1181,7 @@ Monotonic clock, cannot go backward.");
static PyObject * static PyObject *
time_monotonic_ns(PyObject *self, PyObject *unused) time_monotonic_ns(PyObject *self, PyObject *unused)
{ {
_PyTime_t t; PyTime_t t;
if (get_monotonic(&t) < 0) { if (get_monotonic(&t) < 0) {
return NULL; return NULL;
} }
@ -1195,7 +1195,7 @@ Monotonic clock, cannot go backward, as nanoseconds.");
static int static int
get_perf_counter(_PyTime_t *t) get_perf_counter(PyTime_t *t)
{ {
// Avoid _PyTime_GetPerfCounter() which silently ignores errors. // Avoid _PyTime_GetPerfCounter() which silently ignores errors.
return _PyTime_GetPerfCounterWithInfo(t, NULL); return _PyTime_GetPerfCounterWithInfo(t, NULL);
@ -1205,7 +1205,7 @@ get_perf_counter(_PyTime_t *t)
static PyObject * static PyObject *
time_perf_counter(PyObject *self, PyObject *unused) time_perf_counter(PyObject *self, PyObject *unused)
{ {
_PyTime_t t; PyTime_t t;
if (get_perf_counter(&t) < 0) { if (get_perf_counter(&t) < 0) {
return NULL; return NULL;
} }
@ -1221,7 +1221,7 @@ Performance counter for benchmarking.");
static PyObject * static PyObject *
time_perf_counter_ns(PyObject *self, PyObject *unused) time_perf_counter_ns(PyObject *self, PyObject *unused)
{ {
_PyTime_t t; PyTime_t t;
if (get_perf_counter(&t) < 0) { if (get_perf_counter(&t) < 0) {
return NULL; return NULL;
} }
@ -1236,7 +1236,7 @@ Performance counter for benchmarking as nanoseconds.");
#ifdef HAVE_TIMES #ifdef HAVE_TIMES
static int static int
process_time_times(time_module_state *state, _PyTime_t *tp, process_time_times(time_module_state *state, PyTime_t *tp,
_Py_clock_info_t *info) _Py_clock_info_t *info)
{ {
_PyTimeFraction *base = &state->times_base; _PyTimeFraction *base = &state->times_base;
@ -1253,7 +1253,7 @@ process_time_times(time_module_state *state, _PyTime_t *tp,
info->adjustable = 0; info->adjustable = 0;
} }
_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 = _PyTime_FromNanoseconds(ns);
@ -1263,14 +1263,14 @@ process_time_times(time_module_state *state, _PyTime_t *tp,
static int static int
py_process_time(time_module_state *state, _PyTime_t *tp, py_process_time(time_module_state *state, PyTime_t *tp,
_Py_clock_info_t *info) _Py_clock_info_t *info)
{ {
#if defined(MS_WINDOWS) #if defined(MS_WINDOWS)
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, t;
BOOL ok; BOOL ok;
process = GetCurrentProcess(); process = GetCurrentProcess();
@ -1343,7 +1343,7 @@ py_process_time(time_module_state *state, _PyTime_t *tp,
struct rusage ru; struct rusage ru;
if (getrusage(RUSAGE_SELF, &ru) == 0) { if (getrusage(RUSAGE_SELF, &ru) == 0) {
_PyTime_t utime, stime; PyTime_t utime, stime;
if (info) { if (info) {
info->implementation = "getrusage(RUSAGE_SELF)"; info->implementation = "getrusage(RUSAGE_SELF)";
@ -1359,7 +1359,7 @@ py_process_time(time_module_state *state, _PyTime_t *tp,
return -1; return -1;
} }
_PyTime_t total = utime + stime; PyTime_t total = utime + stime;
*tp = total; *tp = total;
return 0; return 0;
} }
@ -1386,7 +1386,7 @@ static PyObject *
time_process_time(PyObject *module, PyObject *unused) time_process_time(PyObject *module, PyObject *unused)
{ {
time_module_state *state = get_time_state(module); time_module_state *state = get_time_state(module);
_PyTime_t t; PyTime_t t;
if (py_process_time(state, &t, NULL) < 0) { if (py_process_time(state, &t, NULL) < 0) {
return NULL; return NULL;
} }
@ -1402,7 +1402,7 @@ static PyObject *
time_process_time_ns(PyObject *module, PyObject *unused) time_process_time_ns(PyObject *module, PyObject *unused)
{ {
time_module_state *state = get_time_state(module); time_module_state *state = get_time_state(module);
_PyTime_t t; PyTime_t t;
if (py_process_time(state, &t, NULL) < 0) { if (py_process_time(state, &t, NULL) < 0) {
return NULL; return NULL;
} }
@ -1419,12 +1419,12 @@ sum of the kernel and user-space CPU time.");
#if defined(MS_WINDOWS) #if defined(MS_WINDOWS)
#define HAVE_THREAD_TIME #define HAVE_THREAD_TIME
static int static int
_PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info) _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, t;
BOOL ok; BOOL ok;
thread = GetCurrentThread(); thread = GetCurrentThread();
@ -1459,7 +1459,7 @@ _PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info)
#elif defined(_AIX) #elif defined(_AIX)
#define HAVE_THREAD_TIME #define HAVE_THREAD_TIME
static int static int
_PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info) _PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info)
{ {
/* bpo-40192: On AIX, thread_cputime() is preferred: it has nanosecond /* bpo-40192: On AIX, thread_cputime() is preferred: it has nanosecond
resolution, whereas clock_gettime(CLOCK_THREAD_CPUTIME_ID) resolution, whereas clock_gettime(CLOCK_THREAD_CPUTIME_ID)
@ -1483,7 +1483,7 @@ _PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info)
#elif defined(__sun) && defined(__SVR4) #elif defined(__sun) && defined(__SVR4)
#define HAVE_THREAD_TIME #define HAVE_THREAD_TIME
static int static int
_PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info) _PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info)
{ {
/* bpo-35455: On Solaris, CLOCK_THREAD_CPUTIME_ID clock is not always /* bpo-35455: On Solaris, CLOCK_THREAD_CPUTIME_ID clock is not always
available; use gethrvtime() to substitute this functionality. */ available; use gethrvtime() to substitute this functionality. */
@ -1504,7 +1504,7 @@ _PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info)
#if defined(__APPLE__) && defined(__has_attribute) && __has_attribute(availability) #if defined(__APPLE__) && defined(__has_attribute) && __has_attribute(availability)
static int static int
_PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info) _PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info)
__attribute__((availability(macos, introduced=10.12))) __attribute__((availability(macos, introduced=10.12)))
__attribute__((availability(ios, introduced=10.0))) __attribute__((availability(ios, introduced=10.0)))
__attribute__((availability(tvos, introduced=10.0))) __attribute__((availability(tvos, introduced=10.0)))
@ -1512,7 +1512,7 @@ _PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info)
#endif #endif
static int static int
_PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info) _PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info)
{ {
struct timespec ts; struct timespec ts;
const clockid_t clk_id = CLOCK_THREAD_CPUTIME_ID; const clockid_t clk_id = CLOCK_THREAD_CPUTIME_ID;
@ -1554,7 +1554,7 @@ _PyTime_GetThreadTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info)
static PyObject * static PyObject *
time_thread_time(PyObject *self, PyObject *unused) time_thread_time(PyObject *self, PyObject *unused)
{ {
_PyTime_t t; PyTime_t t;
if (_PyTime_GetThreadTimeWithInfo(&t, NULL) < 0) { if (_PyTime_GetThreadTimeWithInfo(&t, NULL) < 0) {
return NULL; return NULL;
} }
@ -1569,7 +1569,7 @@ Thread time for profiling: sum of the kernel and user-space CPU time.");
static PyObject * static PyObject *
time_thread_time_ns(PyObject *self, PyObject *unused) time_thread_time_ns(PyObject *self, PyObject *unused)
{ {
_PyTime_t t; PyTime_t t;
if (_PyTime_GetThreadTimeWithInfo(&t, NULL) < 0) { if (_PyTime_GetThreadTimeWithInfo(&t, NULL) < 0) {
return NULL; return NULL;
} }
@ -1595,7 +1595,7 @@ time_get_clock_info(PyObject *module, PyObject *args)
char *name; char *name;
_Py_clock_info_t info; _Py_clock_info_t info;
PyObject *obj = NULL, *dict, *ns; PyObject *obj = NULL, *dict, *ns;
_PyTime_t t; PyTime_t t;
if (!PyArg_ParseTuple(args, "s:get_clock_info", &name)) { if (!PyArg_ParseTuple(args, "s:get_clock_info", &name)) {
return NULL; return NULL;
@ -2174,7 +2174,7 @@ PyInit_time(void)
// On error, raise an exception and return -1. // On error, raise an exception and return -1.
// On success, return 0. // On success, return 0.
static int static int
pysleep(_PyTime_t timeout) pysleep(PyTime_t timeout)
{ {
assert(timeout >= 0); assert(timeout >= 0);
@ -2186,7 +2186,7 @@ pysleep(_PyTime_t timeout)
#else #else
struct timeval timeout_tv; struct timeval timeout_tv;
#endif #endif
_PyTime_t deadline, monotonic; PyTime_t deadline, monotonic;
int err = 0; int err = 0;
if (get_monotonic(&monotonic) < 0) { if (get_monotonic(&monotonic) < 0) {
@ -2255,7 +2255,7 @@ pysleep(_PyTime_t timeout)
return 0; return 0;
#else // MS_WINDOWS #else // MS_WINDOWS
_PyTime_t timeout_100ns = _PyTime_As100Nanoseconds(timeout, PyTime_t timeout_100ns = _PyTime_As100Nanoseconds(timeout,
_PyTime_ROUND_CEILING); _PyTime_ROUND_CEILING);
// Maintain Windows Sleep() semantics for time.sleep(0) // Maintain Windows Sleep() semantics for time.sleep(0)

2
Python/gc.c
View file

@ -1285,7 +1285,7 @@ gc_collect_main(PyThreadState *tstate, int generation, _PyGC_Reason reason)
PyGC_Head unreachable; /* non-problematic unreachable trash */ PyGC_Head unreachable; /* non-problematic unreachable trash */
PyGC_Head finalizers; /* objects with, & reachable from, __del__ */ PyGC_Head finalizers; /* objects with, & reachable from, __del__ */
PyGC_Head *gc; PyGC_Head *gc;
_PyTime_t t1 = 0; /* initialize to prevent a compiler warning */ PyTime_t t1 = 0; /* initialize to prevent a compiler warning */
GCState *gcstate = &tstate->interp->gc; GCState *gcstate = &tstate->interp->gc;
// gc_collect_main() must not be called before _PyGC_Init // gc_collect_main() must not be called before _PyGC_Init

2
Python/gc_free_threading.c
View file

@ -1071,7 +1071,7 @@ gc_collect_main(PyThreadState *tstate, int generation, _PyGC_Reason reason)
int i; int i;
Py_ssize_t m = 0; /* # objects collected */ Py_ssize_t m = 0; /* # objects collected */
Py_ssize_t n = 0; /* # unreachable objects that couldn't be collected */ Py_ssize_t n = 0; /* # unreachable objects that couldn't be collected */
_PyTime_t t1 = 0; /* initialize to prevent a compiler warning */ PyTime_t t1 = 0; /* initialize to prevent a compiler warning */
GCState *gcstate = &tstate->interp->gc; GCState *gcstate = &tstate->interp->gc;
// gc_collect_main() must not be called before _PyGC_Init // gc_collect_main() must not be called before _PyGC_Init

4
Python/import.c
View file

@ -2719,7 +2719,7 @@ import_find_and_load(PyThreadState *tstate, PyObject *abs_name)
#define import_level FIND_AND_LOAD(interp).import_level #define import_level FIND_AND_LOAD(interp).import_level
#define accumulated FIND_AND_LOAD(interp).accumulated #define accumulated FIND_AND_LOAD(interp).accumulated
_PyTime_t t1 = 0, accumulated_copy = accumulated; PyTime_t t1 = 0, accumulated_copy = accumulated;
PyObject *sys_path = PySys_GetObject("path"); PyObject *sys_path = PySys_GetObject("path");
PyObject *sys_meta_path = PySys_GetObject("meta_path"); PyObject *sys_meta_path = PySys_GetObject("meta_path");
@ -2762,7 +2762,7 @@ import_find_and_load(PyThreadState *tstate, PyObject *abs_name)
mod != NULL); mod != NULL);
if (import_time) { if (import_time) {
_PyTime_t cum = _PyTime_GetPerfCounter() - t1; PyTime_t cum = _PyTime_GetPerfCounter() - t1;
import_level--; import_level--;
fprintf(stderr, "import time: %9ld | %10ld | %*s%s\n", fprintf(stderr, "import time: %9ld | %10ld | %*s%s\n",

14
Python/lock.c
View file

@ -16,7 +16,7 @@
// If a thread waits on a lock for longer than TIME_TO_BE_FAIR_NS (1 ms), then // If a thread waits on a lock for longer than TIME_TO_BE_FAIR_NS (1 ms), then
// the unlocking thread directly hands off ownership of the lock. This avoids // the unlocking thread directly hands off ownership of the lock. This avoids
// starvation. // starvation.
static const _PyTime_t TIME_TO_BE_FAIR_NS = 1000*1000; static const PyTime_t TIME_TO_BE_FAIR_NS = 1000*1000;
// Spin for a bit before parking the thread. This is only enabled for // Spin for a bit before parking the thread. This is only enabled for
// `--disable-gil` builds because it is unlikely to be helpful if the GIL is // `--disable-gil` builds because it is unlikely to be helpful if the GIL is
@ -30,7 +30,7 @@ static const int MAX_SPIN_COUNT = 0;
struct mutex_entry { struct mutex_entry {
// The time after which the unlocking thread should hand off lock ownership // The time after which the unlocking thread should hand off lock ownership
// directly to the waiting thread. Written by the waiting thread. // directly to the waiting thread. Written by the waiting thread.
_PyTime_t time_to_be_fair; PyTime_t time_to_be_fair;
// Set to 1 if the lock was handed off. Written by the unlocking thread. // Set to 1 if the lock was handed off. Written by the unlocking thread.
int handed_off; int handed_off;
@ -53,7 +53,7 @@ _PyMutex_LockSlow(PyMutex *m)
} }
PyLockStatus PyLockStatus
_PyMutex_LockTimed(PyMutex *m, _PyTime_t timeout, _PyLockFlags flags) _PyMutex_LockTimed(PyMutex *m, PyTime_t timeout, _PyLockFlags flags)
{ {
uint8_t v = _Py_atomic_load_uint8_relaxed(&m->v); uint8_t v = _Py_atomic_load_uint8_relaxed(&m->v);
if ((v & _Py_LOCKED) == 0) { if ((v & _Py_LOCKED) == 0) {
@ -65,8 +65,8 @@ _PyMutex_LockTimed(PyMutex *m, _PyTime_t timeout, _PyLockFlags flags)
return PY_LOCK_FAILURE; return PY_LOCK_FAILURE;
} }
_PyTime_t now = _PyTime_GetMonotonicClock(); PyTime_t now = _PyTime_GetMonotonicClock();
_PyTime_t endtime = 0; PyTime_t endtime = 0;
if (timeout > 0) { if (timeout > 0) {
endtime = _PyTime_Add(now, timeout); endtime = _PyTime_Add(now, timeout);
} }
@ -142,7 +142,7 @@ mutex_unpark(PyMutex *m, struct mutex_entry *entry, int has_more_waiters)
{ {
uint8_t v = 0; uint8_t v = 0;
if (entry) { if (entry) {
_PyTime_t now = _PyTime_GetMonotonicClock(); PyTime_t now = _PyTime_GetMonotonicClock();
int should_be_fair = now > entry->time_to_be_fair; int should_be_fair = now > entry->time_to_be_fair;
entry->handed_off = should_be_fair; entry->handed_off = should_be_fair;
@ -274,7 +274,7 @@ PyEvent_Wait(PyEvent *evt)
} }
int int
PyEvent_WaitTimed(PyEvent *evt, _PyTime_t timeout_ns) PyEvent_WaitTimed(PyEvent *evt, PyTime_t timeout_ns)
{ {
for (;;) { for (;;) {
uint8_t v = _Py_atomic_load_uint8(&evt->v); uint8_t v = _Py_atomic_load_uint8(&evt->v);

12
Python/parking_lot.c
View file

@ -91,7 +91,7 @@ _PySemaphore_Destroy(_PySemaphore *sema)
} }
static int static int
_PySemaphore_PlatformWait(_PySemaphore *sema, _PyTime_t timeout) _PySemaphore_PlatformWait(_PySemaphore *sema, PyTime_t timeout)
{ {
int res; int res;
#if defined(MS_WINDOWS) #if defined(MS_WINDOWS)
@ -119,13 +119,13 @@ _PySemaphore_PlatformWait(_PySemaphore *sema, _PyTime_t timeout)
struct timespec ts; struct timespec ts;
#if defined(CLOCK_MONOTONIC) && defined(HAVE_SEM_CLOCKWAIT) #if defined(CLOCK_MONOTONIC) && defined(HAVE_SEM_CLOCKWAIT)
_PyTime_t deadline = _PyTime_Add(_PyTime_GetMonotonicClock(), timeout); PyTime_t deadline = _PyTime_Add(_PyTime_GetMonotonicClock(), timeout);
_PyTime_AsTimespec_clamp(deadline, &ts); _PyTime_AsTimespec_clamp(deadline, &ts);
err = sem_clockwait(&sema->platform_sem, CLOCK_MONOTONIC, &ts); err = sem_clockwait(&sema->platform_sem, CLOCK_MONOTONIC, &ts);
#else #else
_PyTime_t deadline = _PyTime_Add(_PyTime_GetSystemClock(), timeout); PyTime_t deadline = _PyTime_Add(_PyTime_GetSystemClock(), timeout);
_PyTime_AsTimespec_clamp(deadline, &ts); _PyTime_AsTimespec_clamp(deadline, &ts);
@ -162,7 +162,7 @@ _PySemaphore_PlatformWait(_PySemaphore *sema, _PyTime_t timeout)
_PyTime_AsTimespec_clamp(timeout, &ts); _PyTime_AsTimespec_clamp(timeout, &ts);
err = pthread_cond_timedwait_relative_np(&sema->cond, &sema->mutex, &ts); err = pthread_cond_timedwait_relative_np(&sema->cond, &sema->mutex, &ts);
#else #else
_PyTime_t deadline = _PyTime_Add(_PyTime_GetSystemClock(), timeout); PyTime_t deadline = _PyTime_Add(_PyTime_GetSystemClock(), timeout);
_PyTime_AsTimespec_clamp(deadline, &ts); _PyTime_AsTimespec_clamp(deadline, &ts);
err = pthread_cond_timedwait(&sema->cond, &sema->mutex, &ts); err = pthread_cond_timedwait(&sema->cond, &sema->mutex, &ts);
@ -188,7 +188,7 @@ _PySemaphore_PlatformWait(_PySemaphore *sema, _PyTime_t timeout)
} }
int int
_PySemaphore_Wait(_PySemaphore *sema, _PyTime_t timeout, int detach) _PySemaphore_Wait(_PySemaphore *sema, PyTime_t timeout, int detach)
{ {
PyThreadState *tstate = NULL; PyThreadState *tstate = NULL;
if (detach) { if (detach) {
@ -283,7 +283,7 @@ atomic_memcmp(const void *addr, const void *expected, size_t addr_size)
int int
_PyParkingLot_Park(const void *addr, const void *expected, size_t size, _PyParkingLot_Park(const void *addr, const void *expected, size_t size,
_PyTime_t timeout_ns, void *park_arg, int detach) PyTime_t timeout_ns, void *park_arg, int detach)
{ {
struct wait_entry wait = { struct wait_entry wait = {
.park_arg = park_arg, .park_arg = park_arg,

2
Python/pystate.c
View file

@ -2072,7 +2072,7 @@ stop_the_world(struct _stoptheworld_state *stw)
break; break;
} }
_PyTime_t wait_ns = 1000*1000; // 1ms (arbitrary, may need tuning) PyTime_t wait_ns = 1000*1000; // 1ms (arbitrary, may need tuning)
if (PyEvent_WaitTimed(&stw->stop_event, wait_ns)) { if (PyEvent_WaitTimed(&stw->stop_event, wait_ns)) {
assert(stw->thread_countdown == 0); assert(stw->thread_countdown == 0);
break; break;

304
Python/pytime.c
View file

@ -1,5 +1,5 @@
#include "Python.h" #include "Python.h"
#include "pycore_time.h" // _PyTime_t #include "pycore_time.h" // PyTime_t
#include <time.h> // gmtime_r() #include <time.h> // gmtime_r()
#ifdef HAVE_SYS_TIME_H #ifdef HAVE_SYS_TIME_H
@ -51,18 +51,18 @@
#endif #endif
#if PyTime_MIN + PyTime_MAX != -1 #if PyTime_MIN + PyTime_MAX != -1
# error "_PyTime_t is not a two's complement integer type" # error "PyTime_t is not a two's complement integer type"
#endif #endif
static _PyTime_t static PyTime_t
_PyTime_GCD(_PyTime_t x, _PyTime_t y) _PyTime_GCD(PyTime_t x, PyTime_t y)
{ {
// Euclidean algorithm // Euclidean algorithm
assert(x >= 1); assert(x >= 1);
assert(y >= 1); assert(y >= 1);
while (y != 0) { while (y != 0) {
_PyTime_t tmp = y; PyTime_t tmp = y;
y = x % y; y = x % y;
x = tmp; x = tmp;
} }
@ -72,13 +72,13 @@ _PyTime_GCD(_PyTime_t x, _PyTime_t y)
int int
_PyTimeFraction_Set(_PyTimeFraction *frac, _PyTime_t numer, _PyTime_t denom) _PyTimeFraction_Set(_PyTimeFraction *frac, PyTime_t numer, PyTime_t denom)
{ {
if (numer < 1 || denom < 1) { if (numer < 1 || denom < 1) {
return -1; return -1;
} }
_PyTime_t gcd = _PyTime_GCD(numer, denom); PyTime_t gcd = _PyTime_GCD(numer, denom);
frac->numer = numer / gcd; frac->numer = numer / gcd;
frac->denom = denom / gcd; frac->denom = denom / gcd;
return 0; return 0;
@ -104,29 +104,29 @@ static void
pytime_overflow(void) pytime_overflow(void)
{ {
PyErr_SetString(PyExc_OverflowError, PyErr_SetString(PyExc_OverflowError,
"timestamp too large to convert to C _PyTime_t"); "timestamp too large to convert to C PyTime_t");
} }
static inline _PyTime_t static inline PyTime_t
pytime_from_nanoseconds(_PyTime_t t) pytime_from_nanoseconds(PyTime_t t)
{ {
// _PyTime_t is a number of nanoseconds // PyTime_t is a number of nanoseconds
return t; return t;
} }
static inline _PyTime_t static inline PyTime_t
pytime_as_nanoseconds(_PyTime_t t) pytime_as_nanoseconds(PyTime_t t)
{ {
// _PyTime_t is a number of nanoseconds: see pytime_from_nanoseconds() // PyTime_t is a number of nanoseconds: see pytime_from_nanoseconds()
return t; 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)
{ {
if (t2 > 0 && *t1 > PyTime_MAX - t2) { if (t2 > 0 && *t1 > PyTime_MAX - t2) {
*t1 = PyTime_MAX; *t1 = PyTime_MAX;
@ -143,8 +143,8 @@ pytime_add(_PyTime_t *t1, _PyTime_t t2)
} }
_PyTime_t PyTime_t
_PyTime_Add(_PyTime_t t1, _PyTime_t t2) _PyTime_Add(PyTime_t t1, PyTime_t t2)
{ {
(void)pytime_add(&t1, t2); (void)pytime_add(&t1, t2);
return t1; return t1;
@ -152,7 +152,7 @@ _PyTime_Add(_PyTime_t t1, _PyTime_t t2)
static inline int static inline int
pytime_mul_check_overflow(_PyTime_t a, _PyTime_t b) pytime_mul_check_overflow(PyTime_t a, PyTime_t b)
{ {
if (b != 0) { if (b != 0) {
assert(b > 0); assert(b > 0);
@ -166,7 +166,7 @@ pytime_mul_check_overflow(_PyTime_t a, _PyTime_t b)
// Compute t * k. Clamp to [PyTime_MIN; PyTime_MAX] on overflow. // Compute t * k. Clamp to [PyTime_MIN; PyTime_MAX] on overflow.
static inline int static inline int
pytime_mul(_PyTime_t *t, _PyTime_t k) pytime_mul(PyTime_t *t, PyTime_t k)
{ {
assert(k >= 0); assert(k >= 0);
if (pytime_mul_check_overflow(*t, k)) { if (pytime_mul_check_overflow(*t, k)) {
@ -181,19 +181,19 @@ pytime_mul(_PyTime_t *t, _PyTime_t k)
// Compute t * k. Clamp to [PyTime_MIN; PyTime_MAX] on overflow. // Compute t * k. Clamp to [PyTime_MIN; PyTime_MAX] on overflow.
static inline _PyTime_t static inline PyTime_t
_PyTime_Mul(_PyTime_t t, _PyTime_t k) _PyTime_Mul(PyTime_t t, PyTime_t k)
{ {
(void)pytime_mul(&t, k); (void)pytime_mul(&t, k);
return t; return t;
} }
_PyTime_t PyTime_t
_PyTimeFraction_Mul(_PyTime_t ticks, const _PyTimeFraction *frac) _PyTimeFraction_Mul(PyTime_t ticks, const _PyTimeFraction *frac)
{ {
const _PyTime_t mul = frac->numer; const PyTime_t mul = frac->numer;
const _PyTime_t div = frac->denom; const PyTime_t div = frac->denom;
if (div == 1) { if (div == 1) {
// Fast-path taken by mach_absolute_time() with 1/1 time base. // Fast-path taken by mach_absolute_time() with 1/1 time base.
@ -205,7 +205,7 @@ _PyTimeFraction_Mul(_PyTime_t ticks, const _PyTimeFraction *frac)
(ticks * mul) / div == (ticks / div) * mul + (ticks % div) * mul / div (ticks * mul) / div == (ticks / div) * mul + (ticks % div) * mul / div
*/ */
_PyTime_t intpart, remaining; PyTime_t intpart, remaining;
intpart = ticks / div; intpart = ticks / div;
ticks %= div; ticks %= div;
remaining = _PyTime_Mul(ticks, mul) / div; remaining = _PyTime_Mul(ticks, mul) / div;
@ -247,17 +247,17 @@ _PyLong_FromTime_t(time_t t)
} }
// Convert _PyTime_t to time_t. // Convert PyTime_t to time_t.
// 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_AsTime_t(_PyTime_t t, time_t *t2) _PyTime_AsTime_t(PyTime_t t, time_t *t2)
{ {
#if SIZEOF_TIME_T < _SIZEOF_PYTIME_T #if SIZEOF_TIME_T < _SIZEOF_PYTIME_T
if ((_PyTime_t)PY_TIME_T_MAX < t) { if ((PyTime_t)PY_TIME_T_MAX < t) {
*t2 = PY_TIME_T_MAX; *t2 = PY_TIME_T_MAX;
return -1; return -1;
} }
if (t < (_PyTime_t)PY_TIME_T_MIN) { if (t < (PyTime_t)PY_TIME_T_MIN) {
*t2 = PY_TIME_T_MIN; *t2 = PY_TIME_T_MIN;
return -1; return -1;
} }
@ -268,17 +268,17 @@ _PyTime_AsTime_t(_PyTime_t t, time_t *t2)
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
// 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_AsLong(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) {
*t2 = LONG_MAX; *t2 = LONG_MAX;
return -1; return -1;
} }
if (t < (_PyTime_t)LONG_MIN) { if (t < (PyTime_t)LONG_MIN) {
*t2 = LONG_MIN; *t2 = LONG_MIN;
return -1; return -1;
} }
@ -453,16 +453,16 @@ _PyTime_ObjectToTimeval(PyObject *obj, time_t *sec, long *usec,
} }
_PyTime_t PyTime_t
_PyTime_FromSeconds(int seconds) _PyTime_FromSeconds(int seconds)
{ {
/* ensure that integer overflow cannot happen, int type should have 32 /* ensure that integer overflow cannot happen, int type should have 32
bits, whereas _PyTime_t type has at least 64 bits (SEC_TO_NS takes 30 bits, whereas PyTime_t type has at least 64 bits (SEC_TO_NS takes 30
bits). */ bits). */
static_assert(INT_MAX <= PyTime_MAX / SEC_TO_NS, "_PyTime_t overflow"); static_assert(INT_MAX <= PyTime_MAX / SEC_TO_NS, "PyTime_t overflow");
static_assert(INT_MIN >= PyTime_MIN / SEC_TO_NS, "_PyTime_t underflow"); static_assert(INT_MIN >= PyTime_MIN / SEC_TO_NS, "PyTime_t underflow");
_PyTime_t t = (_PyTime_t)seconds; PyTime_t t = (PyTime_t)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;
@ -470,23 +470,23 @@ _PyTime_FromSeconds(int seconds)
} }
_PyTime_t PyTime_t
_PyTime_FromNanoseconds(_PyTime_t ns) _PyTime_FromNanoseconds(PyTime_t ns)
{ {
return pytime_from_nanoseconds(ns); return pytime_from_nanoseconds(ns);
} }
_PyTime_t 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 pytime_from_nanoseconds(ns);
} }
int int
_PyTime_FromNanosecondsObject(_PyTime_t *tp, PyObject *obj) _PyTime_FromNanosecondsObject(PyTime_t *tp, PyObject *obj)
{ {
if (!PyLong_Check(obj)) { if (!PyLong_Check(obj)) {
@ -495,8 +495,8 @@ _PyTime_FromNanosecondsObject(_PyTime_t *tp, PyObject *obj)
return -1; return -1;
} }
static_assert(sizeof(long long) == sizeof(_PyTime_t), static_assert(sizeof(long long) == sizeof(PyTime_t),
"_PyTime_t is not long long"); "PyTime_t is not long long");
long long nsec = PyLong_AsLongLong(obj); long long nsec = PyLong_AsLongLong(obj);
if (nsec == -1 && PyErr_Occurred()) { if (nsec == -1 && PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_OverflowError)) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
@ -505,7 +505,7 @@ _PyTime_FromNanosecondsObject(_PyTime_t *tp, PyObject *obj)
return -1; return -1;
} }
_PyTime_t t = (_PyTime_t)nsec; PyTime_t t = (PyTime_t)nsec;
*tp = pytime_from_nanoseconds(t); *tp = pytime_from_nanoseconds(t);
return 0; return 0;
} }
@ -513,13 +513,13 @@ _PyTime_FromNanosecondsObject(_PyTime_t *tp, PyObject *obj)
#ifdef HAVE_CLOCK_GETTIME #ifdef HAVE_CLOCK_GETTIME
static int static int
pytime_fromtimespec(_PyTime_t *tp, const struct timespec *ts, int raise_exc) pytime_fromtimespec(PyTime_t *tp, const struct timespec *ts, int raise_exc)
{ {
_PyTime_t t, tv_nsec; PyTime_t t, tv_nsec;
static_assert(sizeof(ts->tv_sec) <= sizeof(_PyTime_t), static_assert(sizeof(ts->tv_sec) <= sizeof(PyTime_t),
"timespec.tv_sec is larger than _PyTime_t"); "timespec.tv_sec is larger than PyTime_t");
t = (_PyTime_t)ts->tv_sec; t = (PyTime_t)ts->tv_sec;
int res1 = pytime_mul(&t, SEC_TO_NS); int res1 = pytime_mul(&t, SEC_TO_NS);
@ -536,7 +536,7 @@ pytime_fromtimespec(_PyTime_t *tp, const struct timespec *ts, int raise_exc)
} }
int int
_PyTime_FromTimespec(_PyTime_t *tp, const struct timespec *ts) _PyTime_FromTimespec(PyTime_t *tp, const struct timespec *ts)
{ {
return pytime_fromtimespec(tp, ts, 1); return pytime_fromtimespec(tp, ts, 1);
} }
@ -545,15 +545,15 @@ _PyTime_FromTimespec(_PyTime_t *tp, const struct timespec *ts)
#ifndef MS_WINDOWS #ifndef MS_WINDOWS
static int static int
pytime_fromtimeval(_PyTime_t *tp, struct timeval *tv, int raise_exc) pytime_fromtimeval(PyTime_t *tp, struct timeval *tv, int raise_exc)
{ {
static_assert(sizeof(tv->tv_sec) <= sizeof(_PyTime_t), static_assert(sizeof(tv->tv_sec) <= sizeof(PyTime_t),
"timeval.tv_sec is larger than _PyTime_t"); "timeval.tv_sec is larger than PyTime_t");
_PyTime_t t = (_PyTime_t)tv->tv_sec; PyTime_t t = (PyTime_t)tv->tv_sec;
int res1 = pytime_mul(&t, SEC_TO_NS); int res1 = pytime_mul(&t, SEC_TO_NS);
_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 = pytime_from_nanoseconds(t);
@ -567,7 +567,7 @@ pytime_fromtimeval(_PyTime_t *tp, struct timeval *tv, int raise_exc)
int int
_PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv) _PyTime_FromTimeval(PyTime_t *tp, struct timeval *tv)
{ {
return pytime_fromtimeval(tp, tv, 1); return pytime_fromtimeval(tp, tv, 1);
} }
@ -575,7 +575,7 @@ _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv)
static int static int
pytime_from_double(_PyTime_t *tp, double value, _PyTime_round_t round, pytime_from_double(PyTime_t *tp, double value, _PyTime_round_t round,
long unit_to_ns) long unit_to_ns)
{ {
/* volatile avoids optimization changing how numbers are rounded */ /* volatile avoids optimization changing how numbers are rounded */
@ -591,7 +591,7 @@ pytime_from_double(_PyTime_t *tp, double value, _PyTime_round_t round,
pytime_time_t_overflow(); pytime_time_t_overflow();
return -1; return -1;
} }
_PyTime_t ns = (_PyTime_t)d; PyTime_t ns = (PyTime_t)d;
*tp = pytime_from_nanoseconds(ns); *tp = pytime_from_nanoseconds(ns);
return 0; return 0;
@ -599,7 +599,7 @@ pytime_from_double(_PyTime_t *tp, double value, _PyTime_round_t round,
static int static int
pytime_from_object(_PyTime_t *tp, PyObject *obj, _PyTime_round_t round, pytime_from_object(PyTime_t *tp, PyObject *obj, _PyTime_round_t round,
long unit_to_ns) long unit_to_ns)
{ {
if (PyFloat_Check(obj)) { if (PyFloat_Check(obj)) {
@ -620,9 +620,9 @@ pytime_from_object(_PyTime_t *tp, PyObject *obj, _PyTime_round_t round,
return -1; return -1;
} }
static_assert(sizeof(long long) <= sizeof(_PyTime_t), static_assert(sizeof(long long) <= sizeof(PyTime_t),
"_PyTime_t is smaller than long long"); "PyTime_t is smaller than long long");
_PyTime_t ns = (_PyTime_t)sec; PyTime_t ns = (PyTime_t)sec;
if (pytime_mul(&ns, unit_to_ns) < 0) { if (pytime_mul(&ns, unit_to_ns) < 0) {
pytime_overflow(); pytime_overflow();
return -1; return -1;
@ -635,14 +635,14 @@ pytime_from_object(_PyTime_t *tp, PyObject *obj, _PyTime_round_t round,
int int
_PyTime_FromSecondsObject(_PyTime_t *tp, PyObject *obj, _PyTime_round_t round) _PyTime_FromSecondsObject(PyTime_t *tp, PyObject *obj, _PyTime_round_t round)
{ {
return pytime_from_object(tp, obj, round, SEC_TO_NS); return pytime_from_object(tp, obj, round, SEC_TO_NS);
} }
int int
_PyTime_FromMillisecondsObject(_PyTime_t *tp, PyObject *obj, _PyTime_round_t round) _PyTime_FromMillisecondsObject(PyTime_t *tp, PyObject *obj, _PyTime_round_t round)
{ {
return pytime_from_object(tp, obj, round, MS_TO_NS); return pytime_from_object(tp, obj, round, MS_TO_NS);
} }
@ -658,7 +658,7 @@ PyTime_AsSecondsDouble(PyTime_t 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. */
_PyTime_t secs = ns / SEC_TO_NS; PyTime_t secs = ns / SEC_TO_NS;
d = (double)secs; d = (double)secs;
} }
else { else {
@ -670,18 +670,18 @@ PyTime_AsSecondsDouble(PyTime_t t)
PyObject * PyObject *
_PyTime_AsNanosecondsObject(_PyTime_t t) _PyTime_AsNanosecondsObject(PyTime_t t)
{ {
_PyTime_t ns = pytime_as_nanoseconds(t); 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);
} }
_PyTime_t PyTime_t
_PyTime_FromSecondsDouble(double seconds, _PyTime_round_t round) _PyTime_FromSecondsDouble(double seconds, _PyTime_round_t round)
{ {
_PyTime_t tp; PyTime_t tp;
if(pytime_from_double(&tp, seconds, round, SEC_TO_NS) < 0) { if(pytime_from_double(&tp, seconds, round, SEC_TO_NS) < 0) {
return -1; return -1;
} }
@ -689,14 +689,14 @@ _PyTime_FromSecondsDouble(double seconds, _PyTime_round_t round)
} }
static _PyTime_t static PyTime_t
pytime_divide_round_up(const _PyTime_t t, const _PyTime_t k) pytime_divide_round_up(const PyTime_t t, const PyTime_t k)
{ {
assert(k > 1); assert(k > 1);
if (t >= 0) { if (t >= 0) {
// Don't use (t + k - 1) / k to avoid integer overflow // Don't use (t + k - 1) / k to avoid integer overflow
// if t is equal to PyTime_MAX // if t is equal to PyTime_MAX
_PyTime_t q = t / k; PyTime_t q = t / k;
if (t % k) { if (t % k) {
q += 1; q += 1;
} }
@ -705,7 +705,7 @@ pytime_divide_round_up(const _PyTime_t t, const _PyTime_t k)
else { else {
// Don't use (t - (k - 1)) / k to avoid integer overflow // Don't use (t - (k - 1)) / k to avoid integer overflow
// if t is equals to PyTime_MIN. // if t is equals to PyTime_MIN.
_PyTime_t q = t / k; PyTime_t q = t / k;
if (t % k) { if (t % k) {
q -= 1; q -= 1;
} }
@ -714,15 +714,15 @@ pytime_divide_round_up(const _PyTime_t t, const _PyTime_t k)
} }
static _PyTime_t static PyTime_t
pytime_divide(const _PyTime_t t, const _PyTime_t k, pytime_divide(const PyTime_t t, const PyTime_t k,
const _PyTime_round_t round) const _PyTime_round_t round)
{ {
assert(k > 1); assert(k > 1);
if (round == _PyTime_ROUND_HALF_EVEN) { if (round == _PyTime_ROUND_HALF_EVEN) {
_PyTime_t x = t / k; PyTime_t x = t / k;
_PyTime_t r = t % k; PyTime_t r = t % k;
_PyTime_t abs_r = Py_ABS(r); PyTime_t abs_r = Py_ABS(r);
if (abs_r > k / 2 || (abs_r == k / 2 && (Py_ABS(x) & 1))) { if (abs_r > k / 2 || (abs_r == k / 2 && (Py_ABS(x) & 1))) {
if (t >= 0) { if (t >= 0) {
x++; x++;
@ -761,12 +761,12 @@ pytime_divide(const _PyTime_t t, const _PyTime_t k,
// Return 0 on success. // Return 0 on success.
// Return -1 on underflow and store (PyTime_MIN, 0) in (pq, pr). // Return -1 on underflow and store (PyTime_MIN, 0) in (pq, pr).
static int static int
pytime_divmod(const _PyTime_t t, const _PyTime_t k, pytime_divmod(const PyTime_t t, const PyTime_t k,
_PyTime_t *pq, _PyTime_t *pr) PyTime_t *pq, PyTime_t *pr)
{ {
assert(k > 1); assert(k > 1);
_PyTime_t q = t / k; PyTime_t q = t / k;
_PyTime_t r = t % k; PyTime_t r = t % k;
if (r < 0) { if (r < 0) {
if (q == PyTime_MIN) { if (q == PyTime_MIN) {
*pq = PyTime_MIN; *pq = PyTime_MIN;
@ -785,39 +785,39 @@ 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 t, _PyTime_round_t round)
{ {
_PyTime_t ns = pytime_as_nanoseconds(t); 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 t, _PyTime_round_t round)
{ {
_PyTime_t ns = pytime_as_nanoseconds(t); 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 t, _PyTime_round_t round)
{ {
_PyTime_t ns = pytime_as_nanoseconds(t); 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 t, PyTime_t *ptv_sec, int *ptv_usec,
_PyTime_round_t round) _PyTime_round_t round)
{ {
_PyTime_t ns = pytime_as_nanoseconds(t); 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;
int res = pytime_divmod(us, SEC_TO_US, &tv_sec, &tv_usec); int res = pytime_divmod(us, SEC_TO_US, &tv_sec, &tv_usec);
*ptv_sec = tv_sec; *ptv_sec = tv_sec;
*ptv_usec = (int)tv_usec; *ptv_usec = (int)tv_usec;
@ -826,10 +826,10 @@ pytime_as_timeval(_PyTime_t t, _PyTime_t *ptv_sec, int *ptv_usec,
static int static int
pytime_as_timeval_struct(_PyTime_t t, struct timeval *tv, pytime_as_timeval_struct(PyTime_t t, struct timeval *tv,
_PyTime_round_t round, int raise_exc) _PyTime_round_t round, int raise_exc)
{ {
_PyTime_t tv_sec; PyTime_t tv_sec;
int tv_usec; int tv_usec;
int res = pytime_as_timeval(t, &tv_sec, &tv_usec, round); int res = pytime_as_timeval(t, &tv_sec, &tv_usec, round);
int res2; int res2;
@ -853,24 +853,24 @@ pytime_as_timeval_struct(_PyTime_t t, struct timeval *tv,
int int
_PyTime_AsTimeval(_PyTime_t t, struct timeval *tv, _PyTime_round_t round) _PyTime_AsTimeval(PyTime_t t, struct timeval *tv, _PyTime_round_t round)
{ {
return pytime_as_timeval_struct(t, tv, round, 1); return pytime_as_timeval_struct(t, tv, round, 1);
} }
void void
_PyTime_AsTimeval_clamp(_PyTime_t t, struct timeval *tv, _PyTime_round_t round) _PyTime_AsTimeval_clamp(PyTime_t t, struct timeval *tv, _PyTime_round_t round)
{ {
(void)pytime_as_timeval_struct(t, tv, round, 0); (void)pytime_as_timeval_struct(t, tv, round, 0);
} }
int int
_PyTime_AsTimevalTime_t(_PyTime_t t, time_t *p_secs, int *us, _PyTime_AsTimevalTime_t(PyTime_t t, time_t *p_secs, int *us,
_PyTime_round_t round) _PyTime_round_t round)
{ {
_PyTime_t secs; PyTime_t secs;
if (pytime_as_timeval(t, &secs, us, round) < 0) { if (pytime_as_timeval(t, &secs, us, round) < 0) {
pytime_time_t_overflow(); pytime_time_t_overflow();
return -1; return -1;
@ -886,10 +886,10 @@ _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 t, struct timespec *ts, int raise_exc)
{ {
_PyTime_t ns = pytime_as_nanoseconds(t); 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);
int res2 = _PyTime_AsTime_t(tv_sec, &ts->tv_sec); int res2 = _PyTime_AsTime_t(tv_sec, &ts->tv_sec);
@ -906,13 +906,13 @@ pytime_as_timespec(_PyTime_t t, struct timespec *ts, int raise_exc)
} }
void void
_PyTime_AsTimespec_clamp(_PyTime_t t, struct timespec *ts) _PyTime_AsTimespec_clamp(PyTime_t t, struct timespec *ts)
{ {
(void)pytime_as_timespec(t, ts, 0); (void)pytime_as_timespec(t, ts, 0);
} }
int int
_PyTime_AsTimespec(_PyTime_t t, struct timespec *ts) _PyTime_AsTimespec(PyTime_t t, struct timespec *ts)
{ {
return pytime_as_timespec(t, ts, 1); return pytime_as_timespec(t, ts, 1);
} }
@ -921,7 +921,7 @@ _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts)
// N.B. If raise_exc=0, this may be called without the GIL. // N.B. If raise_exc=0, this may be called without the GIL.
static int static int
py_get_system_clock(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc) py_get_system_clock(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
{ {
assert(info == NULL || raise_exc); assert(info == NULL || raise_exc);
@ -935,7 +935,7 @@ py_get_system_clock(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
/* 11,644,473,600,000,000,000: number of nanoseconds between /* 11,644,473,600,000,000,000: number of nanoseconds between
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 = pytime_from_nanoseconds(ns);
if (info) { if (info) {
DWORD timeAdjustment, timeIncrement; DWORD timeAdjustment, timeIncrement;
@ -1031,10 +1031,10 @@ py_get_system_clock(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
} }
_PyTime_t PyTime_t
_PyTime_GetSystemClock(void) _PyTime_GetSystemClock(void)
{ {
_PyTime_t t; PyTime_t t;
if (py_get_system_clock(&t, NULL, 0) < 0) { if (py_get_system_clock(&t, NULL, 0) < 0) {
// If clock_gettime(CLOCK_REALTIME) or gettimeofday() fails: // If clock_gettime(CLOCK_REALTIME) or gettimeofday() fails:
// silently ignore the failure and return 0. // silently ignore the failure and return 0.
@ -1057,7 +1057,7 @@ PyTime_Time(PyTime_t *result)
} }
int int
_PyTime_GetSystemClockWithInfo(_PyTime_t *t, _Py_clock_info_t *info) _PyTime_GetSystemClockWithInfo(PyTime_t *t, _Py_clock_info_t *info)
{ {
return py_get_system_clock(t, info, 1); return py_get_system_clock(t, info, 1);
} }
@ -1073,13 +1073,13 @@ py_mach_timebase_info(_PyTimeFraction *base, int raise)
(void)mach_timebase_info(&timebase); (void)mach_timebase_info(&timebase);
// Check that timebase.numer and timebase.denom can be casted to // Check that timebase.numer and timebase.denom can be casted to
// _PyTime_t. In practice, timebase uses uint32_t, so casting cannot // PyTime_t. In practice, timebase uses uint32_t, so casting cannot
// overflow. At the end, only make sure that the type is uint32_t // overflow. At the end, only make sure that the type is uint32_t
// (_PyTime_t is 64-bit long). // (PyTime_t is 64-bit long).
Py_BUILD_ASSERT(sizeof(timebase.numer) <= sizeof(_PyTime_t)); Py_BUILD_ASSERT(sizeof(timebase.numer) <= sizeof(PyTime_t));
Py_BUILD_ASSERT(sizeof(timebase.denom) <= sizeof(_PyTime_t)); Py_BUILD_ASSERT(sizeof(timebase.denom) <= sizeof(PyTime_t));
_PyTime_t numer = (_PyTime_t)timebase.numer; PyTime_t numer = (PyTime_t)timebase.numer;
_PyTime_t denom = (_PyTime_t)timebase.denom; PyTime_t denom = (PyTime_t)timebase.denom;
// Known time bases: // Known time bases:
// //
@ -1100,21 +1100,21 @@ py_mach_timebase_info(_PyTimeFraction *base, int raise)
// N.B. If raise_exc=0, this may be called without the GIL. // N.B. If raise_exc=0, this may be called without the GIL.
static int static int
py_get_monotonic_clock(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc) py_get_monotonic_clock(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
{ {
assert(info == NULL || raise_exc); assert(info == NULL || raise_exc);
#if defined(MS_WINDOWS) #if defined(MS_WINDOWS)
ULONGLONG ticks = GetTickCount64(); ULONGLONG ticks = GetTickCount64();
static_assert(sizeof(ticks) <= sizeof(_PyTime_t), static_assert(sizeof(ticks) <= sizeof(PyTime_t),
"ULONGLONG is larger than _PyTime_t"); "ULONGLONG is larger than PyTime_t");
_PyTime_t t; PyTime_t t;
if (ticks <= (ULONGLONG)PyTime_MAX) { if (ticks <= (ULONGLONG)PyTime_MAX) {
t = (_PyTime_t)ticks; t = (PyTime_t)ticks;
} }
else { else {
// GetTickCount64() maximum is larger than _PyTime_t maximum: // GetTickCount64() maximum is larger than PyTime_t maximum:
// ULONGLONG is unsigned, whereas _PyTime_t is signed. // ULONGLONG is unsigned, whereas PyTime_t is signed.
t = PyTime_MAX; t = PyTime_MAX;
} }
@ -1159,9 +1159,9 @@ py_get_monotonic_clock(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
uint64_t uticks = mach_absolute_time(); uint64_t uticks = mach_absolute_time();
// unsigned => signed // unsigned => signed
assert(uticks <= (uint64_t)PyTime_MAX); assert(uticks <= (uint64_t)PyTime_MAX);
_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 = pytime_from_nanoseconds(ns);
#elif defined(__hpux) #elif defined(__hpux)
@ -1223,10 +1223,10 @@ py_get_monotonic_clock(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
} }
_PyTime_t PyTime_t
_PyTime_GetMonotonicClock(void) _PyTime_GetMonotonicClock(void)
{ {
_PyTime_t t; PyTime_t t;
if (py_get_monotonic_clock(&t, NULL, 0) < 0) { if (py_get_monotonic_clock(&t, NULL, 0) < 0) {
// If mach_timebase_info(), clock_gettime() or gethrtime() fails: // If mach_timebase_info(), clock_gettime() or gethrtime() fails:
// silently ignore the failure and return 0. // silently ignore the failure and return 0.
@ -1248,7 +1248,7 @@ PyTime_Monotonic(PyTime_t *result)
int int
_PyTime_GetMonotonicClockWithInfo(_PyTime_t *tp, _Py_clock_info_t *info) _PyTime_GetMonotonicClockWithInfo(PyTime_t *tp, _Py_clock_info_t *info)
{ {
return py_get_monotonic_clock(tp, info, 1); return py_get_monotonic_clock(tp, info, 1);
} }
@ -1268,8 +1268,8 @@ py_win_perf_counter_frequency(_PyTimeFraction *base, int raise)
// Since Windows XP, frequency cannot be zero. // Since Windows XP, frequency cannot be zero.
assert(frequency >= 1); assert(frequency >= 1);
Py_BUILD_ASSERT(sizeof(_PyTime_t) == sizeof(frequency)); Py_BUILD_ASSERT(sizeof(PyTime_t) == sizeof(frequency));
_PyTime_t denom = (_PyTime_t)frequency; PyTime_t denom = (PyTime_t)frequency;
// Known QueryPerformanceFrequency() values: // Known QueryPerformanceFrequency() values:
// //
@ -1288,7 +1288,7 @@ py_win_perf_counter_frequency(_PyTimeFraction *base, int raise)
// N.B. If raise_exc=0, this may be called without the GIL. // N.B. If raise_exc=0, this may be called without the GIL.
static int static int
py_get_win_perf_counter(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc) py_get_win_perf_counter(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
{ {
assert(info == NULL || raise_exc); assert(info == NULL || raise_exc);
@ -1310,14 +1310,14 @@ py_get_win_perf_counter(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
QueryPerformanceCounter(&now); QueryPerformanceCounter(&now);
LONGLONG ticksll = now.QuadPart; LONGLONG ticksll = now.QuadPart;
/* Make sure that casting LONGLONG to _PyTime_t cannot overflow, /* Make sure that casting LONGLONG to PyTime_t cannot overflow,
both types are signed */ both types are signed */
_PyTime_t ticks; PyTime_t ticks;
static_assert(sizeof(ticksll) <= sizeof(ticks), static_assert(sizeof(ticksll) <= sizeof(ticks),
"LONGLONG is larger than _PyTime_t"); "LONGLONG is larger than PyTime_t");
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 = pytime_from_nanoseconds(ns);
return 0; return 0;
} }
@ -1325,7 +1325,7 @@ py_get_win_perf_counter(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
int int
_PyTime_GetPerfCounterWithInfo(_PyTime_t *t, _Py_clock_info_t *info) _PyTime_GetPerfCounterWithInfo(PyTime_t *t, _Py_clock_info_t *info)
{ {
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
return py_get_win_perf_counter(t, info, 1); return py_get_win_perf_counter(t, info, 1);
@ -1335,10 +1335,10 @@ _PyTime_GetPerfCounterWithInfo(_PyTime_t *t, _Py_clock_info_t *info)
} }
_PyTime_t PyTime_t
_PyTime_GetPerfCounter(void) _PyTime_GetPerfCounter(void)
{ {
_PyTime_t t; PyTime_t t;
int res; int res;
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
res = py_get_win_perf_counter(&t, NULL, 0); res = py_get_win_perf_counter(&t, NULL, 0);
@ -1440,17 +1440,17 @@ _PyTime_gmtime(time_t t, struct tm *tm)
} }
_PyTime_t PyTime_t
_PyDeadline_Init(_PyTime_t timeout) _PyDeadline_Init(PyTime_t timeout)
{ {
_PyTime_t now = _PyTime_GetMonotonicClock(); PyTime_t now = _PyTime_GetMonotonicClock();
return _PyTime_Add(now, timeout); return _PyTime_Add(now, timeout);
} }
_PyTime_t PyTime_t
_PyDeadline_Get(_PyTime_t deadline) _PyDeadline_Get(PyTime_t deadline)
{ {
_PyTime_t now = _PyTime_GetMonotonicClock(); PyTime_t now = _PyTime_GetMonotonicClock();
return deadline - now; return deadline - now;
} }

6
Python/thread.c
View file

@ -107,7 +107,7 @@ PyThread_ParseTimeoutArg(PyObject *arg, int blocking, PY_TIMEOUT_T *timeout_p)
return -1; return -1;
} }
_PyTime_t timeout; PyTime_t timeout;
if (_PyTime_FromSecondsObject(&timeout, arg, _PyTime_ROUND_TIMEOUT) < 0) { if (_PyTime_FromSecondsObject(&timeout, arg, _PyTime_ROUND_TIMEOUT) < 0) {
return -1; return -1;
} }
@ -132,14 +132,14 @@ PyThread_acquire_lock_timed_with_retries(PyThread_type_lock lock,
PY_TIMEOUT_T timeout) PY_TIMEOUT_T timeout)
{ {
PyThreadState *tstate = _PyThreadState_GET(); PyThreadState *tstate = _PyThreadState_GET();
_PyTime_t endtime = 0; PyTime_t endtime = 0;
if (timeout > 0) { if (timeout > 0) {
endtime = _PyDeadline_Init(timeout); endtime = _PyDeadline_Init(timeout);
} }
PyLockStatus r; PyLockStatus r;
do { do {
_PyTime_t microseconds; PyTime_t microseconds;
microseconds = _PyTime_AsMicroseconds(timeout, _PyTime_ROUND_CEILING); microseconds = _PyTime_AsMicroseconds(timeout, _PyTime_ROUND_CEILING);
/* first a simple non-blocking try without releasing the GIL */ /* first a simple non-blocking try without releasing the GIL */

6
Python/thread_nt.h
View file

@ -76,10 +76,10 @@ 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_FromNanoseconds((PyTime_t)milliseconds * 1000000);
_PyTime_t deadline = _PyTime_Add(_PyTime_GetPerfCounter(), nanoseconds); PyTime_t deadline = _PyTime_Add(_PyTime_GetPerfCounter(), nanoseconds);
while (mutex->locked) { while (mutex->locked) {
_PyTime_t microseconds = _PyTime_AsMicroseconds(nanoseconds, PyTime_t microseconds = _PyTime_AsMicroseconds(nanoseconds,
_PyTime_ROUND_TIMEOUT); _PyTime_ROUND_TIMEOUT);
if (PyCOND_TIMEDWAIT(&mutex->cv, &mutex->cs, microseconds) < 0) { if (PyCOND_TIMEDWAIT(&mutex->cv, &mutex->cs, microseconds) < 0) {
result = WAIT_FAILED; result = WAIT_FAILED;

12
Python/thread_pthread.h
View file

@ -149,8 +149,8 @@ _PyThread_cond_init(PyCOND_T *cond)
void void
_PyThread_cond_after(long long us, struct timespec *abs) _PyThread_cond_after(long long us, struct timespec *abs)
{ {
_PyTime_t timeout = _PyTime_FromMicrosecondsClamp(us); PyTime_t timeout = _PyTime_FromMicrosecondsClamp(us);
_PyTime_t t; PyTime_t t;
#ifdef CONDATTR_MONOTONIC #ifdef CONDATTR_MONOTONIC
if (condattr_monotonic) { if (condattr_monotonic) {
t = _PyTime_GetMonotonicClock(); t = _PyTime_GetMonotonicClock();
@ -481,7 +481,7 @@ PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,
(void) error; /* silence unused-but-set-variable warning */ (void) error; /* silence unused-but-set-variable warning */
_PyTime_t timeout; // relative timeout PyTime_t timeout; // relative timeout
if (microseconds >= 0) { if (microseconds >= 0) {
// bpo-41710: PyThread_acquire_lock_timed() cannot report timeout // bpo-41710: PyThread_acquire_lock_timed() cannot report timeout
// overflow to the caller, so clamp the timeout to // overflow to the caller, so clamp the timeout to
@ -501,11 +501,11 @@ PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,
struct timespec abs_timeout; struct timespec abs_timeout;
// Local scope for deadline // Local scope for deadline
{ {
_PyTime_t deadline = _PyTime_Add(_PyTime_GetMonotonicClock(), timeout); PyTime_t deadline = _PyTime_Add(_PyTime_GetMonotonicClock(), timeout);
_PyTime_AsTimespec_clamp(deadline, &abs_timeout); _PyTime_AsTimespec_clamp(deadline, &abs_timeout);
} }
#else #else
_PyTime_t deadline = 0; PyTime_t deadline = 0;
if (timeout > 0 && !intr_flag) { if (timeout > 0 && !intr_flag) {
deadline = _PyDeadline_Init(timeout); deadline = _PyDeadline_Init(timeout);
} }
@ -517,7 +517,7 @@ PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,
status = fix_status(sem_clockwait(thelock, CLOCK_MONOTONIC, status = fix_status(sem_clockwait(thelock, CLOCK_MONOTONIC,
&abs_timeout)); &abs_timeout));
#else #else
_PyTime_t abs_time = _PyTime_Add(_PyTime_GetSystemClock(), PyTime_t abs_time = _PyTime_Add(_PyTime_GetSystemClock(),
timeout); timeout);
struct timespec ts; struct timespec ts;
_PyTime_AsTimespec_clamp(abs_time, &ts); _PyTime_AsTimespec_clamp(abs_time, &ts);