zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adds signed infinity to timestamps.

Browse Source 
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}
This commit is contained in:
Sebastian Jansson
2018-09-04 17:32:36 +02:00
committed by Commit Bot
parent 376e1147e6
commit 9de4ef4b24
15 changed files with 130 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
api/transport/network_types.cc
View File

@ -48,7 +48,7 @@ std::vector<PacketResult> TransportPacketsFeedback::ReceivedWithSendInfo()
std::vector<PacketResult> TransportPacketsFeedback::LostWithSendInfo() const { std::vector<PacketResult> TransportPacketsFeedback::LostWithSendInfo() const {
std::vector<PacketResult> res; std::vector<PacketResult> res;
for (const PacketResult& fb : packet_feedbacks) { 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); res.push_back(fb);
} }
} }

34
api/transport/network_types.h
View File

@ -30,7 +30,7 @@ struct StreamsConfig {
StreamsConfig(); StreamsConfig();
StreamsConfig(const StreamsConfig&); StreamsConfig(const StreamsConfig&);
~StreamsConfig(); ~StreamsConfig();
Timestamp at_time = Timestamp::Infinity(); Timestamp at_time = Timestamp::PlusInfinity();
bool requests_alr_probing = false; bool requests_alr_probing = false;
absl::optional<double> pacing_factor; absl::optional<double> pacing_factor;
absl::optional<DataRate> min_pacing_rate; absl::optional<DataRate> min_pacing_rate;
@ -42,7 +42,7 @@ struct TargetRateConstraints {
TargetRateConstraints(); TargetRateConstraints();
TargetRateConstraints(const TargetRateConstraints&); TargetRateConstraints(const TargetRateConstraints&);
~TargetRateConstraints(); ~TargetRateConstraints();
Timestamp at_time = Timestamp::Infinity(); Timestamp at_time = Timestamp::PlusInfinity();
absl::optional<DataRate> min_data_rate; absl::optional<DataRate> min_data_rate;
absl::optional<DataRate> max_data_rate; absl::optional<DataRate> max_data_rate;
// The initial bandwidth estimate to base target rate on. This should be used // The initial bandwidth estimate to base target rate on. This should be used
@ -53,7 +53,7 @@ struct TargetRateConstraints {
// Send side information // Send side information
struct NetworkAvailability { struct NetworkAvailability {
Timestamp at_time = Timestamp::Infinity(); Timestamp at_time = Timestamp::PlusInfinity();
bool network_available = false; bool network_available = false;
}; };
@ -61,7 +61,7 @@ struct NetworkRouteChange {
NetworkRouteChange(); NetworkRouteChange();
NetworkRouteChange(const NetworkRouteChange&); NetworkRouteChange(const NetworkRouteChange&);
~NetworkRouteChange(); ~NetworkRouteChange();
Timestamp at_time = Timestamp::Infinity(); Timestamp at_time = Timestamp::PlusInfinity();
// The TargetRateConstraints are set here so they can be changed synchronously // The TargetRateConstraints are set here so they can be changed synchronously
// when network route changes. // when network route changes.
TargetRateConstraints constraints; TargetRateConstraints constraints;
@ -84,7 +84,7 @@ struct PacedPacketInfo {
}; };
struct SentPacket { struct SentPacket {
Timestamp send_time = Timestamp::Infinity(); Timestamp send_time = Timestamp::PlusInfinity();
DataSize size = DataSize::Zero(); DataSize size = DataSize::Zero();
PacedPacketInfo pacing_info; PacedPacketInfo pacing_info;
// Transport independent sequence number, any tracked packet should have a // Transport independent sequence number, any tracked packet should have a
@ -98,20 +98,20 @@ struct SentPacket {
// Transport level feedback // Transport level feedback
struct RemoteBitrateReport { struct RemoteBitrateReport {
Timestamp receive_time = Timestamp::Infinity(); Timestamp receive_time = Timestamp::PlusInfinity();
DataRate bandwidth = DataRate::Infinity(); DataRate bandwidth = DataRate::Infinity();
}; };
struct RoundTripTimeUpdate { struct RoundTripTimeUpdate {
Timestamp receive_time = Timestamp::Infinity(); Timestamp receive_time = Timestamp::PlusInfinity();
TimeDelta round_trip_time = TimeDelta::PlusInfinity(); TimeDelta round_trip_time = TimeDelta::PlusInfinity();
bool smoothed = false; bool smoothed = false;
}; };
struct TransportLossReport { struct TransportLossReport {
Timestamp receive_time = Timestamp::Infinity(); Timestamp receive_time = Timestamp::PlusInfinity();
Timestamp start_time = Timestamp::Infinity(); Timestamp start_time = Timestamp::PlusInfinity();
Timestamp end_time = Timestamp::Infinity(); Timestamp end_time = Timestamp::PlusInfinity();
uint64_t packets_lost_delta = 0; uint64_t packets_lost_delta = 0;
uint64_t packets_received_delta = 0; uint64_t packets_received_delta = 0;
}; };
@ -124,7 +124,7 @@ struct PacketResult {
~PacketResult(); ~PacketResult();
absl::optional<SentPacket> sent_packet; absl::optional<SentPacket> sent_packet;
Timestamp receive_time = Timestamp::Infinity(); Timestamp receive_time = Timestamp::PlusInfinity();
}; };
struct TransportPacketsFeedback { struct TransportPacketsFeedback {
@ -132,7 +132,7 @@ struct TransportPacketsFeedback {
TransportPacketsFeedback(const TransportPacketsFeedback& other); TransportPacketsFeedback(const TransportPacketsFeedback& other);
~TransportPacketsFeedback(); ~TransportPacketsFeedback();
Timestamp feedback_time = Timestamp::Infinity(); Timestamp feedback_time = Timestamp::PlusInfinity();
DataSize data_in_flight = DataSize::Zero(); DataSize data_in_flight = DataSize::Zero();
DataSize prior_in_flight = DataSize::Zero(); DataSize prior_in_flight = DataSize::Zero();
std::vector<PacketResult> packet_feedbacks; std::vector<PacketResult> packet_feedbacks;
@ -145,7 +145,7 @@ struct TransportPacketsFeedback {
// Network estimation // Network estimation
struct NetworkEstimate { struct NetworkEstimate {
Timestamp at_time = Timestamp::Infinity(); Timestamp at_time = Timestamp::PlusInfinity();
DataRate bandwidth = DataRate::Infinity(); DataRate bandwidth = DataRate::Infinity();
TimeDelta round_trip_time = TimeDelta::PlusInfinity(); TimeDelta round_trip_time = TimeDelta::PlusInfinity();
TimeDelta bwe_period = TimeDelta::PlusInfinity(); TimeDelta bwe_period = TimeDelta::PlusInfinity();
@ -156,7 +156,7 @@ struct NetworkEstimate {
// Network control // Network control
struct PacerConfig { struct PacerConfig {
Timestamp at_time = Timestamp::Infinity(); Timestamp at_time = Timestamp::PlusInfinity();
// Pacer should send at most data_window data over time_window duration. // Pacer should send at most data_window data over time_window duration.
DataSize data_window = DataSize::Infinity(); DataSize data_window = DataSize::Infinity();
TimeDelta time_window = TimeDelta::PlusInfinity(); TimeDelta time_window = TimeDelta::PlusInfinity();
@ -167,14 +167,14 @@ struct PacerConfig {
}; };
struct ProbeClusterConfig { struct ProbeClusterConfig {
Timestamp at_time = Timestamp::Infinity(); Timestamp at_time = Timestamp::PlusInfinity();
DataRate target_data_rate = DataRate::Zero(); DataRate target_data_rate = DataRate::Zero();
TimeDelta target_duration = TimeDelta::Zero(); TimeDelta target_duration = TimeDelta::Zero();
int32_t target_probe_count = 0; int32_t target_probe_count = 0;
}; };
struct TargetTransferRate { struct TargetTransferRate {
Timestamp at_time = Timestamp::Infinity(); Timestamp at_time = Timestamp::PlusInfinity();
// The estimate on which the target rate is based on. // The estimate on which the target rate is based on.
NetworkEstimate network_estimate; NetworkEstimate network_estimate;
DataRate target_rate = DataRate::Zero(); DataRate target_rate = DataRate::Zero();
@ -195,7 +195,7 @@ struct NetworkControlUpdate {
// Process control // Process control
struct ProcessInterval { struct ProcessInterval {
Timestamp at_time = Timestamp::Infinity(); Timestamp at_time = Timestamp::PlusInfinity();
}; };
} // namespace webrtc } // namespace webrtc

6
api/units/time_delta_unittest.cc
View File

@ -74,6 +74,12 @@ TEST(TimeDeltaTest, IdentityChecks) {
EXPECT_TRUE(TimeDelta::ms(-kValue).IsFinite()); EXPECT_TRUE(TimeDelta::ms(-kValue).IsFinite());
EXPECT_TRUE(TimeDelta::ms(kValue).IsFinite()); EXPECT_TRUE(TimeDelta::ms(kValue).IsFinite());
EXPECT_TRUE(TimeDelta::Zero().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) { TEST(TimeDeltaTest, ComparisonOperators) {

72
api/units/timestamp.h
View File

@ -36,9 +36,12 @@ constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
class Timestamp { class Timestamp {
public: public:
Timestamp() = delete; Timestamp() = delete;
static constexpr Timestamp Infinity() { static constexpr Timestamp PlusInfinity() {
return Timestamp(timestamp_impl::kPlusInfinityVal); return Timestamp(timestamp_impl::kPlusInfinityVal);
} }
static constexpr Timestamp MinusInfinity() {
return Timestamp(timestamp_impl::kMinusInfinityVal);
}
template <int64_t seconds> template <int64_t seconds>
static constexpr Timestamp Seconds() { static constexpr Timestamp Seconds() {
static_assert(seconds >= 0, ""); static_assert(seconds >= 0, "");
@ -103,7 +106,9 @@ class Timestamp {
nullptr> nullptr>
static Timestamp us(T microseconds) { static Timestamp us(T microseconds) {
if (microseconds == std::numeric_limits<double>::infinity()) { if (microseconds == std::numeric_limits<double>::infinity()) {
return Infinity(); return PlusInfinity();
} else if (microseconds == -std::numeric_limits<double>::infinity()) {
return MinusInfinity();
} else { } else {
RTC_DCHECK(!std::isnan(microseconds)); RTC_DCHECK(!std::isnan(microseconds));
RTC_DCHECK_GE(microseconds, 0); RTC_DCHECK_GE(microseconds, 0);
@ -141,7 +146,10 @@ class Timestamp {
template <typename T> template <typename T>
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
us() const { 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 { constexpr int64_t seconds_or(int64_t fallback_value) const {
@ -154,25 +162,53 @@ class Timestamp {
return IsFinite() ? microseconds_ : fallback_value; return IsFinite() ? microseconds_ : fallback_value;
} }
constexpr bool IsInfinite() const {
return microseconds_ == timestamp_impl::kPlusInfinityVal;
}
constexpr bool IsFinite() const { return !IsInfinite(); } 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 { 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()); 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) { Timestamp& operator-=(const TimeDelta& other) {
*this = *this - other; *this = *this - other;
return *this; return *this;

43
api/units/timestamp_unittest.cc
View File

@ -15,7 +15,7 @@ namespace webrtc {
namespace test { namespace test {
TEST(TimestampTest, ConstExpr) { TEST(TimestampTest, ConstExpr) {
constexpr int64_t kValue = 12345; constexpr int64_t kValue = 12345;
constexpr Timestamp kTimestampInf = Timestamp::Infinity(); constexpr Timestamp kTimestampInf = Timestamp::PlusInfinity();
static_assert(kTimestampInf.IsInfinite(), ""); static_assert(kTimestampInf.IsInfinite(), "");
static_assert(kTimestampInf.ms_or(-1) == -1, ""); static_assert(kTimestampInf.ms_or(-1) == -1, "");
@ -55,20 +55,28 @@ TEST(TimestampTest, GetDifferentPrefix) {
TEST(TimestampTest, IdentityChecks) { TEST(TimestampTest, IdentityChecks) {
const int64_t kValue = 3000; 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::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::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) { TEST(TimestampTest, ComparisonOperators) {
const int64_t kSmall = 450; const int64_t kSmall = 450;
const int64_t kLarge = 451; const int64_t kLarge = 451;
EXPECT_EQ(Timestamp::Infinity(), Timestamp::Infinity()); EXPECT_EQ(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
EXPECT_GE(Timestamp::Infinity(), Timestamp::Infinity()); EXPECT_GE(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
EXPECT_GT(Timestamp::Infinity(), Timestamp::ms(kLarge)); EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::ms(kLarge));
EXPECT_EQ(Timestamp::ms(kSmall), Timestamp::ms(kSmall)); EXPECT_EQ(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kSmall)); EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
EXPECT_GE(Timestamp::ms(kSmall), Timestamp::ms(kSmall)); EXPECT_GE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
@ -102,14 +110,21 @@ TEST(TimestampTest, ConvertsToAndFromDouble) {
EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros); EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros);
const double kPlusInfinity = std::numeric_limits<double>::infinity(); const double kPlusInfinity = std::numeric_limits<double>::infinity();
const double kMinusInfinity = -kPlusInfinity;
EXPECT_EQ(Timestamp::Infinity().seconds<double>(), kPlusInfinity); EXPECT_EQ(Timestamp::PlusInfinity().seconds<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::Infinity().ms<double>(), kPlusInfinity); EXPECT_EQ(Timestamp::MinusInfinity().seconds<double>(), kMinusInfinity);
EXPECT_EQ(Timestamp::Infinity().us<double>(), kPlusInfinity); 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::seconds(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsInfinite()); EXPECT_TRUE(Timestamp::seconds(kMinusInfinity).IsMinusInfinity());
EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsInfinite()); 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) { TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
@ -135,8 +150,8 @@ TEST(UnitConversionTest, InfinityOperations) {
const int64_t kValue = 267; const int64_t kValue = 267;
const Timestamp finite_time = Timestamp::ms(kValue); const Timestamp finite_time = Timestamp::ms(kValue);
const TimeDelta finite_delta = TimeDelta::ms(kValue); const TimeDelta finite_delta = TimeDelta::ms(kValue);
EXPECT_TRUE((Timestamp::Infinity() + finite_delta).IsInfinite()); EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite());
EXPECT_TRUE((Timestamp::Infinity() - finite_delta).IsInfinite()); EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite());
EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite()); EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite());
EXPECT_TRUE((finite_time - TimeDelta::MinusInfinity()).IsInfinite()); EXPECT_TRUE((finite_time - TimeDelta::MinusInfinity()).IsInfinite());
} }

2
modules/congestion_controller/bbr/bandwidth_sampler.cc
View File

@ -189,7 +189,7 @@ BandwidthSampler::ConnectionStateOnSentPacket::ConnectionStateOnSentPacket(
is_app_limited(sampler.is_app_limited_) {} is_app_limited(sampler.is_app_limited_) {}
BandwidthSampler::ConnectionStateOnSentPacket::ConnectionStateOnSentPacket() BandwidthSampler::ConnectionStateOnSentPacket::ConnectionStateOnSentPacket()
: sent_time(Timestamp::ms(0)), : sent_time(Timestamp::MinusInfinity()),
size(DataSize::Zero()), size(DataSize::Zero()),
total_data_sent(DataSize::Zero()), total_data_sent(DataSize::Zero()),
total_data_sent_at_last_acked_packet(DataSize::Zero()), total_data_sent_at_last_acked_packet(DataSize::Zero()),

5
modules/congestion_controller/bbr/bbr_network_controller.cc
View File

@ -155,7 +155,6 @@ BbrNetworkController::BbrControllerConfig::FromTrial() {
webrtc::field_trial::FindFullName(kBbrConfigTrial)); webrtc::field_trial::FindFullName(kBbrConfigTrial));
} }
BbrNetworkController::DebugState::DebugState(const BbrNetworkController& sender) BbrNetworkController::DebugState::DebugState(const BbrNetworkController& sender)
: mode(sender.mode_), : mode(sender.mode_),
max_bandwidth(sender.max_bandwidth_.GetBest()), max_bandwidth(sender.max_bandwidth_.GetBest()),
@ -193,7 +192,7 @@ BbrNetworkController::BbrNetworkController(NetworkControllerConfig config)
max_aggregation_bytes_multiplier_(0), max_aggregation_bytes_multiplier_(0),
min_rtt_(TimeDelta::Zero()), min_rtt_(TimeDelta::Zero()),
last_rtt_(TimeDelta::Zero()), last_rtt_(TimeDelta::Zero()),
min_rtt_timestamp_(Timestamp::ms(0)), min_rtt_timestamp_(Timestamp::MinusInfinity()),
congestion_window_(config_.initial_congestion_window), congestion_window_(config_.initial_congestion_window),
initial_congestion_window_(config_.initial_congestion_window), initial_congestion_window_(config_.initial_congestion_window),
min_congestion_window_(config_.min_congestion_window), min_congestion_window_(config_.min_congestion_window),
@ -203,7 +202,7 @@ BbrNetworkController::BbrNetworkController(NetworkControllerConfig config)
congestion_window_gain_constant_(kProbeBWCongestionWindowGain), congestion_window_gain_constant_(kProbeBWCongestionWindowGain),
rtt_variance_weight_(kBbrRttVariationWeight), rtt_variance_weight_(kBbrRttVariationWeight),
cycle_current_offset_(0), cycle_current_offset_(0),
last_cycle_start_(Timestamp::ms(0)), last_cycle_start_(Timestamp::MinusInfinity()),
is_at_full_bandwidth_(false), is_at_full_bandwidth_(false),
rounds_without_bandwidth_gain_(0), rounds_without_bandwidth_gain_(0),
bandwidth_at_last_round_(DataRate::Zero()), bandwidth_at_last_round_(DataRate::Zero()),

4
modules/congestion_controller/bbr/data_transfer_tracker.h
View File

@ -37,8 +37,8 @@ class DataTransferTracker {
private: private:
struct Sample { struct Sample {
Timestamp ack_time = Timestamp::Infinity(); Timestamp ack_time = Timestamp::PlusInfinity();
Timestamp send_time = Timestamp::Infinity(); Timestamp send_time = Timestamp::PlusInfinity();
DataSize size_delta = DataSize::Zero(); DataSize size_delta = DataSize::Zero();
DataSize size_sum = DataSize::Zero(); DataSize size_sum = DataSize::Zero();
}; };

2
modules/congestion_controller/goog_cc/goog_cc_network_control.cc
View File

@ -326,7 +326,7 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportLossReport(
NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback( NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback(
TransportPacketsFeedback report) { TransportPacketsFeedback report) {
TimeDelta feedback_max_rtt = TimeDelta::MinusInfinity(); TimeDelta feedback_max_rtt = TimeDelta::MinusInfinity();
Timestamp max_recv_time = Timestamp::ms(0); Timestamp max_recv_time = Timestamp::MinusInfinity();
for (const auto& packet_feedback : report.ReceivedWithSendInfo()) { for (const auto& packet_feedback : report.ReceivedWithSendInfo()) {
TimeDelta rtt = TimeDelta rtt =
report.feedback_time - packet_feedback.sent_packet->send_time; report.feedback_time - packet_feedback.sent_packet->send_time;

2
modules/congestion_controller/goog_cc/goog_cc_network_control.h
View File

@ -76,7 +76,7 @@ class GoogCcNetworkController : public NetworkControllerInterface {
absl::optional<NetworkControllerConfig> initial_config_; absl::optional<NetworkControllerConfig> initial_config_;
Timestamp next_loss_update_ = Timestamp::ms(0); Timestamp next_loss_update_ = Timestamp::MinusInfinity();
int lost_packets_since_last_loss_update_ = 0; int lost_packets_since_last_loss_update_ = 0;
int expected_packets_since_last_loss_update_ = 0; int expected_packets_since_last_loss_update_ = 0;

15
modules/congestion_controller/pcc/monitor_interval_unittest.cc
View File

@ -80,7 +80,7 @@ TEST(PccMonitorIntervalTest, LossRateIsOneThirdIfLostOnePacketOutOfThree) {
kStartTime + 2 * kIntervalDuration}; kStartTime + 2 * kIntervalDuration};
std::vector<Timestamp> end_times = { std::vector<Timestamp> end_times = {
kStartTime + 2 * kIntervalDuration, kStartTime + 2 * kIntervalDuration, kStartTime + 2 * kIntervalDuration, kStartTime + 2 * kIntervalDuration,
Timestamp::Infinity(), kStartTime + 2 * kIntervalDuration, Timestamp::PlusInfinity(), kStartTime + 2 * kIntervalDuration,
kStartTime + 4 * kIntervalDuration}; kStartTime + 4 * kIntervalDuration};
std::vector<DataSize> packet_sizes = { std::vector<DataSize> packet_sizes = {
kDefaultPacketSize, 2 * kDefaultPacketSize, 3 * kDefaultPacketSize, kDefaultPacketSize, 2 * kDefaultPacketSize, 3 * kDefaultPacketSize,
@ -99,8 +99,9 @@ TEST(PccMonitorIntervalTest, DelayGradientIsZeroIfNoChangeInPacketDelay) {
monitor_interval.OnPacketsFeedback(CreatePacketResults( monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta, {kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 3 * kPacketsDelta, kStartTime + 2 * kIntervalDuration}, kStartTime + 3 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(), {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay + 2 * kPacketsDelta, Timestamp::Infinity()}, kStartTime + kDefaultDelay + 2 * kPacketsDelta,
Timestamp::PlusInfinity()},
{})); {}));
// Delay gradient should be zero, because both received packets have the // Delay gradient should be zero, because both received packets have the
// same one way delay. // same one way delay.
@ -127,7 +128,7 @@ TEST(PccMonitorIntervalTest, DelayGradientIsOne) {
monitor_interval.OnPacketsFeedback(CreatePacketResults( monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta, {kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 3 * kPacketsDelta, kStartTime + 3 * kIntervalDuration}, kStartTime + 3 * kPacketsDelta, kStartTime + 3 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(), {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + 4 * kPacketsDelta + kDefaultDelay, kStartTime + 4 * kPacketsDelta + kDefaultDelay,
kStartTime + 3 * kIntervalDuration}, kStartTime + 3 * kIntervalDuration},
{})); {}));
@ -141,7 +142,7 @@ TEST(PccMonitorIntervalTest, DelayGradientIsMinusOne) {
monitor_interval.OnPacketsFeedback(CreatePacketResults( monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta, {kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 5 * kPacketsDelta, kStartTime + 2 * kIntervalDuration}, kStartTime + 5 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(), {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay, kStartTime + 3 * kIntervalDuration}, kStartTime + kDefaultDelay, kStartTime + 3 * kIntervalDuration},
{})); {}));
EXPECT_DOUBLE_EQ( EXPECT_DOUBLE_EQ(
@ -155,7 +156,7 @@ TEST(PccMonitorIntervalTest,
monitor_interval.OnPacketsFeedback(CreatePacketResults( monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + kPacketsDelta, {kStartTime + kPacketsDelta, kStartTime + kPacketsDelta,
kStartTime + 102 * kPacketsDelta, kStartTime + 2 * kIntervalDuration}, kStartTime + 102 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(), {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay + kPacketsDelta, kStartTime + kDefaultDelay + kPacketsDelta,
kStartTime + 3 * kIntervalDuration}, kStartTime + 3 * kIntervalDuration},
{})); {}));
@ -171,7 +172,7 @@ TEST(PccMonitorIntervalTest,
monitor_interval.OnPacketsFeedback(CreatePacketResults( monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + kPacketsDelta, {kStartTime + kPacketsDelta, kStartTime + kPacketsDelta,
kStartTime + kPacketsDelta, kStartTime + 2 * kIntervalDuration}, kStartTime + kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(), {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay + kPacketsDelta, kStartTime + kDefaultDelay + kPacketsDelta,
kStartTime + 3 * kIntervalDuration}, kStartTime + 3 * kIntervalDuration},
{})); {}));

4
modules/congestion_controller/pcc/pcc_network_controller.cc
View File

@ -49,8 +49,8 @@ const uint64_t kRandomSeed = 100;
} // namespace } // namespace
PccNetworkController::PccNetworkController(NetworkControllerConfig config) PccNetworkController::PccNetworkController(NetworkControllerConfig config)
: start_time_(Timestamp::Infinity()), : start_time_(Timestamp::PlusInfinity()),
last_sent_packet_time_(Timestamp::Infinity()), last_sent_packet_time_(Timestamp::PlusInfinity()),
smoothed_packets_sending_interval_(TimeDelta::Zero()), smoothed_packets_sending_interval_(TimeDelta::Zero()),
mode_(Mode::kStartup), mode_(Mode::kStartup),
default_bandwidth_(DataRate::kbps(kInitialBandwidthKbps)), default_bandwidth_(DataRate::kbps(kInitialBandwidthKbps)),

2
modules/congestion_controller/pcc/rtt_tracker_unittest.cc
View File

@ -27,7 +27,7 @@ PacketResult GetPacketWithRtt(TimeDelta rtt) {
if (rtt.IsFinite()) { if (rtt.IsFinite()) {
packet_result.receive_time = kStartTime + rtt; packet_result.receive_time = kStartTime + rtt;
} else { } else {
packet_result.receive_time = Timestamp::Infinity(); packet_result.receive_time = Timestamp::PlusInfinity();
} }
return packet_result; return packet_result;
} }

7
modules/congestion_controller/pcc/utility_function_unittest.cc
View File

@ -67,8 +67,9 @@ TEST(PccVivaceUtilityFunctionTest,
monitor_interval.OnPacketsFeedback(CreatePacketResults( monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta, {kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 3 * kPacketsDelta, kStartTime + 2 * kIntervalDuration}, kStartTime + 3 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kPacketsDelta + kDefaultDelay, Timestamp::Infinity(), {kStartTime + kPacketsDelta + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay + 3 * kPacketsDelta, Timestamp::Infinity()}, kStartTime + kDefaultDelay + 3 * kPacketsDelta,
Timestamp::PlusInfinity()},
{kDefaultDataSize, kDefaultDataSize, kDefaultDataSize, {kDefaultDataSize, kDefaultDataSize, kDefaultDataSize,
kDefaultDataSize})); kDefaultDataSize}));
EXPECT_DOUBLE_EQ(utility_function.Compute(monitor_interval), EXPECT_DOUBLE_EQ(utility_function.Compute(monitor_interval),
@ -86,7 +87,7 @@ TEST(PccVivaceUtilityFunctionTest,
monitor_interval.OnPacketsFeedback(CreatePacketResults( monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta, {kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 5 * kPacketsDelta, kStartTime + 2 * kIntervalDuration}, kStartTime + 5 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(), {kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay, kStartTime + 3 * kIntervalDuration}, kStartTime + kDefaultDelay, kStartTime + 3 * kIntervalDuration},
{})); {}));
// The second packet was lost. // The second packet was lost.

2
modules/congestion_controller/rtp/send_side_congestion_controller.cc
View File

@ -78,7 +78,7 @@ PacketResult NetworkPacketFeedbackFromRtpPacketFeedback(
const webrtc::PacketFeedback& pf) { const webrtc::PacketFeedback& pf) {
PacketResult feedback; PacketResult feedback;
if (pf.arrival_time_ms == webrtc::PacketFeedback::kNotReceived) if (pf.arrival_time_ms == webrtc::PacketFeedback::kNotReceived)
feedback.receive_time = Timestamp::Infinity(); feedback.receive_time = Timestamp::PlusInfinity();
else else
feedback.receive_time = Timestamp::ms(pf.arrival_time_ms); feedback.receive_time = Timestamp::ms(pf.arrival_time_ms);
if (pf.send_time_ms != webrtc::PacketFeedback::kNoSendTime) { if (pf.send_time_ms != webrtc::PacketFeedback::kNoSendTime) {