Add experimental 'backlog' heuristic for measuring encoder utilization.

media/cast/sender/external_video_encoder.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/sender/external_video_encoder.h"
 
 #include <cmath>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/media_switches.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_types.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/common/rtp_time.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/vp8_quantizer_parser.h"
 #include "media/filters/h264_parser.h"
 
 namespace {
 
 enum { MAX_H264_QUANTIZER = 51 };
 
 // Number of buffers for encoded bit stream.
 constexpr size_t kOutputBufferCount = 3;
 
 // Maximum number of extra input buffers for encoder. The input buffers are only
 // used when copy is needed to match the required coded size.
 constexpr size_t kExtraInputBufferCount = 2;
 
+// Parses the command-line flag and returns 0 (default) to use the old/flawed
+// "deadline utilization" heuristic to measure encoder utilization. Otherwise,

[xjz, 2016/06/29 23:46:52]

s/deadline/encoder

[miu, 2016/06/30 20:38:45]

No, it's correct the way it is. Here, I am saying that a return value of 0 means
we should use the old heuristic, which is the deadline utilization computation.

+// returns the "redline" value for the "backlog" heuristic (i.e., num_frames /
+// redline = utilization).
+//
+// Example command line switches and results:
+//
+//   --cast-encoder-util-heuristic=foobar    ==> 0  (unrecognized, use deadline)

[xjz, 2016/06/29 23:46:52]

s/deadline/encoding time? 

[miu, 2016/06/30 20:38:45]

Same here. 0 means use the deadline computation.

+//   --cast-encoder-util-heuristic=backlog   ==> 4  (use backlog, default)
+//   --cast-encoder-util-heuristic=backlog7  ==> 7  (use backlog, redline=7)
+//
+// TODO(miu): This is temporary, for lab performance testing, until a
+// good "works for all" solution is confirmed.
+// https://code.google.com/p/chrome-os-partner/issues/detail?id=54806
+int GetConfiguredBacklogRedline() {
+  constexpr char kBacklogSwitchValue[] = "backlog";
+  constexpr int kBacklogDefaultRedline = 4;
+
+  const std::string& switch_value =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kCastEncoderUtilHeuristic);
+  if (switch_value.find(kBacklogSwitchValue) == 0) {
+    int redline = kBacklogDefaultRedline;
+    if (!base::StringToInt(switch_value.substr(sizeof(kBacklogSwitchValue) - 1),
+                           &redline)) {
+      redline = kBacklogDefaultRedline;
+    }
+    VLOG(1) << "Using 'backlog' heuristic with a redline of " << redline
+            << " to compute encoder utilization.";
+    return redline;
+  }
+  return 0;
+}
+
 }  // namespace
 
 namespace media {
 namespace cast {
 
 // Container for the associated data of a video frame being processed.
 struct InProgressFrameEncode {
   // The source content to encode.
   const scoped_refptr<VideoFrame> video_frame;
 
@@ skipping 36 matching lines @@
       std::unique_ptr<media::VideoEncodeAccelerator> vea,
       int max_frame_rate,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
       : cast_environment_(cast_environment),
         task_runner_(encoder_task_runner),
         max_frame_rate_(max_frame_rate),
         status_change_cb_(status_change_cb),
         create_video_encode_memory_cb_(create_video_encode_memory_cb),
         video_encode_accelerator_(std::move(vea)),
+        backlog_redline_threshold_(GetConfiguredBacklogRedline()),
         encoder_active_(false),
         next_frame_id_(FrameId::first()),
         key_frame_encountered_(false),
         codec_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
         key_frame_quantizer_parsable_(false),
         requested_bit_rate_(-1),
         has_seen_zero_length_encoded_frame_(false),
         max_allowed_input_buffers_(0),
         allocate_input_buffer_in_progress_(false) {}
 
@@ skipping 191 matching lines @@
       }
       encoded_frame->data.append(
           static_cast<const char*>(output_buffer->memory()), payload_size);
 
       // If FRAME_DURATION metadata was provided in the source VideoFrame,
       // compute the utilization metrics.
       base::TimeDelta frame_duration;
       if (request.video_frame->metadata()->GetTimeDelta(
               media::VideoFrameMetadata::FRAME_DURATION, &frame_duration) &&
           frame_duration > base::TimeDelta()) {
-        // Compute deadline utilization as the real-world time elapsed divided
-        // by the frame duration.
-        const base::TimeDelta processing_time =
-            base::TimeTicks::Now() - request.start_time;
-        encoded_frame->deadline_utilization =
-            processing_time.InSecondsF() / frame_duration.InSecondsF();
+        if (backlog_redline_threshold_ == 0) {
+          // Compute encoder utilization as the real-world time elapsed divided
+          // by the frame duration.
+          const base::TimeDelta processing_time =
+              base::TimeTicks::Now() - request.start_time;
+          encoded_frame->encoder_utilization =
+              processing_time.InSecondsF() / frame_duration.InSecondsF();
+        } else {
+          // Compute encoder utilization in terms of the backlog.
+          encoded_frame->encoder_utilization =
+              static_cast<double>(in_progress_frame_encodes_.size()) /
+              backlog_redline_threshold_;

[xjz, 2016/06/29 23:46:52]

Shall we use |in_progress_frame_encodes_.size()-1| here since the current frame
is already done with encoding?

[miu, 2016/06/30 20:38:45]

By encoding the frame, we utilized the encoder in some greater-than-zero amount.
So, the current frame needs to be included in the calculation.

Another way to look at this: If the current frame is the only one in backlog, we
still need to report a utilization greater than zero.

BTW--I took another look at this, and added a bit more explanation about our
model/thinking on this problem in the code comments here.

+        }
 
         const double actual_bit_rate =
             encoded_frame->data.size() * 8.0 / frame_duration.InSecondsF();
         DCHECK_GT(request.target_bit_rate, 0);
         const double bitrate_utilization =
             actual_bit_rate / request.target_bit_rate;
         double quantizer = QuantizerEstimator::NO_RESULT;
         // If the quantizer can be parsed from the key frame, try to parse
         // the following delta frames as well.
         // Otherwise, switch back to entropy estimation for the key frame
@@ skipping 207 matching lines @@
     }
     return (num_slices == 0) ? -1 : (total_quantizer / num_slices);
   }
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   const int max_frame_rate_;
   const StatusChangeCallback status_change_cb_;  // Must be run on MAIN thread.
   const CreateVideoEncodeMemoryCallback create_video_encode_memory_cb_;
   std::unique_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
+  const int backlog_redline_threshold_;
   bool encoder_active_;
   FrameId next_frame_id_;
   bool key_frame_encountered_;
   std::string stream_header_;
   VideoCodecProfile codec_profile_;
   bool key_frame_quantizer_parsable_;
   H264Parser h264_parser_;
 
   // Shared memory buffers for output with the VideoAccelerator.
   std::vector<std::unique_ptr<base::SharedMemory>> output_buffers_;
@@ skipping 341 matching lines @@
   const double kEntropyAtMaxQuantizer = 7.5;
   const double slope =
       (MAX_VP8_QUANTIZER - MIN_VP8_QUANTIZER) / kEntropyAtMaxQuantizer;
   const double quantizer = std::min<double>(
       MAX_VP8_QUANTIZER, MIN_VP8_QUANTIZER + slope * shannon_entropy);
   return quantizer;
 }
 
 }  //  namespace cast
 }  //  namespace media