Adds signed infinity to timestamps.
Negative infinity is useful in comparisons as it represents a value
guaranteed to be less than any other timestamp. This avoid using
Timestamp::ms(0) to represent such a value or having to use optional
for the special case of first time execution.
To avoid ambiguity, Timestamp::Infinity is renamed to PlusInfinity.
Bug: webrtc:9709
Change-Id: Ib2debff91036e94d1dc903ec0c6faae30febde4e
Reviewed-on: https://webrtc-review.googlesource.com/79440
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24556}diff --git a/api/transport/network_types.cc b/api/transport/network_types.cc
index b4c09d4..48bdcab 100644
--- a/api/transport/network_types.cc
+++ b/api/transport/network_types.cc
@@ -48,7 +48,7 @@
std::vector<PacketResult> TransportPacketsFeedback::LostWithSendInfo() const {
std::vector<PacketResult> res;
for (const PacketResult& fb : packet_feedbacks) {
- if (fb.receive_time.IsInfinite() && fb.sent_packet.has_value()) {
+ if (fb.receive_time.IsPlusInfinity() && fb.sent_packet.has_value()) {
res.push_back(fb);
}
}
diff --git a/api/transport/network_types.h b/api/transport/network_types.h
index e34bf0e..eee1de0 100644
--- a/api/transport/network_types.h
+++ b/api/transport/network_types.h
@@ -30,7 +30,7 @@
StreamsConfig();
StreamsConfig(const StreamsConfig&);
~StreamsConfig();
- Timestamp at_time = Timestamp::Infinity();
+ Timestamp at_time = Timestamp::PlusInfinity();
bool requests_alr_probing = false;
absl::optional<double> pacing_factor;
absl::optional<DataRate> min_pacing_rate;
@@ -42,7 +42,7 @@
TargetRateConstraints();
TargetRateConstraints(const TargetRateConstraints&);
~TargetRateConstraints();
- Timestamp at_time = Timestamp::Infinity();
+ Timestamp at_time = Timestamp::PlusInfinity();
absl::optional<DataRate> min_data_rate;
absl::optional<DataRate> max_data_rate;
// The initial bandwidth estimate to base target rate on. This should be used
@@ -53,7 +53,7 @@
// Send side information
struct NetworkAvailability {
- Timestamp at_time = Timestamp::Infinity();
+ Timestamp at_time = Timestamp::PlusInfinity();
bool network_available = false;
};
@@ -61,7 +61,7 @@
NetworkRouteChange();
NetworkRouteChange(const NetworkRouteChange&);
~NetworkRouteChange();
- Timestamp at_time = Timestamp::Infinity();
+ Timestamp at_time = Timestamp::PlusInfinity();
// The TargetRateConstraints are set here so they can be changed synchronously
// when network route changes.
TargetRateConstraints constraints;
@@ -84,7 +84,7 @@
};
struct SentPacket {
- Timestamp send_time = Timestamp::Infinity();
+ Timestamp send_time = Timestamp::PlusInfinity();
DataSize size = DataSize::Zero();
PacedPacketInfo pacing_info;
// Transport independent sequence number, any tracked packet should have a
@@ -98,20 +98,20 @@
// Transport level feedback
struct RemoteBitrateReport {
- Timestamp receive_time = Timestamp::Infinity();
+ Timestamp receive_time = Timestamp::PlusInfinity();
DataRate bandwidth = DataRate::Infinity();
};
struct RoundTripTimeUpdate {
- Timestamp receive_time = Timestamp::Infinity();
+ Timestamp receive_time = Timestamp::PlusInfinity();
TimeDelta round_trip_time = TimeDelta::PlusInfinity();
bool smoothed = false;
};
struct TransportLossReport {
- Timestamp receive_time = Timestamp::Infinity();
- Timestamp start_time = Timestamp::Infinity();
- Timestamp end_time = Timestamp::Infinity();
+ Timestamp receive_time = Timestamp::PlusInfinity();
+ Timestamp start_time = Timestamp::PlusInfinity();
+ Timestamp end_time = Timestamp::PlusInfinity();
uint64_t packets_lost_delta = 0;
uint64_t packets_received_delta = 0;
};
@@ -124,7 +124,7 @@
~PacketResult();
absl::optional<SentPacket> sent_packet;
- Timestamp receive_time = Timestamp::Infinity();
+ Timestamp receive_time = Timestamp::PlusInfinity();
};
struct TransportPacketsFeedback {
@@ -132,7 +132,7 @@
TransportPacketsFeedback(const TransportPacketsFeedback& other);
~TransportPacketsFeedback();
- Timestamp feedback_time = Timestamp::Infinity();
+ Timestamp feedback_time = Timestamp::PlusInfinity();
DataSize data_in_flight = DataSize::Zero();
DataSize prior_in_flight = DataSize::Zero();
std::vector<PacketResult> packet_feedbacks;
@@ -145,7 +145,7 @@
// Network estimation
struct NetworkEstimate {
- Timestamp at_time = Timestamp::Infinity();
+ Timestamp at_time = Timestamp::PlusInfinity();
DataRate bandwidth = DataRate::Infinity();
TimeDelta round_trip_time = TimeDelta::PlusInfinity();
TimeDelta bwe_period = TimeDelta::PlusInfinity();
@@ -156,7 +156,7 @@
// Network control
struct PacerConfig {
- Timestamp at_time = Timestamp::Infinity();
+ Timestamp at_time = Timestamp::PlusInfinity();
// Pacer should send at most data_window data over time_window duration.
DataSize data_window = DataSize::Infinity();
TimeDelta time_window = TimeDelta::PlusInfinity();
@@ -167,14 +167,14 @@
};
struct ProbeClusterConfig {
- Timestamp at_time = Timestamp::Infinity();
+ Timestamp at_time = Timestamp::PlusInfinity();
DataRate target_data_rate = DataRate::Zero();
TimeDelta target_duration = TimeDelta::Zero();
int32_t target_probe_count = 0;
};
struct TargetTransferRate {
- Timestamp at_time = Timestamp::Infinity();
+ Timestamp at_time = Timestamp::PlusInfinity();
// The estimate on which the target rate is based on.
NetworkEstimate network_estimate;
DataRate target_rate = DataRate::Zero();
@@ -195,7 +195,7 @@
// Process control
struct ProcessInterval {
- Timestamp at_time = Timestamp::Infinity();
+ Timestamp at_time = Timestamp::PlusInfinity();
};
} // namespace webrtc
diff --git a/api/units/time_delta_unittest.cc b/api/units/time_delta_unittest.cc
index e5906bf..bf8bbce 100644
--- a/api/units/time_delta_unittest.cc
+++ b/api/units/time_delta_unittest.cc
@@ -74,6 +74,12 @@
EXPECT_TRUE(TimeDelta::ms(-kValue).IsFinite());
EXPECT_TRUE(TimeDelta::ms(kValue).IsFinite());
EXPECT_TRUE(TimeDelta::Zero().IsFinite());
+
+ EXPECT_TRUE(TimeDelta::PlusInfinity().IsPlusInfinity());
+ EXPECT_FALSE(TimeDelta::MinusInfinity().IsPlusInfinity());
+
+ EXPECT_TRUE(TimeDelta::MinusInfinity().IsMinusInfinity());
+ EXPECT_FALSE(TimeDelta::PlusInfinity().IsMinusInfinity());
}
TEST(TimeDeltaTest, ComparisonOperators) {
diff --git a/api/units/timestamp.h b/api/units/timestamp.h
index d7e6a8d..0298f5d 100644
--- a/api/units/timestamp.h
+++ b/api/units/timestamp.h
@@ -36,9 +36,12 @@
class Timestamp {
public:
Timestamp() = delete;
- static constexpr Timestamp Infinity() {
+ static constexpr Timestamp PlusInfinity() {
return Timestamp(timestamp_impl::kPlusInfinityVal);
}
+ static constexpr Timestamp MinusInfinity() {
+ return Timestamp(timestamp_impl::kMinusInfinityVal);
+ }
template <int64_t seconds>
static constexpr Timestamp Seconds() {
static_assert(seconds >= 0, "");
@@ -103,7 +106,9 @@
nullptr>
static Timestamp us(T microseconds) {
if (microseconds == std::numeric_limits<double>::infinity()) {
- return Infinity();
+ return PlusInfinity();
+ } else if (microseconds == -std::numeric_limits<double>::infinity()) {
+ return MinusInfinity();
} else {
RTC_DCHECK(!std::isnan(microseconds));
RTC_DCHECK_GE(microseconds, 0);
@@ -141,7 +146,10 @@
template <typename T>
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
us() const {
- return IsInfinite() ? std::numeric_limits<T>::infinity() : microseconds_;
+ return IsPlusInfinity()
+ ? std::numeric_limits<T>::infinity()
+ : IsMinusInfinity() ? -std::numeric_limits<T>::infinity()
+ : microseconds_;
}
constexpr int64_t seconds_or(int64_t fallback_value) const {
@@ -154,25 +162,53 @@
return IsFinite() ? microseconds_ : fallback_value;
}
- constexpr bool IsInfinite() const {
- return microseconds_ == timestamp_impl::kPlusInfinityVal;
- }
constexpr bool IsFinite() const { return !IsInfinite(); }
+ constexpr bool IsInfinite() const {
+ return microseconds_ == timedelta_impl::kPlusInfinityVal ||
+ microseconds_ == timedelta_impl::kMinusInfinityVal;
+ }
+ constexpr bool IsPlusInfinity() const {
+ return microseconds_ == timedelta_impl::kPlusInfinityVal;
+ }
+ constexpr bool IsMinusInfinity() const {
+ return microseconds_ == timedelta_impl::kMinusInfinityVal;
+ }
+ Timestamp operator+(const TimeDelta& other) const {
+ if (IsPlusInfinity() || other.IsPlusInfinity()) {
+ RTC_DCHECK(!IsMinusInfinity());
+ RTC_DCHECK(!other.IsMinusInfinity());
+ return PlusInfinity();
+ } else if (IsMinusInfinity() || other.IsMinusInfinity()) {
+ RTC_DCHECK(!IsPlusInfinity());
+ RTC_DCHECK(!other.IsPlusInfinity());
+ return MinusInfinity();
+ }
+ return Timestamp::us(us() + other.us());
+ }
+ Timestamp operator-(const TimeDelta& other) const {
+ if (IsPlusInfinity() || other.IsMinusInfinity()) {
+ RTC_DCHECK(!IsMinusInfinity());
+ RTC_DCHECK(!other.IsPlusInfinity());
+ return PlusInfinity();
+ } else if (IsMinusInfinity() || other.IsPlusInfinity()) {
+ RTC_DCHECK(!IsPlusInfinity());
+ RTC_DCHECK(!other.IsMinusInfinity());
+ return MinusInfinity();
+ }
+ return Timestamp::us(us() - other.us());
+ }
TimeDelta operator-(const Timestamp& other) const {
+ if (IsPlusInfinity() || other.IsMinusInfinity()) {
+ RTC_DCHECK(!IsMinusInfinity());
+ RTC_DCHECK(!other.IsPlusInfinity());
+ return TimeDelta::PlusInfinity();
+ } else if (IsMinusInfinity() || other.IsPlusInfinity()) {
+ RTC_DCHECK(!IsPlusInfinity());
+ RTC_DCHECK(!other.IsMinusInfinity());
+ return TimeDelta::MinusInfinity();
+ }
return TimeDelta::us(us() - other.us());
}
- Timestamp operator-(const TimeDelta& delta) const {
- RTC_DCHECK(!delta.IsPlusInfinity());
- if (IsInfinite() || delta.IsMinusInfinity())
- return Infinity();
- return Timestamp::us(us() - delta.us());
- }
- Timestamp operator+(const TimeDelta& delta) const {
- RTC_DCHECK(!delta.IsMinusInfinity());
- if (IsInfinite() || delta.IsPlusInfinity())
- return Infinity();
- return Timestamp::us(us() + delta.us());
- }
Timestamp& operator-=(const TimeDelta& other) {
*this = *this - other;
return *this;
diff --git a/api/units/timestamp_unittest.cc b/api/units/timestamp_unittest.cc
index ff0c79e..6c2d1ee 100644
--- a/api/units/timestamp_unittest.cc
+++ b/api/units/timestamp_unittest.cc
@@ -15,7 +15,7 @@
namespace test {
TEST(TimestampTest, ConstExpr) {
constexpr int64_t kValue = 12345;
- constexpr Timestamp kTimestampInf = Timestamp::Infinity();
+ constexpr Timestamp kTimestampInf = Timestamp::PlusInfinity();
static_assert(kTimestampInf.IsInfinite(), "");
static_assert(kTimestampInf.ms_or(-1) == -1, "");
@@ -55,20 +55,28 @@
TEST(TimestampTest, IdentityChecks) {
const int64_t kValue = 3000;
- EXPECT_TRUE(Timestamp::Infinity().IsInfinite());
+ EXPECT_TRUE(Timestamp::PlusInfinity().IsInfinite());
+ EXPECT_TRUE(Timestamp::MinusInfinity().IsInfinite());
EXPECT_FALSE(Timestamp::ms(kValue).IsInfinite());
- EXPECT_FALSE(Timestamp::Infinity().IsFinite());
+ EXPECT_FALSE(Timestamp::PlusInfinity().IsFinite());
+ EXPECT_FALSE(Timestamp::MinusInfinity().IsFinite());
EXPECT_TRUE(Timestamp::ms(kValue).IsFinite());
+
+ EXPECT_TRUE(Timestamp::PlusInfinity().IsPlusInfinity());
+ EXPECT_FALSE(Timestamp::MinusInfinity().IsPlusInfinity());
+
+ EXPECT_TRUE(Timestamp::MinusInfinity().IsMinusInfinity());
+ EXPECT_FALSE(Timestamp::PlusInfinity().IsMinusInfinity());
}
TEST(TimestampTest, ComparisonOperators) {
const int64_t kSmall = 450;
const int64_t kLarge = 451;
- EXPECT_EQ(Timestamp::Infinity(), Timestamp::Infinity());
- EXPECT_GE(Timestamp::Infinity(), Timestamp::Infinity());
- EXPECT_GT(Timestamp::Infinity(), Timestamp::ms(kLarge));
+ EXPECT_EQ(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
+ EXPECT_GE(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
+ EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::ms(kLarge));
EXPECT_EQ(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
EXPECT_GE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
@@ -102,14 +110,21 @@
EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros);
const double kPlusInfinity = std::numeric_limits<double>::infinity();
+ const double kMinusInfinity = -kPlusInfinity;
- EXPECT_EQ(Timestamp::Infinity().seconds<double>(), kPlusInfinity);
- EXPECT_EQ(Timestamp::Infinity().ms<double>(), kPlusInfinity);
- EXPECT_EQ(Timestamp::Infinity().us<double>(), kPlusInfinity);
+ EXPECT_EQ(Timestamp::PlusInfinity().seconds<double>(), kPlusInfinity);
+ EXPECT_EQ(Timestamp::MinusInfinity().seconds<double>(), kMinusInfinity);
+ EXPECT_EQ(Timestamp::PlusInfinity().ms<double>(), kPlusInfinity);
+ EXPECT_EQ(Timestamp::MinusInfinity().ms<double>(), kMinusInfinity);
+ EXPECT_EQ(Timestamp::PlusInfinity().us<double>(), kPlusInfinity);
+ EXPECT_EQ(Timestamp::MinusInfinity().us<double>(), kMinusInfinity);
- EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsInfinite());
- EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsInfinite());
- EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsInfinite());
+ EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsPlusInfinity());
+ EXPECT_TRUE(Timestamp::seconds(kMinusInfinity).IsMinusInfinity());
+ EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsPlusInfinity());
+ EXPECT_TRUE(Timestamp::ms(kMinusInfinity).IsMinusInfinity());
+ EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsPlusInfinity());
+ EXPECT_TRUE(Timestamp::us(kMinusInfinity).IsMinusInfinity());
}
TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
@@ -135,8 +150,8 @@
const int64_t kValue = 267;
const Timestamp finite_time = Timestamp::ms(kValue);
const TimeDelta finite_delta = TimeDelta::ms(kValue);
- EXPECT_TRUE((Timestamp::Infinity() + finite_delta).IsInfinite());
- EXPECT_TRUE((Timestamp::Infinity() - finite_delta).IsInfinite());
+ EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite());
+ EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite());
EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite());
EXPECT_TRUE((finite_time - TimeDelta::MinusInfinity()).IsInfinite());
}