Experimental patch for adapting adaptation to CPU count on Mac.

webrtc/video/overuse_frame_detector.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_VIDEO_OVERUSE_FRAME_DETECTOR_H_
 #define WEBRTC_VIDEO_OVERUSE_FRAME_DETECTOR_H_
 
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/exp_filter.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/modules/include/module.h"
 
+#if WEBRTC_MAC
+#include <mach/mach.h>
+#endif
+
 namespace webrtc {
 
 class Clock;
 
 // CpuOveruseObserver is called when a system overuse is detected and
 // VideoEngine cannot keep up the encoding frequency.
 class CpuOveruseObserver {
  public:
   // Called as soon as an overuse is detected.
   virtual void OveruseDetected() = 0;
   // Called periodically when the system is not overused any longer.
   virtual void NormalUsage() = 0;
 
  protected:
   virtual ~CpuOveruseObserver() {}
 };
 
 struct CpuOveruseOptions {
   CpuOveruseOptions()
-      : low_encode_usage_threshold_percent(55),
-        high_encode_usage_threshold_percent(85),
+      : low_encode_usage_threshold_percent(42),

[tommi, 2016/02/04 16:40:02]

Is 42 something that should be set for all platforms or only for mac?

[torbjorng (webrtc), 2016/02/04 16:54:58]

I decreased this to make it about 85/2; the interval should really reflect the
scaling factors made available by libyuv (or more accurately, these factors
squared!). Else we will presumably tend to oscillate.

I deny that I pulled 42 out of a hat; it is the result of a huge computation.

         frame_timeout_interval_ms(1500),
         min_frame_samples(120),
         min_process_count(3),
-        high_threshold_consecutive_count(2) {}
+        high_threshold_consecutive_count(2) {
+#if WEBRTC_MAC

[tommi, 2016/02/04 16:40:02]

nit: #if defined(WEBRTC_MAC)

[torbjorng (webrtc), 2016/02/04 16:54:59]

Done.

+    // This is a proof-of-concept hack for letting the physical core count
+    // affect the interval into which we attempt to scale.  For now, the code
+    // is Mac OS specific, since that's the platform were we saw the problem.
+    // Note that we make the interval 2x+epsilon wide, since scaling steps are
+    // close to that.
+    struct host_basic_info hbi;
+    mach_msg_type_number_t datasize;
+    // FIXME(torbjorng): Add syscall error checking, fallback code.

[tommi, 2016/02/04 16:40:02]

nit: s/FIXME/TODO

[torbjorng (webrtc), 2016/02/04 16:54:59]

Done.

+    host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hbi, &datasize);

[tommi, 2016/02/04 16:40:02]

does this work as expected inside the sandbox?

[torbjorng (webrtc), 2016/02/04 16:54:58]

Good question. I will verify that.  I observed chrome://webrtc-internals, and it
looked as it was effective. But timing reproducibility could as we know be
better on this platform.

We should use SystemInfo (base/systeminfo.h) but I did not because I couldn't
get *physical* core count from it.

+
+    if (hbi.physical_cpu == 1) {
+      low_encode_usage_threshold_percent = 17;
+    } else if (hbi.physical_cpu == 2) {
+      low_encode_usage_threshold_percent = 27;
+    } else {
+      // Init list default.
+    }
+#endif
+    // Make high = low + epsilon.
+    high_encode_usage_threshold_percent
+      = 33 * low_encode_usage_threshold_percent / 16 + 1;

[tommi, 2016/02/04 16:40:02]

nit: assignment operator on previous line (could also run git cl format)

[torbjorng (webrtc), 2016/02/04 16:54:58]

Done.

+  }
 
   int low_encode_usage_threshold_percent;  // Threshold for triggering underuse.
   int high_encode_usage_threshold_percent;  // Threshold for triggering overuse.
   // General settings.
   int frame_timeout_interval_ms;  // The maximum allowed interval between two
                                   // frames before resetting estimations.
   int min_frame_samples;  // The minimum number of frames required.
   int min_process_count;  // The number of initial process times required before
                           // triggering an overuse/underuse.
   int high_threshold_consecutive_count;  // The number of consecutive checks
@@ skipping 98 matching lines @@
   const rtc::scoped_ptr<FrameQueue> frame_queue_ GUARDED_BY(crit_);
 
   rtc::ThreadChecker processing_thread_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(OveruseFrameDetector);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_VIDEO_OVERUSE_FRAME_DETECTOR_H_