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

Preparing for task queue in congenstion controller

Browse Source 
This cl prepares for a later CL introducing a new send side congestion
controller that will run on a task queue. It mostly consists of minor
fixes but adds some new interfaces that are unused in practice.

Bug: webrtc:8415
Change-Id: I1b58d0180a18eb15320d18733dac0dfe2e0f902a
Reviewed-on: https://webrtc-review.googlesource.com/53321
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22099}
This commit is contained in:
Sebastian Jansson
2018-02-20 10:46:39 +01:00
committed by Commit Bot
parent 645898a454
commit 439f0bc69a
17 changed files with 159 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
modules/bitrate_controller/bitrate_controller_unittest.cc
View File

@ -340,11 +340,11 @@ TEST_F(BitrateControllerTest, OneBitrateObserverMultipleReportBlocks) {
report_blocks.clear();
// All packets lost on stream with few packets, no back-off.
report_blocks.push_back(CreateReportBlock(1, 2, 1, sequence_number[0]));
report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
report_blocks.push_back(CreateReportBlock(1, 3, 255, sequence_number[1]));
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
EXPECT_EQ(bitrate_observer_.last_bitrate_, last_bitrate);
EXPECT_EQ(WeightedLoss(20, 1, 1, 255), bitrate_observer_.last_fraction_loss_);
EXPECT_EQ(WeightedLoss(20, 0, 1, 255), bitrate_observer_.last_fraction_loss_);
EXPECT_EQ(50, bitrate_observer_.last_rtt_);
last_bitrate = bitrate_observer_.last_bitrate_;
sequence_number[0] += 20;

59
modules/bitrate_controller/send_side_bandwidth_estimation.cc
View File

@ -105,7 +105,7 @@ bool ReadBweLossExperimentParameters(float* low_loss_threshold,
} // namespace
SendSideBandwidthEstimation::SendSideBandwidthEstimation(RtcEventLog* event_log)
: lost_packets_since_last_loss_update_Q8_(0),
: lost_packets_since_last_loss_update_(0),
expected_packets_since_last_loss_update_(0),
current_bitrate_bps_(0),
min_bitrate_configured_(congestion_controller::GetMinBitrateBps()),
@ -125,6 +125,7 @@ SendSideBandwidthEstimation::SendSideBandwidthEstimation(RtcEventLog* event_log)
initially_lost_packets_(0),
bitrate_at_2_seconds_kbps_(0),
uma_update_state_(kNoUpdate),
uma_rtt_state_(kNoUpdate),
rampup_uma_stats_updated_(kNumUmaRampupMetrics, false),
event_log_(event_log),
last_rtc_event_log_ms_(-1),
@ -206,24 +207,28 @@ void SendSideBandwidthEstimation::UpdateDelayBasedEstimate(
}
void SendSideBandwidthEstimation::UpdateReceiverBlock(uint8_t fraction_loss,
int64_t rtt,
int64_t rtt_ms,
int number_of_packets,
int64_t now_ms) {
const int kRoundingConstant = 128;
int packets_lost = (static_cast<int>(fraction_loss) * number_of_packets +
kRoundingConstant) >>
8;
UpdatePacketsLost(packets_lost, number_of_packets, now_ms);
UpdateRtt(rtt_ms, now_ms);
}
void SendSideBandwidthEstimation::UpdatePacketsLost(int packets_lost,
int number_of_packets,
int64_t now_ms) {
last_feedback_ms_ = now_ms;
if (first_report_time_ms_ == -1)
first_report_time_ms_ = now_ms;
// Update RTT if we were able to compute an RTT based on this RTCP.
// FlexFEC doesn't send RTCP SR, which means we won't be able to compute RTT.
if (rtt > 0)
last_round_trip_time_ms_ = rtt;
// Check sequence number diff and weight loss report
if (number_of_packets > 0) {
// Calculate number of lost packets.
const int num_lost_packets_Q8 = fraction_loss * number_of_packets;
// Accumulate reports.
lost_packets_since_last_loss_update_Q8_ += num_lost_packets_Q8;
lost_packets_since_last_loss_update_ += packets_lost;
expected_packets_since_last_loss_update_ += number_of_packets;
// Don't generate a loss rate until it can be based on enough packets.
@ -231,21 +236,22 @@ void SendSideBandwidthEstimation::UpdateReceiverBlock(uint8_t fraction_loss,
return;
has_decreased_since_last_fraction_loss_ = false;
last_fraction_loss_ = lost_packets_since_last_loss_update_Q8_ /
expected_packets_since_last_loss_update_;
int64_t lost_q8 = lost_packets_since_last_loss_update_ << 8;
int64_t expected = expected_packets_since_last_loss_update_;
last_fraction_loss_ = std::min<int>(lost_q8 / expected, 255);
// Reset accumulators.
lost_packets_since_last_loss_update_Q8_ = 0;
lost_packets_since_last_loss_update_ = 0;
expected_packets_since_last_loss_update_ = 0;
last_packet_report_ms_ = now_ms;
UpdateEstimate(now_ms);
}
UpdateUmaStats(now_ms, rtt, (fraction_loss * number_of_packets) >> 8);
UpdateUmaStatsPacketsLost(now_ms, packets_lost);
}
void SendSideBandwidthEstimation::UpdateUmaStats(int64_t now_ms,
int64_t rtt,
int lost_packets) {
void SendSideBandwidthEstimation::UpdateUmaStatsPacketsLost(int64_t now_ms,
int packets_lost) {
int bitrate_kbps = static_cast<int>((current_bitrate_bps_ + 500) / 1000);
for (size_t i = 0; i < kNumUmaRampupMetrics; ++i) {
if (!rampup_uma_stats_updated_[i] &&
@ -256,14 +262,12 @@ void SendSideBandwidthEstimation::UpdateUmaStats(int64_t now_ms,
}
}
if (IsInStartPhase(now_ms)) {
initially_lost_packets_ += lost_packets;
initially_lost_packets_ += packets_lost;
} else if (uma_update_state_ == kNoUpdate) {
uma_update_state_ = kFirstDone;
bitrate_at_2_seconds_kbps_ = bitrate_kbps;
RTC_HISTOGRAM_COUNTS("WebRTC.BWE.InitiallyLostPackets",
initially_lost_packets_, 0, 100, 50);
RTC_HISTOGRAM_COUNTS("WebRTC.BWE.InitialRtt", static_cast<int>(rtt), 0,
2000, 50);
RTC_HISTOGRAM_COUNTS("WebRTC.BWE.InitialBandwidthEstimate",
bitrate_at_2_seconds_kbps_, 0, 2000, 50);
} else if (uma_update_state_ == kFirstDone &&
@ -276,6 +280,19 @@ void SendSideBandwidthEstimation::UpdateUmaStats(int64_t now_ms,
}
}
void SendSideBandwidthEstimation::UpdateRtt(int64_t rtt_ms, int64_t now_ms) {
// Update RTT if we were able to compute an RTT based on this RTCP.
// FlexFEC doesn't send RTCP SR, which means we won't be able to compute RTT.
if (rtt_ms > 0)
last_round_trip_time_ms_ = rtt_ms;
if (!IsInStartPhase(now_ms) && uma_rtt_state_ == kNoUpdate) {
uma_rtt_state_ = kDone;
RTC_HISTOGRAM_COUNTS("WebRTC.BWE.InitialRtt", static_cast<int>(rtt_ms), 0,
2000, 50);
}
}
void SendSideBandwidthEstimation::UpdateEstimate(int64_t now_ms) {
uint32_t new_bitrate = current_bitrate_bps_;
// We trust the REMB and/or delay-based estimate during the first 2 seconds if
@ -357,7 +374,7 @@ void SendSideBandwidthEstimation::UpdateEstimate(int64_t now_ms) {
new_bitrate *= 0.8;
// Reset accumulators since we've already acted on missing feedback and
// shouldn't to act again on these old lost packets.
lost_packets_since_last_loss_update_Q8_ = 0;
lost_packets_since_last_loss_update_ = 0;
expected_packets_since_last_loss_update_ = 0;
last_timeout_ms_ = now_ms;
}

15
modules/bitrate_controller/send_side_bandwidth_estimation.h
View File

@ -42,10 +42,18 @@ class SendSideBandwidthEstimation {
// Call when we receive a RTCP message with a ReceiveBlock.
void UpdateReceiverBlock(uint8_t fraction_loss,
int64_t rtt,
int64_t rtt_ms,
int number_of_packets,
int64_t now_ms);
// Call when we receive a RTCP message with a ReceiveBlock.
void UpdatePacketsLost(int packets_lost,
int number_of_packets,
int64_t now_ms);
// Call when we receive a RTCP message with a ReceiveBlock.
void UpdateRtt(int64_t rtt, int64_t now_ms);
void SetBitrates(int send_bitrate,
int min_bitrate,
int max_bitrate);
@ -58,7 +66,7 @@ class SendSideBandwidthEstimation {
bool IsInStartPhase(int64_t now_ms) const;
void UpdateUmaStats(int64_t now_ms, int64_t rtt, int lost_packets);
void UpdateUmaStatsPacketsLost(int64_t now_ms, int packets_lost);
// Updates history of min bitrates.
// After this method returns min_bitrate_history_.front().second contains the
@ -72,7 +80,7 @@ class SendSideBandwidthEstimation {
std::deque<std::pair<int64_t, uint32_t> > min_bitrate_history_;
// incoming filters
int lost_packets_since_last_loss_update_Q8_;
int lost_packets_since_last_loss_update_;
int expected_packets_since_last_loss_update_;
uint32_t current_bitrate_bps_;
@ -95,6 +103,7 @@ class SendSideBandwidthEstimation {
int initially_lost_packets_;
int bitrate_at_2_seconds_kbps_;
UmaState uma_update_state_;
UmaState uma_rtt_state_;
std::vector<bool> rampup_uma_stats_updated_;
RtcEventLog* event_log_;
int64_t last_rtc_event_log_ms_;