Implement periodic bandwidth probing in application-limited region.

webrtc/modules/congestion_controller/probe_controller.cc

Index: webrtc/modules/congestion_controller/probe_controller.cc
diff --git a/webrtc/modules/congestion_controller/probe_controller.cc b/webrtc/modules/congestion_controller/probe_controller.cc
index 272c1eb4e598c82b859beab9548e5258b8dcea4e..bd944ed020152e840be37ecb3abcaaa723808783 100644
--- a/webrtc/modules/congestion_controller/probe_controller.cc
+++ b/webrtc/modules/congestion_controller/probe_controller.cc
@@ -38,8 +38,11 @@ constexpr int kExponentialProbingDisabled = 0;
 constexpr int kDefaultMaxProbingBitrateBps = 100000000;
 
 // This is a limit on how often probing can be done when there is a BW
-// drop detected in ALR region.
-constexpr int kAlrProbingIntervalLimitMs = 5000;
+// drop detected in ALR.
+constexpr int64_t kAlrProbingIntervalMinMs = 5000;
+
+// Interval between probes when ALR periodic probing is enabled.
+constexpr int64_t kAlrPeriodicProbingIntervalMs = 5000;
 
 }  // namespace
 
@@ -53,7 +56,8 @@ ProbeController::ProbeController(PacedSender* pacer, Clock* clock)
       estimated_bitrate_bps_(0),
       start_bitrate_bps_(0),
       max_bitrate_bps_(0),
-      last_alr_probing_time_(clock_->TimeInMilliseconds()) {}
+      last_alr_probing_time_(clock_->TimeInMilliseconds()),
+      enable_periodic_probing_(false) {}
 
 void ProbeController::SetBitrates(int min_bitrate_bps,
                                   int start_bitrate_bps,
@@ -80,7 +84,8 @@ void ProbeController::SetBitrates(int min_bitrate_bps,
       if (estimated_bitrate_bps_ != 0 &&
           estimated_bitrate_bps_ < old_max_bitrate_bps &&
           max_bitrate_bps_ > old_max_bitrate_bps) {
-        InitiateProbing({max_bitrate_bps}, kExponentialProbingDisabled);
+        InitiateProbing(clock_->TimeInMilliseconds(), {max_bitrate_bps},
+                        kExponentialProbingDisabled);
       }
       break;
   }
@@ -100,14 +105,17 @@ void ProbeController::InitiateExponentialProbing() {
 
   // When probing at 1.8 Mbps ( 6x 300), this represents a threshold of
   // 1.2 Mbps to continue probing.
-  InitiateProbing({3 * start_bitrate_bps_, 6 * start_bitrate_bps_},
+  InitiateProbing(clock_->TimeInMilliseconds(),
+                  {3 * start_bitrate_bps_, 6 * start_bitrate_bps_},
                   4 * start_bitrate_bps_);
 }
 
 void ProbeController::SetEstimatedBitrate(int bitrate_bps) {
   rtc::CritScope cs(&critsect_);
+  int64_t now_ms = clock_->TimeInMilliseconds();
+
   if (state_ == State::kWaitingForProbingResult) {
-    if ((clock_->TimeInMilliseconds() - time_last_probing_initiated_ms_) >
+    if ((now_ms - time_last_probing_initiated_ms_) >
         kMaxWaitingTimeForProbingResultMs) {
       LOG(LS_INFO) << "kWaitingForProbingResult: timeout";
       state_ = State::kProbingComplete;
@@ -122,38 +130,69 @@ void ProbeController::SetEstimatedBitrate(int bitrate_bps) {
           bitrate_bps > min_bitrate_to_probe_further_bps_) {
         // Double the probing bitrate and expect a minimum of 25% gain to
         // continue probing.
-        InitiateProbing({2 * bitrate_bps}, 1.25 * bitrate_bps);
-      }
-    }
-  } else {
-    // A drop in estimated BW when operating in ALR and not already probing.
-    // The current response is to initiate a single probe session at the
-    // previous bitrate and immediately use the reported bitrate as the new
-    // bitrate.
-    //
-    // If the probe session fails, the assumption is that this drop was a
-    // real one from a competing flow or something else on the network and
-    // it ramps up from bitrate_bps.
-    if (pacer_->InApplicationLimitedRegion() &&
-        bitrate_bps < 0.5 * estimated_bitrate_bps_) {
-      int64_t now_ms = clock_->TimeInMilliseconds();
-      if ((now_ms - last_alr_probing_time_) > kAlrProbingIntervalLimitMs) {
-        LOG(LS_INFO) << "Detected big BW drop in ALR, start probe.";
-        // Track how often we probe in response to BW drop in ALR.
-        RTC_HISTOGRAM_COUNTS_10000("WebRTC.BWE.AlrProbingIntervalInS",
-                                   (now_ms - last_alr_probing_time_) / 1000);
-        InitiateProbing({estimated_bitrate_bps_}, kExponentialProbingDisabled);
-        last_alr_probing_time_ = now_ms;
+        InitiateProbing(now_ms, {2 * bitrate_bps}, bitrate_bps * 5 / 4);
+      } else {
+        // Stop exponential probing.
+        state_ = State::kProbingComplete;
+        min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled;
       }
     }
+  }
+
+  // Detect a drop in estimated BW when operating in ALR and not already
+  // probing. The current response is to initiate a single probe session at the
+  // previous bitrate and immediately use the reported bitrate as the new
+  // bitrate.
+  //
+  // If the probe session fails, the assumption is that this drop was a
+  // real one from a competing flow or something else on the network and
+  // it ramps up from bitrate_bps.
+  if (state_ == State::kProbingComplete &&
+      pacer_->GetApplicationLimitedRegionStartTime() &&
+      bitrate_bps < estimated_bitrate_bps_ / 2 &&
+      (now_ms - last_alr_probing_time_) > kAlrProbingIntervalMinMs) {
+    LOG(LS_INFO) << "Detected big BW drop in ALR, start probe.";
+    // Track how often we probe in response to BW drop in ALR.
+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.BWE.AlrProbingIntervalInS",
+                               (now_ms - last_alr_probing_time_) / 1000);
+    InitiateProbing(now_ms, {estimated_bitrate_bps_},
+                    kExponentialProbingDisabled);
+    last_alr_probing_time_ = now_ms;
+
     // TODO(isheriff): May want to track when we did ALR probing in order
     // to reset |last_alr_probing_time_| if we validate that it was a
     // drop due to exogenous event.
   }
+
   estimated_bitrate_bps_ = bitrate_bps;
 }
 
+void ProbeController::EnablePeriodicProbing(bool enable) {
+  rtc::CritScope cs(&critsect_);
+  enable_periodic_probing_ = enable;
+}
+
+void ProbeController::Process() {
+  rtc::CritScope cs(&critsect_);
+
+  if (state_ != State::kProbingComplete || !enable_periodic_probing_)
+    return;
+
+  // Probe bandwidth periodically when in ALR state.
+  int64_t alr_start_time = pacer_->GetApplicationLimitedRegionStartTime();
+  if (alr_start_time > 0) {
+    int64_t now_ms = clock_->TimeInMilliseconds();
+    if (now_ms - alr_start_time >= kAlrPeriodicProbingIntervalMs &&

[philipel, 2016/11/21 12:05:42]

I think something like this is a bit clearer:
int64_t next_probe_time_ms = std::max(alr_start_time,
time_last_probing_initiated_ms_) + kAlrPeriodicProbingIntervalMs;
if (next_probe_time_ms <= now_ms) ...

not super important though...

[Sergey Ulanov, 2016/11/21 19:28:18]

Done.

+        now_ms - time_last_probing_initiated_ms_ >=
+            kAlrPeriodicProbingIntervalMs) {
+      InitiateProbing(now_ms, {estimated_bitrate_bps_ * 2},
+                      estimated_bitrate_bps_ * 5 / 4);
+    }
+  }
+}
+
 void ProbeController::InitiateProbing(
+    int64_t now_ms,

[philipel, 2016/11/21 12:05:42]

I don't see why this change is necessary or makes things cleaner. 

[Sergey Ulanov, 2016/11/21 19:28:18]

TimeInMilliseconds() calls are not free, each of them requires a system call, so
it's wasteful to call it more then necessary.

     std::initializer_list<int> bitrates_to_probe,
     int min_bitrate_to_probe_further_bps) {
   bool first_cluster = true;
@@ -169,7 +208,7 @@ void ProbeController::InitiateProbing(
     }
   }
   min_bitrate_to_probe_further_bps_ = min_bitrate_to_probe_further_bps;
-  time_last_probing_initiated_ms_ = clock_->TimeInMilliseconds();
+  time_last_probing_initiated_ms_ = now_ms;
   if (min_bitrate_to_probe_further_bps == kExponentialProbingDisabled)
     state_ = State::kProbingComplete;
   else