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 defined(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),
         frame_timeout_interval_ms(1500),
         min_frame_samples(120),
         min_process_count(3),
-        high_threshold_consecutive_count(2) {}
+        high_threshold_consecutive_count(2) {
+#if defined  (WEBRTC_MAC)

[tommi, 2016/02/04 20:32:44]

#if defined(WEBRTC_MAC)

[torbjorng (webrtc), 2016/02/05 16:31:05]

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;
+    // TODO(torbjorng): Add syscall error checking, fallback code.
+    host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hbi, &datasize);

[tommi, 2016/02/04 20:32:44]

Can you change the cast to a C++ cast?  As is it looks like the cast is casting
a pointer to an object... does host_info() accept a pointer or a by value? (is
host_info_t a pointer type?)

[Robert Sesek, 2016/02/04 22:37:15]

The result of mach_host_self must be deallocated. This is currently leaking a
system resource.

[tommi (sloooow) - chröme, 2016/02/04 22:44:40]

Ah, thanks for catching that!
Now this makes more sense to me. I'd prefer to have the variable of the expected
type too and only cast after error checking (and of course free too).

[torbjorng (webrtc), 2016/02/05 16:31:05]

Yes, host_info_t is a ptr (it is in fact int*).

Fixing cast.

[torbjorng (webrtc), 2016/02/05 16:31:05]

Robert: I changed the code to look more like in other places in WebRTC. This
means calling mach_port_deallocate with mach_task_self(). Since the latter just
like mach_host_self() returns a magic port number (an int) one might suspect
that the deallocation could leak. I cannot find proper documentation, but IIUC,
these port numbers are (small) refcounted kernel resources.

Tommi: This is a message passing API. You are supposed to cast things like this
to the generic message type.

[tommi, 2016/02/05 22:56:35]

Thanks, I'm familiar with APIs like these :)  I was thinking along these lines:

host_info_t host_info = nullptr;
host_info(mach_host_self(), HOST_BASIC_INFO, &host_info, &datasize);
if (data_size == sizeof(host_basic_info)) {
  struct host_basic_info* basic_info =
reintepret_cast<host_basic_info*>(host_info);
  // use |basic_info|
} else {
  NOTREACHED() << "host_info returned something unexpected.";
}


However, what you have now is fine too.

[Robert Sesek, 2016/02/05 22:59:58]

Thanks! This is now OK. mach_task_self() is actually a macro for an extern of
the task port cached in userspace, so you don't need to deallocate it.
mach_host_self() is a real kernel trap, so you do have to deallocate that.

(Yes, this is more confusing than it needs to be).

+
+    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

[tommi, 2016/02/04 20:32:44]

nit:
#endif  // WEBRTC_MAC

[torbjorng (webrtc), 2016/02/05 16:31:05]

Done.

+    // Make high = 2 * low + epsilon.
+    high_encode_usage_threshold_percent =
+      33 * low_encode_usage_threshold_percent / 16 + 1;

[tommi, 2016/02/04 20:32:44]

4 space indent.  (or just run git cl format?)

[torbjorng (webrtc), 2016/02/05 16:31:06]

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_