/*[clinic end generated code: output=da39a3ee5e6b4b0d input=a668a08771581f36]*/
-#if defined(HAVE_TIMES) || defined(HAVE_CLOCK)
-static int
-check_ticks_per_second(long tps, const char *context)
-{
- /* Effectively, check that _PyTime_MulDiv(t, SEC_TO_NS, tps)
- cannot overflow. */
- if (tps >= 0 && (_PyTime_t)tps > _PyTime_MAX / SEC_TO_NS) {
- PyErr_Format(PyExc_OverflowError, "%s is too large", context);
- return -1;
- }
- if (tps < 1) {
- PyErr_Format(PyExc_RuntimeError, "invalid %s", context);
- return -1;
- }
- return 0;
-}
-#endif /* HAVE_TIMES || HAVE_CLOCK */
-
-
/* Forward declarations */
static int pysleep(_PyTime_t timeout);
PyTypeObject *struct_time_type;
#ifdef HAVE_TIMES
// times() clock frequency in hertz
- long ticks_per_second;
+ _PyTimeFraction times_base;
#endif
#ifdef HAVE_CLOCK
// clock() frequency in hertz
- long clocks_per_second;
+ _PyTimeFraction clock_base;
#endif
} time_module_state;
static int
py_clock(time_module_state *state, _PyTime_t *tp, _Py_clock_info_t *info)
{
- long clocks_per_second = state->clocks_per_second;
+ _PyTimeFraction *base = &state->clock_base;
+
if (info) {
info->implementation = "clock()";
- info->resolution = 1.0 / (double)clocks_per_second;
+ info->resolution = _PyTimeFraction_Resolution(base);
info->monotonic = 1;
info->adjustable = 0;
}
"or its value cannot be represented");
return -1;
}
- _PyTime_t ns = _PyTime_MulDiv(ticks, SEC_TO_NS, clocks_per_second);
+ _PyTime_t ns = _PyTimeFraction_Mul(ticks, base);
*tp = _PyTime_FromNanoseconds(ns);
return 0;
}
process_time_times(time_module_state *state, _PyTime_t *tp,
_Py_clock_info_t *info)
{
- long ticks_per_second = state->ticks_per_second;
+ _PyTimeFraction *base = &state->times_base;
struct tms process;
if (times(&process) == (clock_t)-1) {
if (info) {
info->implementation = "times()";
+ info->resolution = _PyTimeFraction_Resolution(base);
info->monotonic = 1;
info->adjustable = 0;
- info->resolution = 1.0 / (double)ticks_per_second;
}
_PyTime_t ns;
- ns = _PyTime_MulDiv(process.tms_utime, SEC_TO_NS, ticks_per_second);
- ns += _PyTime_MulDiv(process.tms_stime, SEC_TO_NS, ticks_per_second);
+ ns = _PyTimeFraction_Mul(process.tms_utime, base);
+ ns += _PyTimeFraction_Mul(process.tms_stime, base);
*tp = _PyTime_FromNanoseconds(ns);
return 1;
}
// times() failed, ignore failure
#endif
- /* clock */
- /* Currently, Python 3 requires clock() to build: see issue #22624 */
+ /* clock(). Python 3 requires clock() to build (see gh-66814) */
return py_clock(state, tp, info);
#endif
}
#endif
#ifdef HAVE_TIMES
- if (_Py_GetTicksPerSecond(&state->ticks_per_second) < 0) {
+ long ticks_per_second;
+ if (_Py_GetTicksPerSecond(&ticks_per_second) < 0) {
PyErr_SetString(PyExc_RuntimeError,
"cannot read ticks_per_second");
return -1;
}
-
- if (check_ticks_per_second(state->ticks_per_second, "_SC_CLK_TCK") < 0) {
+ if (_PyTimeFraction_Set(&state->times_base, SEC_TO_NS,
+ ticks_per_second) < 0) {
+ PyErr_Format(PyExc_OverflowError, "ticks_per_second is too large");
return -1;
}
#endif
#ifdef HAVE_CLOCK
- state->clocks_per_second = CLOCKS_PER_SEC;
- if (check_ticks_per_second(state->clocks_per_second, "CLOCKS_PER_SEC") < 0) {
+ if (_PyTimeFraction_Set(&state->clock_base, SEC_TO_NS,
+ CLOCKS_PER_SEC) < 0) {
+ PyErr_Format(PyExc_OverflowError, "CLOCKS_PER_SEC is too large");
return -1;
}
#endif
#endif
+static _PyTime_t
+_PyTime_GCD(_PyTime_t x, _PyTime_t y)
+{
+ // Euclidean algorithm
+ assert(x >= 1);
+ assert(y >= 1);
+ while (y != 0) {
+ _PyTime_t tmp = y;
+ y = x % y;
+ x = tmp;
+ }
+ assert(x >= 1);
+ return x;
+}
+
+
+int
+_PyTimeFraction_Set(_PyTimeFraction *frac, _PyTime_t numer, _PyTime_t denom)
+{
+ if (numer < 1 || denom < 1) {
+ return -1;
+ }
+
+ _PyTime_t gcd = _PyTime_GCD(numer, denom);
+ frac->numer = numer / gcd;
+ frac->denom = denom / gcd;
+ return 0;
+}
+
+
+double
+_PyTimeFraction_Resolution(const _PyTimeFraction *frac)
+{
+ return (double)frac->numer / (double)frac->denom / 1e9;
+}
+
+
static void
pytime_time_t_overflow(void)
{
}
-
-
_PyTime_t
-_PyTime_MulDiv(_PyTime_t ticks, _PyTime_t mul, _PyTime_t div)
+_PyTimeFraction_Mul(_PyTime_t ticks, const _PyTimeFraction *frac)
{
+ const _PyTime_t mul = frac->numer;
+ const _PyTime_t div = frac->denom;
+
+ if (div == 1) {
+ // Fast-path taken by mach_absolute_time() with 1/1 time base.
+ return _PyTime_Mul(ticks, mul);
+ }
+
/* Compute (ticks * mul / div) in two parts to reduce the risk of integer
overflow: compute the integer part, and then the remaining part.
#ifdef __APPLE__
static int
-py_mach_timebase_info(_PyTime_t *pnumer, _PyTime_t *pdenom, int raise)
+py_mach_timebase_info(_PyTimeFraction *base, int raise)
{
- static mach_timebase_info_data_t timebase;
- /* According to the Technical Q&A QA1398, mach_timebase_info() cannot
- fail: https://developer.apple.com/library/mac/#qa/qa1398/ */
+ mach_timebase_info_data_t timebase;
+ // According to the Technical Q&A QA1398, mach_timebase_info() cannot
+ // fail: https://developer.apple.com/library/mac/#qa/qa1398/
(void)mach_timebase_info(&timebase);
- /* Sanity check: should never occur in practice */
- if (timebase.numer < 1 || timebase.denom < 1) {
+ // Check that timebase.numer and timebase.denom can be casted to
+ // _PyTime_t. In practice, timebase uses uint32_t, so casting cannot
+ // overflow. At the end, only make sure that the type is uint32_t
+ // (_PyTime_t is 64-bit long).
+ Py_BUILD_ASSERT(sizeof(timebase.numer) <= sizeof(_PyTime_t));
+ Py_BUILD_ASSERT(sizeof(timebase.denom) <= sizeof(_PyTime_t));
+ _PyTime_t numer = (_PyTime_t)timebase.numer;
+ _PyTime_t denom = (_PyTime_t)timebase.denom;
+
+ // Known time bases:
+ //
+ // * (1, 1) on Intel: 1 ns
+ // * (1000000000, 33333335) on PowerPC: ~30 ns
+ // * (1000000000, 25000000) on PowerPC: 40 ns
+ if (_PyTimeFraction_Set(base, numer, denom) < 0) {
if (raise) {
PyErr_SetString(PyExc_RuntimeError,
"invalid mach_timebase_info");
}
return -1;
}
-
- /* Check that timebase.numer and timebase.denom can be casted to
- _PyTime_t. In practice, timebase uses uint32_t, so casting cannot
- overflow. At the end, only make sure that the type is uint32_t
- (_PyTime_t is 64-bit long). */
- static_assert(sizeof(timebase.numer) <= sizeof(_PyTime_t),
- "timebase.numer is larger than _PyTime_t");
- static_assert(sizeof(timebase.denom) <= sizeof(_PyTime_t),
- "timebase.denom is larger than _PyTime_t");
-
- /* Make sure that _PyTime_MulDiv(ticks, timebase_numer, timebase_denom)
- cannot overflow.
-
- Known time bases:
-
- * (1, 1) on Intel
- * (1000000000, 33333335) or (1000000000, 25000000) on PowerPC
-
- None of these time bases can overflow with 64-bit _PyTime_t, but
- check for overflow, just in case. */
- if ((_PyTime_t)timebase.numer > _PyTime_MAX / (_PyTime_t)timebase.denom) {
- if (raise) {
- PyErr_SetString(PyExc_OverflowError,
- "mach_timebase_info is too large");
- }
- return -1;
- }
-
- *pnumer = (_PyTime_t)timebase.numer;
- *pdenom = (_PyTime_t)timebase.denom;
return 0;
}
#endif
}
#elif defined(__APPLE__)
- static _PyTime_t timebase_numer = 0;
- static _PyTime_t timebase_denom = 0;
- if (timebase_denom == 0) {
- if (py_mach_timebase_info(&timebase_numer, &timebase_denom, raise_exc) < 0) {
+ static _PyTimeFraction base = {0, 0};
+ if (base.denom == 0) {
+ if (py_mach_timebase_info(&base, raise_exc) < 0) {
return -1;
}
}
if (info) {
info->implementation = "mach_absolute_time()";
- info->resolution = (double)timebase_numer / (double)timebase_denom * 1e-9;
+ info->resolution = _PyTimeFraction_Resolution(&base);
info->monotonic = 1;
info->adjustable = 0;
}
assert(uticks <= (uint64_t)_PyTime_MAX);
_PyTime_t ticks = (_PyTime_t)uticks;
- _PyTime_t ns = _PyTime_MulDiv(ticks, timebase_numer, timebase_denom);
+ _PyTime_t ns = _PyTimeFraction_Mul(ticks, &base);
*tp = pytime_from_nanoseconds(ns);
#elif defined(__hpux)
#ifdef MS_WINDOWS
static int
-py_win_perf_counter_frequency(LONGLONG *pfrequency, int raise)
+py_win_perf_counter_frequency(_PyTimeFraction *base, int raise)
{
LONGLONG frequency;
// Since Windows XP, frequency cannot be zero.
assert(frequency >= 1);
- /* Make also sure that (ticks * SEC_TO_NS) cannot overflow in
- _PyTime_MulDiv(), with ticks < frequency.
+ Py_BUILD_ASSERT(sizeof(_PyTime_t) == sizeof(frequency));
+ _PyTime_t denom = (_PyTime_t)frequency;
- Known QueryPerformanceFrequency() values:
-
- * 10,000,000 (10 MHz): 100 ns resolution
- * 3,579,545 Hz (3.6 MHz): 279 ns resolution
-
- None of these frequencies can overflow with 64-bit _PyTime_t, but
- check for integer overflow just in case. */
- if (frequency > _PyTime_MAX / SEC_TO_NS) {
+ // Known QueryPerformanceFrequency() values:
+ //
+ // * 10,000,000 (10 MHz): 100 ns resolution
+ // * 3,579,545 Hz (3.6 MHz): 279 ns resolution
+ if (_PyTimeFraction_Set(base, SEC_TO_NS, denom) < 0) {
if (raise) {
- PyErr_SetString(PyExc_OverflowError,
- "QueryPerformanceFrequency is too large");
+ PyErr_SetString(PyExc_RuntimeError,
+ "invalid QueryPerformanceFrequency");
}
return -1;
}
-
- *pfrequency = frequency;
return 0;
}
{
assert(info == NULL || raise_exc);
- static LONGLONG frequency = 0;
- if (frequency == 0) {
- if (py_win_perf_counter_frequency(&frequency, raise_exc) < 0) {
+ static _PyTimeFraction base = {0, 0};
+ if (base.denom == 0) {
+ if (py_win_perf_counter_frequency(&base, raise_exc) < 0) {
return -1;
}
}
if (info) {
info->implementation = "QueryPerformanceCounter()";
- info->resolution = 1.0 / (double)frequency;
+ info->resolution = _PyTimeFraction_Resolution(&base);
info->monotonic = 1;
info->adjustable = 0;
}
"LONGLONG is larger than _PyTime_t");
ticks = (_PyTime_t)ticksll;
- _PyTime_t ns = _PyTime_MulDiv(ticks, SEC_TO_NS, (_PyTime_t)frequency);
+ _PyTime_t ns = _PyTimeFraction_Mul(ticks, &base);
*tp = pytime_from_nanoseconds(ns);
return 0;
}
projects / thirdparty / Python / cpython.git / commitdiff
