Revert "Refactors BitrateProber with unit types and absolute probe time."
This reverts commit 739a5b3692880cb6b41ae620fb9e755c39b044b1.
Reason for revert: Speculate revert due to perf alerts.
Original change's description:
> Refactors BitrateProber with unit types and absolute probe time.
>
> Using unit types improves readability and some conversion in PacedSender
> can be removed.
>
> TimeUntilNextProbe() is replaced by NextProbeTime(), so returning an
> absolute time rather than a delta. This fits better with the upcoming
> TaskQueue based pacer, and is also what is already stored internally
> in BitrateProber.
>
> Bug: webrtc:10809
> Change-Id: I5a4e289d2b53e99d3c0a2f4b36a966dba759d5cf
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/158743
> Commit-Queue: Erik Språng <sprang@webrtc.org>
> Reviewed-by: Sebastian Jansson <srte@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#29670}
TBR=sprang@webrtc.org,srte@webrtc.org
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: webrtc:10809
Change-Id: Ic0ad7d45031bf33c24583dfde308bdd8087a62aa
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/158799
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29682}
diff --git a/modules/pacing/bitrate_prober.cc b/modules/pacing/bitrate_prober.cc
index 8dc89e4..4192df9 100644
--- a/modules/pacing/bitrate_prober.cc
+++ b/modules/pacing/bitrate_prober.cc
@@ -28,7 +28,7 @@
// we have a min probe packet size of 200 bytes.
constexpr size_t kMinProbePacketSize = 200;
-constexpr TimeDelta kProbeClusterTimeout = TimeDelta::Seconds<5>();
+constexpr int64_t kProbeClusterTimeoutMs = 5000;
} // namespace
@@ -55,7 +55,7 @@
BitrateProber::BitrateProber(const WebRtcKeyValueConfig& field_trials)
: probing_state_(ProbingState::kDisabled),
- next_probe_time_(Timestamp::PlusInfinity()),
+ next_probe_time_ms_(-1),
total_probe_count_(0),
total_failed_probe_count_(0),
config_(&field_trials) {
@@ -85,31 +85,32 @@
packet_size >=
std::min<size_t>(RecommendedMinProbeSize(), kMinProbePacketSize)) {
// Send next probe right away.
- next_probe_time_ = Timestamp::MinusInfinity();
+ next_probe_time_ms_ = -1;
probing_state_ = ProbingState::kActive;
}
}
-void BitrateProber::CreateProbeCluster(DataRate bitrate,
- Timestamp now,
+void BitrateProber::CreateProbeCluster(int bitrate_bps,
+ int64_t now_ms,
int cluster_id) {
RTC_DCHECK(probing_state_ != ProbingState::kDisabled);
- RTC_DCHECK_GT(bitrate, DataRate::Zero());
+ RTC_DCHECK_GT(bitrate_bps, 0);
total_probe_count_++;
while (!clusters_.empty() &&
- now - clusters_.front().created_at > kProbeClusterTimeout) {
+ now_ms - clusters_.front().time_created_ms > kProbeClusterTimeoutMs) {
clusters_.pop();
total_failed_probe_count_++;
}
ProbeCluster cluster;
- cluster.created_at = now;
+ cluster.time_created_ms = now_ms;
cluster.pace_info.probe_cluster_min_probes = config_.min_probe_packets_sent;
cluster.pace_info.probe_cluster_min_bytes =
- (bitrate * config_.min_probe_duration.Get()).bytes();
+ static_cast<int32_t>(static_cast<int64_t>(bitrate_bps) *
+ config_.min_probe_duration->ms() / 8000);
RTC_DCHECK_GE(cluster.pace_info.probe_cluster_min_bytes, 0);
- cluster.pace_info.send_bitrate_bps = bitrate.bps();
+ cluster.pace_info.send_bitrate_bps = bitrate_bps;
cluster.pace_info.probe_cluster_id = cluster_id;
clusters_.push(cluster);
@@ -123,21 +124,23 @@
probing_state_ = ProbingState::kInactive;
}
-Timestamp BitrateProber::NextProbeTime(Timestamp now) const {
+int BitrateProber::TimeUntilNextProbe(int64_t now_ms) {
// Probing is not active or probing is already complete.
- if (probing_state_ != ProbingState::kActive || clusters_.empty()) {
- return Timestamp::PlusInfinity();
+ if (probing_state_ != ProbingState::kActive || clusters_.empty())
+ return -1;
+
+ int time_until_probe_ms = 0;
+ if (next_probe_time_ms_ >= 0) {
+ time_until_probe_ms = next_probe_time_ms_ - now_ms;
+ if (time_until_probe_ms < -config_.max_probe_delay->ms()) {
+ RTC_DLOG(LS_WARNING) << "Probe delay too high"
+ << " (next_ms:" << next_probe_time_ms_
+ << ", now_ms: " << now_ms << ")";
+ return -1;
+ }
}
- if (next_probe_time_.IsFinite() &&
- now - next_probe_time_ > config_.max_probe_delay.Get()) {
- RTC_DLOG(LS_WARNING) << "Probe delay too high"
- << " (next_ms:" << next_probe_time_.ms()
- << ", now_ms: " << now.ms() << ")";
- return Timestamp::PlusInfinity();
- }
-
- return next_probe_time_;
+ return std::max(time_until_probe_ms, 0);
}
PacedPacketInfo BitrateProber::CurrentCluster() const {
@@ -157,19 +160,19 @@
config_.min_probe_delta->ms() / (8 * 1000);
}
-void BitrateProber::ProbeSent(Timestamp now, size_t bytes) {
+void BitrateProber::ProbeSent(int64_t now_ms, size_t bytes) {
RTC_DCHECK(probing_state_ == ProbingState::kActive);
RTC_DCHECK_GT(bytes, 0);
if (!clusters_.empty()) {
ProbeCluster* cluster = &clusters_.front();
if (cluster->sent_probes == 0) {
- RTC_DCHECK(cluster->started_at.IsInfinite());
- cluster->started_at = now;
+ RTC_DCHECK_EQ(cluster->time_started_ms, -1);
+ cluster->time_started_ms = now_ms;
}
cluster->sent_bytes += static_cast<int>(bytes);
cluster->sent_probes += 1;
- next_probe_time_ = CalculateNextProbeTime(*cluster);
+ next_probe_time_ms_ = GetNextProbeTime(*cluster);
if (cluster->sent_bytes >= cluster->pace_info.probe_cluster_min_bytes &&
cluster->sent_probes >= cluster->pace_info.probe_cluster_min_probes) {
RTC_HISTOGRAM_COUNTS_100000("WebRTC.BWE.Probing.ProbeClusterSizeInBytes",
@@ -177,7 +180,7 @@
RTC_HISTOGRAM_COUNTS_100("WebRTC.BWE.Probing.ProbesPerCluster",
cluster->sent_probes);
RTC_HISTOGRAM_COUNTS_10000("WebRTC.BWE.Probing.TimePerProbeCluster",
- (now - cluster->started_at).ms());
+ now_ms - cluster->time_started_ms);
clusters_.pop();
}
@@ -186,17 +189,16 @@
}
}
-Timestamp BitrateProber::CalculateNextProbeTime(
- const ProbeCluster& cluster) const {
+int64_t BitrateProber::GetNextProbeTime(const ProbeCluster& cluster) {
RTC_CHECK_GT(cluster.pace_info.send_bitrate_bps, 0);
- RTC_CHECK(cluster.started_at.IsFinite());
+ RTC_CHECK_GE(cluster.time_started_ms, 0);
// Compute the time delta from the cluster start to ensure probe bitrate stays
// close to the target bitrate. Result is in milliseconds.
- DataSize sent_bytes = DataSize::bytes(cluster.sent_bytes);
- DataRate send_bitrate = DataRate::bps(cluster.pace_info.send_bitrate_bps);
- TimeDelta delta = sent_bytes / send_bitrate;
- return cluster.started_at + delta;
+ int64_t delta_ms =
+ (8000ll * cluster.sent_bytes + cluster.pace_info.send_bitrate_bps / 2) /
+ cluster.pace_info.send_bitrate_bps;
+ return cluster.time_started_ms + delta_ms;
}
} // namespace webrtc
diff --git a/modules/pacing/bitrate_prober.h b/modules/pacing/bitrate_prober.h
index ec234e8..0a9f961 100644
--- a/modules/pacing/bitrate_prober.h
+++ b/modules/pacing/bitrate_prober.h
@@ -61,12 +61,11 @@
// Create a cluster used to probe for |bitrate_bps| with |num_probes| number
// of probes.
- void CreateProbeCluster(DataRate bitrate, Timestamp now, int cluster_id);
+ void CreateProbeCluster(int bitrate_bps, int64_t now_ms, int cluster_id);
- // Returns the at which the next probe should be sent to get accurate probing.
- // If probing is not desired at this time, Timestamp::PlusInfinity() will be
- // returned.
- Timestamp NextProbeTime(Timestamp now) const;
+ // Returns the number of milliseconds until the next probe should be sent to
+ // get accurate probing.
+ int TimeUntilNextProbe(int64_t now_ms);
// Information about the current probing cluster.
PacedPacketInfo CurrentCluster() const;
@@ -79,7 +78,7 @@
// multiple packets per probe, this call would be made at the end of sending
// the last packet in probe. |probe_size| is the total size of all packets
// in probe.
- void ProbeSent(Timestamp now, size_t probe_size);
+ void ProbeSent(int64_t now_ms, size_t probe_size);
private:
enum class ProbingState {
@@ -102,12 +101,12 @@
int sent_probes = 0;
int sent_bytes = 0;
- Timestamp created_at = Timestamp::MinusInfinity();
- Timestamp started_at = Timestamp::MinusInfinity();
+ int64_t time_created_ms = -1;
+ int64_t time_started_ms = -1;
int retries = 0;
};
- Timestamp CalculateNextProbeTime(const ProbeCluster& cluster) const;
+ int64_t GetNextProbeTime(const ProbeCluster& cluster);
ProbingState probing_state_;
@@ -117,7 +116,7 @@
std::queue<ProbeCluster> clusters_;
// Time the next probe should be sent when in kActive state.
- Timestamp next_probe_time_;
+ int64_t next_probe_time_ms_;
int total_probe_count_;
int total_failed_probe_count_;
diff --git a/modules/pacing/bitrate_prober_unittest.cc b/modules/pacing/bitrate_prober_unittest.cc
index 6f3624f..c907cdd 100644
--- a/modules/pacing/bitrate_prober_unittest.cc
+++ b/modules/pacing/bitrate_prober_unittest.cc
@@ -10,8 +10,6 @@
#include "modules/pacing/bitrate_prober.h"
-#include <algorithm>
-
#include "test/gtest.h"
namespace webrtc {
@@ -21,18 +19,17 @@
BitrateProber prober(config);
EXPECT_FALSE(prober.IsProbing());
- Timestamp now = Timestamp::ms(0);
- const Timestamp start_time = now;
- EXPECT_EQ(prober.NextProbeTime(now), Timestamp::PlusInfinity());
+ int64_t now_ms = 0;
+ EXPECT_EQ(-1, prober.TimeUntilNextProbe(now_ms));
- const DataRate kTestBitrate1 = DataRate::kbps(900);
- const DataRate kTestBitrate2 = DataRate::kbps(1800);
+ const int kTestBitrate1 = 900000;
+ const int kTestBitrate2 = 1800000;
const int kClusterSize = 5;
const int kProbeSize = 1000;
- const TimeDelta kMinProbeDuration = TimeDelta::ms(15);
+ const int kMinProbeDurationMs = 15;
- prober.CreateProbeCluster(kTestBitrate1, now, 0);
- prober.CreateProbeCluster(kTestBitrate2, now, 1);
+ prober.CreateProbeCluster(kTestBitrate1, now_ms, 0);
+ prober.CreateProbeCluster(kTestBitrate2, now_ms, 1);
EXPECT_FALSE(prober.IsProbing());
prober.OnIncomingPacket(kProbeSize);
@@ -40,40 +37,39 @@
EXPECT_EQ(0, prober.CurrentCluster().probe_cluster_id);
// First packet should probe as soon as possible.
- EXPECT_EQ(Timestamp::MinusInfinity(), prober.NextProbeTime(now));
+ EXPECT_EQ(0, prober.TimeUntilNextProbe(now_ms));
for (int i = 0; i < kClusterSize; ++i) {
- now = std::max(now, prober.NextProbeTime(now));
- EXPECT_EQ(now, std::max(now, prober.NextProbeTime(now)));
+ now_ms += prober.TimeUntilNextProbe(now_ms);
+ EXPECT_EQ(0, prober.TimeUntilNextProbe(now_ms));
EXPECT_EQ(0, prober.CurrentCluster().probe_cluster_id);
- prober.ProbeSent(now, kProbeSize);
+ prober.ProbeSent(now_ms, kProbeSize);
}
- EXPECT_GE(now - start_time, kMinProbeDuration);
+ EXPECT_GE(now_ms, kMinProbeDurationMs);
// Verify that the actual bitrate is withing 10% of the target.
- DataRate bitrate =
- DataSize::bytes(kProbeSize * (kClusterSize - 1)) / (now - start_time);
+ double bitrate = kProbeSize * (kClusterSize - 1) * 8 * 1000.0 / now_ms;
EXPECT_GT(bitrate, kTestBitrate1 * 0.9);
EXPECT_LT(bitrate, kTestBitrate1 * 1.1);
- now = std::max(now, prober.NextProbeTime(now));
- Timestamp probe2_started = now;
+ now_ms += prober.TimeUntilNextProbe(now_ms);
+ int64_t probe2_started = now_ms;
for (int i = 0; i < kClusterSize; ++i) {
- now = std::max(now, prober.NextProbeTime(now));
- EXPECT_EQ(now, std::max(now, prober.NextProbeTime(now)));
+ now_ms += prober.TimeUntilNextProbe(now_ms);
+ EXPECT_EQ(0, prober.TimeUntilNextProbe(now_ms));
EXPECT_EQ(1, prober.CurrentCluster().probe_cluster_id);
- prober.ProbeSent(now, kProbeSize);
+ prober.ProbeSent(now_ms, kProbeSize);
}
// Verify that the actual bitrate is withing 10% of the target.
- TimeDelta duration = now - probe2_started;
- EXPECT_GE(duration, kMinProbeDuration);
- bitrate = DataSize::bytes(kProbeSize * (kClusterSize - 1)) / duration;
+ int duration = now_ms - probe2_started;
+ EXPECT_GE(duration, kMinProbeDurationMs);
+ bitrate = kProbeSize * (kClusterSize - 1) * 8 * 1000.0 / duration;
EXPECT_GT(bitrate, kTestBitrate2 * 0.9);
EXPECT_LT(bitrate, kTestBitrate2 * 1.1);
- EXPECT_EQ(prober.NextProbeTime(now), Timestamp::PlusInfinity());
+ EXPECT_EQ(-1, prober.TimeUntilNextProbe(now_ms));
EXPECT_FALSE(prober.IsProbing());
}
@@ -81,23 +77,23 @@
const FieldTrialBasedConfig config;
BitrateProber prober(config);
- Timestamp now = Timestamp::Zero();
- EXPECT_EQ(prober.NextProbeTime(now), Timestamp::PlusInfinity());
+ int64_t now_ms = 0;
+ EXPECT_EQ(-1, prober.TimeUntilNextProbe(now_ms));
- prober.CreateProbeCluster(DataRate::kbps(900), now, 0);
+ prober.CreateProbeCluster(900000, now_ms, 0);
EXPECT_FALSE(prober.IsProbing());
prober.OnIncomingPacket(1000);
EXPECT_TRUE(prober.IsProbing());
- EXPECT_EQ(now, std::max(now, prober.NextProbeTime(now)));
- prober.ProbeSent(now, 1000);
+ EXPECT_EQ(0, prober.TimeUntilNextProbe(now_ms));
+ prober.ProbeSent(now_ms, 1000);
// Let time pass, no large enough packets put into prober.
- now += TimeDelta::seconds(6);
- EXPECT_EQ(prober.NextProbeTime(now), Timestamp::PlusInfinity());
+ now_ms += 6000;
+ EXPECT_EQ(-1, prober.TimeUntilNextProbe(now_ms));
// Check that legacy behaviour where prober is reset in TimeUntilNextProbe is
// no longer there. Probes are no longer retried if they are timed out.
prober.OnIncomingPacket(1000);
- EXPECT_EQ(prober.NextProbeTime(now), Timestamp::PlusInfinity());
+ EXPECT_EQ(-1, prober.TimeUntilNextProbe(now_ms));
}
TEST(BitrateProberTest, DoesntInitializeProbingForSmallPackets) {
@@ -115,12 +111,11 @@
const FieldTrialBasedConfig config;
BitrateProber prober(config);
- const DataRate kHighBitrate = DataRate::kbps(10000); // 10 Mbps
+ constexpr unsigned kHighBitrateBps = 10000000; // 10 Mbps
- prober.CreateProbeCluster(kHighBitrate, Timestamp::ms(0), /*cluster_id=*/0);
+ prober.CreateProbeCluster(kHighBitrateBps, 0, /*cluster_id=*/0);
// Probe size should ensure a minimum of 1 ms interval.
- EXPECT_GT(prober.RecommendedMinProbeSize(),
- (kHighBitrate * TimeDelta::ms(1)).bytes<size_t>());
+ EXPECT_GT(prober.RecommendedMinProbeSize(), kHighBitrateBps / 8000);
}
TEST(BitrateProberTest, MinumumNumberOfProbingPackets) {
@@ -128,15 +123,14 @@
BitrateProber prober(config);
// Even when probing at a low bitrate we expect a minimum number
// of packets to be sent.
- const DataRate kBitrate = DataRate::kbps(100);
- const int kPacketSizeBytes = 1000;
+ constexpr int kBitrateBps = 100000; // 100 kbps
+ constexpr int kPacketSizeBytes = 1000;
- Timestamp now = Timestamp::ms(0);
- prober.CreateProbeCluster(kBitrate, now, 0);
+ prober.CreateProbeCluster(kBitrateBps, 0, 0);
prober.OnIncomingPacket(kPacketSizeBytes);
for (int i = 0; i < 5; ++i) {
EXPECT_TRUE(prober.IsProbing());
- prober.ProbeSent(now, kPacketSizeBytes);
+ prober.ProbeSent(0, kPacketSizeBytes);
}
EXPECT_FALSE(prober.IsProbing());
@@ -145,17 +139,16 @@
TEST(BitrateProberTest, ScaleBytesUsedForProbing) {
const FieldTrialBasedConfig config;
BitrateProber prober(config);
- const DataRate kBitrate = DataRate::kbps(10000); // 10 Mbps.
- const int kPacketSizeBytes = 1000;
- const int kExpectedBytesSent = (kBitrate * TimeDelta::ms(15)).bytes();
+ constexpr int kBitrateBps = 10000000; // 10 Mbps
+ constexpr int kPacketSizeBytes = 1000;
+ constexpr int kExpectedBytesSent = kBitrateBps * 15 / 8000;
- Timestamp now = Timestamp::ms(0);
- prober.CreateProbeCluster(kBitrate, now, /*cluster_id=*/0);
+ prober.CreateProbeCluster(kBitrateBps, 0, /*cluster_id=*/0);
prober.OnIncomingPacket(kPacketSizeBytes);
int bytes_sent = 0;
while (bytes_sent < kExpectedBytesSent) {
ASSERT_TRUE(prober.IsProbing());
- prober.ProbeSent(now, kPacketSizeBytes);
+ prober.ProbeSent(0, kPacketSizeBytes);
bytes_sent += kPacketSizeBytes;
}
@@ -165,17 +158,16 @@
TEST(BitrateProberTest, HighBitrateProbing) {
const FieldTrialBasedConfig config;
BitrateProber prober(config);
- const DataRate kBitrate = DataRate::kbps(1000000); // 1 Gbps.
- const int kPacketSizeBytes = 1000;
- const int kExpectedBytesSent = (kBitrate * TimeDelta::ms(15)).bytes();
+ constexpr int kBitrateBps = 1000000000; // 1 Gbps.
+ constexpr int kPacketSizeBytes = 1000;
+ constexpr int kExpectedBytesSent = (kBitrateBps / 8000) * 15;
- Timestamp now = Timestamp::ms(0);
- prober.CreateProbeCluster(kBitrate, now, 0);
+ prober.CreateProbeCluster(kBitrateBps, 0, 0);
prober.OnIncomingPacket(kPacketSizeBytes);
int bytes_sent = 0;
while (bytes_sent < kExpectedBytesSent) {
ASSERT_TRUE(prober.IsProbing());
- prober.ProbeSent(now, kPacketSizeBytes);
+ prober.ProbeSent(0, kPacketSizeBytes);
bytes_sent += kPacketSizeBytes;
}
@@ -185,28 +177,28 @@
TEST(BitrateProberTest, ProbeClusterTimeout) {
const FieldTrialBasedConfig config;
BitrateProber prober(config);
- const DataRate kBitrate = DataRate::kbps(300);
- const int kSmallPacketSize = 20;
+ constexpr int kBitrateBps = 300000; // 300 kbps
+ constexpr int kSmallPacketSize = 20;
// Expecting two probe clusters of 5 packets each.
- const int kExpectedBytesSent = 20 * 2 * 5;
- const TimeDelta kTimeout = TimeDelta::ms(5000);
+ constexpr int kExpectedBytesSent = 20 * 2 * 5;
+ constexpr int64_t kTimeoutMs = 5000;
- Timestamp now = Timestamp::ms(0);
- prober.CreateProbeCluster(kBitrate, now, /*cluster_id=*/0);
+ int64_t now_ms = 0;
+ prober.CreateProbeCluster(kBitrateBps, now_ms, /*cluster_id=*/0);
prober.OnIncomingPacket(kSmallPacketSize);
EXPECT_FALSE(prober.IsProbing());
- now += kTimeout;
- prober.CreateProbeCluster(kBitrate / 10, now, /*cluster_id=*/1);
+ now_ms += kTimeoutMs;
+ prober.CreateProbeCluster(kBitrateBps / 10, now_ms, /*cluster_id=*/1);
prober.OnIncomingPacket(kSmallPacketSize);
EXPECT_FALSE(prober.IsProbing());
- now += TimeDelta::ms(1);
- prober.CreateProbeCluster(kBitrate / 10, now, /*cluster_id=*/2);
+ now_ms += 1;
+ prober.CreateProbeCluster(kBitrateBps / 10, now_ms, /*cluster_id=*/2);
prober.OnIncomingPacket(kSmallPacketSize);
EXPECT_TRUE(prober.IsProbing());
int bytes_sent = 0;
while (bytes_sent < kExpectedBytesSent) {
ASSERT_TRUE(prober.IsProbing());
- prober.ProbeSent(now, kSmallPacketSize);
+ prober.ProbeSent(0, kSmallPacketSize);
bytes_sent += kSmallPacketSize;
}
diff --git a/modules/pacing/paced_sender.cc b/modules/pacing/paced_sender.cc
index a961f5b..0579b8e 100644
--- a/modules/pacing/paced_sender.cc
+++ b/modules/pacing/paced_sender.cc
@@ -36,7 +36,6 @@
static_cast<PacingController::PacketSender*>(this),
event_log,
field_trials),
- clock_(clock),
packet_router_(packet_router),
process_thread_(process_thread) {
if (process_thread_)
@@ -137,9 +136,9 @@
.ms();
}
- Timestamp next_probe = pacing_controller_.NextProbeTime();
- if (next_probe != Timestamp::PlusInfinity()) {
- return std::max(TimeDelta::Zero(), next_probe - clock_->CurrentTime()).ms();
+ auto next_probe = pacing_controller_.TimeUntilNextProbe();
+ if (next_probe) {
+ return next_probe->ms();
}
const TimeDelta min_packet_limit = TimeDelta::ms(5);
diff --git a/modules/pacing/paced_sender.h b/modules/pacing/paced_sender.h
index 3539c53..f28cb63 100644
--- a/modules/pacing/paced_sender.h
+++ b/modules/pacing/paced_sender.h
@@ -165,7 +165,6 @@
rtc::CriticalSection critsect_;
PacingController pacing_controller_ RTC_GUARDED_BY(critsect_);
- Clock* const clock_;
PacketRouter* const packet_router_;
ProcessThread* const process_thread_;
};
diff --git a/modules/pacing/pacing_controller.cc b/modules/pacing/pacing_controller.cc
index de31a9e..b603bce 100644
--- a/modules/pacing/pacing_controller.cc
+++ b/modules/pacing/pacing_controller.cc
@@ -123,7 +123,7 @@
PacingController::~PacingController() = default;
void PacingController::CreateProbeCluster(DataRate bitrate, int cluster_id) {
- prober_.CreateProbeCluster(bitrate, CurrentTime(), cluster_id);
+ prober_.CreateProbeCluster(bitrate.bps(), CurrentTime().ms(), cluster_id);
}
void PacingController::Pause() {
@@ -233,10 +233,10 @@
void PacingController::EnqueuePacketInternal(
std::unique_ptr<RtpPacketToSend> packet,
int priority) {
+ Timestamp now = CurrentTime();
prober_.OnIncomingPacket(packet->payload_size());
// TODO(sprang): Make sure tests respect this, replace with DCHECK.
- Timestamp now = CurrentTime();
if (packet->capture_time_ms() < 0) {
packet->set_capture_time_ms(now.ms());
}
@@ -272,26 +272,19 @@
return false;
}
-Timestamp PacingController::NextProbeTime() {
+absl::optional<TimeDelta> PacingController::TimeUntilNextProbe() {
if (!prober_.IsProbing()) {
- return Timestamp::PlusInfinity();
+ return absl::nullopt;
}
- Timestamp now = CurrentTime();
- Timestamp probe_time = prober_.NextProbeTime(now);
- if (probe_time.IsInfinite()) {
- return probe_time;
+ TimeDelta time_delta =
+ TimeDelta::ms(prober_.TimeUntilNextProbe(CurrentTime().ms()));
+ if (time_delta > TimeDelta::Zero() ||
+ (time_delta == TimeDelta::Zero() && !probing_send_failure_)) {
+ return time_delta;
}
- if (probe_time > now) {
- return probe_time;
- }
-
- if (probing_send_failure_ || now - probe_time > TimeDelta::Zero()) {
- return Timestamp::PlusInfinity();
- }
-
- return probe_time;
+ return absl::nullopt;
}
TimeDelta PacingController::TimeElapsedSinceLastProcess() const {
@@ -407,7 +400,7 @@
if (is_probing) {
probing_send_failure_ = data_sent == DataSize::Zero();
if (!probing_send_failure_) {
- prober_.ProbeSent(CurrentTime(), data_sent.bytes());
+ prober_.ProbeSent(CurrentTime().ms(), data_sent.bytes());
}
}
}
diff --git a/modules/pacing/pacing_controller.h b/modules/pacing/pacing_controller.h
index 6f3f9fb..d0e68a9 100644
--- a/modules/pacing/pacing_controller.h
+++ b/modules/pacing/pacing_controller.h
@@ -118,11 +118,10 @@
// effect.
void SetProbingEnabled(bool enabled);
- // Time at which next probe should be sent. If this value is set, it should be
+ // Time until next probe should be sent. If this value is set, it should be
// respected - i.e. don't call ProcessPackets() before this specified time as
// that can have unintended side effects.
- // If no scheduled probe, Timestamp::PlusInifinity() is returned.
- Timestamp NextProbeTime();
+ absl::optional<TimeDelta> TimeUntilNextProbe();
// Time since ProcessPackets() was last executed.
TimeDelta TimeElapsedSinceLastProcess() const;
diff --git a/modules/pacing/pacing_controller_unittest.cc b/modules/pacing/pacing_controller_unittest.cc
index 8727e07..caec575 100644
--- a/modules/pacing/pacing_controller_unittest.cc
+++ b/modules/pacing/pacing_controller_unittest.cc
@@ -246,9 +246,9 @@
TimeDelta::Zero());
}
- Timestamp next_probe = pacer_->NextProbeTime();
- if (next_probe != Timestamp::PlusInfinity()) {
- return std::max(TimeDelta::Zero(), next_probe - clock_.CurrentTime());
+ auto next_probe = pacer_->TimeUntilNextProbe();
+ if (next_probe) {
+ return *next_probe;
}
const TimeDelta min_packet_limit = TimeDelta::ms(5);