Add WebRTC.BWE.MidCallProbing.* metrics.

webrtc/modules/congestion_controller/probe_controller.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 40 matching lines @@
     : pacer_(pacer),
       clock_(clock),
       network_state_(kNetworkUp),
       state_(State::kInit),
       min_bitrate_to_probe_further_bps_(kExponentialProbingDisabled),
       time_last_probing_initiated_ms_(0),
       estimated_bitrate_bps_(0),
       start_bitrate_bps_(0),
       max_bitrate_bps_(0),
       last_alr_probing_time_(clock_->TimeInMilliseconds()),
-      enable_periodic_alr_probing_(false) {}
+      enable_periodic_alr_probing_(false),
+      mid_call_probing_waiting_for_result_(false) {}
 
 void ProbeController::SetBitrates(int64_t min_bitrate_bps,
                                   int64_t start_bitrate_bps,
                                   int64_t max_bitrate_bps) {
   rtc::CritScope cs(&critsect_);
 
   if (start_bitrate_bps > 0)  {
     start_bitrate_bps_ = start_bitrate_bps;
   } else if (start_bitrate_bps_ == 0) {
     start_bitrate_bps_ = min_bitrate_bps;
   }
 
   int64_t old_max_bitrate_bps = max_bitrate_bps_;
   max_bitrate_bps_ = max_bitrate_bps;
 
   switch (state_) {
     case State::kInit:
       if (network_state_ == kNetworkUp)
         InitiateExponentialProbing();
       break;
 
     case State::kWaitingForProbingResult:
       break;
 
     case State::kProbingComplete:
       // Initiate probing when |max_bitrate_| was increased mid-call.
       if (estimated_bitrate_bps_ != kExponentialProbingDisabled &&
           estimated_bitrate_bps_ < old_max_bitrate_bps &&
           max_bitrate_bps_ > old_max_bitrate_bps) {
+        // The assumption is that if we jump more than 20% in the bandwidth
+        // estimate or if the bandwidth estimate is within 90% of the new
+        // max bitrate then the probing attempt was successful.

[terelius, 2017/01/16 13:48:01]

I'd like to unify this class with the ProbeBitrateEstimator (and maybe
BitrateProber too?) so we would always know whether the probe has succeeded.
That way we could avoid this hack.

[philipel, 2017/01/16 13:56:20]

I agree that we could change the structure of the bandwidth estimation but that
would require major refactoring. 

+        mid_call_probing_succcess_threshold_ =
+            std::min(estimated_bitrate_bps_ * 1.2, max_bitrate_bps_ * 0.9);
+        mid_call_probing_waiting_for_result_ = true;
+        mid_call_probing_bitrate_bps_ = max_bitrate_bps_;
+
+        RTC_HISTOGRAM_COUNTS_10000("WebRTC.BWE.MidCallProbing.Initiated",
+                                   max_bitrate_bps_ / 1000);
+
         InitiateProbing(clock_->TimeInMilliseconds(), {max_bitrate_bps}, false);
       }
       break;
   }
 }
 
 void ProbeController::OnNetworkStateChanged(NetworkState network_state) {
   rtc::CritScope cs(&critsect_);
   network_state_ = network_state;
   if (network_state_ == kNetworkUp && state_ == State::kInit)
     InitiateExponentialProbing();
 }
 
 void ProbeController::InitiateExponentialProbing() {
   RTC_DCHECK(network_state_ == kNetworkUp);
   RTC_DCHECK(state_ == State::kInit);
   RTC_DCHECK_GT(start_bitrate_bps_, 0);
 
   // When probing at 1.8 Mbps ( 6x 300), this represents a threshold of
   // 1.2 Mbps to continue probing.
   InitiateProbing(clock_->TimeInMilliseconds(),
                   {3 * start_bitrate_bps_, 6 * start_bitrate_bps_}, true);
 }
 
 void ProbeController::SetEstimatedBitrate(int64_t bitrate_bps) {
   rtc::CritScope cs(&critsect_);
   int64_t now_ms = clock_->TimeInMilliseconds();
 
+  if (mid_call_probing_waiting_for_result_ &&
+      bitrate_bps >= mid_call_probing_succcess_threshold_) {
+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.BWE.MidCallProbing.Success",
+                               mid_call_probing_bitrate_bps_ / 1000);
+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.BWE.MidCallProbing.ProbedKbps",
+                               bitrate_bps / 1000);
+    mid_call_probing_waiting_for_result_ = false;
+  }
+
   if (state_ == State::kWaitingForProbingResult) {
     // Continue probing if probing results indicate channel has greater
     // capacity.
     LOG(LS_INFO) << "Measured bitrate: " << bitrate_bps
                  << " Minimum to probe further: "
                  << min_bitrate_to_probe_further_bps_;
+
     if (min_bitrate_to_probe_further_bps_ != kExponentialProbingDisabled &&
         bitrate_bps > min_bitrate_to_probe_further_bps_) {
       // Double the probing bitrate.
       InitiateProbing(now_ms, {2 * bitrate_bps}, true);
     }
   }
 
   // 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
@@ skipping 24 matching lines @@
 void ProbeController::EnablePeriodicAlrProbing(bool enable) {
   rtc::CritScope cs(&critsect_);
   enable_periodic_alr_probing_ = enable;
 }
 
 void ProbeController::Process() {
   rtc::CritScope cs(&critsect_);
 
   int64_t now_ms = clock_->TimeInMilliseconds();
 
-  if (state_ == State::kWaitingForProbingResult &&
-      (now_ms - time_last_probing_initiated_ms_) >
-          kMaxWaitingTimeForProbingResultMs) {
-    LOG(LS_INFO) << "kWaitingForProbingResult: timeout";
-    state_ = State::kProbingComplete;
-    min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled;
+  if (now_ms - time_last_probing_initiated_ms_ >
+      kMaxWaitingTimeForProbingResultMs) {
+    mid_call_probing_waiting_for_result_ = false;
+
+    if (state_ == State::kWaitingForProbingResult) {

[terelius, 2017/01/16 13:48:01]

Can you be in mid_call_probing_waiting_for_result_ without being in
State::kWaitingForProbingResult? I.e, is there any reason to reset
mid_call_probing_waiting_for_result_ before checking state_ ==
State::kWaitingForProbingResult?

[philipel, 2017/01/16 13:56:20]

The only time we are in State::kWaitingForProbingResult is when we are waiting
for a new estimate (which we interpret as a successful probing attempt) to see
if we should continue with the exponential probing.

That means |mid_call_probing_waiting_for_result_| can be true even if we are not
in State::kWaitingForProbingResult since mid call probing is not exponential.

[terelius, 2017/01/16 14:07:43]

Acknowledged.

+      LOG(LS_INFO) << "kWaitingForProbingResult: timeout";
+      state_ = State::kProbingComplete;
+      min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled;
+    }
   }
 
   if (state_ != State::kProbingComplete || !enable_periodic_alr_probing_)
     return;
 
   // Probe bandwidth periodically when in ALR state.
   rtc::Optional<int64_t> alr_start_time =
       pacer_->GetApplicationLimitedRegionStartTime();
   if (alr_start_time) {
     int64_t next_probe_time_ms =
@@ skipping 23 matching lines @@
     state_ = State::kWaitingForProbingResult;
     min_bitrate_to_probe_further_bps_ =
         (*(bitrates_to_probe.end() - 1)) * kRepeatedProbeMinPercentage / 100;
   } else {
     state_ = State::kProbingComplete;
     min_bitrate_to_probe_further_bps_ = kExponentialProbingDisabled;
   }
 }
 
 }  // namespace webrtc