Add 64-bit tick fast paths to `absl::IDivDuration` When dividing a non-negative `Duration` up to `kint64max / kTicksPerSecond` (~73 years) by a positive sub-second divisor in `IDivFastPath`, compute quotient and remainder directly in `uint64_t` quarter-nanosecond ticks instead of falling back to 128-bit `uint128` division. In `IDivSlowPath`, also use 64-bit unsigned division when both `MakeU128Ticks` operands fit in `uint64_t` (`(Uint128High64(a) | Uint128High64(b)) == 0`). PiperOrigin-RevId: 1011671250
diff --git a/absl/time/duration.cc b/absl/time/duration.cc index 160e253..5a31f5d 100644 --- a/absl/time/duration.cc +++ b/absl/time/duration.cc
@@ -314,6 +314,15 @@ *rem = time_internal::MakeDuration(0, num_lo % den_lo); return true; } + } else if (den_lo != 0 && num_hi >= 0 && + static_cast<uint64_t>(num_hi) < + static_cast<uint64_t>(kint64max) / kTicksPerSecond) { + const uint64_t num_ticks = + static_cast<uint64_t>(num_hi) * kTicksPerSecond + num_lo; + *q = static_cast<int64_t>(num_ticks / den_lo); + *rem = time_internal::MakeDuration( + 0, static_cast<uint32_t>(num_ticks % den_lo)); + return true; } } else if (den_hi > 0 && den_lo == 0) { // Dividing by positive multiple of 1s @@ -368,17 +377,29 @@ const uint128 a = MakeU128Ticks(num); const uint128 b = MakeU128Ticks(den); - uint128 quotient128 = a / b; - - if (satq) { - // Limits the quotient to the range of int64_t. - if (quotient128 > uint128(static_cast<uint64_t>(kint64max))) { - quotient128 = quotient_neg ? uint128(static_cast<uint64_t>(kint64min)) - : uint128(static_cast<uint64_t>(kint64max)); + uint128 quotient128; + uint128 remainder128; + if ((Uint128High64(a) | Uint128High64(b)) == 0) { + const uint64_t a64 = Uint128Low64(a); + const uint64_t b64 = Uint128Low64(b); + uint64_t q64 = a64 / b64; + if (satq && q64 > static_cast<uint64_t>(kint64max)) { + q64 = quotient_neg ? static_cast<uint64_t>(kint64min) + : static_cast<uint64_t>(kint64max); } + quotient128 = q64; + remainder128 = a64 - q64 * b64; + } else { + quotient128 = a / b; + if (satq) { + // Limits the quotient to the range of int64_t. + if (quotient128 > uint128(static_cast<uint64_t>(kint64max))) { + quotient128 = quotient_neg ? uint128(static_cast<uint64_t>(kint64min)) + : uint128(static_cast<uint64_t>(kint64max)); + } + } + remainder128 = a - quotient128 * b; } - - const uint128 remainder128 = a - quotient128 * b; *rem = MakeDurationFromU128(remainder128, num_neg); if (!quotient_neg || quotient128 == 0) {
diff --git a/absl/time/duration_test.cc b/absl/time/duration_test.cc index 6645c53..c712c61 100644 --- a/absl/time/duration_test.cc +++ b/absl/time/duration_test.cc
@@ -1909,4 +1909,47 @@ EXPECT_EQ(alignof(NoPadding), alignof(absl::Duration)); } +TEST(Duration, IDivDurationFastPathBoundaries) { + // Exercise 64-bit tick IDivDuration boundaries around + // kint64max / kTicksPerSecond (2305843009s) and uint64_max / kTicksPerSecond + // (4611686018s) across both sub-second and multi-second divisors. + const absl::Duration kDivisors[] = { + absl::Nanoseconds(7) + absl::Nanoseconds(1) / 4, + absl::Seconds(1) + absl::Milliseconds(500), + }; + for (absl::Duration den : kDivisors) { + for (int64_t sec : + {int64_t{0}, int64_t{1}, int64_t{2305843008}, int64_t{2305843009}, + int64_t{2305843010}, int64_t{4611686018}, int64_t{4611686019}}) { + const absl::Duration num = absl::Seconds(sec) + + absl::Nanoseconds(999999999) + + absl::Nanoseconds(3) / 4; + absl::Duration rem; + const int64_t q = absl::IDivDuration(num, den, &rem); + if (q < std::numeric_limits<int64_t>::max()) { + EXPECT_EQ(num, q * den + rem); + EXPECT_GE(rem, absl::ZeroDuration()); + EXPECT_LT(rem, den); + } + absl::Duration neg_rem; + EXPECT_EQ(-q, absl::IDivDuration(-num, den, &neg_rem)); + EXPECT_EQ(-rem, neg_rem); + EXPECT_EQ(-q, absl::IDivDuration(num, -den, &neg_rem)); + EXPECT_EQ(rem, neg_rem); + EXPECT_EQ(q, absl::IDivDuration(-num, -den, &neg_rem)); + EXPECT_EQ(-rem, neg_rem); + } + } + + // Exercise 64-bit IDivSlowPath saturation when ticks fit in uint64_t + // (4611686018s * 4e9 < 2^64) while quotient exceeds int64_t. + const absl::Duration large_u64 = absl::Seconds(4611686018); + const absl::Duration quarter_ns = absl::Nanoseconds(1) / 4; + absl::Duration sat_rem; + EXPECT_EQ(std::numeric_limits<int64_t>::min(), + absl::IDivDuration(large_u64, -quarter_ns, &sat_rem)); + EXPECT_EQ(std::numeric_limits<int64_t>::max(), + absl::IDivDuration(-large_u64, -quarter_ns, &sat_rem)); +} + } // namespace