Reduce locking in overuse frame detector now that (as of r9508) the observer_ and options_ can only

webrtc/video_engine/overuse_frame_detector.cc

 /*
  *  Copyright (c) 2013 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 181 matching lines @@
 
 OveruseFrameDetector::OveruseFrameDetector(
     Clock* clock,
     const CpuOveruseOptions& options,
     CpuOveruseObserver* observer,
     CpuOveruseMetricsObserver* metrics_observer)
     : options_(options),
       observer_(observer),
       metrics_observer_(metrics_observer),
       clock_(clock),
-      next_process_time_(clock_->TimeInMilliseconds()),
       num_process_times_(0),
       last_capture_time_(0),
+      num_pixels_(0),
+      next_process_time_(clock_->TimeInMilliseconds()),
       last_overuse_time_(0),
       checks_above_threshold_(0),
       num_overuse_detections_(0),
       last_rampup_time_(0),
       in_quick_rampup_(false),
       current_rampup_delay_ms_(kStandardRampUpDelayMs),
-      num_pixels_(0),
       last_encode_sample_ms_(0),
+      last_sample_time_ms_(0),
       encode_time_(new EncodeTimeAvg()),
       usage_(new SendProcessingUsage(options)),
-      frame_queue_(new FrameQueue()),
-      last_sample_time_ms_(0) {
+      frame_queue_(new FrameQueue()) {
   RTC_DCHECK(metrics_observer != nullptr);
   // Make sure stats are initially up-to-date. This simplifies unit testing
   // since we don't have to trigger an update using one of the methods which
   // would also alter the overuse state.
   UpdateCpuOveruseMetrics();
   processing_thread_.DetachFromThread();
 }
 
 OveruseFrameDetector::~OveruseFrameDetector() {
 }
@@ skipping 104 matching lines @@
   RTC_DCHECK(processing_thread_.CalledOnValidThread());
 
   int64_t now = clock_->TimeInMilliseconds();
 
   // Used to protect against Process() being called too often.
   if (now < next_process_time_)
     return 0;
 
   next_process_time_ = now + kProcessIntervalMs;
 
-  rtc::CritScope cs(&crit_);
-  ++num_process_times_;
+  CpuOveruseMetrics current_metrics;
+  {
+    rtc::CritScope cs(&crit_);
+    ++num_process_times_;
 
-  if (num_process_times_ <= options_.min_process_count) {
-    return 0;
+    current_metrics = metrics_;
+    if (num_process_times_ <= options_.min_process_count)
+      return 0;
   }
 
-  if (IsOverusing()) {
+  if (IsOverusing(current_metrics)) {
     // If the last thing we did was going up, and now have to back down, we need
     // to check if this peak was short. If so we should back off to avoid going
     // back and forth between this load, the system doesn't seem to handle it.
     bool check_for_backoff = last_rampup_time_ > last_overuse_time_;
     if (check_for_backoff) {
       if (now - last_rampup_time_ < kStandardRampUpDelayMs ||
           num_overuse_detections_ > kMaxOverusesBeforeApplyRampupDelay) {
         // Going up was not ok for very long, back off.
         current_rampup_delay_ms_ *= kRampUpBackoffFactor;
         if (current_rampup_delay_ms_ > kMaxRampUpDelayMs)
           current_rampup_delay_ms_ = kMaxRampUpDelayMs;
       } else {
         // Not currently backing off, reset rampup delay.
         current_rampup_delay_ms_ = kStandardRampUpDelayMs;
       }
     }
 
     last_overuse_time_ = now;
     in_quick_rampup_ = false;
     checks_above_threshold_ = 0;
     ++num_overuse_detections_;
 
     if (observer_ != NULL)
       observer_->OveruseDetected();
-  } else if (IsUnderusing(now)) {
+  } else if (IsUnderusing(current_metrics, now)) {
     last_rampup_time_ = now;
     in_quick_rampup_ = true;
 
     if (observer_ != NULL)
       observer_->NormalUsage();
   }
 
   int rampup_delay =
       in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_;
-  LOG(LS_VERBOSE) << " Frame stats: encode usage: " << usage_->Value()
+
+  LOG(LS_VERBOSE) << " Frame stats: "
+                  << " encode usage " << current_metrics.encode_usage_percent
                   << " overuse detections " << num_overuse_detections_
                   << " rampup delay " << rampup_delay;
 
   return 0;
 }
 
-bool OveruseFrameDetector::IsOverusing() {
+bool OveruseFrameDetector::IsOverusing(const CpuOveruseMetrics& metrics) {
   bool overusing = false;
-  if (options_.enable_encode_usage_method)
-    overusing = usage_->Value() >= options_.high_encode_usage_threshold_percent;
-
+  if (options_.enable_encode_usage_method) {
+    overusing = metrics.encode_usage_percent >=
+                options_.high_encode_usage_threshold_percent;
+  }
   if (overusing) {
     ++checks_above_threshold_;
   } else {
     checks_above_threshold_ = 0;
   }
   return checks_above_threshold_ >= options_.high_threshold_consecutive_count;
 }
 
-bool OveruseFrameDetector::IsUnderusing(int64_t time_now) {
+bool OveruseFrameDetector::IsUnderusing(const CpuOveruseMetrics& metrics,
+                                        int64_t time_now) {
   int delay = in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_;
   if (time_now < last_rampup_time_ + delay)
     return false;
 
   bool underusing = false;
-  if (options_.enable_encode_usage_method)
-    underusing = usage_->Value() < options_.low_encode_usage_threshold_percent;
-
+  if (options_.enable_encode_usage_method) {
+    underusing = metrics.encode_usage_percent <
+                 options_.low_encode_usage_threshold_percent;
+  }
   return underusing;
 }
 }  // namespace webrtc