Add probing to recover faster from large bitrate drops.

webrtc/modules/congestion_controller/delay_based_bwe.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 28 matching lines @@
 // after the API has been changed.
 constexpr uint32_t kFixedSsrc = 0;
 
 // Parameters for linear least squares fit of regression line to noisy data.
 constexpr size_t kDefaultTrendlineWindowSize = 20;
 constexpr double kDefaultTrendlineSmoothingCoeff = 0.9;
 constexpr double kDefaultTrendlineThresholdGain = 4.0;
 
 constexpr int kMaxConsecutiveFailedLookups = 5;
 
+// If the bitrate drops to a factor |kBitrateDropThreshold| or lower
+// and we recover within |kBitrateDropTimeLimitMs|, then we'll send
+// a probe at a fraction |kBitrateDropProbeFraction| of the original bitrate.
+constexpr double kBitrateDropThreshold = 0.5;
+constexpr int kBitrateDropTimeLimitMs = 3000;
+constexpr double kBitrateDropProbeFraction = 0.85;
+
 const char kBweSparseUpdateExperiment[] = "WebRTC-BweSparseUpdateExperiment";
 
 bool BweSparseUpdateExperimentIsEnabled() {
   std::string experiment_string =
       webrtc::field_trial::FindFullName(kBweSparseUpdateExperiment);
   return experiment_string == "Enabled";
 }
 }  // namespace
 
 namespace webrtc {
 
+DelayBasedBwe::Result::Result()
+    : updated(false),
+      probe(false),
+      target_bitrate_bps(0),
+      suggested_probe_bps() {}
+
+DelayBasedBwe::Result::Result(bool probe, uint32_t target_bitrate_bps)
+    : updated(true),
+      probe(probe),
+      target_bitrate_bps(target_bitrate_bps),
+      suggested_probe_bps() {}
+
+DelayBasedBwe::Result::Result(bool probe,
+                              uint32_t target_bitrate_bps,
+                              uint32_t suggested_probe_bps)
+    : updated(true),
+      probe(probe),
+      target_bitrate_bps(target_bitrate_bps),
+      suggested_probe_bps(suggested_probe_bps) {}
+
+DelayBasedBwe::Result::~Result() {}
+
 DelayBasedBwe::DelayBasedBwe(RtcEventLog* event_log, const Clock* clock)
     : event_log_(event_log),
       clock_(clock),
       inter_arrival_(),
       trendline_estimator_(),
       detector_(),
       last_seen_packet_ms_(-1),
       uma_recorded_(false),
       probe_bitrate_estimator_(event_log),
       trendline_window_size_(kDefaultTrendlineWindowSize),
@@ skipping 25 matching lines @@
   }
 
   if (!uma_recorded_) {
     RTC_HISTOGRAM_ENUMERATION(kBweTypeHistogram,
                               BweNames::kSendSideTransportSeqNum,
                               BweNames::kBweNamesMax);
     uma_recorded_ = true;
   }
   bool overusing = false;
   bool delayed_feedback = true;
+  bool request_probe = false;
+  BandwidthUsage prev_detector_state = detector_.State();
   for (const auto& packet_feedback : packet_feedback_vector) {
     if (packet_feedback.send_time_ms < 0)
       continue;
     delayed_feedback = false;
     IncomingPacketFeedback(packet_feedback);
     if (!in_sparse_update_experiment_)
       overusing |= (detector_.State() == BandwidthUsage::kBwOverusing);
+    if (prev_detector_state == BandwidthUsage::kBwUnderusing &&
+        detector_.State() == BandwidthUsage::kBwNormal) {
+      request_probe = true;
+    }
+    prev_detector_state = detector_.State();
   }
   if (in_sparse_update_experiment_)
     overusing = (detector_.State() == BandwidthUsage::kBwOverusing);
+
   if (delayed_feedback) {
     ++consecutive_delayed_feedbacks_;
     if (consecutive_delayed_feedbacks_ >= kMaxConsecutiveFailedLookups) {
       consecutive_delayed_feedbacks_ = 0;
       return OnLongFeedbackDelay(packet_feedback_vector.back().arrival_time_ms);
     }
   } else {
     consecutive_delayed_feedbacks_ = 0;
-    return MaybeUpdateEstimate(overusing, acked_bitrate_bps);
+    return MaybeUpdateEstimate(overusing, acked_bitrate_bps, request_probe);
   }
   return Result();
 }
 
 DelayBasedBwe::Result DelayBasedBwe::OnLongFeedbackDelay(
     int64_t arrival_time_ms) {
   // Estimate should always be valid since a start bitrate always is set in the
   // Call constructor. An alternative would be to return an empty Result here,
   // or to estimate the throughput based on the feedback we received.
   RTC_DCHECK(rate_control_.ValidEstimate());
@@ skipping 48 matching lines @@
                      packet_feedback.arrival_time_ms);
   }
   if (packet_feedback.pacing_info.probe_cluster_id !=
       PacedPacketInfo::kNotAProbe) {
     probe_bitrate_estimator_.HandleProbeAndEstimateBitrate(packet_feedback);
   }
 }
 
 DelayBasedBwe::Result DelayBasedBwe::MaybeUpdateEstimate(
     bool overusing,
-    rtc::Optional<uint32_t> acked_bitrate_bps) {
+    rtc::Optional<uint32_t> acked_bitrate_bps,
+    bool request_probe) {
   Result result;
   int64_t now_ms = clock_->TimeInMilliseconds();
 
   rtc::Optional<int> probe_bitrate_bps =
       probe_bitrate_estimator_.FetchAndResetLastEstimatedBitrateBps();
   // Currently overusing the bandwidth.
   if (overusing) {
     if (acked_bitrate_bps &&
         rate_control_.TimeToReduceFurther(now_ms, *acked_bitrate_bps)) {
       result.updated = UpdateEstimate(now_ms, acked_bitrate_bps, overusing,
@@ skipping 13 matching lines @@
     }
   } else {
     if (probe_bitrate_bps) {
       result.probe = true;
       result.updated = true;
       result.target_bitrate_bps = *probe_bitrate_bps;
       rate_control_.SetEstimate(*probe_bitrate_bps, now_ms);
     } else {
       result.updated = UpdateEstimate(now_ms, acked_bitrate_bps, overusing,
                                       &result.target_bitrate_bps);
+      if (request_probe &&
+          result.target_bitrate_bps <
+              kBitrateDropProbeFraction * bitrate_before_last_large_drop_ &&

[philipel, 2017/07/25 11:26:04]

I think a slightly clearer way of doing this check is to replace 
"result.target_bitrate_bps < 
    kBitrateDropProbeFraction * bitrate_before_last_large_drop_"
with
"time_of_last_drop_ms_ == now_ms"

[terelius, 2017/07/27 21:02:45]

It is not the same thing. However, it seems a bit redundant to check that we're
not probing at a lower bitrate that the current target both here and in the
ProbeController. The main difference is that the ProbeController gets its
estimate from the BitrateController. One the other hand, maybe it is safer and
clearer to do the similar checks in both places? WDYT?

[terelius, 2017/07/28 17:14:47]

Moved the entire drop detection into the ProbeController as discussed offline.

+          now_ms - time_of_last_large_drop_ms_ < kBitrateDropTimeLimitMs) {
+        result.suggested_probe_bps = static_cast<rtc::Optional<uint32_t>>(

[philipel, 2017/07/25 11:26:04]

result.suggested_probe_bps.emplace 

[terelius, 2017/07/27 21:02:45]

Done.

+            kBitrateDropProbeFraction * bitrate_before_last_large_drop_);
+      }
     }
   }
   if (result.updated) {
     BWE_TEST_LOGGING_PLOT(1, "target_bitrate_bps", now_ms,
                           result.target_bitrate_bps);
     if (event_log_ && (result.target_bitrate_bps != last_logged_bitrate_ ||
                        detector_.State() != last_logged_state_)) {
       event_log_->LogDelayBasedBweUpdate(result.target_bitrate_bps,
                                          detector_.State());
       last_logged_bitrate_ = result.target_bitrate_bps;
       last_logged_state_ = detector_.State();
     }
   }
   return result;
 }
 
 bool DelayBasedBwe::UpdateEstimate(int64_t now_ms,
                                    rtc::Optional<uint32_t> acked_bitrate_bps,
                                    bool overusing,
                                    uint32_t* target_bitrate_bps) {
   // TODO(terelius): RateControlInput::noise_var is deprecated and will be
   // removed. In the meantime, we set it to zero.
   const RateControlInput input(
       overusing ? BandwidthUsage::kBwOverusing : detector_.State(),
       acked_bitrate_bps, 0);
   uint32_t prev_target_bitrate_bps = rate_control_.LatestEstimate();
   *target_bitrate_bps = rate_control_.Update(&input, now_ms);
+  if (*target_bitrate_bps < kBitrateDropThreshold * prev_target_bitrate_bps) {
+    time_of_last_large_drop_ms_ = now_ms;
+    bitrate_before_last_large_drop_ = prev_target_bitrate_bps;
+  }
   return rate_control_.ValidEstimate() &&
          prev_target_bitrate_bps != *target_bitrate_bps;
 }
 
 void DelayBasedBwe::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
   rate_control_.SetRtt(avg_rtt_ms);
 }
 
 bool DelayBasedBwe::LatestEstimate(std::vector<uint32_t>* ssrcs,
                                    uint32_t* bitrate_bps) const {
@@ skipping 19 matching lines @@
 void DelayBasedBwe::SetMinBitrate(int min_bitrate_bps) {
   // Called from both the configuration thread and the network thread. Shouldn't
   // be called from the network thread in the future.
   rate_control_.SetMinBitrate(min_bitrate_bps);
 }
 
 int64_t DelayBasedBwe::GetExpectedBwePeriodMs() const {
   return rate_control_.GetExpectedBandwidthPeriodMs();
 }
 }  // namespace webrtc